quantlib-dev — Discussion of QuantLib development

[Quantlib-dev] [ quantlib-Patches-1035879 ] Changing Xibor to index in indexed coupon

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

Patches item #1035879, was opened at 2004-09-28 04:34
Message generated for change (Comment added) made by lballabio
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=312740&aid=1035879&group_id=12740

Category: None
Group: None
Status: Open
Resolution: None
Priority: 5
Submitted By: Daniele De Francesco (qq7te)
>Assigned to: Luigi Ballabio (lballabio)
Summary: Changing Xibor to index in indexed coupon

Initial Comment:
Hi, 

I had promised a while ago that I would send in this
patch so that IndexedCoupon would only be required to
take an Index and not necessarily a Xibor. 

All the changes seem to work in our set up, compiling
with VC 7.1 on windows. 

-Daniele

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

>Comment By: Luigi Ballabio (lballabio)
Date: 2004-09-29 09:51

Message:
Logged In: YES 
user_id=75450

Daniele,
    thanks. I'll apply the patch to the repository as soon
as I get the chance.

Later,
    Luigi


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

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

[Quantlib-dev] [ quantlib-Patches-1035879 ] Changing Xibor to index in indexed coupon

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

Patches item #1035879, was opened at 2004-09-27 22:34
Message generated for change (Tracker Item Submitted) made by Item Submitter
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=312740&aid=1035879&group_id=12740

Category: None
Group: None
Status: Open
Resolution: None
Priority: 5
Submitted By: Daniele De Francesco (qq7te)
Assigned to: Nobody/Anonymous (nobody)
Summary: Changing Xibor to index in indexed coupon

Initial Comment:
Hi, 

I had promised a while ago that I would send in this
patch so that IndexedCoupon would only be required to
take an Index and not necessarily a Xibor. 

All the changes seem to work in our set up, compiling
with VC 7.1 on windows. 

-Daniele

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

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

[Quantlib-dev] Ju engine: bug report

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

Hi Neil

Ju engine test fails under Borland (floating point error). This bug was 
present since day one, and my report is late just because I hoped to have 
time enough to take personally a look into it. I gave up :(

The same error can be reproduced with Visual C++ uncommenting lines 31 and 
32 of config.msvc.hpp

Would you take a look into it? 99% it's a division by zero, and using 
Visual Studio debug should get you to the point.

thank you

ciao -- Nando

[Quantlib-dev] [ quantlib-Bugs-1023663 ] VC6 "internal compiler error"

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

Bugs item #1023663, was opened at 2004-09-07 15:04
Message generated for change (Comment added) made by nando
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=112740&aid=1023663&group_id=12740

Category: None
Group: None
>Status: Closed
Resolution: None
Priority: 5
Submitted By: Ferdinando Ametrano (nando)
Assigned to: Nobody/Anonymous (nobody)
Summary: VC6 "internal compiler error"

Initial Comment:
I get an "internal compiler error" when compiling with 
Microsoft VC6

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

>Comment By: Ferdinando Ametrano (nando)
Date: 2004-09-07 15:05

Message:
Logged In: YES 
user_id=34616

There are 2 solutions:
a) patch your VC6 installation with Service Pack 5
b) keep your old Service Pack and just disable the "Maximize 
for speed" option for the project


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

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

[Quantlib-dev] [ quantlib-Bugs-1023663 ] VC6 "internal compiler error"

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

Bugs item #1023663, was opened at 2004-09-07 15:04
Message generated for change (Tracker Item Submitted) made by Item Submitter
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=112740&aid=1023663&group_id=12740

Category: None
Group: None
Status: Open
Resolution: None
Priority: 5
Submitted By: Ferdinando Ametrano (nando)
Assigned to: Nobody/Anonymous (nobody)
Summary: VC6 "internal compiler error"

Initial Comment:
I get an "internal compiler error" when compiling with 
Microsoft VC6

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

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

[Quantlib-dev] [ quantlib-Bugs-1021082 ] Error in InverseCumulativeNormal

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

Bugs item #1021082, was opened at 2004-09-02 03:56
Message generated for change (Tracker Item Submitted) made by Item Submitter
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=112740&aid=1021082&group_id=12740

Category: None
Group: None
Status: Open
Resolution: None
Priority: 5
Submitted By: Nobody/Anonymous (nobody)
Assigned to: Nobody/Anonymous (nobody)
Summary: Error in InverseCumulativeNormal

Initial Comment:
I get wrong values when using the class
InverseCumulativeNormal. I was expecting the result to
be zero when I tried with a Uniform value of 0.5 but
received something completely different. Luckily
MoroInverseCumulativeNormal seems to work fine though...


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

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

Re: [Quantlib-dev] Evaluation date

[Nicolas Di <nic...@fr...>]

Le lun 30/08/2004 =E0 18:51, Ferdinando Ametrano a =E9crit :
> Hi Luigi
>=20
> >I'd create some kind of singleton Settings class through which
> >the global evaluation date can be set and retrieved, as in
> >
> >Settings::instance().evaluationDate() =3D Date(30,August,2004);
> >Date d =3D Settings::instance().evaluationDate()
> >
> >The stored date would be used whenever one needs to know what day it's
> >supposed to be, and the actual today's date would be returned if none
> >was set.
> I agree

I am also agree.

--=20
Nicolas Di C=E9sar=E9 <nic...@fr...>

[Quantlib-dev] dev and users mailing lists

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

Hi all

as you probably know the quantlib-dev list is not public, but it has been 
used as private communication channel between those with CVS write-access.

We have been more restrictive lately in granting write access, and I feel 
that we have never really used the dev list that much. Besides we now have 
a very large audience on quantlib-users, and development issues are often 
discussed on the users list.

All things considered I would make quantlib-dev public, so that we have 2 
distinct public lists for people using QuantLib and people interested in 
the QL development. Any thoughts?

ciao -- Nando

Re: [Quantlib-dev] Evaluation date

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

Hi Luigi

>I'd create some kind of singleton Settings class through which
>the global evaluation date can be set and retrieved, as in
>
>Settings::instance().evaluationDate() = Date(30,August,2004);
>Date d = Settings::instance().evaluationDate()
>
>The stored date would be used whenever one needs to know what day it's
>supposed to be, and the actual today's date would be returned if none
>was set.
I agree

>  (As a side effect, todaysDate() would eventually disappear
>from TermStructure.)
the side effect alone would have me to agree :)

>Thoughts?
why don't you post to the user list too? I guess we might receive 
worthwhile suggestions.

ciao -- Nando

[Quantlib-dev] Evaluation date

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

Hi all,
	a few functions/methods need to know which date it is, or which  
date it is supposed to be for calculation purposes---e.g., a LIBOR  
index needs to know today's date in order to know whether it should  
forecast or look for past fixings; and when adding two Money instances  
with different currencies, the current date must be known in order to  
look up the correct exchange rate.  In the former case, the date  
returned by index.termStructure().todaysDate() is used (which, as Nando  
pointed out to me, is not fully satisfactory;) in the latter case,  
Date::todaysDate() is used (which is even less satisfactory.)

Instead, I'd create some kind of singleton Settings class through which  
the global evaluation date can be set and retrieved, as in

Settings::instance().evaluationDate() = Date(30,August,2004);
Date d = Settings::instance().evaluationDate()

The stored date would be used whenever one needs to know what day it's  
supposed to be, and the actual today's date would be returned if none  
was set. (As a side effect, todaysDate() would eventually disappear  
from TermStructure.)

Thoughts?

Later,
	Luigi

Re: [Quantlib-dev] Re: Bug#266454: quantlib: FTBFS with gcc-3.4: 'this->' missing

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

Andreas, Dirk,

thank you for the patch.

This has been really a timely patch as I had few email exchanges yesterday 
with Luigi, about MS VC7 not compiling QuantLib with "Language extensions" 
disabled. Luigi replied that if gcc do compile QuantLib, then it was safe 
to assume that the code was standard-compliant. So gcc 3.4 is welcome :)

Many (maybe all) the problems I had are solved with this patch.

Luigi today is away, I will wait and synch with him to apply the patch.

ciao -- Nando

At 03:03 AM 8/18/2004, Dirk Eddelbuettel wrote:

>Andreas,
>
>         Thanks for the detailed bug report and patch.  I think I won't make
>a new release quite yet given how gcc / g++ 3.3 are still the default -- and
>QuantLib may have a 0.3.8 release before we switch to 3.4.
>
>QuantLib crew,
>
>         Haven't checked with CVS whether this is already in the sources; if
>it isn't this may make a nice addition.
>
>Cheers,  Dirk
>
>On Wed, Aug 18, 2004 at 12:28:16AM +0200, Andreas Jochens wrote:
> > Package: quantlib
> > Severity: normal
> > Tags: patch
> >
> > With the attached patch 'quantlib' can be compiled using gcc-3.4.
> >
> > Regards
> > Andreas Jochens

[Quantlib-dev] Re: Bug#266454: quantlib: FTBFS with gcc-3.4: 'this->' missing

[Dirk E. <ed...@de...>]

Andreas,

	Thanks for the detailed bug report and patch.  I think I won't make
a new release quite yet given how gcc / g++ 3.3 are still the default -- and
QuantLib may have a 0.3.8 release before we switch to 3.4.

QuantLib crew,

	Haven't checked with CVS whether this is already in the sources; if
it isn't this may make a nice addition.

Cheers,  Dirk

On Wed, Aug 18, 2004 at 12:28:16AM +0200, Andreas Jochens wrote:
> Package: quantlib
> Severity: normal
> Tags: patch
> 
> With the attached patch 'quantlib' can be compiled using gcc-3.4.
> 
> Regards
> Andreas Jochens
> 
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/CashFlows/shortindexedcoupon.hpp ./ql/CashFlows/shortindexedcoupon.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/CashFlows/shortindexedcoupon.hpp	2004-05-12 11:46:10.000000000 +0200
> +++ ./ql/CashFlows/shortindexedcoupon.hpp	2004-08-18 00:06:02.164098553 +0200
> @@ -53,9 +53,9 @@
>          Real amount() const {
>              QL_FAIL("short/long indexed coupons not supported yet"
>                      " (start = " +
> -                    DateFormatter::toString(accrualStartDate_) +
> +                    DateFormatter::toString(this->accrualStartDate_) +
>                      ", end = " +
> -                    DateFormatter::toString(accrualEndDate_) + ")");
> +                    DateFormatter::toString(this->accrualEndDate_) + ")");
>          }
>      };
>  
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/Math/bicubicsplineinterpolation.hpp ./ql/Math/bicubicsplineinterpolation.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/Math/bicubicsplineinterpolation.hpp	2004-05-12 18:16:52.000000000 +0200
> +++ ./ql/Math/bicubicsplineinterpolation.hpp	2004-08-17 23:43:16.623692249 +0200
> @@ -42,16 +42,16 @@
>              : Interpolation2D::templateImpl<I1,I2,M>(xBegin,xEnd,
>                                                       yBegin,yEnd,
>                                                       zData) {
> -                for (Size i=0; i<zData_.rows(); i++)
> +                for (Size i=0; i<this->zData_.rows(); i++)
>                      splines_.push_back(NaturalCubicSpline(
> -                                           xBegin, xEnd, zData_.row_begin(i)));
> +                                           xBegin, xEnd, this->zData_.row_begin(i)));
>              }
>              Real value(Real x, Real y) const {
>                  std::vector<Real> section(splines_.size());
>                  for (Size i=0; i<splines_.size(); i++)
>                      section[i]=splines_[i](x,true);
>  
> -                NaturalCubicSpline spline(yBegin_, yEnd_, section.begin());
> +                NaturalCubicSpline spline(this->yBegin_, this->yEnd_, section.begin());
>                  return spline(y,true);
>              }
>            private:
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/Math/bilinearinterpolation.hpp ./ql/Math/bilinearinterpolation.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/Math/bilinearinterpolation.hpp	2004-05-12 18:16:52.000000000 +0200
> +++ ./ql/Math/bilinearinterpolation.hpp	2004-08-17 23:54:17.673197449 +0200
> @@ -40,15 +40,15 @@
>                                                       yBegin,yEnd,
>                                                       zData) {}
>              Real value(Real x, Real y) const {
> -                Size i = locateX(x), j = locateY(y);
> +                Size i = this->locateX(x), j = this->locateY(y);
>  
> -                Real z1=zData_[j][i];
> -                Real z2=zData_[j][i+1];
> -                Real z3=zData_[j+1][i];
> -                Real z4=zData_[j+1][i+1];
> +                Real z1=this->zData_[j][i];
> +                Real z2=this->zData_[j][i+1];
> +                Real z3=this->zData_[j+1][i];
> +                Real z4=this->zData_[j+1][i+1];
>  
> -                Real t=(x-xBegin_[i])/(xBegin_[i+1]-xBegin_[i]);
> -                Real u=(y-yBegin_[j])/(yBegin_[j+1]-yBegin_[j]);
> +                Real t=(x-this->xBegin_[i])/(this->xBegin_[i+1]-this->xBegin_[i]);
> +                Real u=(y-this->yBegin_[j])/(this->yBegin_[j+1]-this->yBegin_[j]);
>  
>                  return (1.0-t)*(1.0-u)*z1 + t*(1.0-u)*z2 
>                       + (1.0-t)*u*z3 + t*u*z4;
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/Math/cubicspline.hpp ./ql/Math/cubicspline.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/Math/cubicspline.hpp	2004-05-17 18:39:49.000000000 +0200
> +++ ./ql/Math/cubicspline.hpp	2004-08-17 21:56:04.049592153 +0200
> @@ -96,11 +96,11 @@
>                  std::vector<Real> dx(n_-1), S(n_-1);
>  
>                  Size i=0;
> -                dx[i]= xBegin_[i+1] - xBegin_[i];
> -                S[i] =(yBegin_[i+1] - yBegin_[i])/dx[i];
> +                dx[i]= this->xBegin_[i+1] - this->xBegin_[i];
> +                S[i] =(this->yBegin_[i+1] - this->yBegin_[i])/dx[i];
>                  for (i=1; i<n_-1; i++) {
> -                    dx[i]= xBegin_[i+1] - xBegin_[i];
> -                    S[i] =(yBegin_[i+1] - yBegin_[i])/dx[i];
> +                    dx[i]= this->xBegin_[i+1] - this->xBegin_[i];
> +                    S[i] =(this->yBegin_[i+1] - this->yBegin_[i])/dx[i];
>  
>                      L.setMidRow(i, dx[i], 2.0*(dx[i]+dx[i-1]), dx[i-1]);
>                      tmp[i] = 3.0*(dx[i]*S[i-1] + dx[i-1]*S[i]);
> @@ -234,30 +234,30 @@
>                  for (i=1; i<n_-1; i++) {
>                      primitiveConst_[i] = primitiveConst_[i-1]
>                          + dx[i-1] * 
> -                        (yBegin_[i-1] + dx[i-1] *
> +                        (this->yBegin_[i-1] + dx[i-1] *
>                           (a_[i-1]/2.0 + dx[i-1] *
>                            (b_[i-1]/3.0 + dx[i-1] * c_[i-1]/4.0)));
>                  }
>              }
>              Real value(Real x) const {
> -                Size j = locate(x);
> -                Real dx = x-xBegin_[j];
> -                return yBegin_[j] + dx*(a_[j] + dx*(b_[j] + dx*c_[j]));
> +                Size j = this->locate(x);
> +                Real dx = x-this->xBegin_[j];
> +                return this->yBegin_[j] + dx*(a_[j] + dx*(b_[j] + dx*c_[j]));
>              }
>              Real primitive(Real x) const {
> -                Size j = locate(x);
> -                Real dx = x-xBegin_[j];
> -                return primitiveConst_[j] + dx*(yBegin_[j] + dx*(a_[j]/2.0 
> +                Size j = this->locate(x);
> +                Real dx = x-this->xBegin_[j];
> +                return primitiveConst_[j] + dx*(this->yBegin_[j] + dx*(a_[j]/2.0 
>                                            + dx*(b_[j]/3.0 + dx*c_[j]/4.0)));
>              }
>              Real derivative(Real x) const {
> -                Size j = locate(x);
> -                Real dx = x-xBegin_[j];
> +                Size j = this->locate(x);
> +                Real dx = x-this->xBegin_[j];
>                  return a_[j] + (2.0*b_[j] + 3.0*c_[j]*dx)*dx;
>              }
>              Real secondDerivative(Real x) const {
> -                Size j = locate(x);
> -                Real dx = x-xBegin_[j];
> +                Size j = this->locate(x);
> +                Real dx = x-this->xBegin_[j];
>                  return 2.0*b_[j] + 6.0*c_[j]*dx;
>              }
>            private:
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/Math/gaussianstatistics.hpp ./ql/Math/gaussianstatistics.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/Math/gaussianstatistics.hpp	2004-05-18 15:05:24.000000000 +0200
> +++ ./ql/Math/gaussianstatistics.hpp	2004-08-17 23:58:18.389602993 +0200
> @@ -120,8 +120,8 @@
>      template<class Stat>
>      inline
>      Real GaussianStatistics<Stat>::gaussianRegret(Real target) const {
> -        Real m = mean();
> -        Real std = standardDeviation();
> +        Real m = this->mean();
> +        Real std = this->standardDeviation();
>          Real variance = std*std;
>          CumulativeNormalDistribution gIntegral(m, std);
>          NormalDistribution g(m, std);
> @@ -197,8 +197,8 @@
>                     DecimalFormatter::toString(percentile) +
>                     ") out of range [0.9, 1.0)");
>  
> -        Real m = mean();
> -        Real std = standardDeviation();
> +        Real m = this->mean();
> +        Real std = this->standardDeviation();
>          InverseCumulativeNormal gInverse(m, std);
>          Real var = gInverse(1.0-percentile);
>          NormalDistribution g(m, std);
> @@ -213,8 +213,8 @@
>      template<class Stat>
>      inline Real GaussianStatistics<Stat>::gaussianShortfall(
>                                                          Real target) const {
> -        CumulativeNormalDistribution gIntegral(mean(),
> -                                               standardDeviation());
> +        CumulativeNormalDistribution gIntegral(this->mean(),
> +                                               this->standardDeviation());
>          return gIntegral(target);
>      }
>  
> @@ -222,8 +222,8 @@
>      template<class Stat>
>      inline Real GaussianStatistics<Stat>::gaussianAverageShortfall(
>                                                          Real target) const {
> -        Real m = mean();
> -        Real std = standardDeviation();
> +        Real m = this->mean();
> +        Real std = this->standardDeviation();
>          CumulativeNormalDistribution gIntegral(m, std);
>          NormalDistribution g(m, std);
>          return ( (target-m) + std*std*g(target)/gIntegral(target) );
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/Math/linearinterpolation.hpp ./ql/Math/linearinterpolation.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/Math/linearinterpolation.hpp	2004-05-18 12:43:26.000000000 +0200
> +++ ./ql/Math/linearinterpolation.hpp	2004-08-17 23:42:27.772118817 +0200
> @@ -37,24 +37,24 @@
>                primitiveConst_(xEnd-xBegin), s_(xEnd-xBegin) {
>                  primitiveConst_[0] = 0.0;
>                  for (Size i=1; i<Size(xEnd-xBegin); i++) {
> -                    Real dx = xBegin_[i]-xBegin_[i-1];
> -                    s_[i-1] = (yBegin_[i]-yBegin_[i-1])/dx;
> +                    Real dx = this->xBegin_[i]-this->xBegin_[i-1];
> +                    s_[i-1] = (this->yBegin_[i]-this->yBegin_[i-1])/dx;
>                      primitiveConst_[i] = primitiveConst_[i-1]
> -                        + dx*(yBegin_[i-1] +0.5*dx*s_[i-1]);
> +                        + dx*(this->yBegin_[i-1] +0.5*dx*s_[i-1]);
>                  }
>              }
>              Real value(Real x) const {
> -                Size i = locate(x);
> -                return yBegin_[i] + (x-xBegin_[i])*s_[i];
> +                Size i = this->locate(x);
> +                return this->yBegin_[i] + (x-this->xBegin_[i])*s_[i];
>              }
>              Real primitive(Real x) const {
> -                Size i = locate(x);
> -                Real dx = x-xBegin_[i];
> +                Size i = this->locate(x);
> +                Real dx = x-this->xBegin_[i];
>                  return primitiveConst_[i] +
> -                    dx*(yBegin_[i] + 0.5*dx*s_[i]);
> +                    dx*(this->yBegin_[i] + 0.5*dx*s_[i]);
>              }
>              Real derivative(Real x) const {
> -                Size i = locate(x);
> +                Size i = this->locate(x);
>                  return s_[i];
>              }
>              Real secondDerivative(Real) const {
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/Math/riskstatistics.hpp ./ql/Math/riskstatistics.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/Math/riskstatistics.hpp	2004-05-18 15:05:24.000000000 +0200
> +++ ./ql/Math/riskstatistics.hpp	2004-08-18 00:03:28.948390881 +0200
> @@ -124,7 +124,7 @@
>  
>      template <class S>
>      inline Real GenericRiskStatistics<S>::semiVariance() const {
> -        return regret(mean());
> +        return regret(this->mean());
>      }
>  
>      template <class S>
> @@ -148,7 +148,7 @@
>      Real GenericRiskStatistics<S>::regret(Real target) const {
>          // average over the range below the target
>          std::pair<Real,Size> result =
> -            expectationValue(compose(square<Real>(),
> +            this->expectationValue(compose(square<Real>(),
>                                       std::bind2nd(std::minus<Real>(),
>                                                    target)),
>                               std::bind2nd(std::less<Real>(),
> @@ -170,7 +170,7 @@
>                     ") out of range [0.9, 1.0)");
>  
>          // must be a gain, i.e., floored at 0.0
> -        return QL_MAX<Real>(topPercentile(1.0-centile), 0.0);
> +        return QL_MAX<Real>(this->topPercentile(1.0-centile), 0.0);
>      }
>  
>      /*! \pre percentile must be in range [90%-100%) */
> @@ -183,7 +183,7 @@
>                     ") out of range [0.9, 1.0)");
>  
>          // must be a loss, i.e., capped at 0.0 and negated
> -        return -QL_MIN<Real>(percentile(1.0-centile), 0.0);
> +        return -QL_MIN<Real>(this->percentile(1.0-centile), 0.0);
>      }
>  
>      /*! \pre percentile must be in range [90%-100%) */
> @@ -194,10 +194,10 @@
>                     DecimalFormatter::toString(centile) +
>                     ") out of range [0.9, 1.0)");
>  
> -        QL_ENSURE(samples() != 0, "empty sample set");
> +        QL_ENSURE(this->samples() != 0, "empty sample set");
>          Real target = -valueAtRisk(centile);
>          std::pair<Real,Size> result = 
> -            expectationValue(identity<Real>(),
> +            this->expectationValue(identity<Real>(),
>                               std::bind2nd(std::less<Real>(),
>                                            target));
>          Real x = result.first;
> @@ -209,8 +209,8 @@
>  
>      template <class S>
>      Real GenericRiskStatistics<S>::shortfall(Real target) const {
> -        QL_ENSURE(samples() != 0, "empty sample set");
> -        return expectationValue(clip(constant<Real,Real>(1.0),
> +        QL_ENSURE(this->samples() != 0, "empty sample set");
> +        return this->expectationValue(clip(constant<Real,Real>(1.0),
>                                       std::bind2nd(std::less<Real>(),
>                                                    target)),
>                                  everywhere()).first;
> @@ -220,7 +220,7 @@
>      Real GenericRiskStatistics<S>::averageShortfall(Real target) 
>          const {
>          std::pair<Real,Size> result = 
> -            expectationValue(std::bind1st(std::minus<Real>(),
> +            this->expectationValue(std::bind1st(std::minus<Real>(),
>                                            target),
>                               std::bind2nd(std::less<Real>(),
>                                            target));
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/Barrier/mcbarrierengine.hpp ./ql/PricingEngines/Barrier/mcbarrierengine.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/Barrier/mcbarrierengine.hpp	2004-05-17 18:40:06.000000000 +0200
> +++ ./ql/PricingEngines/Barrier/mcbarrierengine.hpp	2004-08-17 21:56:04.049592153 +0200
> @@ -174,7 +174,7 @@
>  
>          // do this with template parameters?
>          if (isBiased_) {
> -            return boost::shared_ptr<MCBarrierEngine<RNG,S>::path_pricer_type>(
> +            return boost::shared_ptr<typename MCBarrierEngine<RNG,S>::path_pricer_type>(
>                  new BiasedBarrierPathPricer(
>                      arguments_.barrierType,
>                      arguments_.barrier,
> @@ -192,7 +192,7 @@
>              RelinkableHandle<TermStructure> dividend(process->dividendYield());
>              RelinkableHandle<BlackVolTermStructure> volatility(
>                                                    process->blackVolatility());
> -            return boost::shared_ptr<MCBarrierEngine<RNG,S>::path_pricer_type>(
> +            return boost::shared_ptr<typename MCBarrierEngine<RNG,S>::path_pricer_type>(
>                  new BarrierPathPricer(
>                      arguments_.barrierType,
>                      arguments_.barrier,
> @@ -231,16 +231,16 @@
>                     "not an European Option");
>  
>          //! Initialize the one-factor Monte Carlo
> -        if (controlVariate_) {
> +        if (this->controlVariate_) {
>  
>              boost::shared_ptr<path_pricer_type> controlPP = 
> -                controlPathPricer();
> +                this->controlPathPricer();
>              QL_REQUIRE(controlPP,
>                         "engine does not provide "
>                         "control variation path pricer");
>  
>              boost::shared_ptr<PricingEngine> controlPE = 
> -                controlPricingEngine();
> +                this->controlPricingEngine();
>  
>              QL_REQUIRE(controlPE,
>                         "engine does not provide "
> @@ -257,34 +257,34 @@
>                      controlPE->results());
>              Real controlVariateValue = controlResults->value;
>  
> -            mcModel_ =
> +            this->mcModel_ =
>                  boost::shared_ptr<MonteCarloModel<SingleAsset<RNG>, S> >(
>                      new MonteCarloModel<SingleAsset<RNG>, S>(
>                          pathGenerator(), pathPricer(), stats_type(),
> -                        antitheticVariate_, controlPP,
> +                        this->antitheticVariate_, controlPP,
>                          controlVariateValue));
>              */
>          } else {
> -            mcModel_ =
> +            this->mcModel_ =
>                  boost::shared_ptr<MonteCarloModel<SingleAsset<RNG>, S> >(
>                      new MonteCarloModel<SingleAsset<RNG>, S>(
>                          pathGenerator(), pathPricer(), S(),
> -                        antitheticVariate_));
> +                        this->antitheticVariate_));
>          }
>  
>          if (requiredTolerance_ != Null<Real>()) {
>              if (maxSamples_ != Null<Size>())
> -                value(requiredTolerance_, maxSamples_);
> +                this->value(requiredTolerance_, maxSamples_);
>              else
> -                value(requiredTolerance_);
> +                this->value(requiredTolerance_);
>          } else {
> -            valueWithSamples(requiredSamples_);
> +            this->valueWithSamples(requiredSamples_);
>          }
>  
> -        results_.value = mcModel_->sampleAccumulator().mean();
> +        results_.value = this->mcModel_->sampleAccumulator().mean();
>          if (RNG::allowsErrorEstimate)
>              results_.errorEstimate =
> -                mcModel_->sampleAccumulator().errorEstimate();
> +                this->mcModel_->sampleAccumulator().errorEstimate();
>      }
>  
>  }
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/Basket/mcbasketengine.hpp ./ql/PricingEngines/Basket/mcbasketengine.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/Basket/mcbasketengine.hpp	2004-05-13 18:30:08.000000000 +0200
> +++ ./ql/PricingEngines/Basket/mcbasketengine.hpp	2004-08-17 23:27:30.835473913 +0200
> @@ -144,7 +144,7 @@
>                  ->stateVariable()->value();
>          }
>  
> -        return boost::shared_ptr<MCBasketEngine<RNG,S>::path_pricer_type>(new
> +        return boost::shared_ptr<typename MCBasketEngine<RNG,S>::path_pricer_type>(new
>              EuropeanMultiPathPricer(
>                  arguments_.basketType,
>                  payoff->optionType(),
> @@ -179,16 +179,16 @@
>                     "not an European Option");
>  */
>          //! Initialize the multi-factor Monte Carlo
> -        if (controlVariate_) {
> +        if (this->controlVariate_) {
>  
>              boost::shared_ptr<path_pricer_type> controlPP = 
> -                controlPathPricer();
> +                this->controlPathPricer();
>              QL_REQUIRE(controlPP,
>                         "engine does not provide "
>                         "control variation path pricer");
>  
>              boost::shared_ptr<PricingEngine> controlPE = 
> -                controlPricingEngine();
> +                this->controlPricingEngine();
>  
>              QL_REQUIRE(controlPE,
>                         "engine does not provide "
> @@ -205,34 +205,34 @@
>                      controlPE->results());
>              Real controlVariateValue = controlResults->value;
>  
> -            mcModel_ =
> +            this->mcModel_ =
>                  boost::shared_ptr<MonteCarloModel<MultiAsset<RNG>, S> >(
>                      new MonteCarloModel<MultiAsset<RNG>, S>(
>                             pathGenerator(), pathPricer(), stats_type(),
> -                           antitheticVariate_, controlPP,
> +                           this->antitheticVariate_, controlPP,
>                             controlVariateValue));
>  
>          } else {
> -            mcModel_ =
> +            this->mcModel_ =
>                  boost::shared_ptr<MonteCarloModel<MultiAsset<RNG>, S> >(
>                      new MonteCarloModel<MultiAsset<RNG>, S>(
>                             pathGenerator(), pathPricer(), S(),
> -                           antitheticVariate_));
> +                           this->antitheticVariate_));
>          }
>  
>          if (requiredTolerance_ != Null<Real>()) {
>              if (maxSamples_ != Null<Size>())
> -                value(requiredTolerance_, maxSamples_);
> +                this->value(requiredTolerance_, maxSamples_);
>              else
> -                value(requiredTolerance_);
> +                this->value(requiredTolerance_);
>          } else {
> -            valueWithSamples(requiredSamples_);
> +            this->valueWithSamples(requiredSamples_);
>          }
>  
> -        results_.value = mcModel_->sampleAccumulator().mean();
> +        results_.value = this->mcModel_->sampleAccumulator().mean();
>          if (RNG::allowsErrorEstimate)
>              results_.errorEstimate =
> -                mcModel_->sampleAccumulator().errorEstimate();
> +                this->mcModel_->sampleAccumulator().errorEstimate();
>      }
>  
>  }
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/Forward/forwardengine.hpp ./ql/PricingEngines/Forward/forwardengine.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/Forward/forwardengine.hpp	2004-05-13 16:53:49.000000000 +0200
> +++ ./ql/PricingEngines/Forward/forwardengine.hpp	2004-08-17 21:57:49.015634889 +0200
> @@ -69,10 +69,10 @@
>          QL_REQUIRE(moneyness > 0.0, "negative or zero moneyness given");
>  
>          QL_REQUIRE(resetDate != Null<Date>(), "null reset date given");
> -        QL_REQUIRE(resetDate >= blackScholesProcess->riskFreeRate()
> +        QL_REQUIRE(resetDate >= this->blackScholesProcess->riskFreeRate()
>                                                            ->referenceDate(),
>                     "reset date later than settlement");
> -        QL_REQUIRE(exercise->lastDate() > resetDate,
> +        QL_REQUIRE(this->exercise->lastDate() > resetDate,
>                     "reset date later or equal to maturity");
>      }
>  
> @@ -95,15 +95,15 @@
>                                                                          const {
>  
>          boost::shared_ptr<StrikedTypePayoff> argumentsPayoff =
> -            boost::dynamic_pointer_cast<StrikedTypePayoff>(arguments_.payoff);
> +            boost::dynamic_pointer_cast<StrikedTypePayoff>(this->arguments_.payoff);
>          QL_REQUIRE(argumentsPayoff, "wrong payoff given");
>  
>          const boost::shared_ptr<BlackScholesProcess>& process =
> -            arguments_.blackScholesProcess;
> +            this->arguments_.blackScholesProcess;
>  
>          boost::shared_ptr<StrikedTypePayoff> payoff(
>                     new PlainVanillaPayoff(argumentsPayoff->optionType(),
> -                                          arguments_.moneyness * 
> +                                          this->arguments_.moneyness * 
>                                            process->stateVariable()->value()));
>          originalArguments_->payoff = payoff;
>  
> @@ -115,14 +115,14 @@
>              boost::shared_ptr<TermStructure>(
>                 new ImpliedTermStructure(
>                     RelinkableHandle<TermStructure>(process->dividendYield()), 
> -                   arguments_.resetDate,
> -                   arguments_.resetDate)));
> +                   this->arguments_.resetDate,
> +                   this->arguments_.resetDate)));
>          RelinkableHandle<TermStructure> riskFreeRate(
>              boost::shared_ptr<TermStructure>(
>                 new ImpliedTermStructure(
>                     RelinkableHandle<TermStructure>(process->riskFreeRate()), 
> -                   arguments_.resetDate,
> -                   arguments_.resetDate)));
> +                   this->arguments_.resetDate,
> +                   this->arguments_.resetDate)));
>          // The following approach is ok if the vol is at most
>          // time dependant. It is plain wrong if it is asset dependant.
>          // In the latter case the right solution would be stochastic
> @@ -133,14 +133,14 @@
>                 new ImpliedVolTermStructure(
>                                    RelinkableHandle<BlackVolTermStructure>(
>                                                    process->blackVolatility()),
> -                                  arguments_.resetDate)));
> +                                  this->arguments_.resetDate)));
>  
>          originalArguments_->blackScholesProcess =
>              boost::shared_ptr<BlackScholesProcess>(
>                        new BlackScholesProcess(spot, dividendYield,
>                                                riskFreeRate, blackVolatility));
>  
> -        originalArguments_->exercise = arguments_.exercise;
> +        originalArguments_->exercise = this->arguments_.exercise;
>  
>          originalArguments_->validate();
>      }
> @@ -158,25 +158,25 @@
>                                                                        const {
>  
>          const boost::shared_ptr<BlackScholesProcess>& process =
> -            arguments_.blackScholesProcess;
> +            this->arguments_.blackScholesProcess;
>  
>          Time resetTime = process->riskFreeRate()->dayCounter().yearFraction(
>                                      process->riskFreeRate()->referenceDate(), 
> -                                    arguments_.resetDate);
> +                                    this->arguments_.resetDate);
>          DiscountFactor discQ = process->dividendYield()->discount(
> -                                                        arguments_.resetDate);
> +                                                        this->arguments_.resetDate);
>  
> -        results_.value = discQ * originalResults_->value;
> +        this->results_.value = discQ * originalResults_->value;
>          // I need the strike derivative here ...
> -        results_.delta = discQ * (originalResults_->delta +
> -                  arguments_.moneyness * originalResults_->strikeSensitivity);
> -        results_.gamma = 0.0;
> -        results_.theta = process->dividendYield()->zeroYield(
> -                                                        arguments_.resetDate) 
> -            * results_.value;
> -        results_.vega  = discQ * originalResults_->vega;
> -        results_.rho   = discQ *  originalResults_->rho;
> -        results_.dividendRho = - resetTime * results_.value
> +        this->results_.delta = discQ * (originalResults_->delta +
> +                  this->arguments_.moneyness * originalResults_->strikeSensitivity);
> +        this->results_.gamma = 0.0;
> +        this->results_.theta = process->dividendYield()->zeroYield(
> +                                                        this->arguments_.resetDate) 
> +            * this->results_.value;
> +        this->results_.vega  = discQ * originalResults_->vega;
> +        this->results_.rho   = discQ *  originalResults_->rho;
> +        this->results_.dividendRho = - resetTime * this->results_.value
>              + discQ * originalResults_->dividendRho;
>      }
>  
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/Forward/forwardperformanceengine.hpp ./ql/PricingEngines/Forward/forwardperformanceengine.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/Forward/forwardperformanceengine.hpp	2004-05-13 16:53:49.000000000 +0200
> +++ ./ql/PricingEngines/Forward/forwardperformanceengine.hpp	2004-08-18 00:06:48.855000457 +0200
> @@ -52,8 +52,8 @@
>      void ForwardPerformanceEngine<ArgumentsType, ResultsType>::calculate() 
>                                                                         const {
>  
> -        setOriginalArguments();
> -        originalEngine_->calculate();
> +        this->setOriginalArguments();
> +        this->originalEngine_->calculate();
>          getOriginalResults();
>      }
>  
> @@ -62,27 +62,27 @@
>      getOriginalResults() const {
>  
>          const boost::shared_ptr<BlackScholesProcess>& process =
> -            arguments_.blackScholesProcess;
> +            this->arguments_.blackScholesProcess;
>  
>          Time resetTime = process->riskFreeRate()->dayCounter().yearFraction(
>                                      process->riskFreeRate()->referenceDate(), 
> -                                    arguments_.resetDate);
> +                                    this->arguments_.resetDate);
>          DiscountFactor discR = 
> -            process->riskFreeRate()->discount(arguments_.resetDate);
> +            process->riskFreeRate()->discount(this->arguments_.resetDate);
>          // it's a performance option
>          discR /= process->stateVariable()->value();
>  
> -        Real temp = originalResults_->value;
> -        results_.value = discR * temp;
> -        results_.delta = 0.0;
> -        results_.gamma = 0.0;
> -        results_.theta = process->riskFreeRate()->zeroYield(
> -                                                        arguments_.resetDate) 
> -            * results_.value;
> -        results_.vega = discR * originalResults_->vega;
> -        results_.rho = - resetTime * results_.value +
> -            discR * originalResults_->rho;
> -        results_.dividendRho = discR * originalResults_->dividendRho;
> +        Real temp = this->originalResults_->value;
> +        this->results_.value = discR * temp;
> +        this->results_.delta = 0.0;
> +        this->results_.gamma = 0.0;
> +        this->results_.theta = process->riskFreeRate()->zeroYield(
> +                                                        this->arguments_.resetDate) 
> +            * this->results_.value;
> +        this->results_.vega = discR * this->originalResults_->vega;
> +        this->results_.rho = - resetTime * this->results_.value +
> +            discR * this->originalResults_->rho;
> +        this->results_.dividendRho = discR * this->originalResults_->dividendRho;
>      }
>  
>  }
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/Quanto/quantoengine.hpp ./ql/PricingEngines/Quanto/quantoengine.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/Quanto/quantoengine.hpp	2004-05-13 16:53:50.000000000 +0200
> +++ ./ql/PricingEngines/Quanto/quantoengine.hpp	2004-08-17 21:56:04.052591697 +0200
> @@ -117,14 +117,14 @@
>  
>          // determine strike from payoff
>          boost::shared_ptr<StrikedTypePayoff> payoff =
> -            boost::dynamic_pointer_cast<StrikedTypePayoff>(arguments_.payoff);
> +            boost::dynamic_pointer_cast<StrikedTypePayoff>(this->arguments_.payoff);
>          QL_REQUIRE(payoff, "non-striked payoff given");
>          Real strike = payoff->strike();
>  
> -        originalArguments_->payoff = arguments_.payoff;
> +        originalArguments_->payoff = this->arguments_.payoff;
>  
>          const boost::shared_ptr<BlackScholesProcess>& process =
> -            arguments_.blackScholesProcess;
> +            this->arguments_.blackScholesProcess;
>  
>          RelinkableHandle<Quote> spot(process->stateVariable());
>          RelinkableHandle<TermStructure> riskFreeRate(process->riskFreeRate());
> @@ -134,11 +134,11 @@
>                  new QuantoTermStructure(
>                      RelinkableHandle<TermStructure>(process->dividendYield()),
>                      RelinkableHandle<TermStructure>(process->riskFreeRate()),
> -                    arguments_.foreignRiskFreeTS,
> +                    this->arguments_.foreignRiskFreeTS,
>                      RelinkableHandle<BlackVolTermStructure>(
>                                                    process->blackVolatility()),
> -                    strike, arguments_.exchRateVolTS, exchangeRateATMlevel,
> -                    arguments_.correlation)));
> +                    strike, this->arguments_.exchRateVolTS, exchangeRateATMlevel,
> +                    this->arguments_.correlation)));
>          RelinkableHandle<BlackVolTermStructure> blackVol(
>                                                    process->blackVolatility());
>          originalArguments_->blackScholesProcess = 
> @@ -146,36 +146,36 @@
>                               new BlackScholesProcess(spot, dividendYield, 
>                                                       riskFreeRate, blackVol));
>  
> -        originalArguments_->exercise = arguments_.exercise;
> +        originalArguments_->exercise = this->arguments_.exercise;
>  
>          originalArguments_->validate();
>          originalEngine_->calculate();
>  
> -        results_.value = originalResults_->value;
> -        results_.delta = originalResults_->delta;
> -        results_.gamma = originalResults_->gamma;
> -        results_.theta = originalResults_->theta;
> -        results_.rho = originalResults_->rho +
> +        this->results_.value = originalResults_->value;
> +        this->results_.delta = originalResults_->delta;
> +        this->results_.gamma = originalResults_->gamma;
> +        this->results_.theta = originalResults_->theta;
> +        this->results_.rho = originalResults_->rho +
>              originalResults_->dividendRho;
> -        results_.dividendRho = originalResults_->dividendRho;
> -        Volatility exchangeRateFlatVol = arguments_.exchRateVolTS->blackVol(
> -            arguments_.exercise->lastDate(),
> +        this->results_.dividendRho = originalResults_->dividendRho;
> +        Volatility exchangeRateFlatVol = this->arguments_.exchRateVolTS->blackVol(
> +            this->arguments_.exercise->lastDate(),
>              exchangeRateATMlevel);
> -        results_.vega = originalResults_->vega +
> -            arguments_.correlation * exchangeRateFlatVol *
> +        this->results_.vega = originalResults_->vega +
> +            this->arguments_.correlation * exchangeRateFlatVol *
>              originalResults_->dividendRho;
>  
>  
>          Volatility volatility = process->blackVolatility()->blackVol(
> -                                           arguments_.exercise->lastDate(),
> +                                           this->arguments_.exercise->lastDate(),
>                                             process->stateVariable()->value());
> -        results_.qvega = + arguments_.correlation
> +        this->results_.qvega = + this->arguments_.correlation
>              * process->blackVolatility()->blackVol(
> -                                          arguments_.exercise->lastDate(),
> +                                          this->arguments_.exercise->lastDate(),
>                                            process->stateVariable()->value()) *
>              originalResults_->dividendRho;
> -        results_.qrho = - originalResults_->dividendRho;
> -        results_.qlambda = exchangeRateFlatVol *
> +        this->results_.qrho = - originalResults_->dividendRho;
> +        this->results_.qlambda = exchangeRateFlatVol *
>              volatility * originalResults_->dividendRho;
>      }
>  
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/Vanilla/mcdigitalengine.hpp ./ql/PricingEngines/Vanilla/mcdigitalengine.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/Vanilla/mcdigitalengine.hpp	2004-05-17 18:40:10.000000000 +0200
> +++ ./ql/PricingEngines/Vanilla/mcdigitalengine.hpp	2004-08-17 23:40:24.356880785 +0200
> @@ -154,25 +154,25 @@
>      MCDigitalEngine<RNG,S>::pathPricer() const {
>  
>          boost::shared_ptr<CashOrNothingPayoff> payoff =
> -            boost::dynamic_pointer_cast<CashOrNothingPayoff>(arguments_.payoff);
> +            boost::dynamic_pointer_cast<CashOrNothingPayoff>(this->arguments_.payoff);
>          QL_REQUIRE(payoff, "wrong payoff given");
>  
>          boost::shared_ptr<AmericanExercise> exercise =
> -            boost::dynamic_pointer_cast<AmericanExercise>(arguments_.exercise);
> +            boost::dynamic_pointer_cast<AmericanExercise>(this->arguments_.exercise);
>          QL_REQUIRE(exercise, "wrong exercise given");
>  
>          TimeGrid grid = timeGrid();
>          PseudoRandom::ursg_type sequenceGen(grid.size()-1, 
>                                              PseudoRandom::urng_type(76));
>  
> -        return boost::shared_ptr<MCDigitalEngine<RNG,S>::path_pricer_type>(new
> +        return boost::shared_ptr<typename MCDigitalEngine<RNG,S>::path_pricer_type>(new
>            DigitalPathPricer(
>              payoff,
>              exercise,
> -            arguments_.blackScholesProcess->stateVariable()->value(),
> +            this->arguments_.blackScholesProcess->stateVariable()->value(),
>              RelinkableHandle<TermStructure>(
> -                              arguments_.blackScholesProcess->riskFreeRate()),
> -            arguments_.blackScholesProcess,
> +                              this->arguments_.blackScholesProcess->riskFreeRate()),
> +            this->arguments_.blackScholesProcess,
>              sequenceGen));
>      }
>  
> @@ -180,55 +180,55 @@
>      template <class RNG, class S>
>      inline
>      TimeGrid MCDigitalEngine<RNG,S>::timeGrid() const {
> -        Time t = arguments_.blackScholesProcess->riskFreeRate()
> +        Time t = this->arguments_.blackScholesProcess->riskFreeRate()
>              ->dayCounter().yearFraction(
> -            arguments_.blackScholesProcess->riskFreeRate()->referenceDate(),
> -            arguments_.exercise->lastDate());
> -        return TimeGrid(t, Size(QL_MAX<Real>(t * maxTimeStepsPerYear_, 1.0)));
> +            this->arguments_.blackScholesProcess->riskFreeRate()->referenceDate(),
> +            this->arguments_.exercise->lastDate());
> +        return TimeGrid(t, Size(QL_MAX<Real>(t * this->maxTimeStepsPerYear_, 1.0)));
>      }
>  
>      template<class RNG, class S>
>      void MCDigitalEngine<RNG,S>::calculate() const {
>  
> -        QL_REQUIRE(requiredTolerance_ != Null<Real>() ||
> -                   requiredSamples_ != Null<Size>(),
> +        QL_REQUIRE(this->requiredTolerance_ != Null<Real>() ||
> +                   this->requiredSamples_ != Null<Size>(),
>                     "neither tolerance nor number of samples set");
>  
>          //! Initialize the one-factor Monte Carlo
> -        if (controlVariate_) {
> +        if (this->controlVariate_) {
>  
>              boost::shared_ptr<path_pricer_type> controlPP = 
> -                controlPathPricer();
> +                this->controlPathPricer();
>              QL_REQUIRE(controlPP,
>                         "engine does not provide "
>                         "control variation path pricer");
>  
>              boost::shared_ptr<PricingEngine> controlPE = 
> -                controlPricingEngine();
> +                this->controlPricingEngine();
>              QL_REQUIRE(controlPE,
>                         "engine does not provide "
>                         "control variation pricing engine");
>          } else {
> -            mcModel_ =
> +            this->mcModel_ =
>                  boost::shared_ptr<MonteCarloModel<SingleAsset<RNG>, S> >(
>                      new MonteCarloModel<SingleAsset<RNG>, S>(
> -                        pathGenerator(), pathPricer(), S(),
> -                        antitheticVariate_));
> +                        this->pathGenerator(), this->pathPricer(), S(),
> +                        this->antitheticVariate_));
>          }
>  
> -        if (requiredTolerance_ != Null<Real>()) {
> -            if (maxSamples_ != Null<Size>())
> -                value(requiredTolerance_, maxSamples_);
> +        if (this->requiredTolerance_ != Null<Real>()) {
> +            if (this->maxSamples_ != Null<Size>())
> +                this->value(this->requiredTolerance_, this->maxSamples_);
>              else
> -                value(requiredTolerance_);
> +                this->value(this->requiredTolerance_);
>          } else {
> -            valueWithSamples(requiredSamples_);
> +            this->valueWithSamples(this->requiredSamples_);
>          }
>  
> -        results_.value = mcModel_->sampleAccumulator().mean();
> +        this->results_.value = this->mcModel_->sampleAccumulator().mean();
>          if (RNG::allowsErrorEstimate)
> -            results_.errorEstimate =
> -                mcModel_->sampleAccumulator().errorEstimate();
> +            this->results_.errorEstimate =
> +                this->mcModel_->sampleAccumulator().errorEstimate();
>      }
>  
>  }
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/Vanilla/mceuropeanengine.hpp ./ql/PricingEngines/Vanilla/mceuropeanengine.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/Vanilla/mceuropeanengine.hpp	2004-06-08 15:50:41.000000000 +0200
> +++ ./ql/PricingEngines/Vanilla/mceuropeanengine.hpp	2004-08-18 00:05:09.944037209 +0200
> @@ -113,16 +113,16 @@
>      MCEuropeanEngine<RNG,S>::pathPricer() const {
>  
>          boost::shared_ptr<PlainVanillaPayoff> payoff =
> -            boost::dynamic_pointer_cast<PlainVanillaPayoff>(arguments_.payoff);
> +            boost::dynamic_pointer_cast<PlainVanillaPayoff>(this->arguments_.payoff);
>          QL_REQUIRE(payoff, "non-plain payoff given");
>  
> -        return boost::shared_ptr<MCEuropeanEngine<RNG,S>::path_pricer_type>(
> +        return boost::shared_ptr<typename MCEuropeanEngine<RNG,S>::path_pricer_type>(
>              new EuropeanPathPricer(
>                  payoff->optionType(),
> -                arguments_.blackScholesProcess->stateVariable()->value(),
> +                this->arguments_.blackScholesProcess->stateVariable()->value(),
>                  payoff->strike(),
>                  RelinkableHandle<TermStructure>(
> -                            arguments_.blackScholesProcess->riskFreeRate())));
> +                            this->arguments_.blackScholesProcess->riskFreeRate())));
>      }
>  
>  
> @@ -159,13 +159,13 @@
>      template <class RNG, class S>
>      inline TimeGrid MCEuropeanEngine<RNG,S>::timeGrid() const {
>  
> -        Time t = arguments_.blackScholesProcess->riskFreeRate()
> +        Time t = this->arguments_.blackScholesProcess->riskFreeRate()
>              ->dayCounter().yearFraction(
> -              arguments_.blackScholesProcess->riskFreeRate()->referenceDate(),
> -              arguments_.exercise->lastDate());
> +              this->arguments_.blackScholesProcess->riskFreeRate()->referenceDate(),
> +              this->arguments_.exercise->lastDate());
>  
> -        TimeGridCalculator calc(t, maxTimeStepsPerYear_);
> -        arguments_.blackScholesProcess->blackVolatility()->accept(calc);
> +        TimeGridCalculator calc(t, this->maxTimeStepsPerYear_);
> +        this->arguments_.blackScholesProcess->blackVolatility()->accept(calc);
>          return TimeGrid(t, calc.size());
>      }
>  
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/Vanilla/mcvanillaengine.hpp ./ql/PricingEngines/Vanilla/mcvanillaengine.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/Vanilla/mcvanillaengine.hpp	2004-05-13 18:30:09.000000000 +0200
> +++ ./ql/PricingEngines/Vanilla/mcvanillaengine.hpp	2004-08-17 23:35:40.933967617 +0200
> @@ -82,7 +82,7 @@
>      boost::shared_ptr<QL_TYPENAME MCVanillaEngine<RNG,S>::path_generator_type>
>      MCVanillaEngine<RNG,S>::pathGenerator() const {
>  
> -        TimeGrid grid = timeGrid();
> +        TimeGrid grid = this->timeGrid();
>          typename RNG::rsg_type gen =
>              RNG::make_sequence_generator(grid.size()-1,seed_);
>          // BB here
> @@ -103,16 +103,16 @@
>                     "not an European Option");
>  
>          //! Initialize the one-factor Monte Carlo
> -        if (controlVariate_) {
> +        if (this->controlVariate_) {
>  
>              boost::shared_ptr<path_pricer_type> controlPP = 
> -                controlPathPricer();
> +                this->controlPathPricer();
>              QL_REQUIRE(controlPP,
>                         "engine does not provide "
>                         "control variation path pricer");
>  
>              boost::shared_ptr<PricingEngine> controlPE = 
> -                controlPricingEngine();
> +                this->controlPricingEngine();
>              QL_REQUIRE(controlPE,
>                         "engine does not provide "
>                         "control variation pricing engine");
> @@ -128,34 +128,34 @@
>                      controlPE->results());
>              Real controlVariateValue = controlResults->value;
>  
> -            mcModel_ =
> +            this->mcModel_ =
>                  boost::shared_ptr<MonteCarloModel<SingleAsset<RNG>, S> >(
>                      new MonteCarloModel<SingleAsset<RNG>, S>(
> -                           pathGenerator(), pathPricer(), stats_type(),
> -                           antitheticVariate_, controlPP,
> +                           pathGenerator(), this->pathPricer(), stats_type(),
> +                           this->antitheticVariate_, controlPP,
>                             controlVariateValue));
>  
>          } else {
> -            mcModel_ =
> +            this->mcModel_ =
>                  boost::shared_ptr<MonteCarloModel<SingleAsset<RNG>, S> >(
>                      new MonteCarloModel<SingleAsset<RNG>, S>(
> -                           pathGenerator(), pathPricer(), S(),
> -                           antitheticVariate_));
> +                           pathGenerator(), this->pathPricer(), S(),
> +                           this->antitheticVariate_));
>          }
>  
>          if (requiredTolerance_ != Null<Real>()) {
>              if (maxSamples_ != Null<Size>())
> -                value(requiredTolerance_, maxSamples_);
> +                this->value(requiredTolerance_, maxSamples_);
>              else
> -                value(requiredTolerance_);
> +                this->value(requiredTolerance_);
>          } else {
> -            valueWithSamples(requiredSamples_);
> +            this->valueWithSamples(requiredSamples_);
>          }
>  
> -        results_.value = mcModel_->sampleAccumulator().mean();
> +        results_.value = this->mcModel_->sampleAccumulator().mean();
>          if (RNG::allowsErrorEstimate)
>              results_.errorEstimate =
> -                mcModel_->sampleAccumulator().errorEstimate();
> +                this->mcModel_->sampleAccumulator().errorEstimate();
>      }
>  
>  }
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/genericmodelengine.hpp ./ql/PricingEngines/genericmodelengine.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/genericmodelengine.hpp	2004-05-19 10:53:11.000000000 +0200
> +++ ./ql/PricingEngines/genericmodelengine.hpp	2004-08-17 21:53:38.708687329 +0200
> @@ -48,7 +48,7 @@
>              update();
>          }
>          virtual void update() {
> -            notifyObservers();
> +            this->notifyObservers();
>          }
>        protected:
>          boost::shared_ptr<ModelType> model_;
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/latticeshortratemodelengine.hpp ./ql/PricingEngines/latticeshortratemodelengine.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/PricingEngines/latticeshortratemodelengine.hpp	2004-03-25 17:52:28.000000000 +0100
> +++ ./ql/PricingEngines/latticeshortratemodelengine.hpp	2004-08-17 23:28:31.045320625 +0200
> @@ -62,15 +62,15 @@
>              const TimeGrid& timeGrid) 
>      : GenericModelEngine<ShortRateModel, Arguments, Results>(model), 
>        timeGrid_(timeGrid), timeSteps_(0) {
> -        lattice_ = model_->tree(timeGrid);
> +        lattice_ = this->model_->tree(timeGrid);
>      }
>  
>      template <class Arguments, class Results>
>      void LatticeShortRateModelEngine<Arguments, Results>::update() 
>      {
>          if (timeGrid_.size() > 0)
> -            lattice_ = model_->tree(timeGrid_);
> -        notifyObservers();
> +            lattice_ = this->model_->tree(timeGrid_);
> +        this->notifyObservers();
>      }
>  
>  }
> diff -urN ../tmp-orig/quantlib-0.3.7/ql/solver1d.hpp ./ql/solver1d.hpp
> --- ../tmp-orig/quantlib-0.3.7/ql/solver1d.hpp	2004-05-28 15:10:39.000000000 +0200
> +++ ./ql/solver1d.hpp	2004-08-17 21:54:32.632489665 +0200
> @@ -105,7 +105,7 @@
>                      if (fxMax_ == 0.0)    return xMax_;
>                      root_ = (xMax_+xMin_)/2.0;
>                      // check whether we really want to pass epsilon
> -                    return impl().solveImpl(f, QL_MAX(QL_FABS(accuracy), 
> +                    return this->impl().solveImpl(f, QL_MAX(QL_FABS(accuracy), 
>                                                        QL_EPSILON));
>                  }
>                  if (QL_FABS(fxMin_) < QL_FABS(fxMax_)) {
> @@ -197,7 +197,7 @@
>  
>              root_ = guess;
>  
> -            return impl().solveImpl(f, QL_MAX(QL_FABS(accuracy), QL_EPSILON));
> +            return this->impl().solveImpl(f, QL_MAX(QL_FABS(accuracy), QL_EPSILON));
>          }
>  
>          /*! This method sets the maximum number of function
> 
> 

-- 
Those are my principles, and if you don't like them... well, I have others.
                                                -- Groucho Marx

[Quantlib-dev] [ quantlib-Feature Requests-997298 ] Add bonds

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

Feature Requests item #997298, was opened at 2004-07-24 16:30
Message generated for change (Tracker Item Submitted) made by Item Submitter
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=362740&aid=997298&group_id=12740

Category: None
Group: None
Status: Open
Priority: 5
Submitted By: Nobody/Anonymous (nobody)
Assigned to: Nobody/Anonymous (nobody)
Summary: Add bonds 

Initial Comment:
please add bonds (floating and fix coupon) and callable 
bonds to quantlib.
I recently discovered quantlib on the web and i think 
that it would be more useful if it also includes the 
instrument bond. 
Where in the class model of quantlib would be the most 
natural place to add bonds? If I intend to program it 
myself, from which class would you recommend to derive 
a class bond?

lot...@on...

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

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

[Quantlib-dev] [ quantlib-Feature Requests-997288 ] Add Instrument Bond

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

Feature Requests item #997288, was opened at 2004-07-24 16:12
Message generated for change (Tracker Item Submitted) made by Item Submitter
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=362740&aid=997288&group_id=12740

Category: None
Group: None
Status: Open
Priority: 5
Submitted By: Nobody/Anonymous (nobody)
Assigned to: Nobody/Anonymous (nobody)
Summary: Add Instrument Bond

Initial Comment:
Please add bonds (fixed and floating) and callable bonds 
to Quantlib.

lot...@on...

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

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

[Quantlib-dev] [ANN] QuantLib 0.3.7 released

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

QuantLib is a cross-platform, free/open-source quantitative finance C++ 
library for modeling, pricing, trading, and risk management in real-life.

Version 0.3.7 has been released. See 
http://sourceforge.net/project/shownotes.php?group_id=12740&release_id=252500 
for a summary of the changes since version 0.3.6

QuantLib now depends on the Boost library (www.boost.org). You will need 
a working Boost installation in order to compile and use QuantLib. 
Instructions for installing Boost from sources are available at 
<http://www.boost.org/more/getting_started.html>. Pre-packaged binaries 
might be available from other sources. Google is your friend (or Debian, 
or Fink...)

Furthermore, Python, Ruby, Guile, and MzScheme bindings are available 
for QuantLib 0.3.7 as well as an Excel add-in.

Feedback is welcome.

Ferdinando Ametrano

[Quantlib-dev] Vacations

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

Hi all,
	starting a couple of hours from now, I won't be reading my  
mailbox for three weeks. I'll be back August 16th. Don't take it  
personally if I don't answer any questions in the meantime :)

Cheers,
	Luigi

Re: [Quantlib-dev] When to exclude payment from SWAP valuation

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

On 2004.07.13 14:50, Andre Louw wrote:
> Just a quick question.
> 
> Looking at the swap module I see QuantLib excludes cashflows from the
> NPV of a Swap according to the termstructure's settlementDate.  
> Depending on how you look at it, could this not alternatively be  
> todaysDate?

The main problem right now is that the term structure does not  
extrapolate backwards to today's date.

> Is there a specific market convention applicable to this?

I don't know. Anybody?

In the meantime, you can create your term structure with referenceDate  
= todaysDate and capitalize 2 days...

Later,
	Luigi

Re: [Quantlib-dev] Final 0.3.7 tarballs

[Mark T. <mrt...@en...>]

The fink packages for QuantLib, QuantLib-Python, and QuantLib-Ruby 
build and test okay.  Although I still have to reduce the 
optimizations.  Apple is rumored to be releasing an updated version of 
gcc with XCode 1.5 sometime in the summer so I'll test the package with 
it once it's released.  Cheers

Mark.

On Jul 13, 2004, at 4:33 AM, Ferdinando Ametrano wrote:

> Luigi Ballabio wrote:
>
>>     final tarballs for release 0.3.7 are available at  
>> <http://quantlib.org/gm/>.
>> Packagers can work their magic from those.
>
> I've created the 0.3.7 release on SourceForge, with the tarballs from 
> <http://quantlib.org/gm/> and the Win32 packages. The release is 
> "hidden" for the time being and I will wait packagers feedback before 
> announcing it and making it "active".
>

[Quantlib-dev] lost messages - messaggi persi

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

Hi/ciao

sorry to bother you all with my problems, but chances are that if you 
have sent me a message yesterday and/or today it hasn't reached me, 
because of unpleasant (!!) interaction between the company anti-virus 
and my personal e-mail client. Please send your message(s) again if 
relevant.
Any suggestion about how to recover mailboxes lost by the Thunderbird 
e-mail client because of virus deletion by McAfee anti-virus would be 
appreciated.

Scusate se vi secco con i miei problemi, ma a causa di una spiacevole 
interazione tra l'antivirus aziendale ed il mio programma di posta ho 
perso i messaggi ricevuti ieri e oggi. Rispeditemeli se erano importanti.
Sarebbe apprezzatissimo ovviamente qualsiasi aiuto per recuperare 
mailbox perse dal client email Thunderbird a causa di virus cancellati 
da McAfee

ciao -- Ferdinando

[edd: Re: [Quantlib-dev] Final 0.3.7 tarballs]

[Dirk E. <ed...@de...>]

Oops -- didn't group reply.

Dirk

----- Forwarded message from Dirk Eddelbuettel <edd> -----

From: Dirk Eddelbuettel <edd>
To: Luigi Ballabio <lui...@fa...>
Subject: Re: [Quantlib-dev] Final 0.3.7 tarballs

On Tue, Jul 13, 2004 at 09:48:45AM +0200, Luigi Ballabio wrote:
> 	final tarballs for release 0.3.7 are available at  
> <http://quantlib.org/gm/>.
> Packagers can work their magic from those.

Debian packages for QL itself are uploads, will do QL-Python and QL-Ruby
(which need it, obviously) tomorrow to give the autobuilders a day, and will
do the documentation packages today or tomorrow.

Thanks as always for the release.

Dirk

-- 
Those are my principles, and if you don't like them... well, I have others.
                                                -- Groucho Marx

----- End forwarded message -----

-- 
Those are my principles, and if you don't like them... well, I have others.
                                                -- Groucho Marx

[Quantlib-dev] When to exclude payment from SWAP valuation

[Andre L. <an...@de...>]

Hi,

Just a quick question. 

Looking at the swap module I see QuantLib excludes cashflows from the NPV 
of a Swap according to the termstructure's settlementDate. Depending on 
how you look at it, could this not alternatively be todaysDate? Could we 
maybe add a ifdef to give the flexibility for both? Is there a specific 
market convention applicable to this?

Andre

Re: [Quantlib-dev] Final 0.3.7 tarballs

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

Luigi Ballabio wrote:

>     final tarballs for release 0.3.7 are available at  
> <http://quantlib.org/gm/>.
> Packagers can work their magic from those.

I've created the 0.3.7 release on SourceForge, with the tarballs from 
<http://quantlib.org/gm/> and the Win32 packages. The release is 
"hidden" for the time being and I will wait packagers feedback before 
announcing it and making it "active".

Thank you to all those involved.

ciao -- Nando

[Quantlib-dev] Final 0.3.7 tarballs

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

Hi all,
	final tarballs for release 0.3.7 are available at  
<http://quantlib.org/gm/>.
Packagers can work their magic from those.

Later,
	Luigi

[Quantlib-dev] [ quantlib-Bugs-934626 ] Excel is hung when calling qlAmericanOption_FD

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

Bugs item #934626, was opened at 2004-04-14 02:09
Message generated for change (Comment added) made by nando
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=112740&aid=934626&group_id=12740

Category: None
Group: None
>Status: Closed
>Resolution: Fixed
Priority: 5
Submitted By: Nobody/Anonymous (nobody)
>Assigned to: Ferdinando Ametrano (nando)
Summary: Excel is hung when calling qlAmericanOption_FD

Initial Comment:
it seems it only happens when the Type = C, and when 
the function template is used.

XL version = 0.35,
OS = XP Professional SP1;
QuantLib & QuantLibXL are compiled off the source code 
by the user using the 0.35 release.



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

>Comment By: Ferdinando Ametrano (nando)
Date: 2004-07-12 17:22

Message:
Logged In: YES 
user_id=34616

The bug is now fixed in CVS.
Thank you for the report.


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

Comment By: Ferdinando Ametrano (nando)
Date: 2004-07-12 17:22

Message:
Logged In: YES 
user_id=34616

Fixed in CVS. Fixed in the forthcoming 0.3.7 release

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

Comment By: Nobody/Anonymous (nobody)
Date: 2004-06-25 01:53

Message:
Logged In: NO 

Excel's function template invokes the function each time you
tab through the input fields.  Excel hangs when you enter
the expiry date (the 8th of the 10 input parameters).  The
reason that Excel does not hang before then is because the
relevant QuantLibXL function (xlAmericanOption_FD in file
QuantLibXL\qlxl\pricers.cpp) contains the line
                                                           
                                                           
double maturity      = Actual365().yearFraction(valueDate,
maturityDate);            
                                                           
                                                     which
throws an exception when either or both date is null,
causing the function to return #N/A to Excel.  Once both
dates are provided, the above line completes successfully,
and the code proceeds to call the underlying Quantlib
constructor FdAmericanOption(), which hangs because the
remaining input parameters are still null.           
                                                           
                                                     The
problem can be corrected by validating the input parameters
at the beginning of function xlAmericanOption_FD() and
exiting if any is missing:                                 
                                                           
             
    if (xltype.IsMissing() ||    
    xlunderlying.IsMissing() ||    
    ... etc ...    
    xlgridPoints.IsMissing())
        throw("missing inputs"); // returns #N/A to Excel  
     
                                                           
                                                         but
I'm not sure that's the right thing to do, there may be
times when you legitimately want to call a function with
some parameters missing, in which case the validation would
have to be more elaborate.

this bug occurs regardless of whether the type is C or P.

eric at ehlers dot plus dot com.

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

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

[Quantlib-dev] [ quantlib-Bugs-979504 ] G2 gives wrong result.

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

Bugs item #979504, was opened at 2004-06-24 23:23
Message generated for change (Tracker Item Submitted) made by Item Submitter
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=112740&aid=979504&group_id=12740

Category: None
Group: None
Status: Open
Resolution: None
Priority: 5
Submitted By: Nobody/Anonymous (nobody)
Assigned to: Nobody/Anonymous (nobody)
Summary: G2 gives wrong result.

Initial Comment:
I was trying to use the newest CVS version of the G2++
model and I realized that the ATM and OTM values of the
bermudan swaption example look much lower than for the
HW and BK models.

Actually, in my opinion for a 2 factor model the
results should be more accurate than for 1 factor. So I
guess there might be still a little bug?

 

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

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