From b73d626cf17424218c60e85fe654b333d9ec1557 Mon Sep 17 00:00:00 2001 From: Luigi Ballabio Date: Sun, 17 May 2020 20:29:00 +0200 Subject: [PATCH 1/3] Deprecate CurveDependentStepCondition class. --- .../finitedifferences/americancondition.hpp | 61 +++++++++++-- ql/methods/finitedifferences/fdtypedefs.hpp | 6 ++ .../finitedifferences/shoutcondition.hpp | 87 +++++++++++++------ .../finitedifferences/stepcondition.hpp | 11 ++- 4 files changed, 127 insertions(+), 38 deletions(-) diff --git a/ql/methods/finitedifferences/americancondition.hpp b/ql/methods/finitedifferences/americancondition.hpp index 8b6077a5add..9f45f2912d8 100644 --- a/ql/methods/finitedifferences/americancondition.hpp +++ b/ql/methods/finitedifferences/americancondition.hpp @@ -32,19 +32,62 @@ namespace QuantLib { //! American exercise condition. - /*! \todo unify the intrinsicValues/Payoff thing */ class AmericanCondition : - public StandardCurveDependentStepCondition { - public: + public StandardStepCondition { + public: + AmericanCondition(const Array& intrinsicValues) + : impl_(new ArrayImpl(intrinsicValues)) {}; + /*! \deprecated Use the other constructor. + Deprecated in version 1.19. + */ + QL_DEPRECATED AmericanCondition(Option::Type type, Real strike) - : StandardCurveDependentStepCondition(type, strike) {}; - AmericanCondition(const Array& intrinsicValues) - : StandardCurveDependentStepCondition(intrinsicValues) {}; - private: - Real applyToValue(Real current, Real intrinsic) const { - return std::max(current, intrinsic); + : impl_(new PayoffImpl(type, strike)) {}; + void applyTo(Array &a, Time) const { + //#pragma omp parallel for + for (Size i = 0; i < a.size(); i++) { + a[i] = std::max(a[i], impl_->getValue(a, i)); + } } + private: + // This part should be removed and the array-based implementation + // inlined once the payoff-based constructor is removed. + + class Impl; + + ext::shared_ptr impl_; + + class Impl { + public: + virtual ~Impl() {} + virtual Real getValue(const Array &a, + int i) = 0; + }; + + class ArrayImpl : public Impl { + private: + Array intrinsicValues_; + public: + ArrayImpl (const Array &a) + : intrinsicValues_(a) {} + + Real getValue(const Array&, int i) { + return intrinsicValues_[i]; + } + }; + + class PayoffImpl : public Impl { + private: + ext::shared_ptr payoff_; + public: + PayoffImpl (Option::Type type, Real strike) + : payoff_(new PlainVanillaPayoff(type, strike)) {}; + Real getValue(const Array &a, + int i) { + return (*payoff_)(std::exp(a[i])); + } + }; }; } diff --git a/ql/methods/finitedifferences/fdtypedefs.hpp b/ql/methods/finitedifferences/fdtypedefs.hpp index c882ca2f1b4..5771ceece80 100644 --- a/ql/methods/finitedifferences/fdtypedefs.hpp +++ b/ql/methods/finitedifferences/fdtypedefs.hpp @@ -41,6 +41,12 @@ namespace QuantLib { //! default choice for step condition typedef StepCondition StandardStepCondition; + + + /*! \deprecated Inherit from StandardStepCondition directly. + Deprecated in version 1.19. + */ + QL_DEPRECATED typedef CurveDependentStepCondition StandardCurveDependentStepCondition; } diff --git a/ql/methods/finitedifferences/shoutcondition.hpp b/ql/methods/finitedifferences/shoutcondition.hpp index 0f8e8434487..3c20f0583c4 100644 --- a/ql/methods/finitedifferences/shoutcondition.hpp +++ b/ql/methods/finitedifferences/shoutcondition.hpp @@ -37,42 +37,77 @@ namespace QuantLib { during the option's life. The minimum value is the option's intrinsic value at the shout time. */ - class ShoutCondition : public StandardCurveDependentStepCondition { + class ShoutCondition : public StandardStepCondition { public: + ShoutCondition(const Array& intrinsicValues, + Time resTime, + Rate rate) + : resTime_(resTime), rate_(rate), + impl_(new ArrayImpl(intrinsicValues)) {} + + /*! \deprecated Use the other constructor. + Deprecated in version 1.19. + */ + QL_DEPRECATED ShoutCondition(Option::Type type, Real strike, Time resTime, - Rate rate); - ShoutCondition(const Array& intrinsicValues, - Time resTime, - Rate rate); + Rate rate) + : resTime_(resTime), rate_(rate), + impl_(new PayoffImpl(type, strike)) {} + void applyTo(Array& a, - Time t) const; - private: - virtual Real applyToValue(Real current, - Real intrinsic) const { - return std::max(current, disc_ * intrinsic ); + Time t) const { + DiscountFactor B = std::exp(-rate_ * (t - resTime_)); + //#pragma omp parallel for + for (Size i = 0; i < a.size(); i++) { + a[i] = std::max(a[i], B * impl_->getValue(a, i)); + } } + + private: Time resTime_; Rate rate_; - mutable DiscountFactor disc_; + + // This part should be removed and the array-based implementation + // inlined once the payoff-based constructor is removed. + + class Impl; + + ext::shared_ptr impl_; + + class Impl { + public: + virtual ~Impl() {} + virtual Real getValue(const Array &a, + int i) = 0; + }; + + class ArrayImpl : public Impl { + private: + Array intrinsicValues_; + public: + ArrayImpl (const Array &a) + : intrinsicValues_(a) {} + + Real getValue(const Array&, int i) { + return intrinsicValues_[i]; + } + }; + + class PayoffImpl : public Impl { + private: + ext::shared_ptr payoff_; + public: + PayoffImpl (Option::Type type, Real strike) + : payoff_(new PlainVanillaPayoff(type, strike)) {}; + + Real getValue(const Array &a, int i) { + return (*payoff_)(std::exp(a[i])); + } + }; }; - inline ShoutCondition::ShoutCondition(Option::Type type, - Real strike, Time resTime, - Rate rate) - : StandardCurveDependentStepCondition(type, strike), - resTime_(resTime), rate_(rate) {} - - inline ShoutCondition::ShoutCondition(const Array& intrinsicValues, - Time resTime, Rate rate) - : StandardCurveDependentStepCondition(intrinsicValues), - resTime_(resTime), rate_(rate) {} - - inline void ShoutCondition::applyTo(Array& a, Time t) const { - disc_ = std::exp(-rate_ * (t - resTime_)); - StandardCurveDependentStepCondition::applyTo(a, t); - } } diff --git a/ql/methods/finitedifferences/stepcondition.hpp b/ql/methods/finitedifferences/stepcondition.hpp index fada5879045..9655ae0f538 100644 --- a/ql/methods/finitedifferences/stepcondition.hpp +++ b/ql/methods/finitedifferences/stepcondition.hpp @@ -38,10 +38,15 @@ namespace QuantLib { virtual void applyTo(array_type& a, Time t) const = 0; }; - /* Abstract base class which allows step conditions to use both - payoff and array functions */ + /* */ + /*! Abstract base class which allows step conditions to use both + payoff and array functions. + + \deprecated Inherit from StepCondition directly instead. + Deprecated in version 1.19. + */ template - class CurveDependentStepCondition : + class QL_DEPRECATED CurveDependentStepCondition : public StepCondition { public: void applyTo(Array &a, Time) const { From 7329633540433c30c9a75ec1d963a29c0e6fb668 Mon Sep 17 00:00:00 2001 From: Luigi Ballabio Date: Mon, 18 May 2020 19:20:48 +0200 Subject: [PATCH 2/3] Avoid warnings in VC++ and gcc. --- ql/methods/finitedifferences/fdtypedefs.hpp | 22 +++++++++++++++++++ .../finitedifferences/stepcondition.hpp | 11 ++++++++++ 2 files changed, 33 insertions(+) diff --git a/ql/methods/finitedifferences/fdtypedefs.hpp b/ql/methods/finitedifferences/fdtypedefs.hpp index 5771ceece80..24742527067 100644 --- a/ql/methods/finitedifferences/fdtypedefs.hpp +++ b/ql/methods/finitedifferences/fdtypedefs.hpp @@ -42,6 +42,18 @@ namespace QuantLib { //! default choice for step condition typedef StepCondition StandardStepCondition; +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +#endif +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-declarations" +#endif +#if defined(QL_PATCH_MSVC) +#pragma warning(push) +#pragma warning(disable:4996) +#endif /*! \deprecated Inherit from StandardStepCondition directly. Deprecated in version 1.19. @@ -49,6 +61,16 @@ namespace QuantLib { QL_DEPRECATED typedef CurveDependentStepCondition StandardCurveDependentStepCondition; +#if defined(QL_PATCH_MSVC) +#pragma warning(pop) +#endif +#if defined(__clang__) +#pragma clang diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } diff --git a/ql/methods/finitedifferences/stepcondition.hpp b/ql/methods/finitedifferences/stepcondition.hpp index 9655ae0f538..58429860cd7 100644 --- a/ql/methods/finitedifferences/stepcondition.hpp +++ b/ql/methods/finitedifferences/stepcondition.hpp @@ -57,12 +57,23 @@ namespace QuantLib { } } protected: + +#if defined(QL_PATCH_MSVC) +#pragma warning(push) +#pragma warning(disable:4996) +#endif + CurveDependentStepCondition(Option::Type type, Real strike) : curveItem_(new PayoffWrapper(type, strike)) {}; CurveDependentStepCondition(const Payoff *p) : curveItem_(new PayoffWrapper(p)) {}; CurveDependentStepCondition(const array_type & a) : curveItem_(new ArrayWrapper(a)) {}; + +#if defined(QL_PATCH_MSVC) +#pragma warning(pop) +#endif + class CurveWrapper; ext::shared_ptr curveItem_; From 2977bc018734cced7d5389e1c6b0c8aa8b8802ad Mon Sep 17 00:00:00 2001 From: Luigi Ballabio Date: Mon, 18 May 2020 23:18:11 +0200 Subject: [PATCH 3/3] Use explicit constructors. --- ql/methods/finitedifferences/americancondition.hpp | 12 +++++++----- ql/methods/finitedifferences/shoutcondition.hpp | 4 ++-- 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/ql/methods/finitedifferences/americancondition.hpp b/ql/methods/finitedifferences/americancondition.hpp index 9f45f2912d8..d69b5a1e627 100644 --- a/ql/methods/finitedifferences/americancondition.hpp +++ b/ql/methods/finitedifferences/americancondition.hpp @@ -35,15 +35,17 @@ namespace QuantLib { class AmericanCondition : public StandardStepCondition { public: - AmericanCondition(const Array& intrinsicValues) - : impl_(new ArrayImpl(intrinsicValues)) {}; + explicit AmericanCondition(const Array& intrinsicValues) + : impl_(new ArrayImpl(intrinsicValues)) {} + /*! \deprecated Use the other constructor. Deprecated in version 1.19. */ QL_DEPRECATED AmericanCondition(Option::Type type, Real strike) - : impl_(new PayoffImpl(type, strike)) {}; + : impl_(new PayoffImpl(type, strike)) {} + void applyTo(Array &a, Time) const { //#pragma omp parallel for for (Size i = 0; i < a.size(); i++) { @@ -69,7 +71,7 @@ namespace QuantLib { private: Array intrinsicValues_; public: - ArrayImpl (const Array &a) + explicit ArrayImpl(const Array &a) : intrinsicValues_(a) {} Real getValue(const Array&, int i) { @@ -81,7 +83,7 @@ namespace QuantLib { private: ext::shared_ptr payoff_; public: - PayoffImpl (Option::Type type, Real strike) + PayoffImpl(Option::Type type, Real strike) : payoff_(new PlainVanillaPayoff(type, strike)) {}; Real getValue(const Array &a, int i) { diff --git a/ql/methods/finitedifferences/shoutcondition.hpp b/ql/methods/finitedifferences/shoutcondition.hpp index 3c20f0583c4..9b4dc9eace5 100644 --- a/ql/methods/finitedifferences/shoutcondition.hpp +++ b/ql/methods/finitedifferences/shoutcondition.hpp @@ -87,7 +87,7 @@ namespace QuantLib { private: Array intrinsicValues_; public: - ArrayImpl (const Array &a) + explicit ArrayImpl(const Array &a) : intrinsicValues_(a) {} Real getValue(const Array&, int i) { @@ -99,7 +99,7 @@ namespace QuantLib { private: ext::shared_ptr payoff_; public: - PayoffImpl (Option::Type type, Real strike) + PayoffImpl(Option::Type type, Real strike) : payoff_(new PlainVanillaPayoff(type, strike)) {}; Real getValue(const Array &a, int i) {