1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
Copyright (C) 2015 Johannes Göttker-Schnetmann
Copyright (C) 2015 Klaus Spanderen
This file is part of QuantLib, a free-software/open-source library
for financial quantitative analysts and developers - http://quantlib.org/
QuantLib is free software: you can redistribute it and/or modify it
under the terms of the QuantLib license. You should have received a
copy of the license along with this program; if not, please email
<quantlib-dev@lists.sf.net>. The license is also available online at
<https://www.quantlib.org/license.shtml>.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the license for more details.
*/
/*! \file hestonblackvolsurface.hpp
\brief Black volatility surface back by Heston model
*/
#include <ql/math/functional.hpp>
#include <ql/math/solvers1d/brent.hpp>
#include <ql/pricingengines/blackformula.hpp>
#include <ql/termstructures/volatility/equityfx/hestonblackvolsurface.hpp>
#include <ql/time/calendars/nullcalendar.hpp>
#include <limits>
#include <utility>
namespace QuantLib {
namespace {
Real blackValue(Option::Type optionType, Real strike,
Real forward, Real maturity,
Volatility vol, Real discount, Real npv) {
return blackFormula(optionType, strike, forward,
std::max(0.0, vol)*std::sqrt(maturity),
discount)-npv;
}
}
HestonBlackVolSurface::HestonBlackVolSurface(
const Handle<HestonModel>& hestonModel,
const AnalyticHestonEngine::ComplexLogFormula cpxLogFormula,
AnalyticHestonEngine::Integration integration)
: BlackVolTermStructure(hestonModel->process()->riskFreeRate()->referenceDate(),
NullCalendar(),
Following,
hestonModel->process()->riskFreeRate()->dayCounter()),
hestonModel_(hestonModel), cpxLogFormula_(cpxLogFormula),
integration_(std::move(integration)) {
registerWith(hestonModel_);
}
DayCounter HestonBlackVolSurface::dayCounter() const {
return hestonModel_->process()->riskFreeRate()->dayCounter();
}
Date HestonBlackVolSurface::maxDate() const {
return Date::maxDate();
}
Real HestonBlackVolSurface::minStrike() const {
return 0.0;
}
Real HestonBlackVolSurface::maxStrike() const {
return std::numeric_limits<Real>::max();
}
Real HestonBlackVolSurface::blackVarianceImpl(Time t, Real strike) const {
return squared(blackVolImpl(t, strike))*t;
}
Volatility HestonBlackVolSurface::blackVolImpl(Time t, Real strike) const {
AnalyticHestonEngine hestonEngine(
hestonModel_.currentLink(), cpxLogFormula_, integration_);
const ext::shared_ptr<HestonProcess>& process = hestonModel_->process();
const DiscountFactor df = process->riskFreeRate()->discount(t, true);
const Real fwd = process->s0()->value()
* process->dividendYield()->discount(t, true) / df;
const ext::shared_ptr<PlainVanillaPayoff> payoff =
ext::make_shared<PlainVanillaPayoff>(
fwd > strike ? Option::Put : Option::Call, strike);
const Real npv = hestonEngine.priceVanillaPayoff(payoff, t);
const Real theta = hestonModel_->theta();
if (npv <= 0.0) return std::sqrt(theta);
Brent solver;
solver.setMaxEvaluations(10000);
const Volatility guess = std::sqrt(theta);
constexpr double accuracy = std::numeric_limits<double>::epsilon();
return solver.solve(
[&](Volatility _v) {
return blackValue(
payoff->optionType(), strike, fwd, t, _v, df, npv);
},
accuracy, guess, 0.01
);
}
}
|
