quantlib-dev — Discussion of QuantLib development

Re: [Quantlib-dev] Questions beginner

[Michael B. <mjb...@gm...>]

Hi, I'd also like to comment on this.

I'm in the process of writing a PhD research proposal at the moment and was
considering centering it on an FPGA/HW acceleration wrapper for QuantLib.
Does anyone know if attempts have been made to do this? Or if it would be
of utility to the users?

It looks at the moment that while many accelerators exist there is nothing
open source with the community following of QuantLib. GPGPU is one option,
but a dedicated card may be more appropriate in some cases (for example,
should the card feature on-board Ethernet).

A loose specification could involve a PCI express card recognized by
quantlib that offloads library calls to the card, and perhaps at a stretch
certain code paths of user applications.

Any feedback?

Thanks and best regards,

Mike

On Fri, Dec 28, 2012 at 4:20 PM, Luigi Ballabio <lui...@gm...>wrote:

> Hi Minos and Steph,
>     I'm afraid we're kind of bad at this...  we don't have a roadmap
> at this time, or a list of todo items, so I don't think I have tasks
> to suggest.  Anyway: if you want to get familiar with the library, you
> might start from the design notes I'm putting together at
> <https://sites.google.com/site/luigiballabio/qlbook>.
>
> Minos: if you're interested in CUDA, Klaus Spanderen has been doing
> some research on that (you can read his blog at
> <http://hpcquantlib.wordpress.com/>; you might want to get in thouch
> with him and check if you can collaborate (he's in cc).
>
> Steph: do you have in mind anything in particular with regard to
> options? Maybe some project you might be pursuing in the context of
> your studies? (If you have an advisor, you might check with him).
>
> Later,
>     Luigi
>
>
>
> On Sun, Dec 16, 2012 at 9:00 PM, Minos Bambinos
> <min...@gm...> wrote:
> > Hi,
> >
> > I'm a s/w engineer, I'd like to contribute but I don't know how or where
> to
> > start.  I'm interested in C++/STL/BOOST/CUDA/OpenCL.
> >
> > Thank you,
> > -Minos
>
> On Fri, Dec 14, 2012 at 2:04 PM, prj sli <pro...@li...> wrote:
> > Hi all ,
> >
> > I am an student in quantitative finance and I just join the group.
> > Actually I would relly like to help but I don't really knpow where and
> > how to start!!
> > I am very interested with option pricing (vanilla and exotics options
> ...)
> >
> > Could you help me with that and give me some tips ?
> >
> > Thanks for your answer.
> >
> > Regards.
> >
> > Steph
>
>
> ------------------------------------------------------------------------------
> Master HTML5, CSS3, ASP.NET, MVC, AJAX, Knockout.js, Web API and
> much more. Get web development skills now with LearnDevNow -
> 350+ hours of step-by-step video tutorials by Microsoft MVPs and experts.
> SALE $99.99 this month only -- learn more at:
> http://p.sf.net/sfu/learnmore_122812
> _______________________________________________
> QuantLib-dev mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-dev
>

Re: [Quantlib-dev] Questions beginner

[Luigi B. <lui...@gm...>]

Hi Minos and Steph,
    I'm afraid we're kind of bad at this...  we don't have a roadmap
at this time, or a list of todo items, so I don't think I have tasks
to suggest.  Anyway: if you want to get familiar with the library, you
might start from the design notes I'm putting together at
<https://sites.google.com/site/luigiballabio/qlbook>.

Minos: if you're interested in CUDA, Klaus Spanderen has been doing
some research on that (you can read his blog at
<http://hpcquantlib.wordpress.com/>; you might want to get in thouch
with him and check if you can collaborate (he's in cc).

Steph: do you have in mind anything in particular with regard to
options? Maybe some project you might be pursuing in the context of
your studies? (If you have an advisor, you might check with him).

Later,
    Luigi



On Sun, Dec 16, 2012 at 9:00 PM, Minos Bambinos
<min...@gm...> wrote:
> Hi,
>
> I'm a s/w engineer, I'd like to contribute but I don't know how or where to
> start.  I'm interested in C++/STL/BOOST/CUDA/OpenCL.
>
> Thank you,
> -Minos

On Fri, Dec 14, 2012 at 2:04 PM, prj sli <pro...@li...> wrote:
> Hi all ,
>
> I am an student in quantitative finance and I just join the group.
> Actually I would relly like to help but I don't really knpow where and
> how to start!!
> I am very interested with option pricing (vanilla and exotics options ...)
>
> Could you help me with that and give me some tips ?
>
> Thanks for your answer.
>
> Regards.
>
> Steph

Re: [Quantlib-dev] MF1F NTL Support

[Klaus S. <kl...@sp...>]

Hi Peter,

I've used gcc's type __float128 to calculate high precision reference prices 
for some stoch vol models but I'd to change multiple parts of QuantLib to get 
it working. Just changing the typedef for Real in types.hpp was not enough.

regards
 Klaus

On Thursday, December 27, 2012 02:26:55 PM Peter Caspers wrote:
> Hi,
> 
> I added high precision floating point support to the markov functional
> model making use of NTL (and supplementary boost functions). This allows
> for a better numeraire fit to long term (like say 50y) constant maturity
> calibration sets. NTL is only used for some intermediate results, the
> interface does not change. While there are other, faster yet dirty ways
> to stabilize the calibration (like the AdjustYts option) this is
> probably a good way to produce benchmark results and check convergence
> in the numerical parameters. I updated the code on my github as well as
> the doc on ssrn giving an example.
> 
> More generally, is high precision arithmetic a topic anyone came across
> in some context he or she wants to share ?
> 
> Peter
> 
> ----------------------------------------------------------------------------
> -- Master Visual Studio, SharePoint, SQL, ASP.NET, C# 2012, HTML5, CSS, MVC,
> Windows 8 Apps, JavaScript and much more. Keep your skills current with
> LearnDevNow - 3,200 step-by-step video tutorials by Microsoft MVPs and
> experts. ON SALE this month only -- learn more at:
> http://p.sf.net/sfu/learnmore_122712
> _______________________________________________
> QuantLib-dev mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-dev

[Quantlib-dev] MF1F NTL Support

[Peter C. <pca...@gm...>]

Hi,

I added high precision floating point support to the markov functional 
model making use of NTL (and supplementary boost functions). This allows 
for a better numeraire fit to long term (like say 50y) constant maturity 
calibration sets. NTL is only used for some intermediate results, the 
interface does not change. While there are other, faster yet dirty ways 
to stabilize the calibration (like the AdjustYts option) this is 
probably a good way to produce benchmark results and check convergence 
in the numerical parameters. I updated the code on my github as well as 
the doc on ssrn giving an example.

More generally, is high precision arithmetic a topic anyone came across 
in some context he or she wants to share ?

Peter

Re: [Quantlib-dev] CAT Bond valuation

[Grześ A. <gan...@gm...>]

Hi Luigi,

After spending way too much time on reading termsheets and talking to
people I am finally ready to write some code :)

I managed to find a class that seems rather similar to what I am trying to
achieve: RiskyFloatingBond in experimental/credit. It seems to create
coupons as if there was no credit (CAT in my case) risk. The risk is only
taken into account while calculating (1) NPV (2) expectedCashflows(). In my
case I would still need to run Monte Carlo simulation in these two places.
If I ignore (2) for now, then I hopefully will be able to use the standard
approach for MC.

Have you seen this class before? It was written by Roland Lichters in 2008.
Unfortunately a quick search didn't find any associated tests. Is it
actually used?

This kind of approach gives me an easy way to calculate the yield of the
bond (disregarding the risks), which is often used by practitioners to
compare different bonds, combined with expected loss.

Kind regards,
Grzegorz



On 15 October 2012 15:11, Luigi Ballabio <lui...@gm...> wrote:

> Grześ,
>     apologies for the delay.  As I was telling you, there's currently
> no example for coupon amounts calculated in a MC simulation.  If you
> want to go that route, you'll have to:
>
> - write the simulation itself.  There are a number of engines you can
> use as an example, so you should be covered with regards to creating a
> path generator, a path pricer and the several other pieces you'll
> need.  The notable difference in your case is that you'll want to
> return a number of cashflow amounts from the simulation, not a single
> number.  To do that, you'll have to use the second template argument
> of PathPricer: I think all the existing engines use its default (that
> is, Real for a single number) but you'll have to specify that you'll
> return a vector<Real> or something like it.
>
> - link the coupons to the simulation.  Again, there's no code doing
> this yet.  What I'd do is to create a new class inheriting from
> CashFlow and taking a pointer to the MC simulation.  When their
> amount() method is called, instances of this class should ask the
> simulation for the corresponding result.  In turn, this means that a)
> they should know which cashflow they are (the 1st, the 2nd...) among
> those calculated by the simulation and b) the simulation must
> implement some kind of caching to avoid being run several times as the
> Bond class asks its cashflows for their amounts.
>
> The above should keep you busy for a while :)
> Let me know when you need further advice...
>
> Later,
>     Luigi
>
>
> On Thu, Sep 13, 2012 at 5:56 PM, Grześ Andruszkiewicz
> <gan...@gm...> wrote:
> > Hi Luigi,
> >
> > Thanks for a long reply. We were just trying to follow your advice and
> > extend the Bond class, but we found a few potential issues:
> > 1. The Coupon class seems to have a fixed notional, whereas in our
> > case the notional could become smaller as a result of CAT events (that
> > deplete the notional of the CAT bond)
> > 2. The Bond class seems to assume that we can always calculate the
> > coupon amounts (independently for every coupon). I am not sure that
> > this is possible for CAT bonds (i.e. that coupons will be correlated
> > as a result of depleting the notional, catastrophe seasonality, etc.),
> > at least I am not comfortable to assume it at this point.
> > 3. Moreover, we wanted to have a way to price these instruments using
> > Monte Carlo techniques, i.e. use the underlying CAT engine to generate
> > random scenarios of events, given the events calculate the NPV of the
> > bond for every case, and average the results at the end. It is not
> > clear to how to achieve this with the Bond class...
> >
> > Are there other types of instruments in QuantLib with similar
> > characteristics, that we could use as examples?
> >
> > Kind regards,
> > Grzegorz
> >
> > On 31 August 2012 15:45, Luigi Ballabio <lui...@gm...>
> wrote:
> >> Hi Grześ,
> >>     I'd start by doing the least possible coding :)   Let me elaborate.
> >>
> >> In the architecture of QuantLib, you'll need an instrument class
> >> (describing the contract) and an engine class (doing the actual
> >> pricing).  You can ask your resident expert (hi, Lorenzo) or read
> >> chapter 2 of <https://sites.google.com/site/luigiballabio/>.
> >>
> >> As for the instrument, it is very tempting to inherit it from the
> >> existing Bond class (it's a bond, after all).  In the short term,
> >> that's what I advice.
> >>
> >> In the long term, I'm a bit worried that functions taking a Bond
> >> instance (such as, for instance, BondFunctions::yield, which
> >> calculates the bond yield) would take a CAT bond and do their job like
> >> they do for each other bond; that is, extract its coupons and perform
> >> the yield calculations disregarding the catastrophe feature.  This
> >> might or might not be what you want.
> >>
> >> In the _very_ short term, though, I'd just use the existing fixed-rate
> >> and floating-rate bond classes and use those until you see that the
> >> thing works.  It will save you some development time which I'd rather
> >> use for getting to a first working version.
> >>
> >> Which brings me to the second part, i.e., the engine class.  It will
> >> probably need to contain a discount curve and your loss distribution.
> >> Any idea about how you'll use them?
> >>
> >> Later,
> >>     Luigi
> >>
> >>
> >> On Fri, Aug 24, 2012 at 5:08 PM, Grześ Andruszkiewicz
> >> <gan...@gm...> wrote:
> >>> Hi Luigi,
> >>>
> >>> Thanks for your reply! I personally can't claim to be proficient with
> >>> Quantlib, but my colleague Lorenzo (CC'd) did the 3-day course in
> >>> London with yourself, so he must be an expert ;)
> >>>
> >>> I don't think there are any established models for CAT bonds. We are
> >>> actually part of one of these academic-industry projects and one of
> >>> the goals is to come up with a model and implementation for these
> >>> instruments. We thought it might be a good idea to make this
> >>> implementation part of quantlib, to make it potentially useful for
> >>> someone.
> >>>
> >>> To start with, I would be grateful for any hints on where to start,
> >>> e.g. what would be your first guess on the place in the class
> >>> hierarchy where this instrument would fit?
>

[Quantlib-dev] Inflation Index Interpolation

[Peter C. <pca...@gm...>]

Hi,

I am comparing Murex and QuantLib concerning Inflation Pricing. I observe a
difference in the way an index fixing is interpolated between known (i.e.
already fixed) values. Here is an example:

Take the EUHICP XT index which has fixings

01.08.2012 (Aug 12)    115.10
01.09.2012 (Sep 12)    115.97

Now I want to look up the fixing on 28.08.2012 belonging to an observation
date on 28.11.2012 (3m observation lag). In QL the interpolation is done as
follows:

Days between 01.08. and 01.09. = 31, Days between 01.08. and 28.08. = 27,
Interpolated Fixing = 115.10 + 27/31 * ( 115.97 - 115.10 )

In Murex on the opposite:

 Days between 01.11. and 01.12. = 30, Days between 01.11. and 28.11. = 27,
Interpolated Fixing = 115.10 + 27/30 * ( 115.97 - 115.10 )

Which computation is the correct one, i.e. what is the market convention
that is actually applied to deals ? Maybe I am using the QL classes not as
intended ?

Thanks a lot
Peter

[Quantlib-dev] How to contribute

[Minos B. <min...@gm...>]

Hi,

I'm a s/w engineer, I'd like to contribute but I don't know how or where to
start.  I'm interested in C++/STL/BOOST/CUDA/OpenCL.

Thank you,
-Minos

Re: [Quantlib-dev] Local Vol

[<Tb...@ao...>]

Whilst on the subject, in cases where you don't have a very smooth and well defined BS volatility surface, what do you do?

Sent from my iPad

On 16 Dec 2012, at 17:19, "Simon Ibbotson" <Sim...@fs...> wrote:

> I have an implementation on Andreason's method for generating no-arbitrage local vol surfaces. I will submit it into QuantLib after New Years...
> 
> From: Klaus Spanderen <kl...@sp...> 
> To: Luigi Ballabio <lui...@gm...>; Theo Boafo <tb...@ao...> 
> Cc: qua...@li... <qua...@li...> 
> Sent: Fri Dec 14 14:44:51 2012
> Subject: Re: [Quantlib-dev] Local Vol 
> 
> Hi
>  
> The implementation is based on the original Dupire formula and therefore works only if you have a very "smooth" and well-defined BS volatility surface.  The test case 
>  
> BarrierOptionTest :: testLocalVolAndHestonComparison ()
>  
> shows a usage of it.
>  
> This algorithm
>  
> http://papers.ssrn.com/sol3/papers.cfm?abstract_id=1694972
>  
> might be helpful to generate "smooth" volatility surfaces.
>  
> cheers
>  Klaus
>  
> But then is seems to work, 
> Luigi Ballabio <lui...@gm...> hat am 14. Dezember 2012 um 12:01 geschrieben: 
> > Hi, 
> > the LocalVolSurface is what we have. It's not overly tested, 
> > though, so it would be great if anyone tried it out and reported. 
> > 
> > Luigi 
> > 
> > 
> > On Wed, Dec 12, 2012 at 3:43 PM, Theo Boafo <tb...@ao...> wrote: 
> > > Hi All, 
> > > 
> > > Do we have an implementation of Local Vol in Quantlib? I see a LocalVol 
> > > surface but does not seem like its used. 
> > > 
> > > Regards 
> > > 
> > > Theo 
> > 
> > ------------------------------------------------------------------------------ 
> > LogMeIn Rescue: Anywhere, Anytime Remote support for IT. Free Trial 
> > Remotely access PCs and mobile devices and provide instant support 
> > Improve your efficiency, and focus on delivering more value-add services 
> > Discover what IT Professionals Know. Rescue delivers 
> > http://p.sf.net/sfu/logmein_12329d2d 
> > _______________________________________________ 
> > QuantLib-dev mailing list 
> > Qua...@li... 
> > https://lists.sourceforge.net/lists/listinfo/quantlib-dev
> 
> 
> This communication and any attachments contains information which is confidential and may be subject to legal privilege. It is for intended recipients only. If you are not the intended recipient you must not copy, distribute, publish, rely on or otherwise use it without our consent. Some of our communications may contain confidential information which it could be a criminal offence for you to disclose or use without authority. If you have received this email in error please notify pos...@fs... immediately and delete the email from your computer.
> 
> The FSA reserves the right to monitor all email communications for compliance with legal, regulatory and professional standards.
> 
> This email is not intended to nor should it be taken to create any legal relations or contractual relationships. This email has originated from
> 
> The Financial Services Authority (FSA)
> 25 The North Colonnade,
> Canary Wharf,
> London
> E14 5HS
> United Kingdom
> 
> Registered as a Limited Company in England and Wales No.1920623.
> Registered Office as above
> 
> Switchboard: 020 7066 1000
> Web Site: http://www.fsa.gov.uk
> *****************************************************************

Re: [Quantlib-dev] Local Vol

[Simon I. <Sim...@fs...>]

I have an implementation on Andreason's method for generating no-arbitrage local vol surfaces. I will submit it into QuantLib after New Years...


________________________________

From: Klaus Spanderen <kl...@sp...> 
To: Luigi Ballabio <lui...@gm...>; Theo Boafo <tb...@ao...> 
Cc: qua...@li... <qua...@li...> 
Sent: Fri Dec 14 14:44:51 2012
Subject: Re: [Quantlib-dev] Local Vol 


Hi 
  
The implementation is based on the original Dupire formula and therefore works only if you have a very "smooth" and well-defined BS volatility surface.  The test case  
  
BarrierOptionTest :: testLocalVolAndHestonComparison () 
  
shows a usage of it. 
  
This algorithm 
  
http://papers.ssrn.com/sol3/papers.cfm?abstract_id=1694972 
  
might be helpful to generate "smooth" volatility surfaces. 
  
cheers 
 Klaus 
  
But then is seems to work, 
Luigi Ballabio <lui...@gm...> hat am 14. Dezember 2012 um 12:01 geschrieben: 
> Hi, 
> the LocalVolSurface is what we have. It's not overly tested, 
> though, so it would be great if anyone tried it out and reported. 
> 
> Luigi 
> 
> 
> On Wed, Dec 12, 2012 at 3:43 PM, Theo Boafo <tb...@ao...> wrote: 
> > Hi All, 
> > 
> > Do we have an implementation of Local Vol in Quantlib? I see a LocalVol 
> > surface but does not seem like its used. 
> > 
> > Regards 
> > 
> > Theo 
> 
> ------------------------------------------------------------------------------ 
> LogMeIn Rescue: Anywhere, Anytime Remote support for IT. Free Trial 
> Remotely access PCs and mobile devices and provide instant support 
> Improve your efficiency, and focus on delivering more value-add services 
> Discover what IT Professionals Know. Rescue delivers 
> http://p.sf.net/sfu/logmein_12329d2d 
> _______________________________________________ 
> QuantLib-dev mailing list 
> Qua...@li... 
> https://lists.sourceforge.net/lists/listinfo/quantlib-dev 



This communication and any attachments contains information which is confidential and may be subject to legal privilege. It is for intended recipients only. If you are not the intended recipient you must not copy, distribute, publish, rely on or otherwise use it without our consent. Some of our communications may contain confidential information which it could be a criminal offence for you to disclose or use without authority. If you have received this email in error please notify pos...@fs... immediately and delete the email from your computer.

The FSA reserves the right to monitor all email communications for compliance with legal, regulatory and professional standards.
This email is not intended to nor should it be taken to create any legal relations or contractual relationships. This email has originated from

The Financial Services Authority (FSA)
25 The North Colonnade,
Canary Wharf,
London
E14 5HS
United Kingdom

Registered as a Limited Company in England and Wales No.1920623.
Registered Office as above

Switchboard: 020 7066 1000
Web Site: http://www.fsa.gov.uk
*****************************************************************

Re: [Quantlib-dev] Local Vol

[Klaus S. <kl...@sp...>]

Hi

The implementation is based on the original Dupire formula and therefore works
only if you have a very "smooth" and well-defined BS volatility surface.  The
test case

BarrierOptionTest :: testLocalVolAndHestonComparison ()

shows a usage of it.

This algorithm

http://papers.ssrn.com/sol3/papers.cfm?abstract_id=1694972

might be helpful to generate "smooth" volatility surfaces.

cheers
 Klaus

But then is seems to work,
Luigi Ballabio <lui...@gm...> hat am 14. Dezember 2012 um 12:01
geschrieben:
> Hi,
> the LocalVolSurface is what we have. It's not overly tested,
> though, so it would be great if anyone tried it out and reported.
>
> Luigi
>
>
> On Wed, Dec 12, 2012 at 3:43 PM, Theo Boafo <tb...@ao...> wrote:
> > Hi All,
> >
> > Do we have an implementation of Local Vol in Quantlib? I see a LocalVol
> > surface but does not seem like its used.
> >
> > Regards
> >
> > Theo
>
> ------------------------------------------------------------------------------
> LogMeIn Rescue: Anywhere, Anytime Remote support for IT. Free Trial
> Remotely access PCs and mobile devices and provide instant support
> Improve your efficiency, and focus on delivering more value-add services
> Discover what IT Professionals Know. Rescue delivers
> http://p.sf.net/sfu/logmein_12329d2d
> _______________________________________________
> QuantLib-dev mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-dev

[Quantlib-dev] Questions beginner

[prj s. <pro...@li...>]

Hi all ,

I am an student in quantitative finance and I just join the group.
Actually I would relly like to help but I don't really knpow where and 
how to start!!
I am very interested with option pricing (vanilla and exotics options ...)

Could you help me with that and give me some tips ?

Thanks for your answer.

Regards.

Steph

Re: [Quantlib-dev] Local Vol

[Luigi B. <lui...@gm...>]

Hi,
    the LocalVolSurface is what we have.  It's not overly tested,
though, so it would be great if anyone tried it out and reported.

Luigi


On Wed, Dec 12, 2012 at 3:43 PM, Theo Boafo <tb...@ao...> wrote:
> Hi All,
>
> Do we have an implementation of Local Vol in Quantlib?  I see a LocalVol
> surface but does not seem like its used.
>
> Regards
>
> Theo

Re: [Quantlib-dev] credit on Saturdays

[Luigi B. <lui...@gm...>]

It doesn't seem bad to me.  Any others wanting to weigh in?

Luigi


On Tue, Dec 4, 2012 at 11:25 AM,  <ja...@fr...> wrote:
>
> If I define CDS helpers on a Saturday. The curve ref date is then the next monday.
> Now use the curve to price a coupon with that Saturday (i.e. today) placed within the coupon period, that date becomes the effective start date for the coupon and the pricing fails because of the negative time requested to the default probability (see below)
>
> I am not saying it is a bug. Something similar happens in FI defining a reference date for an index on a Saturday and calling for a fixing which now falls before the index  ref date.
>
> Anyway, all this to ask you what do you think of modifying the code below
> (see: ql/termstructures/defaulttermstructure.cpp)
> -------------------------------------------------------------------------------
>     Probability DefaultProbabilityTermStructure::defaultProbability(
>                                                      const Date& d1,
>                                                      const Date& d2,
>                                                      bool extrapolate) const {
>         QL_REQUIRE(d1 <= d2,
>                    "initial date (" << d1 << ") "
>                    "later than final date (" << d2 << ")");
>         Probability p1 = (d1<=referenceDate()) ? 0. : defaultProbability(d1,extrapolate);//<<<<<<<<<<
>         Probability p2 = defaultProbability(d2,extrapolate);
>
>         return p2 - p1;
>     }
> -------------------------------------------------------------------------------
> and similarly for the Time version.
> It bypasses the negative time check by assuming survival before the curve reference date.
>
> What do you think?
>
> Best regards
> Pepe
>
> ------------------------------------------------------------------------------
> LogMeIn Rescue: Anywhere, Anytime Remote support for IT. Free Trial
> Remotely access PCs and mobile devices and provide instant support
> Improve your efficiency, and focus on delivering more value-add services
> Discover what IT Professionals Know. Rescue delivers
> http://p.sf.net/sfu/logmein_12329d2d
> _______________________________________________
> QuantLib-dev mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-dev

[Quantlib-dev] Local Vol

[Theo B. <tb...@ao...>]

Hi All,


Do we have an implementation of Local Vol in Quantlib?  I see a LocalVol surface but does not seem like its used.


Regards


Theo


-----Original Message-----
From: Luigi Ballabio <lui...@gm...>
To: Theo Boafo <tb...@ao...>
CC: quantlib-dev <qua...@li...>
Sent: Wed, 28 Nov 2012 16:39
Subject: Re: [Quantlib-dev] QuantLib-dev Digest, Vol 78, Issue 12


Yes, you can do that.

Luigi


On Wed, Nov 28, 2012 at 5:36 PM, Theo Boafo <tb...@ao...> wrote:
> Hi,
>
> So I can have a new class FloatFloatSwap inheriting from Swap class and
> build the two legs as you suggested?
>
> Regards
>
> Theo
>
>
>
> -----Original Message-----
> From: Luigi Ballabio <lui...@gm...>
> To: Theo Boafo <tb...@ao...>
> CC: quantlib-dev <qua...@li...>
> Sent: Wed, 28 Nov 2012 16:32
> Subject: Re: [Quantlib-dev] QuantLib-dev Digest, Vol 78, Issue 12
>
> You'll have to build the two legs yourself and use the Swap class instead.
>
> Luigi
>
>
> On Wed, Nov 28, 2012 at 5:22 PM, Theo Boafo <tb...@ao...> wrote:
>> Hi,
>>
>> Looking at the vanillaswap it values swaps with  fixed for floating
>> schedules or legs.  I cant see anything doing float for float or am I
>> missing something.
>>
>> Regards
>>
>> Theo
>>
>>
>> ------------------------------------------------------------------------------
>> Keep yourself connected to Go Parallel:
>> INSIGHTS What's next for parallel hardware, programming and related areas?
>> Interviews and blogs by thought leaders keep you ahead of the curve.
>> http://goparallel.sourceforge.net
>> _______________________________________________
>> QuantLib-dev mailing list
>> Qua...@li...
>> https://lists.sourceforge.net/lists/listinfo/quantlib-dev
>>

 

[Quantlib-dev] Historical back testing

[colman <col...@gm...>]

- Using stock data 

I would like to know how to get the quantlib up and running with some
collected time series data. There exists a "timeseries.hpp", it would be
nice to see an example on how to make the most of that. Does anyone have a
suggest how to get started in this way with the library. It has been up and
running in my system for a while, however without *good doc's its difficult
to get the most out of it.

Also I'm new to the mailing list here, so please inform me should this
request land in the wrong place.

Thank in advance for any help,
Colman



--
View this message in context: http://quantlib.10058.n7.nabble.com/Historical-back-testing-tp13792.html
Sent from the quantlib-dev mailing list archive at Nabble.com.

[Quantlib-dev] Exposing the BondFunctions class using SWIG.

[Simon S. <sim...@es...>]

/*
 Copyright (C) 2012 Simon Shakeshaft

 This file is part of QuantLib, a free-software/open-source library
 for financial quantitative analysts and developers - http://quantlib.org/

 QuantLib is free software: you can redistribute it and/or modify it
 under the terms of the QuantLib license.  You should have received a
 copy of the license along with this program; if not, please email
 <qua...@li...>. The license is also available online at
 <http://quantlib.org/license.shtml>.

 This program is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE.  See the license for more details.
*/

#ifndef quantlib_bond_functions_i
#define quantlib_bond_functions_i

%include bonds.i
%include common.i
%include types.i
%include daycounters.i


%{
using QuantLib::BondFunctions;

typedef boost::shared_ptr<YieldTermStructure> DiscountCurvePtr;
%}

class BondFunctions {
    #if defined(SWIGMZSCHEME) || defined(SWIGGUILE)
    %rename("start-date")                 startDate;
    %rename("maturity-date")              maturityDate;
    %rename("is-tradeable")               isTradable;
    %rename("previous-cash-flow-date")    previousCashFlowDate
    %rename("next-cash-flow-date")        nextCashFlowDate
    %rename("previous-cash-flow-amount")  previousCashFlowAmount
    %rename("next-cash-flow-amount")      nextCashFlowAmount
    %rename("previous-coupon-rate")       previousCouponRate
    %rename("next-coupon-rate")           nextCouponRate
    %rename("accrual-start-date")         accrualStartDate
    %rename("accrual-end-date")           accrualEndDate
    %rename("accrual-period")             accrualPeriod
    %rename("accrual-days")               accrualDays
    %rename("clean-price")                cleanPrice
    %rename("atm-rate")                   atmRate
    %rename("basis-point-value")          basisPointValue
    %rename("yield-value-basis-point")    yieldValueBasisPoint
    #endif
  public:
    %extend {
        static Date startDate(const BondPtr& bond) {
            return QuantLib::BondFunctions::startDate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)));
        }
        static Date maturityDate(const BondPtr& bond) {
            return QuantLib::BondFunctions::maturityDate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)));
        }
        static bool isTradable(const BondPtr& bond,
                               Date settlementDate = Date()) {
            return QuantLib::BondFunctions::isTradable(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    settlementDate);
        }
        static Date previousCashFlowDate(const BondPtr& bond,
                                         Date refDate = Date()) {
            return QuantLib::BondFunctions::previousCashFlowDate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    refDate);
        }
        static Date nextCashFlowDate(const BondPtr& bond,
                                     Date refDate = Date()) {
            return QuantLib::BondFunctions::nextCashFlowDate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    refDate);
        }
        static Real previousCashFlowAmount(const BondPtr& bond,
                                           Date refDate = Date()) {
            return QuantLib::BondFunctions::previousCashFlowAmount(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    refDate);
        }
        static Real nextCashFlowAmount(const BondPtr& bond,
                                       Date refDate = Date()) {
            return QuantLib::BondFunctions::nextCashFlowAmount(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    refDate);
        }
        static Rate previousCouponRate(const BondPtr& bond,
                                       Date settlementDate = Date()) {
            return QuantLib::BondFunctions::previousCouponRate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    settlementDate);
        }
        static Rate nextCouponRate(const BondPtr& bond,
                                   Date settlementDate = Date()) {
            return QuantLib::BondFunctions::nextCouponRate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    settlementDate);
        }
        static Date accrualStartDate(const BondPtr& bond,
                                     Date settlementDate = Date()) {
            return QuantLib::BondFunctions::accrualStartDate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    settlementDate);
        }
        static Date accrualEndDate(const BondPtr& bond,
                                   Date settlementDate = Date()) {
            return QuantLib::BondFunctions::accrualEndDate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    settlementDate);
        }
        static Time accrualPeriod(const BondPtr& bond,
                                  Date settlementDate = Date()) {
            return QuantLib::BondFunctions::accrualPeriod(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    settlementDate);
        }
        static BigInteger accrualDays(const BondPtr& bond,
                                      Date settlementDate = Date()) {
            return QuantLib::BondFunctions::accrualDays(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    settlementDate);
        }
        static Real cleanPrice(const BondPtr& bond,
                               const DiscountCurvePtr& discountCurve,
                               Date settlementDate = Date()) {
            return QuantLib::BondFunctions::cleanPrice(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    *(boost::dynamic_pointer_cast<YieldTermStructure>(discountCurve)),
                    settlementDate);
        }
        static Real bps(const BondPtr& bond,
                        const DiscountCurvePtr& discountCurve,
                        Date settlementDate = Date()) {
            return QuantLib::BondFunctions::bps(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    *(boost::dynamic_pointer_cast<YieldTermStructure>(discountCurve)),
                    settlementDate);
        }
        static Rate atmRate(const BondPtr& bond,
                            const DiscountCurvePtr& discountCurve,
                            Date settlementDate = Date(),
                            Real cleanPrice = Null<Real>()) {
            return QuantLib::BondFunctions::atmRate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    *(boost::dynamic_pointer_cast<YieldTermStructure>(discountCurve)),
                    settlementDate,
                    cleanPrice);
        }
        static Real cleanPrice(const BondPtr& bond,
                               const InterestRate& yield,
                               Date settlementDate = Date()) {
            return QuantLib::BondFunctions::cleanPrice(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    yield,
                    settlementDate);
        }
        static Real cleanPrice(const BondPtr& bond,
                               Rate yield,
                               const DayCounter& dayCounter,
                               Compounding compounding,
                               Frequency frequency,
                               Date settlementDate = Date()) {
            return QuantLib::BondFunctions::cleanPrice(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    yield,
                    dayCounter,
                    compounding,
                    frequency,
                    settlementDate);
        }
        static Real bps(const BondPtr& bond,
                        const InterestRate& yield,
                        Date settlementDate = Date()) {
            return QuantLib::BondFunctions::bps(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        settlementDate);
        }
        static Real bps(const BondPtr& bond,
                        Rate yield,
                        const DayCounter& dayCounter,
                        Compounding compounding,
                        Frequency frequency,
                        Date settlementDate = Date()) {
            return QuantLib::BondFunctions::bps(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate);
        }
        static Rate yield(const BondPtr& bond,
                          Real cleanPrice,
                          const DayCounter& dayCounter,
                          Compounding compounding,
                          Frequency frequency,
                          Date settlementDate = Date(),
                          Real accuracy = 1.0e-10,
                          Size maxIterations = 100,
                          Rate guess = 0.05) {
            return QuantLib::BondFunctions::yield(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        maxIterations,
                        guess);
        }
        static Time duration(const BondPtr& bond,
                             const InterestRate& yield,
                             Duration::Type type = Duration::Modified,
                             Date settlementDate = Date() ) {
            return QuantLib::BondFunctions::duration(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        type,
                        settlementDate);
        }
        static Time duration(const BondPtr& bond,
                        Rate yield,
                        const DayCounter& dayCounter,
                        Compounding compounding,
                        Frequency frequency,
                        Duration::Type type = Duration::Modified,
                        Date settlementDate = Date()) {
            return QuantLib::BondFunctions::yield(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate);
        }
        static Real convexity(const BondPtr& bond,
                              const InterestRate& yield,
                              Date settlementDate = Date()) {
            return QuantLib::BondFunctions::convexity(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        settlementDate);
        }
        static Real convexity(const BondPtr& bond,
                              Rate yield,
                              const DayCounter& dayCounter,
                              Compounding compounding,
                              Frequency frequency,
                              Date settlementDate = Date()) {
            return QuantLib::BondFunctions::convexity(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate);
        }
        static Real basisPointValue(const BondPtr& bond,
                                    const InterestRate& yield,
                                    Date settlementDate = Date()) {
            return QuantLib::BondFunctions::basisPointValue(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        settlementDate);
        }
        static Real basisPointValue(const BondPtr& bond,
                                    Rate yield,
                                    const DayCounter& dayCounter,
                                    Compounding compounding,
                                    Frequency frequency,
                                    Date settlementDate = Date()) {
            return QuantLib::BondFunctions::basisPointValue(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate);
        }
        static Real yieldValueBasisPoint(const BondPtr& bond,
                                         const InterestRate& yield,
                                         Date settlementDate = Date()) {
            return QuantLib::BondFunctions::yieldValueBasisPoint(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        settlementDate);
        }
        static Real yieldValueBasisPoint(const BondPtr& bond,
                                         Rate yield,
                                         const DayCounter& dayCounter,
                                         Compounding compounding,
                                         Frequency frequency,
                                         Date settlementDate = Date()) {
            return QuantLib::BondFunctions::yieldValueBasisPoint(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate);
        }
    }
};


#endif

Re: [Quantlib-dev] Markov Functional Model

[Peter C. <pca...@gm...>]

Thanks for your interest in the code, Roland, Klaus, Luigi. It may be 
worth to pull from the current HEAD from time to time, since it is still 
work in progress (already put some minor changes there ...). As I said 
any hints you might have are very very welcome.
Peter

[Quantlib-dev] credit on Saturdays

[<ja...@fr...>]

If I define CDS helpers on a Saturday. The curve ref date is then the next monday.
Now use the curve to price a coupon with that Saturday (i.e. today) placed within the coupon period, that date becomes the effective start date for the coupon and the pricing fails because of the negative time requested to the default probability (see below)

I am not saying it is a bug. Something similar happens in FI defining a reference date for an index on a Saturday and calling for a fixing which now falls before the index  ref date.
 
Anyway, all this to ask you what do you think of modifying the code below
(see: ql/termstructures/defaulttermstructure.cpp)
-------------------------------------------------------------------------------
    Probability DefaultProbabilityTermStructure::defaultProbability(
                                                     const Date& d1,
                                                     const Date& d2,
                                                     bool extrapolate) const {
        QL_REQUIRE(d1 <= d2,
                   "initial date (" << d1 << ") "
                   "later than final date (" << d2 << ")");
        Probability p1 = (d1<=referenceDate()) ? 0. : defaultProbability(d1,extrapolate);//<<<<<<<<<<
        Probability p2 = defaultProbability(d2,extrapolate);
 
        return p2 - p1;
    }
-------------------------------------------------------------------------------
and similarly for the Time version.
It bypasses the negative time check by assuming survival before the curve reference date.

What do you think?

Best regards
Pepe

Re: [Quantlib-dev] Markov Functional Model

[Klaus S. <kl...@sp...>]

Hi Peter,

impressive! ...and it will take some time to browse throw the code.

regards
 Klaus

On Sunday, December 02, 2012 09:03:54 PM Peter Caspers wrote:
> Hi,
> 
> I implemented a Markov functional model which I would like to contribute
> to the lib. I would consider the development to be something like an
> alpha version.
> 
> The model is an one factor interest rate model with a non parametric
> numeraire that can be fitted to a set of (arbitrage free) smiles on an
> option expiry grid. In addition a volatility function can be used to
> calibrate to a second instrument set (but only for one strike per
> expiry). An example would be a numeraire calibration to constant
> maturity swaption smiles which allows to recover market cms coupon
> prices. As a second instrument set atm coterminal swaptions can be
> chosen. The resulting model is then a good candidate for pricing
> callable cms swaps. The mean reversion parameter in the model is fixed,
> i.e. it can not be calibrated, but must be given externally. It can be
> used to control intertemporal correlations. References can be found in
> the documentation mentioned below.
> 
> The package comes with the model, an implementation of Kahale's method
> for arbitrage free smile extrapolation (because arbitrage free smile
> input is essential for the numeraire to calibrate) and vanilla pricing
> engines for caps and swaptions. The swaption engine can also handle
> bermudan exercise rights. At the moment all engines are based on
> numerical integration. PDE engines and more product support will follow
> soon.
> 
> You can find the code on github. I updated only the project files for
> msvc10, but it should be easy to include the relevant files in other
> enviroments. They are located in ql/experimental/models/markovfunctional.
> 
> https://github.com/pcaspers/quantlib/commit/879c0fdd4f4149facdc8e771d838acaf
> a7d6aae9
> 
> A good starting point is probably running the test-suite to which I
> added a suite for the mf model which can be found in
> test-suite/markovfunctional.xpp.
> 
> There are some changes in the ql I made, some essential for the model to
> work, others which I found worthwhile to do in the context and which
> support the test cases to run smoothly. I posted some of these changes
> on this list in the past, but I summarize all of them at the end of this
> mail.
> 
> Any feedback is highly appreciated. There is also some documentation
> available here
> 
> http://papers.ssrn.com/sol3/papers.cfm?abstract_id=2183721
> 
> Thank you and kind regards
> Peter
> 
> 
> Changes to the lib I made:
> 
> 1 ql/math/cubicinterpolation.hpp
> 
> essential for mf model, I added the Lagrange boundary condition. I
> tested against the MatLab implementation. Works fine.
> 
> 
> 2 ql/math/sabrinterpolation.hpp
> 
> not essential for mf model, but necessary for the test suite to run.
> 
> I use a derivative of swaptionvolcube1 for daily swaption smile
> calibration for quite a time now. I noticed that two problems occur from
> time to time: First, calibration is not satisfactory because of unlucky
> start values. The solution for this I implemented is not very smart, but
> it is working well and is still fast enough. Secondly (very rarely)
> calibration stops with error values. I located the problem to be the
> transformation of valid parameters to numeric error values during
> optimization. Fix is very easy.
> 
> More specifically I added a try and error method for calibration. Up to
> maxGuesses start values for the calibration are generated. If the error
> is below errorAccept the current calibration is returned immedeately
> without further tries. Otherwise the best calibration seen is returned.
> The error here may be specified to be the average error instead of the
> maximum error. The parameter transformation is adjusted to ensure that
> valid parameter values are not
> transformed into error values during calibration.
> 
> 
> 3 ql/models/calibrationhelper.xpp
> 
> not essential for mf model, but necessary for test suite to run.
> 
> I made the calibration helpers lazy objects. Seems reasonable because
> otherwise market data structures loose their lazy behaviour.
> 
> 
> 4 ql/models/model.xpp
> 
> essential for mf model. I replaced the update() call during calibration
> by generateArguments() and notifyObservers(). This allows to separate
> the smile update triggered by market data change from the numeraire
> update triggered by model volatility changes.
> The calibration to a second instrument set is faster then. Behaviour of
> existing models is not affected by this change.
> 
> 
> 5 ql/pricingengines/blackformula.xpp
> 
> not essential for mf model, but model trace output may contain false
> vega for zero strike, which I corrected.
> 
> 
> 6 ql/termstructures/volatility/optionlet/strippedoptionletadapter.xpp
> 
> not essential for mf model, but if you want to calibrate the numeraire
> to caplet smiles, you need a volatility structure returning a smile section.
> 
> I added a smile section section implementation returning a smooth spline
> interpolated smile curve. The markov functional
> model requires the volatility structure to provide a smile section. In
> addition this should be smooth in prices, at least C^1,
> to ensure smooth digital prices. I did not put much energy in this
> enhancement, just wanted to make the model work with cap smiles.
> 
> 
> 7 ql/termstructures/volatility/sabrsmilesection.xpp
> 
> not essential for mf model, but needed if you want to feed
> sabrsmilesections for numeraire calibration. I floored the strike at
> 0.1bp for volatility computation to avoid problems for strikes near zero.
> 
> 
> 8 ql/termstructures/volatility/smilesection.xpp
> 
> essential for mf model. I added some supporting functions including
> arbitrage tests and option price calculation. The best place for these
> functions seemed here.
> 
> 
> 9 ql/termstructures/volatility/swaption/swaptionvolcube1.xpp
> 
> not essential for mf model, just the same comments as under 2 apply.
> 
> I added functionality to exclude negative strikes in single smiles, so
> that the -200bp quotes can be used where reasonable. Furthermore I added
> the same functionality as in sabrinterpolation above.
> 
> 
> ----------------------------------------------------------------------------
> -- Keep yourself connected to Go Parallel:
> DESIGN Expert tips on starting your parallel project right.
> http://goparallel.sourceforge.net/
> _______________________________________________
> QuantLib-dev mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-dev

[Quantlib-dev] [ quantlib-Bugs-3588373 ] (with fix) warning C4244: std::ostream::setw() with STLPort

[SourceForge.net <no...@so...>]

Bugs item #3588373, was opened at 2012-11-18 13:55
Message generated for change (Comment added) made by lballabio
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=112740&aid=3588373&group_id=12740

Please note that this message will contain a full copy of the comment thread,
including the initial issue submission, for this request,
not just the latest update.
Category: None
Group: None
>Status: Closed
>Resolution: Fixed
Priority: 5
Private: No
Submitted By: Marcello Pietrobon (marcello-ptr)
>Assigned to: Luigi Ballabio (lballabio)
Summary: (with fix) warning C4244: std::ostream::setw() with STLPort

Initial Comment:
vs2010 with STLPort.5.2.1 and Boost.1_52
XP SP3

error:
ql/math/array.hpp(634): warning C4244: 'argument' : conversion from 'stlpd_std::streamsize' to 'int', possible loss of data
ql/math/array.hpp(635): warning C4244: 'argument' : conversion from 'stlpd_std::streamsize' to 'int', possible loss of data 
ql/math/matrix.hpp(584): warning C4244: 'argument' : conversion from 'stlpd_std::streamsize' to 'int', possible loss of data

The fix consists in providing a cast to int because required by STLPort  std::ostream::setw() when compiling with vs2010 (and quite probably all others of versions of Microsoft compilers)

So the fixes are:

ql\math\array.hpp : lines 634, 635
#ifdef _STLPORT_VERSION
            for (Size n=0; n<a.size()-1; ++n)
                out << std::setw((int)width) << a[n] << "; ";
            out << std::setw((int)width) << a.back();
#else
            for (Size n=0; n<a.size()-1; ++n)
                out << std::setw(width) << a[n] << "; ";
            out << std::setw(width) << a.back();
#endif



ql\math\matrix.hpp : lines 584
#ifdef _STLPORT_VERSION
            for (Size j=0; j<m.columns(); j++)
                out << std::setw((int)width) << m[i][j] << " ";
#else
            for (Size j=0; j<m.columns(); j++)
                out << std::setw(width) << m[i][j] << " ";
#endif



----------------------------------------------------------------------

Comment By: Luigi Ballabio (lballabio)
Date: 2012-12-03 05:24

Message:
The patch was applied to the Subversion repository.
Thank you for the report and the fix.


----------------------------------------------------------------------

You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=112740&aid=3588373&group_id=12740

[Quantlib-dev] [ quantlib-Bugs-3588369 ] (with fix) vs2010 warning C4005: 'M_PI' : macro redefinition

[SourceForge.net <no...@so...>]

Bugs item #3588369, was opened at 2012-11-18 13:11
Message generated for change (Comment added) made by lballabio
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=112740&aid=3588369&group_id=12740

Please note that this message will contain a full copy of the comment thread,
including the initial issue submission, for this request,
not just the latest update.
Category: None
Group: None
>Status: Closed
>Resolution: Fixed
Priority: 5
Private: No
Submitted By: Marcello Pietrobon (marcello-ptr)
>Assigned to: Luigi Ballabio (lballabio)
Summary: (with fix) vs2010 warning C4005: 'M_PI' : macro redefinition

Initial Comment:
vs2010 with STLPort.5.2.1 and Boost.1_52
XP SP3

I get the annoying warnings:
1>C:\Program Files\Microsoft Visual Studio 10.0\VC\include\../include/math.h(632): warning C4005: 'M_PI' : macro redefinition
1>          D:\Projs\Libraries\Public\QuantLib\QuantLib-Active\ql/mathconstants.hpp(54) : see previous definition of 'M_PI'
1>C:\Program Files\Microsoft Visual Studio 10.0\VC\include\../include/math.h(639): warning C4005: 'M_SQRT1_2' : macro redefinition
1>          D:\Projs\Libraries\Public\QuantLib\QuantLib-Active\ql/mathconstants.hpp(102) : see previous definition of 'M_SQRT1_2'

while compiling ql/utilities/dataparser.cpp
I didn't go to find out if the problem appears without STLPort too,

In syntesis this is what appears as output build with the option 'show includes':
1>  Note: including file: D:\Projs\Libraries\Public\QuantLib\QuantLib-Active\ql/utilities/dataparsers.hpp
1>  Note: including file:  D:\Projs\Libraries\Public\QuantLib\QuantLib-Active\ql/time/date.hpp
1>  Note: including file:   D:\Projs\Libraries\Public\QuantLib\QuantLib-Active\ql/time/period.hpp
1>  Note: including file:    D:\Projs\Libraries\Public\QuantLib\QuantLib-Active\ql/time/frequency.hpp
1>  Note: including file:     D:\Projs\Libraries\Public\QuantLib\QuantLib-Active\ql/qldefines.hpp
1>  Note: including file:      D:\Projs\Libraries\Bsd\Boost\Boost-Active\boost/config.hpp
1>  Note: including file:       D:\Projs\Libraries\Bsd\Boost\Boost-Active\boost/config/select_stdlib_config.hpp
1>  Note: including file:        d:\Projs\Libraries\BSD\STLPort\STLport-Active\stlport\cstddef
1>  Note: including file:         d:\Projs\Libraries\BSD\STLPort\STLport-Active\stlport\stl/_prolog.h
1>  Note: including file:          d:\Projs\Libraries\BSD\STLPort\STLport-Active\stlport\stl/debug/_debug.h
1>  Note: including file:           d:\Projs\Libraries\BSD\STLPort\STLport-Active\stlport\stl/_threads.h
1>  Note: including file:            d:\Projs\Libraries\BSD\STLPort\STLport-Active\stlport\stl/_cstdlib.h
1>  Note: including file:             d:\Projs\Libraries\BSD\STLPort\STLport-Active\stlport\stl/_cmath.h
1>  Note: including file:              C:\Program Files\Microsoft Visual Studio 10.0\VC\include\../include/cmath
1>  Note: including file:               d:\Projs\Libraries\BSD\STLPort\STLport-Active\stlport\math.h
1>  Note: including file:                C:\Program Files\Microsoft Visual Studio 10.0\VC\include\../include/math.h
	// ** defined here **
1>  Note: including file: D:\Projs\Libraries\Public\QuantLib\QuantLib-Active\ql/utilities/null.hpp
1>  Note: including file: D:\Projs\Libraries\Public\QuantLib\QuantLib-Active\ql/time/period.hpp
1>  Note: including file: D:\Projs\Libraries\Public\QuantLib\QuantLib-Active\ql/errors.hpp
1>  Note: including file: D:\Projs\Libraries\Bsd\Boost\Boost-Active\boost/lexical_cast.hpp
...
1>  Note: including file:  D:\Projs\Libraries\Bsd\Boost\Boost-Active\boost/math/special_functions/sign.hpp
...
1>  Note: including file:   D:\Projs\Libraries\Bsd\Boost\Boost-Active\boost/math/special_functions/math_fwd.hpp
...
1>  Note: including file:    D:\Projs\Libraries\Bsd\Boost\Boost-Active\boost/math/policies/policy.hpp
...
1>  Note: including file:     d:\Projs\Libraries\BSD\STLPort\STLport-Active\stlport\math.h
1>  Note: including file:      d:\Projs\Libraries\BSD\STLPort\STLport-Active\stlport\stl/_cprolog.h
1>  Note: including file:       d:\Projs\Libraries\BSD\STLPort\STLport-Active\stlport\stl/config/_prolog.h
1>  Note: including file:        d:\Projs\Libraries\BSD\STLPort\STLport-Active\stlport\stl/config/_warnings_off.h
1>  Note: including file:      C:\Program Files\Microsoft Visual Studio 10.0\VC\include\../include/math.h
1>C:\Program Files\Microsoft Visual Studio 10.0\VC\include\../include/math.h(643): warning C4005: 'M_SQRT1_2' : macro redefinition
1>          D:\Projs\Libraries\Public\QuantLib\QuantLib-Active\ql/mathconstants.hpp(103) : see previous definition of 'M_SQRT1_2'


Analysis:
	C:\Program Files\Microsoft Visual Studio 10.0\VC\include\../include/math.h
	is included twice, but the first time M_PI doesnt get defined
	then D:\Projs\Libraries\Public\QuantLib\QuantLib-Active\ql\mathconstants.hpp is included
	and then again (the 2nd time)
	C:\Program Files\Microsoft Visual Studio 10.0\VC\include\../include/math.h
	but this time with the macro _USE_MATH_DEFINES defined (see note in math.h)
	and here we get the warning message.

Solution:
	In ql\utilities\dataparsers.cpp
	before 
	#include <ql/utilities/dataparsers.hpp>
	add the following lines:
#ifdef _MSC_VER // MP-
#  define _USE_MATH_DEFINES
//#  include <math.h> // not necessary
#endif // MP-

To #include <math.h> is not necessary because dataparsers.hpp indirectly already includes it
	before ql\mathconstants.hpp gets included.





----------------------------------------------------------------------

>Comment By: Luigi Ballabio (lballabio)
Date: 2012-12-03 03:40

Message:
Thanks.  I've applied your patch in qldefines.hpp so that it applies
globally (just in case the same problem surfaces in another file).


----------------------------------------------------------------------

You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=112740&aid=3588369&group_id=12740

Re: [Quantlib-dev] Small error in QuantLibXL (leg.xml)

[Luigi B. <lui...@gm...>]

Fixed, thanks.

Luigi

On Fri, Oct 19, 2012 at 6:49 PM, Sebastian Poloczek
<Seb...@gm...> wrote:
>
> Hi,
>
> I do not know if this is the right place to report small errors/typos in the
> quantlib environment. Given that I don't know any other place I will post it
> here this time.
>
> In the QuantLibAddin\gensrc\metadata\functions\leg.xml the static function
> QuantLib::CashFlows::startDate is called for qlLegStartDate and
> qlLegMaturityDate. I suppose the latter is not the expected behaviour:
>   <!-- Leg Date functions -->
>
>     <Procedure name='qlLegStartDate'>
>       <description>Returns the start (i.e. first accrual) date for the given
> Leg object.</description>
>       <alias>QuantLib::CashFlows::startDate</alias>
> <<-------------------------------------------
>       <SupportedPlatforms>
>         <SupportedPlatform name='Excel'/>
>         <!--SupportedPlatform name='Cpp'/-->
>       </SupportedPlatforms>
>       <ParameterList>
>         <Parameters>
>           <Parameter name='ObjectId'>
>             <type>QuantLib::Leg</type>
>             <superType>underlyingClass</superType>
>             <tensorRank>scalar</tensorRank>
>             <description>id of existing QuantLib::Leg object</description>
>           </Parameter>
>         </Parameters>
>       </ParameterList>
>       <ReturnValue>
>         <type>QuantLib::Date</type>
>         <tensorRank>scalar</tensorRank>
>       </ReturnValue>
>     </Procedure>
>
>     <Procedure name='qlLegMaturityDate'>
>       <description>Returns the maturity (i.e. last payment) date for the
> given Leg object.</description>
>       <alias>QuantLib::CashFlows::startDate</alias>
> <<----------------------------------------------
>       <SupportedPlatforms>
>         <SupportedPlatform name='Excel'/>
>         <!--SupportedPlatform name='Cpp'/-->
>       </SupportedPlatforms>
>       <ParameterList>
>         <Parameters>
>           <Parameter name='ObjectId'>
>             <type>QuantLib::Leg</type>
>             <superType>underlyingClass</superType>
>             <tensorRank>scalar</tensorRank>
>             <description>id of existing QuantLib::Leg object</description>
>           </Parameter>
>         </Parameters>
>       </ParameterList>
>       <ReturnValue>
>         <type>QuantLib::Date</type>
>         <tensorRank>scalar</tensorRank>
>       </ReturnValue>
>     </Procedure>
>
> Regards,
>
> Sebastian
>
> --
> View this message in context: http://old.nabble.com/Small-error-in-QuantLibXL-%28leg.xml%29-tp34576796p34576796.html
> Sent from the quantlib-dev mailing list archive at Nabble.com.
>
>
> ------------------------------------------------------------------------------
> Everyone hates slow websites. So do we.
> Make your web apps faster with AppDynamics
> Download AppDynamics Lite for free today:
> http://p.sf.net/sfu/appdyn_sfd2d_oct
> _______________________________________________
> QuantLib-dev mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-dev

Re: [Quantlib-dev] Markov Functional Model

[Roland L. <rol...@go...>]

Hi Peter,

great! I will have a look at it over Christmas and come back to you in January.

Best wishes,
Roland

On 2 Dec 2012, at 21:03, Peter Caspers wrote:

> Hi,
> 
> I implemented a Markov functional model which I would like to contribute 
> to the lib. I would consider the development to be something like an 
> alpha version.
> 
> The model is an one factor interest rate model with a non parametric 
> numeraire that can be fitted to a set of (arbitrage free) smiles on an 
> option expiry grid. In addition a volatility function can be used to 
> calibrate to a second instrument set (but only for one strike per 
> expiry). An example would be a numeraire calibration to constant 
> maturity swaption smiles which allows to recover market cms coupon 
> prices. As a second instrument set atm coterminal swaptions can be 
> chosen. The resulting model is then a good candidate for pricing 
> callable cms swaps. The mean reversion parameter in the model is fixed, 
> i.e. it can not be calibrated, but must be given externally. It can be 
> used to control intertemporal correlations. References can be found in 
> the documentation mentioned below.
> 
> The package comes with the model, an implementation of Kahale's method 
> for arbitrage free smile extrapolation (because arbitrage free smile 
> input is essential for the numeraire to calibrate) and vanilla pricing 
> engines for caps and swaptions. The swaption engine can also handle 
> bermudan exercise rights. At the moment all engines are based on 
> numerical integration. PDE engines and more product support will follow 
> soon.
> 
> You can find the code on github. I updated only the project files for 
> msvc10, but it should be easy to include the relevant files in other 
> enviroments. They are located in ql/experimental/models/markovfunctional.
> 
> https://github.com/pcaspers/quantlib/commit/879c0fdd4f4149facdc8e771d838acafa7d6aae9
> 
> A good starting point is probably running the test-suite to which I 
> added a suite for the mf model which can be found in 
> test-suite/markovfunctional.xpp.
> 
> There are some changes in the ql I made, some essential for the model to 
> work, others which I found worthwhile to do in the context and which 
> support the test cases to run smoothly. I posted some of these changes 
> on this list in the past, but I summarize all of them at the end of this 
> mail.
> 
> Any feedback is highly appreciated. There is also some documentation 
> available here
> 
> http://papers.ssrn.com/sol3/papers.cfm?abstract_id=2183721
> 
> Thank you and kind regards
> Peter
> 
> 
> Changes to the lib I made:
> 
> 1 ql/math/cubicinterpolation.hpp
> 
> essential for mf model, I added the Lagrange boundary condition. I 
> tested against the MatLab implementation. Works fine.
> 
> 
> 2 ql/math/sabrinterpolation.hpp
> 
> not essential for mf model, but necessary for the test suite to run.
> 
> I use a derivative of swaptionvolcube1 for daily swaption smile 
> calibration for quite a time now. I noticed that two problems occur from 
> time to time: First, calibration is not satisfactory because of unlucky 
> start values. The solution for this I implemented is not very smart, but 
> it is working well and is still fast enough. Secondly (very rarely) 
> calibration stops with error values. I located the problem to be the 
> transformation of valid parameters to numeric error values during 
> optimization. Fix is very easy.
> 
> More specifically I added a try and error method for calibration. Up to 
> maxGuesses start values for the calibration are generated. If the error 
> is below errorAccept the current calibration is returned immedeately 
> without further tries. Otherwise the best calibration seen is returned. 
> The error here may be specified to be the average error instead of the 
> maximum error. The parameter transformation is adjusted to ensure that 
> valid parameter values are not
> transformed into error values during calibration.
> 
> 
> 3 ql/models/calibrationhelper.xpp
> 
> not essential for mf model, but necessary for test suite to run.
> 
> I made the calibration helpers lazy objects. Seems reasonable because 
> otherwise market data structures loose their lazy behaviour.
> 
> 
> 4 ql/models/model.xpp
> 
> essential for mf model. I replaced the update() call during calibration 
> by generateArguments() and notifyObservers(). This allows to separate
> the smile update triggered by market data change from the numeraire 
> update triggered by model volatility changes.
> The calibration to a second instrument set is faster then. Behaviour of 
> existing models is not affected by this change.
> 
> 
> 5 ql/pricingengines/blackformula.xpp
> 
> not essential for mf model, but model trace output may contain false 
> vega for zero strike, which I corrected.
> 
> 
> 6 ql/termstructures/volatility/optionlet/strippedoptionletadapter.xpp
> 
> not essential for mf model, but if you want to calibrate the numeraire 
> to caplet smiles, you need a volatility structure returning a smile section.
> 
> I added a smile section section implementation returning a smooth spline 
> interpolated smile curve. The markov functional
> model requires the volatility structure to provide a smile section. In 
> addition this should be smooth in prices, at least C^1,
> to ensure smooth digital prices. I did not put much energy in this 
> enhancement, just wanted to make the model work with cap smiles.
> 
> 
> 7 ql/termstructures/volatility/sabrsmilesection.xpp
> 
> not essential for mf model, but needed if you want to feed 
> sabrsmilesections for numeraire calibration. I floored the strike at 
> 0.1bp for volatility computation to avoid problems for strikes near zero.
> 
> 
> 8 ql/termstructures/volatility/smilesection.xpp
> 
> essential for mf model. I added some supporting functions including 
> arbitrage tests and option price calculation. The best place for these 
> functions seemed here.
> 
> 
> 9 ql/termstructures/volatility/swaption/swaptionvolcube1.xpp
> 
> not essential for mf model, just the same comments as under 2 apply.
> 
> I added functionality to exclude negative strikes in single smiles, so 
> that the -200bp quotes can be used where reasonable. Furthermore I added 
> the same functionality as in sabrinterpolation above.
> 
> 
> ------------------------------------------------------------------------------
> Keep yourself connected to Go Parallel: 
> DESIGN Expert tips on starting your parallel project right.
> http://goparallel.sourceforge.net/
> _______________________________________________
> QuantLib-dev mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-dev

Re: [Quantlib-dev] Markov Functional Model

[Luigi B. <lui...@gm...>]

Thanks Peter, I'll try and have a look.

Luigi

On Sun, Dec 2, 2012 at 9:03 PM, Peter Caspers <pca...@gm...> wrote:
> Hi,
>
> I implemented a Markov functional model which I would like to contribute
> to the lib. I would consider the development to be something like an
> alpha version.
>
> The model is an one factor interest rate model with a non parametric
> numeraire that can be fitted to a set of (arbitrage free) smiles on an
> option expiry grid. In addition a volatility function can be used to
> calibrate to a second instrument set (but only for one strike per
> expiry). An example would be a numeraire calibration to constant
> maturity swaption smiles which allows to recover market cms coupon
> prices. As a second instrument set atm coterminal swaptions can be
> chosen. The resulting model is then a good candidate for pricing
> callable cms swaps. The mean reversion parameter in the model is fixed,
> i.e. it can not be calibrated, but must be given externally. It can be
> used to control intertemporal correlations. References can be found in
> the documentation mentioned below.
>
> The package comes with the model, an implementation of Kahale's method
> for arbitrage free smile extrapolation (because arbitrage free smile
> input is essential for the numeraire to calibrate) and vanilla pricing
> engines for caps and swaptions. The swaption engine can also handle
> bermudan exercise rights. At the moment all engines are based on
> numerical integration. PDE engines and more product support will follow
> soon.
>
> You can find the code on github. I updated only the project files for
> msvc10, but it should be easy to include the relevant files in other
> enviroments. They are located in ql/experimental/models/markovfunctional.
>
> https://github.com/pcaspers/quantlib/commit/879c0fdd4f4149facdc8e771d838acafa7d6aae9
>
> A good starting point is probably running the test-suite to which I
> added a suite for the mf model which can be found in
> test-suite/markovfunctional.xpp.
>
> There are some changes in the ql I made, some essential for the model to
> work, others which I found worthwhile to do in the context and which
> support the test cases to run smoothly. I posted some of these changes
> on this list in the past, but I summarize all of them at the end of this
> mail.
>
> Any feedback is highly appreciated. There is also some documentation
> available here
>
> http://papers.ssrn.com/sol3/papers.cfm?abstract_id=2183721
>
> Thank you and kind regards
> Peter
>
>
> Changes to the lib I made:
>
> 1 ql/math/cubicinterpolation.hpp
>
> essential for mf model, I added the Lagrange boundary condition. I
> tested against the MatLab implementation. Works fine.
>
>
> 2 ql/math/sabrinterpolation.hpp
>
> not essential for mf model, but necessary for the test suite to run.
>
> I use a derivative of swaptionvolcube1 for daily swaption smile
> calibration for quite a time now. I noticed that two problems occur from
> time to time: First, calibration is not satisfactory because of unlucky
> start values. The solution for this I implemented is not very smart, but
> it is working well and is still fast enough. Secondly (very rarely)
> calibration stops with error values. I located the problem to be the
> transformation of valid parameters to numeric error values during
> optimization. Fix is very easy.
>
> More specifically I added a try and error method for calibration. Up to
> maxGuesses start values for the calibration are generated. If the error
> is below errorAccept the current calibration is returned immedeately
> without further tries. Otherwise the best calibration seen is returned.
> The error here may be specified to be the average error instead of the
> maximum error. The parameter transformation is adjusted to ensure that
> valid parameter values are not
> transformed into error values during calibration.
>
>
> 3 ql/models/calibrationhelper.xpp
>
> not essential for mf model, but necessary for test suite to run.
>
> I made the calibration helpers lazy objects. Seems reasonable because
> otherwise market data structures loose their lazy behaviour.
>
>
> 4 ql/models/model.xpp
>
> essential for mf model. I replaced the update() call during calibration
> by generateArguments() and notifyObservers(). This allows to separate
> the smile update triggered by market data change from the numeraire
> update triggered by model volatility changes.
> The calibration to a second instrument set is faster then. Behaviour of
> existing models is not affected by this change.
>
>
> 5 ql/pricingengines/blackformula.xpp
>
> not essential for mf model, but model trace output may contain false
> vega for zero strike, which I corrected.
>
>
> 6 ql/termstructures/volatility/optionlet/strippedoptionletadapter.xpp
>
> not essential for mf model, but if you want to calibrate the numeraire
> to caplet smiles, you need a volatility structure returning a smile section.
>
> I added a smile section section implementation returning a smooth spline
> interpolated smile curve. The markov functional
> model requires the volatility structure to provide a smile section. In
> addition this should be smooth in prices, at least C^1,
> to ensure smooth digital prices. I did not put much energy in this
> enhancement, just wanted to make the model work with cap smiles.
>
>
> 7 ql/termstructures/volatility/sabrsmilesection.xpp
>
> not essential for mf model, but needed if you want to feed
> sabrsmilesections for numeraire calibration. I floored the strike at
> 0.1bp for volatility computation to avoid problems for strikes near zero.
>
>
> 8 ql/termstructures/volatility/smilesection.xpp
>
> essential for mf model. I added some supporting functions including
> arbitrage tests and option price calculation. The best place for these
> functions seemed here.
>
>
> 9 ql/termstructures/volatility/swaption/swaptionvolcube1.xpp
>
> not essential for mf model, just the same comments as under 2 apply.
>
> I added functionality to exclude negative strikes in single smiles, so
> that the -200bp quotes can be used where reasonable. Furthermore I added
> the same functionality as in sabrinterpolation above.
>
>
> ------------------------------------------------------------------------------
> Keep yourself connected to Go Parallel:
> DESIGN Expert tips on starting your parallel project right.
> http://goparallel.sourceforge.net/
> _______________________________________________
> QuantLib-dev mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-dev

[Quantlib-dev] Markov Functional Model

[Peter C. <pca...@gm...>]

Hi,

I implemented a Markov functional model which I would like to contribute 
to the lib. I would consider the development to be something like an 
alpha version.

The model is an one factor interest rate model with a non parametric 
numeraire that can be fitted to a set of (arbitrage free) smiles on an 
option expiry grid. In addition a volatility function can be used to 
calibrate to a second instrument set (but only for one strike per 
expiry). An example would be a numeraire calibration to constant 
maturity swaption smiles which allows to recover market cms coupon 
prices. As a second instrument set atm coterminal swaptions can be 
chosen. The resulting model is then a good candidate for pricing 
callable cms swaps. The mean reversion parameter in the model is fixed, 
i.e. it can not be calibrated, but must be given externally. It can be 
used to control intertemporal correlations. References can be found in 
the documentation mentioned below.

The package comes with the model, an implementation of Kahale's method 
for arbitrage free smile extrapolation (because arbitrage free smile 
input is essential for the numeraire to calibrate) and vanilla pricing 
engines for caps and swaptions. The swaption engine can also handle 
bermudan exercise rights. At the moment all engines are based on 
numerical integration. PDE engines and more product support will follow 
soon.

You can find the code on github. I updated only the project files for 
msvc10, but it should be easy to include the relevant files in other 
enviroments. They are located in ql/experimental/models/markovfunctional.

https://github.com/pcaspers/quantlib/commit/879c0fdd4f4149facdc8e771d838acafa7d6aae9

A good starting point is probably running the test-suite to which I 
added a suite for the mf model which can be found in 
test-suite/markovfunctional.xpp.

There are some changes in the ql I made, some essential for the model to 
work, others which I found worthwhile to do in the context and which 
support the test cases to run smoothly. I posted some of these changes 
on this list in the past, but I summarize all of them at the end of this 
mail.

Any feedback is highly appreciated. There is also some documentation 
available here

http://papers.ssrn.com/sol3/papers.cfm?abstract_id=2183721

Thank you and kind regards
Peter


Changes to the lib I made:

1 ql/math/cubicinterpolation.hpp

essential for mf model, I added the Lagrange boundary condition. I 
tested against the MatLab implementation. Works fine.


2 ql/math/sabrinterpolation.hpp

not essential for mf model, but necessary for the test suite to run.

I use a derivative of swaptionvolcube1 for daily swaption smile 
calibration for quite a time now. I noticed that two problems occur from 
time to time: First, calibration is not satisfactory because of unlucky 
start values. The solution for this I implemented is not very smart, but 
it is working well and is still fast enough. Secondly (very rarely) 
calibration stops with error values. I located the problem to be the 
transformation of valid parameters to numeric error values during 
optimization. Fix is very easy.

More specifically I added a try and error method for calibration. Up to 
maxGuesses start values for the calibration are generated. If the error 
is below errorAccept the current calibration is returned immedeately 
without further tries. Otherwise the best calibration seen is returned. 
The error here may be specified to be the average error instead of the 
maximum error. The parameter transformation is adjusted to ensure that 
valid parameter values are not
transformed into error values during calibration.


3 ql/models/calibrationhelper.xpp

not essential for mf model, but necessary for test suite to run.

I made the calibration helpers lazy objects. Seems reasonable because 
otherwise market data structures loose their lazy behaviour.


4 ql/models/model.xpp

essential for mf model. I replaced the update() call during calibration 
by generateArguments() and notifyObservers(). This allows to separate
the smile update triggered by market data change from the numeraire 
update triggered by model volatility changes.
The calibration to a second instrument set is faster then. Behaviour of 
existing models is not affected by this change.


5 ql/pricingengines/blackformula.xpp

not essential for mf model, but model trace output may contain false 
vega for zero strike, which I corrected.


6 ql/termstructures/volatility/optionlet/strippedoptionletadapter.xpp

not essential for mf model, but if you want to calibrate the numeraire 
to caplet smiles, you need a volatility structure returning a smile section.

I added a smile section section implementation returning a smooth spline 
interpolated smile curve. The markov functional
model requires the volatility structure to provide a smile section. In 
addition this should be smooth in prices, at least C^1,
to ensure smooth digital prices. I did not put much energy in this 
enhancement, just wanted to make the model work with cap smiles.


7 ql/termstructures/volatility/sabrsmilesection.xpp

not essential for mf model, but needed if you want to feed 
sabrsmilesections for numeraire calibration. I floored the strike at 
0.1bp for volatility computation to avoid problems for strikes near zero.


8 ql/termstructures/volatility/smilesection.xpp

essential for mf model. I added some supporting functions including 
arbitrage tests and option price calculation. The best place for these 
functions seemed here.


9 ql/termstructures/volatility/swaption/swaptionvolcube1.xpp

not essential for mf model, just the same comments as under 2 apply.

I added functionality to exclude negative strikes in single smiles, so 
that the -200bp quotes can be used where reasonable. Furthermore I added 
the same functionality as in sabrinterpolation above.