1 /* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 
3 /*
4  Copyright (C) 2003, 2006 Ferdinando Ametrano
5  Copyright (C) 2006 Warren Chou
6  Copyright (C) 2006, 2008 StatPro Italia srl
7  Copyright (C) 2006 Chiara Fornarola
8 
9  This file is part of QuantLib, a free-software/open-source library
10  for financial quantitative analysts and developers - http://quantlib.org/
11 
12  QuantLib is free software: you can redistribute it and/or modify it
13  under the terms of the QuantLib license.  You should have received a
14  copy of the license along with this program; if not, please email
15  <quantlib-dev@lists.sf.net>. The license is also available online at
16  <http://quantlib.org/license.shtml>.
17 
18  This program is distributed in the hope that it will be useful, but WITHOUT
19  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
20  FOR A PARTICULAR PURPOSE.  See the license for more details.
21 */
22 
23 /*! \file payoffs.hpp
24     \brief Payoffs for various options
25 */
26 
27 #ifndef quantlib_payoffs_hpp
28 #define quantlib_payoffs_hpp
29 
30 #include <ql/option.hpp>
31 #include <ql/payoff.hpp>
32 
33 namespace QuantLib {
34 
35     //! Dummy %payoff class
36     class NullPayoff : public Payoff {
37       public:
38         //! \name Payoff interface
39         //@{
40         std::string name() const;
41         std::string description() const;
42         Real operator()(Real price) const;
43         virtual void accept(AcyclicVisitor&);
44         //@}
45     };
46 
47 
48     //! Intermediate class for put/call payoffs
49     class TypePayoff : public Payoff {
50       public:
optionType() const51         Option::Type optionType() const { return type_; };
52         //! \name Payoff interface
53         //@{
54         std::string description() const;
55         //@}
56       protected:
TypePayoff(Option::Type type)57         explicit TypePayoff(Option::Type type) : type_(type) {}
58         Option::Type type_;
59     };
60 
61     ////! Intermediate class for payoffs based on a fixed strike
62     //class StrikedPayoff : public Payoff {
63     //  public:
64     //    StrikedPayoff(Real strike) : strike_(strike) {}
65     //    Real strike() const { return strike_; };
66     //    //! \name Payoff interface
67     //    //@{
68     //    std::string description() const;
69     //    //@}
70     //  protected:
71     //    Real strike_;
72     //};
73 
74     //! %Payoff based on a floating strike
75     class FloatingTypePayoff : public TypePayoff {
76       public:
FloatingTypePayoff(Option::Type type)77         FloatingTypePayoff(Option::Type type) : TypePayoff(type) {}
78         //! \name Payoff interface
79         //@{
name() const80         std::string name() const { return "FloatingType";}
81         Real operator()(Real price, Real strike) const;
82         Real operator()(Real price) const;
83         virtual void accept(AcyclicVisitor&);
84         //@}
85     };
86 
87     //! Intermediate class for payoffs based on a fixed strike
88     class StrikedTypePayoff : public TypePayoff
89                               //, public StrikedPayoff
90     {
91       public:
92         //! \name Payoff interface
93         //@{
94         std::string description() const;
95         //@}
strike() const96         Real strike() const { return strike_; };
97       protected:
StrikedTypePayoff(Option::Type type,Real strike)98         StrikedTypePayoff(Option::Type type,
99                           Real strike)
100         : TypePayoff(type), strike_(strike) {}
101         Real strike_;
102     };
103 
104     //! Plain-vanilla payoff
105     class PlainVanillaPayoff : public StrikedTypePayoff {
106       public:
PlainVanillaPayoff(Option::Type type,Real strike)107         PlainVanillaPayoff(Option::Type type,
108                            Real strike)
109         : StrikedTypePayoff(type, strike) {}
110         //! \name Payoff interface
111         //@{
name() const112         std::string name() const { return "Vanilla";}
113         Real operator()(Real price) const;
114         virtual void accept(AcyclicVisitor&);
115         //@}
116     };
117 
118     //! %Payoff with strike expressed as percentage
119     class PercentageStrikePayoff : public StrikedTypePayoff {
120       public:
PercentageStrikePayoff(Option::Type type,Real moneyness)121         PercentageStrikePayoff(Option::Type type,
122                                Real moneyness)
123         : StrikedTypePayoff(type, moneyness) {}
124         //! \name Payoff interface
125         //@{
name() const126         std::string name() const { return "PercentageStrike";}
127         Real operator()(Real price) const;
128         virtual void accept(AcyclicVisitor&);
129         //@}
130     };
131 
132     /*! Definitions of Binary path-independent payoffs used below,
133         can be found in M. Rubinstein, E. Reiner:"Unscrambling The Binary Code", Risk, Vol.4 no.9,1991.
134         (see: http://www.in-the-money.com/artandpap/Binary%20Options.doc)
135     */
136 
137     //! Binary asset-or-nothing payoff
138     class AssetOrNothingPayoff : public StrikedTypePayoff {
139       public:
AssetOrNothingPayoff(Option::Type type,Real strike)140         AssetOrNothingPayoff(Option::Type type,
141                              Real strike)
142         : StrikedTypePayoff(type, strike) {}
143         //! \name Payoff interface
144         //@{
name() const145         std::string name() const { return "AssetOrNothing";}
146         Real operator()(Real price) const;
147         virtual void accept(AcyclicVisitor&);
148         //@}
149     };
150 
151     //! Binary cash-or-nothing payoff
152     class CashOrNothingPayoff : public StrikedTypePayoff {
153       public:
CashOrNothingPayoff(Option::Type type,Real strike,Real cashPayoff)154         CashOrNothingPayoff(Option::Type type,
155                             Real strike,
156                             Real cashPayoff)
157         : StrikedTypePayoff(type, strike), cashPayoff_(cashPayoff) {}
158         //! \name Payoff interface
159         //@{
name() const160         std::string name() const { return "CashOrNothing";}
161         std::string description() const;
162         Real operator()(Real price) const;
163         virtual void accept(AcyclicVisitor&);
164         //@}
cashPayoff() const165         Real cashPayoff() const { return cashPayoff_;}
166       protected:
167         Real cashPayoff_;
168     };
169 
170     //! Binary gap payoff
171     /*! This payoff is equivalent to being a) long a PlainVanillaPayoff at
172         the first strike (same Call/Put type) and b) short a
173         CashOrNothingPayoff at the first strike (same Call/Put type) with
174         cash payoff equal to the difference between the second and the first
175         strike.
176         \warning this payoff can be negative depending on the strikes
177     */
178     class GapPayoff : public StrikedTypePayoff {
179       public:
GapPayoff(Option::Type type,Real strike,Real secondStrike)180         GapPayoff(Option::Type type,
181                   Real strike,
182                   Real secondStrike) // a.k.a. payoff strike
183         : StrikedTypePayoff(type, strike), secondStrike_(secondStrike) {}
184         //! \name Payoff interface
185         //@{
name() const186         std::string name() const { return "Gap";}
187         std::string description() const;
188         Real operator()(Real price) const;
189         virtual void accept(AcyclicVisitor&);
190         //@}
secondStrike() const191         Real secondStrike() const { return secondStrike_;}
192       protected:
193         Real secondStrike_;
194     };
195 
196     //! Binary supershare and superfund payoffs
197 
198     //! Binary superfund payoff
199     /*! Superfund sometimes also called "supershare", which can lead to ambiguity; within QuantLib
200         the terms supershare and superfund are used consistently according to the definitions in
201         Bloomberg OVX function's help pages.
202     */
203     /*! This payoff is equivalent to being (1/lowerstrike) a) long (short) an AssetOrNothing
204         Call (Put) at the lower strike and b) short (long) an AssetOrNothing
205         Call (Put) at the higher strike
206     */
207     class SuperFundPayoff : public StrikedTypePayoff {
208       public:
SuperFundPayoff(Real strike,Real secondStrike)209         SuperFundPayoff(Real strike,
210                         Real secondStrike)
211         : StrikedTypePayoff(Option::Call, strike),
212           secondStrike_(secondStrike) {
213             QL_REQUIRE(strike>0.0,
214                        "strike (" <<  strike << ") must be "
215                        "positive");
216             QL_REQUIRE(secondStrike>strike,
217                        "second strike (" <<  secondStrike << ") must be "
218                        "higher than first strike (" << strike << ")");
219         }
220         //! \name Payoff interface
221         //@{
name() const222         std::string name() const { return "SuperFund";}
223         Real operator()(Real price) const;
224         virtual void accept(AcyclicVisitor&);
225         //@}
secondStrike() const226         Real secondStrike() const { return secondStrike_;}
227       protected:
228         Real secondStrike_;
229     };
230 
231     //! Binary supershare payoff
232     class SuperSharePayoff : public StrikedTypePayoff {
233       public:
SuperSharePayoff(Real strike,Real secondStrike,Real cashPayoff)234         SuperSharePayoff(Real strike,
235                          Real secondStrike,
236                          Real cashPayoff)
237         : StrikedTypePayoff(Option::Call, strike),
238           secondStrike_(secondStrike),
239           cashPayoff_(cashPayoff){
240               QL_REQUIRE(secondStrike>strike,
241               "second strike (" <<  secondStrike << ") must be "
242               "higher than first strike (" << strike << ")");}
243 
244         //! \name Payoff interface
245         //@{
name() const246         std::string name() const { return "SuperShare";}
247         std::string description() const;
248         Real operator()(Real price) const;
249         virtual void accept(AcyclicVisitor&);
250         //@}
secondStrike() const251         Real secondStrike() const { return secondStrike_;}
cashPayoff() const252         Real cashPayoff() const { return cashPayoff_;}
253       protected:
254         Real secondStrike_;
255         Real cashPayoff_;
256     };
257 }
258 
259 #endif
260