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
110
111
112
113
114
115
116
117
118
119
120
121
|
/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
Copyright (C) 2006 Allen Kuo
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
<http://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.
*/
#include <ql/instruments/forwardrateagreement.hpp>
#include <ql/indexes/iborindex.hpp>
#include <ql/event.hpp>
namespace QuantLib {
ForwardRateAgreement::ForwardRateAgreement(
const Date& valueDate,
const Date& maturityDate,
Position::Type type,
Rate strikeForwardRate,
Real notionalAmount,
const ext::shared_ptr<IborIndex>& index,
const Handle<YieldTermStructure>& discountCurve,
bool useIndexedCoupon)
: Forward(index->dayCounter(), index->fixingCalendar(),
index->businessDayConvention(),
index->fixingDays(), ext::shared_ptr<Payoff>(),
valueDate, maturityDate, discountCurve),
fraType_(type), notionalAmount_(notionalAmount), index_(index),
useIndexedCoupon_(useIndexedCoupon) {
QL_REQUIRE(notionalAmount > 0.0, "notionalAmount must be positive");
strikeForwardRate_ = InterestRate(strikeForwardRate,
index->dayCounter(),
Simple, Once);
Real strike = notionalAmount_ *
strikeForwardRate_.compoundFactor(valueDate_,
maturityDate_);
payoff_ = ext::shared_ptr<Payoff>(new ForwardTypePayoff(fraType_,
strike));
// incomeDiscountCurve_ is irrelevant to an FRA
incomeDiscountCurve_ = discountCurve_;
// income is irrelevant to FRA - set it to zero
underlyingIncome_ = 0.0;
registerWith(index_);
}
Date ForwardRateAgreement::settlementDate() const {
return calendar_.advance(Settings::instance().evaluationDate(),
settlementDays_, Days);
}
Date ForwardRateAgreement::fixingDate() const {
return calendar_.advance(valueDate_,
-static_cast<Integer>(settlementDays_), Days);
}
bool ForwardRateAgreement::isExpired() const {
return detail::simple_event(valueDate_).hasOccurred(settlementDate());
}
Real ForwardRateAgreement::spotIncome(
const Handle<YieldTermStructure>&) const {
return 0.0;
}
// In theory, no need to implement this for a FRA (could directly
// supply a forwardValue). For the sake of keeping a consistent
// framework, we adhere to the concept of the forward contract as
// defined in the base class, with an underlying having a
// spotPrice (in this case, a loan or deposit with an NPV). Thus,
// spotValue() is defined here.
Real ForwardRateAgreement::spotValue() const {
calculate();
return notionalAmount_ *
forwardRate().compoundFactor(valueDate_, maturityDate_) *
discountCurve_->discount(maturityDate_);
}
InterestRate ForwardRateAgreement::forwardRate() const {
calculate();
return forwardRate_;
}
void ForwardRateAgreement::setupExpired() const {
Forward::setupExpired();
calculateForwardRate();
}
void ForwardRateAgreement::performCalculations() const {
calculateForwardRate();
underlyingSpotValue_ = spotValue();
underlyingIncome_ = 0.0;
Forward::performCalculations();
}
void ForwardRateAgreement::calculateForwardRate() const {
if (useIndexedCoupon_)
forwardRate_ =
InterestRate(index_->fixing(fixingDate()), index_->dayCounter(), Simple, Once);
else
// par coupon approximation
forwardRate_ =
InterestRate((index_->forwardingTermStructure()->discount(valueDate_) /
index_->forwardingTermStructure()->discount(maturityDate_) -
1.0) /
index_->dayCounter().yearFraction(valueDate_, maturityDate_),
index_->dayCounter(), Simple, Once);
}
}
|
