quantlib-dev — Discussion of QuantLib development

Re: [Quantlib-dev] what is the ql swig download url?

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

On May 21, 2010, at 5:54 PM, Irakli Machabeli wrote:

> Sorry for stupid question but what is the link for ql swig?

 From the download page on Sourceforge (<http://sourceforge.net/projects/quantlib/files/ 
 >) expand the "QuantLib" folder, then "1.0", then "bindings".

Luigi

[Quantlib-dev] Generalized Hull-White model problems

[Alexander L. <ale...@go...>]

Hello Javit,

I found the Generalized Hull-White model checked by Luigi into the trunk a
couple of months ago.

As you told me, the newest version was (see .zip file):
http://old.nabble.com/Generalized-Hull-White-model-with-non-constant-parameters-td26287370.html#a26635940

The last version in trunk on sourceforge as far as I know 17226. This
version have some differences to the version you posted in that archive in
december 2009.

There is also no examples in the current trunk of the QuantLib, which
contains your version of BermudanSwaptions or some code for the test-suite. 

There is no a version of PiecewiseConstantParameter2 as you proposed to
implement. So, without this change, I couldn't get the current trunk version
to run without run-time error (vector subscript out of range). As I added
this class, I got the current version to run, but calibration took me too
long to wait.

To be simple:

trunk version (quick check
http://quantlib.svn.sourceforge.net/viewvc/quantlib/trunk/QuantLib/ql/experimental/shortrate/)

generalizedhullwhite.cpp

...
a_ = PiecewiseConstantParameter(speedperiods_, PositiveConstraint());
...

your version in the zip file

a_ = PiecewiseConstantParameter2(speedperiods_, PositiveConstraint());

I reduced the TimeGrid from 30 to 1 as you proposed (see your
BermudanSwaption example):

// Building time-grid
TimeGrid grid(times.begin(), times.end(), 1);

The calibration still take too long, never comes back.

I get stuck here on calibrateModel:

---------------------------------------
	std::cout << "Generalized Hull-White calibration" << std::endl;
        for (i=0; i<swaptions.size(); i++)
            swaptions[i]->setPricingEngine(boost::shared_ptr<PricingEngine>(
                                      new
TreeSwaptionEngine(generalizedHWmodel, grid)));

		calibrateModel(generalizedHWmodel, swaptions);

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

I tried 

 // Building time-grid
        TimeGrid grid(times.begin(), times.end(), 30);

as well as

 // Building time-grid
        TimeGrid grid(times.begin(), times.end(), 1);

Any suggestions?

I would like to assist on this issues and get the trunk version to work
properly. We could also add the sample to the BermudanSwaption and
test-suite as well. 

Please correct me if I missed something.

Take care

Alex
-- 
View this message in context: http://old.nabble.com/Generalized-Hull-White-model-problems-tp28647789p28647789.html
Sent from the quantlib-dev mailing list archive at Nabble.com.

[Quantlib-dev] what is the ql swig download url?

[Irakli M. <ima...@ho...>]

Sorry for stupid question but what is the link for ql swig? 

[Quantlib-dev] [ quantlib-Bugs-3004009 ] Excel function qlFixedRateBondHelper is deprecated

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

Bugs item #3004009, was opened at 2010-05-19 13:28
Message generated for change (Tracker Item Submitted) made by wasix
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=112740&aid=3004009&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: Open
Resolution: None
Priority: 5
Private: No
Submitted By: Wasi (wasix)
Assigned to: Nobody/Anonymous (nobody)
Summary: Excel function qlFixedRateBondHelper  is deprecated

Initial Comment:
Problem:
The Excel function qlFixedRateBondHelper in QuantlibXL Version 1.0b3
produces an error messsage: "qlFixedRateBondHelper - Boost assertion
failed: px != 0" which is due to an uninitialized bond parameter in the
BondHelper constructor.

Solution:
The function qlfixedratebondhelper is deprecated and 
will or should be removed in the coming version. The new function is qlBondHelper.

One can create a fixed rate bond using qlFixedRateBond and forward this 
object to qlBondHelper. This should be the same financial construct.

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

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

[Quantlib-dev] [ quantlib-Patches-3003152 ] Array.hpp extension with a typedef for size_type

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

Patches item #3003152, was opened at 2010-05-18 10:15
Message generated for change (Tracker Item Submitted) made by kimtang
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=312740&aid=3003152&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: Open
Resolution: None
Priority: 5
Private: No
Submitted By: Kim Tang (kimtang)
Assigned to: Nobody/Anonymous (nobody)
Summary: Array.hpp extension with a typedef for size_type

Initial Comment:
Hi all,

since class Array is there to model a sequence, it should also provide a size_type to indicate the return_type of the member function size().
This is also often needed to write generic algorithm with sequences as input.



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

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

[Quantlib-dev] [ quantlib-Patches-3003124 ] Array.hpp extension with a typedef for size_type

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

Patches item #3003124, was opened at 2010-05-18 09:01
Message generated for change (Tracker Item Submitted) made by kimtang
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=312740&aid=3003124&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: Open
Resolution: None
Priority: 5
Private: No
Submitted By: Kim Tang (kimtang)
Assigned to: Nobody/Anonymous (nobody)
Summary: Array.hpp extension with a typedef for size_type

Initial Comment:
Hi all,

since class Array is there to model a sequence, it should also provide a size_type to indicate the return_type of the member function size().
This is also often needed to write generic algorithm with sequences as input.



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

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

Re: [Quantlib-dev] Basis functions for Longstaff-Schwartz method

[Kakhkhor A. <kab...@gm...>]

Both versions are equivalent,  because default constractor for numeric
types is equivalent to setting to 0. But in the final version of the
code it doesn't matter, since x is overwritten through assignment
inside the nested loop.


On Sat, May 15, 2010 at 5:10 PM, Klaus Spanderen <kl...@sp...> wrote:
> Hi
>
> short question, shouldn't it be
>             std::vector<Size> x(dim, 0u);
> instead of
>             std::vector<Size> x(dim);
>
> I guess C++ vector aren't initialized by zero by default(?)
>
> regards
>  Klaus
>
> On Friday 14 May 2010 03:30:19 Kakhkhor Abdijalilov wrote:
>> It seems that increasing the threshold in std::find_if algorithm
>> doesn't solve the problem. I tried it with very high threshold and
>> there are still many more basis functions than needed. The basis set
>> size is the same as it is reported in my original message. I guess
>> "remove-o-zap" works correctly, but something else goes wrong. The
>> correct number of basis functions should be (Dim+Order-1)! / [
>> (Dim-1)! * Order!] and it shouldn't depend on polynomial type.
>>
>> To fix the problem I implemented different basis generation algorithm
>> which is described below.
>>
>> The idea is to build multi-factor basis set by multiplying together
>> single factor basis functions.
>> Let's say we have the single factor basis:
>>
>> F_0(.), F_1(.), F_2(.),...
>>
>> and we want to build a 3-dimensional basis set. In order to build the
>> order N basis set, we need all terms of the type
>> F_i(x)*F_j*(y)*F_k(z)  such that i+j+k <= N. We first compute all
>> tuples (i, j, k) such that i+j+k <= N and then generate the basis set
>> from those tuples. This would avoid duplicates if the tuple set
>> contains only unique elements. The required tuple set can be generated
>> by the following induction algorithm:
>>
>> Assume that we have all order N (i.e. i+j+k = N) tuples. In order to
>> build order N+1 tuples do the following:
>> 1) Start with the set:  (N+1, 0, 0), (0, N+1, 0), (0, 0, N+1).
>> 2) For each tuple (i, j, k) from the order N set add the tuples (i+1,
>> j, k), (i, j+1, k+2) to the order N+1 set.
>> 3) Remove the duplicates from the order N+1 set.
>>
>> The resulting order N+1 set will contain all order N+1 tuples. The
>> function next_order_tuples implements the induction algorithm.
>> Duplicates can be avoided if  we use STL container std::set to store
>> the tuples.
>>
>> The code is below. Please feel free to ask any question you might have.
>>
>> ==================================================
>>
>> // lsmbasissystem.hpp
>>
>> #ifndef quantlib_lsm_basis_system_hpp
>> #define quantlib_lsm_basis_system_hpp
>>
>> #include <ql/qldefines.hpp>
>> #include <ql/math/array.hpp>
>> #include <boost/function.hpp>
>> #include <vector>
>>
>> namespace QuantLib {
>>
>>     class LsmBasisSystem {
>>     public:
>>         enum PolynomType { Monomial, Laguerre, Hermite, Hyperbolic,
>>                            Legendre, Chebyshev, Chebyshev2nd };
>>
>>         static std::vector<boost::function1<Real, Real> >
>>         pathBasisSystem(Size order, PolynomType polyType);
>>
>>         static std::vector<boost::function1<Real, Array> >
>>         multiPathBasisSystem(Size dim, Size order, PolynomType polyType);
>>     };
>>
>>
>> } // namespace QuantLib
>>
>> #endif
>>
>> ==================================================
>>
>> // lsmbasissystem.hpp
>>
>> #include <ql/methods/montecarlo/lsmbasissystem.hpp>
>> #include <ql/math/functional.hpp>
>> #include <ql/math/integrals/gaussianquadratures.hpp>
>> #include <boost/bind.hpp>
>> #include <set>
>> #include <numeric>
>>
>> namespace QuantLib {
>> namespace {
>>
>>     // makes typing a little easier
>>     typedef std::vector<boost::function1<Real, Real> > VF_R;
>>     typedef std::vector<boost::function1<Real, Array> > VF_A;
>>     typedef std::vector<std::vector<Size> > VV;
>>     Real (GaussianOrthogonalPolynomial::*ptr_w)(Size, Real) const =
>>         &GaussianOrthogonalPolynomial::weightedValue;
>>
>>     // pow(x, order)
>>     class MonomialFct : public std::unary_function<Real, Real> {
>>     public:
>>         MonomialFct(Size order): order_(order) {}
>>         inline Real operator()(const Real x) const {
>>             Real ret = 1.0;
>>             for(Size i=0; i<order_; ++i)
>>                 ret *= x;
>>             return ret;
>>         }
>>     private:
>>         const Size order_;
>>     };
>>
>>     /* multiplies [Real -> Real] functors
>>        to create [Array -> Real] functor */
>>     class MultiDimFct : public std::unary_function<Real, Array> {
>>     public:
>>         MultiDimFct(const VF_R b): b_(b) {
>>             QL_REQUIRE(b_.size()>0, "zero size basis");
>>         }
>>         inline Real operator()(const Array& a) const {
>>             #if defined(QL_EXTRA_SAFETY_CHECKS)
>>             QL_REQUIRE(b_.size()==a.size(), "wrong argument size");
>>             #endif
>>             Real ret = b_[0].operator()(a[0]);
>>             for(Size i=1; i<b_.size(); ++i)
>>                 ret *= b_[i].operator()(a[i]);
>>             return ret;
>>         }
>>     private:
>>         const VF_R b_;
>>     };
>>
>>     // constant functor [Real -> Real] (returns 1.0)
>>     class MultiDimConstFct : public std::unary_function<Real, Array> {
>>     public:
>>         MultiDimConstFct(Size dim): dim_(dim) {
>>             QL_REQUIRE(dim>0, "zero dimension");
>>         }
>>         inline Real operator()(const Array& a) const {
>>             #if defined(QL_EXTRA_SAFETY_CHECKS)
>>             QL_REQUIRE(dim_==a.size(), "wrong argument size");
>>             #endif
>>             return 1.0;
>>         }
>>     private:
>>         const Size dim_;
>>     };
>>
>>     // check size and order of tuples
>>     void check_tuples(const VV& v, Size dim, Size order) {
>>         for(Size i=0; i<v.size(); ++i) {
>>             QL_REQUIRE(dim==v[i].size(), "wrong tuple size");
>>             QL_REQUIRE(order==std::accumulate(v[i].begin(), v[i].end(), 0),
>>                 "wrong tuple order");
>>         }
>>     }
>>
>>     // build order N+1 tuples from order N tuples
>>     VV next_order_tuples(const VV& v) {
>>         const Size order = std::accumulate(v[0].begin(), v[0].end(), 0);
>>         const Size dim = v[0].size();
>>
>>         check_tuples(v, dim, order);
>>
>>         // the set of unique tuples
>>         std::set<std::vector<Size> > tuples;
>>
>>         for(Size i=0; i<dim; ++i) {
>>             // order+1 for i-th dimension, the rest is 0
>>             std::vector<Size> x(dim);
>>             x[i] += order+1;
>>             tuples.insert(x);
>>             // increase i-th value in every tuple by 1
>>             for(Size j=0; j<v.size(); ++j) {
>>                 x = v[j];
>>                 x[i] += 1;
>>                 tuples.insert(x);
>>             }
>>         }
>>
>>         VV ret(tuples.begin(), tuples.end());
>>         return ret;
>>     }
>>
>> } // unnamed namespace
>>
>>     // LsmBasisSystem static methods
>>
>>     VF_R LsmBasisSystem::pathBasisSystem(Size order, PolynomType polyType)
>> { VF_R ret(order+1);
>>         for (Size i=0; i<=order; ++i) {
>>             switch (polyType) {
>>               case Monomial:
>>                 ret[i] = MonomialFct(i);
>>                 break;
>>               case Laguerre:
>>                 ret[i] = boost::bind(ptr_w, GaussLaguerrePolynomial(), i,
>> _1); break;
>>               case Hermite:
>>                 ret[i] = boost::bind(ptr_w, GaussHermitePolynomial(), i,
>> _1); break;
>>               case Hyperbolic:
>>                 ret[i] = boost::bind(ptr_w, GaussHyperbolicPolynomial(), i,
>> _1); break;
>>               case Legendre:
>>                 ret[i] = boost::bind(ptr_w, GaussLegendrePolynomial(), i,
>> _1); break;
>>               case Chebyshev:
>>                 ret[i] = boost::bind(ptr_w, GaussChebyshevPolynomial(), i,
>> _1); break;
>>               case Chebyshev2nd:
>>                 ret[i] = boost::bind(ptr_w,
>> GaussChebyshev2ndPolynomial(), i, _1);
>>                 break;
>>               default:
>>                 QL_FAIL("unknown regression type");
>>             }
>>         }
>>         return ret;
>>     }
>>
>>     VF_A LsmBasisSystem::multiPathBasisSystem(Size dim, Size order,
>> PolynomType polyType) {
>>         QL_REQUIRE(dim>0, "zero dimension");
>>         // constant function
>>         VF_A ret(1, MultiDimConstFct(dim));
>>         // get single factor basis
>>         VF_R pathBasis = pathBasisSystem(order, polyType);
>>         // start with all 0 tuple
>>         VV tuples(1, std::vector<Size>(dim));
>>         // add multi-factor terms
>>         for(Size i=1; i<=order; ++i) {
>>             tuples = next_order_tuples(tuples);
>>             // now we have all tuples of order i
>>             // for each tuple add the corresponding term
>>             for(Size j=0; j<tuples.size(); ++j) {
>>                 VF_R term(dim);
>>                 for(Size k=0; k<dim; ++k)
>>                     term[k] = pathBasis[tuples[j][k]];
>>                 ret.push_back(MultiDimFct(term));
>>             }
>>         }
>>         return ret;
>>     }
>>
>> } // namespace QuantLib
>>
>> =============================================================
>>
>> On Thu, May 13, 2010 at 6:22 PM, Klaus Spanderen <kl...@sp...> wrote:
>> > Hi
>> >
>> >> ..The size of basis is not the same for different
>> >> polynomial types.
>> >
>> > I've fixed one issue in the SVN.
>> >
>> >> .. I reworked the
>> >> implementation, so that basis sizes are the same for all polynomial
>> >> types and no duplicates are created during the process. I would like
>> >> to submit my code to QuantLib, but not sure how to do it.
>> >
>> > Please submit the code to this mailing list or via email. I'm going to
>> > merge it into the SVN.
>> >
>> > thanks in advance
>> >  Klaus
>>
>> ---------------------------------------------------------------------------
>>---
>>
>> _______________________________________________
>> QuantLib-dev mailing list
>> Qua...@li...
>> https://lists.sourceforge.net/lists/listinfo/quantlib-dev
>
>
>

Re: [Quantlib-dev] Basis functions for Longstaff-Schwartz method

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

Hi

Using your version I'm getting  the following sizes of the basis system. 

dim = 1:
order  Mnm      Lgr     Hrm     Hpr     Lgn     Chb     Chb2
0        1           1         1         1         1         1        1
1        2           2         2         2         2         2        2
2        3           3         3         3         3         3        3
3        4           4         4         4         4         4        4
4        5           5         5         5         5         5        5

dim = 2:
order  Mnm      Lgr     Hrm     Hpr     Lgn     Chb     Chb2
0        1            1         1          1         1         1         1
1        3            3         3          3         3         3         3
2        6            6         6          6         6         6         6
3        10          10       10        10       10       10       10
4        15          15       15       15       15        15       15

I guess this is what you intended. The smaller basis sets should increase the 
run time efficiency of the algorithm.

best regards
 Klaus

Re: [Quantlib-dev] Basis functions for Longstaff-Schwartz method

[Kakhkhor A. <kab...@gm...>]

It seems that increasing the threshold in std::find_if algorithm
doesn't solve the problem. I tried it with very high threshold and
there are still many more basis functions than needed. The basis set
size is the same as it is reported in my original message. I guess
"remove-o-zap" works correctly, but something else goes wrong. The
correct number of basis functions should be (Dim+Order-1)! / [
(Dim-1)! * Order!] and it shouldn't depend on polynomial type.

To fix the problem I implemented different basis generation algorithm
which is described below.

The idea is to build multi-factor basis set by multiplying together
single factor basis functions.
Let's say we have the single factor basis:

F_0(.), F_1(.), F_2(.),...

and we want to build a 3-dimensional basis set. In order to build the
order N basis set, we need all terms of the type
F_i(x)*F_j*(y)*F_k(z)  such that i+j+k <= N. We first compute all
tuples (i, j, k) such that i+j+k <= N and then generate the basis set
from those tuples. This would avoid duplicates if the tuple set
contains only unique elements. The required tuple set can be generated
by the following induction algorithm:

Assume that we have all order N (i.e. i+j+k = N) tuples. In order to
build order N+1 tuples do the following:
1) Start with the set:  (N+1, 0, 0), (0, N+1, 0), (0, 0, N+1).
2) For each tuple (i, j, k) from the order N set add the tuples (i+1,
j, k), (i, j+1, k+2) to the order N+1 set.
3) Remove the duplicates from the order N+1 set.

The resulting order N+1 set will contain all order N+1 tuples. The
function next_order_tuples implements the induction algorithm.
Duplicates can be avoided if  we use STL container std::set to store
the tuples.

The code is below. Please feel free to ask any question you might have.

==================================================

// lsmbasissystem.hpp

#ifndef quantlib_lsm_basis_system_hpp
#define quantlib_lsm_basis_system_hpp

#include <ql/qldefines.hpp>
#include <ql/math/array.hpp>
#include <boost/function.hpp>
#include <vector>

namespace QuantLib {

    class LsmBasisSystem {
    public:
        enum PolynomType { Monomial, Laguerre, Hermite, Hyperbolic,
                           Legendre, Chebyshev, Chebyshev2nd };

        static std::vector<boost::function1<Real, Real> >
        pathBasisSystem(Size order, PolynomType polyType);

        static std::vector<boost::function1<Real, Array> >
        multiPathBasisSystem(Size dim, Size order, PolynomType polyType);
    };


} // namespace QuantLib

#endif

==================================================

// lsmbasissystem.hpp

#include <ql/methods/montecarlo/lsmbasissystem.hpp>
#include <ql/math/functional.hpp>
#include <ql/math/integrals/gaussianquadratures.hpp>
#include <boost/bind.hpp>
#include <set>
#include <numeric>

namespace QuantLib {
namespace {

    // makes typing a little easier
    typedef std::vector<boost::function1<Real, Real> > VF_R;
    typedef std::vector<boost::function1<Real, Array> > VF_A;
    typedef std::vector<std::vector<Size> > VV;
    Real (GaussianOrthogonalPolynomial::*ptr_w)(Size, Real) const =
        &GaussianOrthogonalPolynomial::weightedValue;

    // pow(x, order)
    class MonomialFct : public std::unary_function<Real, Real> {
    public:
        MonomialFct(Size order): order_(order) {}
        inline Real operator()(const Real x) const {
            Real ret = 1.0;
            for(Size i=0; i<order_; ++i)
                ret *= x;
            return ret;
        }
    private:
        const Size order_;
    };

    /* multiplies [Real -> Real] functors
       to create [Array -> Real] functor */
    class MultiDimFct : public std::unary_function<Real, Array> {
    public:
        MultiDimFct(const VF_R b): b_(b) {
            QL_REQUIRE(b_.size()>0, "zero size basis");
        }
        inline Real operator()(const Array& a) const {
            #if defined(QL_EXTRA_SAFETY_CHECKS)
            QL_REQUIRE(b_.size()==a.size(), "wrong argument size");
            #endif
            Real ret = b_[0].operator()(a[0]);
            for(Size i=1; i<b_.size(); ++i)
                ret *= b_[i].operator()(a[i]);
            return ret;
        }
    private:
        const VF_R b_;
    };

    // constant functor [Real -> Real] (returns 1.0)
    class MultiDimConstFct : public std::unary_function<Real, Array> {
    public:
        MultiDimConstFct(Size dim): dim_(dim) {
            QL_REQUIRE(dim>0, "zero dimension");
        }
        inline Real operator()(const Array& a) const {
            #if defined(QL_EXTRA_SAFETY_CHECKS)
            QL_REQUIRE(dim_==a.size(), "wrong argument size");
            #endif
            return 1.0;
        }
    private:
        const Size dim_;
    };

    // check size and order of tuples
    void check_tuples(const VV& v, Size dim, Size order) {
        for(Size i=0; i<v.size(); ++i) {
            QL_REQUIRE(dim==v[i].size(), "wrong tuple size");
            QL_REQUIRE(order==std::accumulate(v[i].begin(), v[i].end(), 0),
                "wrong tuple order");
        }
    }

    // build order N+1 tuples from order N tuples
    VV next_order_tuples(const VV& v) {
        const Size order = std::accumulate(v[0].begin(), v[0].end(), 0);
        const Size dim = v[0].size();

        check_tuples(v, dim, order);

        // the set of unique tuples
        std::set<std::vector<Size> > tuples;

        for(Size i=0; i<dim; ++i) {
            // order+1 for i-th dimension, the rest is 0
            std::vector<Size> x(dim);
            x[i] += order+1;
            tuples.insert(x);
            // increase i-th value in every tuple by 1
            for(Size j=0; j<v.size(); ++j) {
                x = v[j];
                x[i] += 1;
                tuples.insert(x);
            }
        }

        VV ret(tuples.begin(), tuples.end());
        return ret;
    }

} // unnamed namespace

    // LsmBasisSystem static methods

    VF_R LsmBasisSystem::pathBasisSystem(Size order, PolynomType polyType) {
        VF_R ret(order+1);
        for (Size i=0; i<=order; ++i) {
            switch (polyType) {
              case Monomial:
                ret[i] = MonomialFct(i);
                break;
              case Laguerre:
                ret[i] = boost::bind(ptr_w, GaussLaguerrePolynomial(), i, _1);
                break;
              case Hermite:
                ret[i] = boost::bind(ptr_w, GaussHermitePolynomial(), i, _1);
                break;
              case Hyperbolic:
                ret[i] = boost::bind(ptr_w, GaussHyperbolicPolynomial(), i, _1);
                break;
              case Legendre:
                ret[i] = boost::bind(ptr_w, GaussLegendrePolynomial(), i, _1);
                break;
              case Chebyshev:
                ret[i] = boost::bind(ptr_w, GaussChebyshevPolynomial(), i, _1);
                break;
              case Chebyshev2nd:
                ret[i] = boost::bind(ptr_w,
GaussChebyshev2ndPolynomial(), i, _1);
                break;
              default:
                QL_FAIL("unknown regression type");
            }
        }
        return ret;
    }

    VF_A LsmBasisSystem::multiPathBasisSystem(Size dim, Size order,
PolynomType polyType) {
        QL_REQUIRE(dim>0, "zero dimension");
        // constant function
        VF_A ret(1, MultiDimConstFct(dim));
        // get single factor basis
        VF_R pathBasis = pathBasisSystem(order, polyType);
        // start with all 0 tuple
        VV tuples(1, std::vector<Size>(dim));
        // add multi-factor terms
        for(Size i=1; i<=order; ++i) {
            tuples = next_order_tuples(tuples);
            // now we have all tuples of order i
            // for each tuple add the corresponding term
            for(Size j=0; j<tuples.size(); ++j) {
                VF_R term(dim);
                for(Size k=0; k<dim; ++k)
                    term[k] = pathBasis[tuples[j][k]];
                ret.push_back(MultiDimFct(term));
            }
        }
        return ret;
    }

} // namespace QuantLib

=============================================================





On Thu, May 13, 2010 at 6:22 PM, Klaus Spanderen <kl...@sp...> wrote:
> Hi
>
>> ..The size of basis is not the same for different
>> polynomial types.
>
> I've fixed one issue in the SVN.
>
>> .. I reworked the
>> implementation, so that basis sizes are the same for all polynomial
>> types and no duplicates are created during the process. I would like
>> to submit my code to QuantLib, but not sure how to do it.
>
> Please submit the code to this mailing list or via email. I'm going to merge
> it into the SVN.
>
> thanks in advance
>  Klaus
>

Re: [Quantlib-dev] Basis functions for Longstaff-Schwartz method

[Kakhkhor A. <kab...@gm...>]

Sorry, in my previous message  the formula for size of basis was wrong.
(Dim+Order-1)! / [(Dim-1)! * Order!] is the number of terms of a given
order, not the basis size.

Re: [Quantlib-dev] Basis functions for Longstaff-Schwartz method

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

Hi

> ..The size of basis is not the same for different
> polynomial types.  

I've fixed one issue in the SVN. 

> .. I reworked the 
> implementation, so that basis sizes are the same for all polynomial
> types and no duplicates are created during the process. I would like
> to submit my code to QuantLib, but not sure how to do it.

Please submit the code to this mailing list or via email. I'm going to merge 
it into the SVN.

thanks in advance
 Klaus

Re: [Quantlib-dev] [ quantlib-Patches-2998216 ] Asset-or-nothing option

[Ferdinando A. <na...@am...>]

On Fri, May 7, 2010 at 5:22 PM, SourceForge.net <no...@so...> wrote:
> https://sourceforge.net/tracker/?func=detail&atid=312740&aid=2998216&group_id=12740
>
> Submitted By: Hachemi Benyahia (hachemidxp)
> Summary: Asset-or-nothing option
>
> Initial Comment:
> Digital asset-or-nothing option with an analytic engine.
> see:E.G. Haug p.175

cash-or-nothing, asset-or-nothing, and gap options are all available
in AnalyticEuropeanEngine, and Haug values are reproduced in the
test-suite.
Am I missing something about your contribution ?

ciao -- Nando

[Quantlib-dev] [ quantlib-Patches-3000492 ] Enhancements to TimeSeries class

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

Patches item #3000492, was opened at 2010-05-12 11:02
Message generated for change (Tracker Item Submitted) made by shlagbaum
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=312740&aid=3000492&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: Open
Resolution: None
Priority: 5
Private: No
Submitted By: Slava Mazur (shlagbaum)
Assigned to: Nobody/Anonymous (nobody)
Summary: Enhancements to TimeSeries class

Initial Comment:
I propose the following changes to TimeSeries class:
-- to add an extra template parameter Time with default to Date - this will allow for use of alternative data/time types (e.g. time_t);
-- to add time and value projection iterators so that one would be able to iterate through time and values independently - this feature would allow for treatment of a TimeSeries object as a simple sequence of time and/or value elemnets;
-- to add time and value iterator generating members: begin_time(), end_time(), begin_values(), end_values()

The diff of proposed changes is attached

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

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

[Quantlib-dev] Basis functions for Longstaff-Schwartz method

[Kakhkhor A. <kab...@gm...>]

Dear All,
Class LsmBasisSystem (lsmbasissystem.hpp) doesn't look good. Its
implementation uses very inefficient and probability broken method to
generate multidimensional basis functions from single factor basis
functions. It generates many duplicates and then uses "remove-o-zap"
method to remove them. The size of basis is not the same for different
polynomial types.  You can see the test results below. I reworked the
implementation, so that basis sizes are the same for all polynomial
types and no duplicates are created during the process. I would like
to submit my code to QuantLib, but not sure how to do it.

Regards,
Kakhkhor Abdijalilov.


------------------------------------------------------------------------------------------------------------------------
The number of functions returned by multiPathBasisSystem method.

In (n-m), n - size after "remove-o-zap",
m - number of functions removed by "remove-o-zap"

dimension = 1
order; Mnm; Lgr; Hrm; Hpr; Lgn; Chb; Chb2
=========================================
0; 1-0; 1-0; 1-0; 1-0; 1-0; 1-0; 1-0
1; 2-0; 1-1; 2-0; 2-0; 2-0; 2-0; 2-0
2; 3-1; 3-1; 4-0; 3-1; 4-0; 4-0; 4-0
3; 4-4; 5-3; 6-2; 4-4; 7-1; 6-2; 7-1
4; 5-11; 10-6; 10-6; 7-9; 12-4; 10-6; 12-4

dimension = 2
order; Mnm; Lgr; Hrm; Hpr; Lgn; Chb; Chb2
=========================================
0; 1-0; 1-0; 1-0; 1-0; 1-0; 1-0; 1-0
1; 3-0; 1-2; 3-0; 3-0; 3-0; 3-0; 3-0
2; 6-3; 6-3; 8-1; 6-3; 8-1; 8-1; 8-1
3; 10-17; 12-15; 16-11; 10-17; 18-9; 17-10; 18-9
4; 15-66; 32-49; 32-49; 20-61; 38-43; 35-46; 38-43

dimension = 3
order; Mnm; Lgr; Hrm; Hpr; Lgn; Chb; Chb2
=========================================
0; 1-0; 1-0; 1-0; 1-0; 1-0; 1-0; 1-0
1; 4-0; 1-3; 4-0; 4-0; 4-0; 4-0; 4-0
2; 10-6; 10-6; 13-3; 10-6; 13-3; 13-3; 13-3
3; 20-44; 22-42; 32-32; 20-44; 35-29; 34-30; 35-29
4; 35-221; 73-183; 74-182; 44-212; 86-170; 82-174; 86-170

dimension = 4
order; Mnm; Lgr; Hrm; Hpr; Lgn; Chb; Chb2
=========================================
0; 1-0; 1-0; 1-0; 1-0; 1-0; 1-0; 1-0
1; 5-0; 1-4; 5-0; 5-0; 5-0; 5-0; 5-0
2; 15-10; 15-10; 19-6; 15-10; 19-6; 19-6; 19-6
3; 35-90; 35-90; 55-70; 35-90; 59-66; 57-68; 59-66
4; 70-555; 140-485; 144-481; 84-541; 164-461; 154-471; 164-461
------------------------------------------------------------------------------------------------------------------------

[Quantlib-dev] [ quantlib-Bugs-3000039 ] qlCalendarBusinessDaysBetween

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

Bugs item #3000039, was opened at 2010-05-11 11:51
Message generated for change (Tracker Item Submitted) made by bruceken
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=112740&aid=3000039&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: Open
Resolution: None
Priority: 5
Private: No
Submitted By: bruceK (bruceken)
Assigned to: Nobody/Anonymous (nobody)
Summary: qlCalendarBusinessDaysBetween 

Initial Comment:
I have 2 dates, 5/11/2010 and 6/16/2010 days between is 26 days.  It doesn't seem to matter what flags I use for "inclusion".   The last 2 arguments are used set to TRUE or FALSE depending on the endpoints you want to include.  I've attached a real simple spreadsheet to show what I'm looking at.  The field in yellow are my dates.  The cells in green are my results.  Can anybody tell me if I'm doing something wrong?

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

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

[Quantlib-dev] [ quantlib-Bugs-3000028 ] Performance issue

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

Bugs item #3000028, was opened at 2010-05-11 11:23
Message generated for change (Tracker Item Submitted) made by bruceken
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=112740&aid=3000028&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: Open
Resolution: None
Priority: 5
Private: No
Submitted By: bruceK (bruceken)
Assigned to: Nobody/Anonymous (nobody)
Summary: Performance issue

Initial Comment:
After 10 minutes, the spreadsheet has a severe performance problems.   This spreadsheet has both Reuters and Bloomberg market data feeds.
One other thing I\'ve noticed, after minimizing the spreadsheet, the \"Task Manager\" shows \"mem usage\" of about 50,000K.  This continues to grow at 5K per minute for the rest of the day.  I also, use \"Tech hackers\" addins.  I\'ve stripped out those calls.  My apologies, if missed one.  If more explanations are needed please let me know.  (In order to get under 250k file limit, I've deleted a couple of sheets, that introduce a few errors)  Thank you for your time.

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

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

[Quantlib-dev] [ quantlib-Bugs-2999437 ] problem linking testsuite in 1.0.1

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

Bugs item #2999437, was opened at 2010-05-10 15:45
Message generated for change (Tracker Item Submitted) made by 
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=112740&aid=2999437&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: Open
Resolution: None
Priority: 5
Private: No
Submitted By: https://me.yahoo.com/a/BexvNwZm ()
Assigned to: Nobody/Anonymous (nobody)
Summary: problem linking testsuite in 1.0.1

Initial Comment:
Testsuite is looking for this library (libboost_unit_test_framework-vc80-mt-sgd-1_40.lib) and unable to find one. When I copied a corresponding library from boost/stage/lib to boost/lib, I get bunch of duplicate defination like below.


msvcprt.lib(MSVCP80.dll) : error LNK2005: "public: __thiscall std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >::~basic_string<char,struct std::char_traits<char>,class std::allocator<char> >(void)" (??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ) already defined in americanoption.obj
msvcprt.lib(MSVCP80.dll) : error LNK2005: "public: __thiscall std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const &)" (??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@ABV01@@Z) already defined in americanoption.obj

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

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

[Quantlib-dev] [ quantlib-Patches-2998228 ] Gap option

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

Patches item #2998228, was opened at 2010-05-07 17:56
Message generated for change (Tracker Item Submitted) made by hachemidxp
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=312740&aid=2998228&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: Open
Resolution: None
Priority: 5
Private: No
Submitted By: Hachemi Benyahia (hachemidxp)
Assigned to: Nobody/Anonymous (nobody)
Summary: Gap option

Initial Comment:
Digital gap option with an analytic engine.
A negative NPV is possible.
see:E.G. Haug p. 174 and 175

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

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

[Quantlib-dev] [ quantlib-Patches-2998216 ] Asset-or-nothing option

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

Patches item #2998216, was opened at 2010-05-07 17:22
Message generated for change (Tracker Item Submitted) made by hachemidxp
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=312740&aid=2998216&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: Open
Resolution: None
Priority: 5
Private: No
Submitted By: Hachemi Benyahia (hachemidxp)
Assigned to: Nobody/Anonymous (nobody)
Summary: Asset-or-nothing option

Initial Comment:
Digital asset-or-nothing option with an analytic engine.
see:E.G. Haug p.175

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

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

[Quantlib-dev] [ quantlib-Patches-2998186 ] Cash-or-nothing option

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

Patches item #2998186, was opened at 2010-05-07 16:23
Message generated for change (Tracker Item Submitted) made by hachemidxp
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=312740&aid=2998186&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: Open
Resolution: None
Priority: 5
Private: No
Submitted By: Hachemi Benyahia (hachemidxp)
Assigned to: Nobody/Anonymous (nobody)
Summary: Cash-or-nothing option

Initial Comment:
Digital cash-or-nothing option with an analytic and a integral engine.
see:E.G. Haug p. 174 and 175

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

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

Re: [Quantlib-dev] mortgage bond

[Nathan A. <nka...@gm...>]

I finish working on creating a loan class and mortgagebond class for
QuantLib. I and my user plan on submitting the classes to QuantLib, but we
want to do so clean up first. He is out of town at the moment. I do not know
when we will submit the classes, because I do not know when he will coming
back. I can give you and anybody that wants the classes a prerelease copy of
the classes. As for the database stuff I am sorry I am way to busy to help
you there.

On Fri, Apr 30, 2010 at 10:09 AM, mtgequant <tkm...@ya...> wrote:

>
> Nathan,
>
> I wanted to see if you can help me with my problem. My current
> infrastructure is one where I have a Database of loan level information. I
> have another database which are the coefficients of a Regression model that
> takes the loan level information as input and then outputs the probability
> of default, prepayment and severity. I want to create a C++ program that
> reads the data from the 1st database ( loan level information) then reads
> the second database and then runs the equation to give loan level
> probability of default, prepayment and severity for each loan. It then
> should aggregate all the probabilities into one single prepayment,default
> and loss severity curve.
>
> I heard from people that using a .dll file ( subroutine) would be the best
> approach and I wanted to see if you can help me with writing the code. I
> can
> send you the database if you want.
>
> Thanks and Regards,
>
>
>

Re: [Quantlib-dev] mortgage bond

[mtgequant <tkm...@ya...>]

Nathan,

I wanted to see if you can help me with my problem. My current
infrastructure is one where I have a Database of loan level information. I
have another database which are the coefficients of a Regression model that
takes the loan level information as input and then outputs the probability
of default, prepayment and severity. I want to create a C++ program that
reads the data from the 1st database ( loan level information) then reads
the second database and then runs the equation to give loan level
probability of default, prepayment and severity for each loan. It then
should aggregate all the probabilities into one single prepayment,default
and loss severity curve. 

I heard from people that using a .dll file ( subroutine) would be the best
approach and I wanted to see if you can help me with writing the code. I can
send you the database if you want.

Thanks and Regards, 


Nathan Abbott wrote:
> 
> I am c++ programmer that only knows the basics of quantitative finance.
> Because I have been programming with QuantLib for two years, I think I
> have
> a good understanding on how QuantLib works. Luigi Ballabio's *
> Implementing
> QuantLib *has been a great help on understanding QuantLib. I am working
> with
> a financial person who uses my program, He is fluent with quantitative
> finance, but only knows a little c++ and does not know how QuantLib works.
> 
> We want to implement a simple version of mortgage bonds through a
> MorgtageBond class that will probably inherit from the Bond class (and
> maybe
> a FixedRateMortageBond and FloatingRateMortageBond classes derived from
> the
> MortgageBond class) and would like to solicit some
> opinions/suggestions/objections.
> 
> Currently we are thinking that it will be defined similar to the
> amortizing
> bond classes (taking in a vector of nominals and dates generated outside
> of
> QuantLib), but be derived from bond (and inherit all it's functions) and
> adding specific functions to it (like weighted average life calculation).
> Has anyone already done/thought of doing something similar?
> 
> Secondly, assuming prepayments are not an issue (which for our purposes
> they
> are not), a simple mortgage bond is priced similar to corporate bonds,
> meaning as a spread over swaps (i.e. on a yield basis, yield = swap rate +
> spread), then use that sum as the yield to calculate the price. The bond
> class has dirtyPrice and cleanPrice functions which take yield as an
> input.
> We can get the par rate from the yield curve by using the parRate function
> or instantiate a simple swap (as explained in yieldtermstructure.hpp
> comments).
> 
> Our question is w.r.t the spread. We want to build a spread grid/matrix
> with
> rating on one axis/rows and maturity/columns on the other. We were
> thinking
> of creating a termspreadsurface (similar to capfloortermvolsurface) which
> could be useful for mbs and corporate bonds (spread per rating/term). Has
> anyone already done something similar?
> 
> Btw, if anybody is interested in residential prepayments/OAS calculations
> and willing to implement that or is working on that, please contact me and
> we can hopefully coordinate. Please note however that we have limited
> (almost zero) expertise on that subject.
> 
> ------------------------------------------------------------------------------
> Open Source Business Conference (OSBC), March 24-25, 2009, San Francisco,
> CA
> -OSBC tackles the biggest issue in open source: Open Sourcing the
> Enterprise
> -Strategies to boost innovation and cut costs with open source
> participation
> -Receive a $600 discount off the registration fee with the source code:
> SFAD
> http://p.sf.net/sfu/XcvMzF8H
> _______________________________________________
> QuantLib-dev mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-dev
> 
> 

-- 
View this message in context: http://old.nabble.com/mortgage-bond-tp22403757p28414564.html
Sent from the quantlib-dev mailing list archive at Nabble.com.

Re: [Quantlib-dev] BDT, HJM models

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

On Thu, 2010-04-15 at 16:47 -0400, Krishna Manchiraju wrote:
>   Can I find BDT, HJM models in QuantLib. Could someone point me to
> files or examples. Thanks.

Hi Krishna,
	what short-rate models we have are in the <ql/models/shortrate>
directory in the downloaded sources.

Luigi


-- 

A little inaccuracy sometimes saves tons of explanation. 
-- H.H. Munro, "Saki" 

Re: [Quantlib-dev] improvment of quantlib

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

On Fri, 2010-04-02 at 19:40 +0200, Stéphane Lefranc wrote:
> in the toDo list i saw that improvments are to be made in the and of
> spline implementation.
> So if someone may say to me what are the problems ill be ok to see
> what it returns about.

Hello Stéphane,
	I was hoping that whoever wrote the todo item answered, but no such
luck, it seems.

Anyway, from the todo list (just to be sure, you're referring to
<http://quantlib.org/reference/todo.html>, right?) it looks like there
are a couple of schemes and boundary conditions that are included in the
enumeration but are not in fact implemented (the class throws an
exception if asked for them.)  So there are not problems as such; it's
just that those methods should be written.

Later,
	Luigi


-- 

Hofstadter's Law: 
It always takes longer than you expect, even when you take 
Hofstadter's Law into account. 

[Quantlib-dev] [ quantlib-Feature Requests-2972966 ] COM, DLL

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

Feature Requests item #2972966, was opened at 2010-03-19 06:34
Message generated for change (Comment added) made by lballabio
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=362740&aid=2972966&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: Open
Priority: 5
Private: No
Submitted By: Eugene Lavrenov (mistral7)
Assigned to: Nobody/Anonymous (nobody)
Summary: COM, DLL

Initial Comment:
Hi people, is QuantLib available in DLL or COM? If not I will likely crete COM. Let me know if there is any inerest to add it to the project.

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

>Comment By: Luigi Ballabio (lballabio)
Date: 2010-04-28 10:00

Message:
QuantLib is not currently available in DLL or COM.
I'm not sure about the interest, though; we haven't had requests for it in
the past years.

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

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