量化金融深度解析：QuantLib模块与实现详解

需积分: 5 20 浏览量更新于2024-06-20 收藏 4.95MB PDF 举报

"Implementing QuantLib 是一本深度探索量化金融领域的专业书籍，由 Luigi Ballabio 所著，于 2021 年 1 月 16 日发布。该书旨在详细介绍如何构建和实现 QuantLib，一个在 C++ 中广泛应用的金融工程库，专注于模拟复杂的金融工具、建模金融概念和提供统一的解决方案来处理金融计算问题。作者以一种迭代的方式呈现内容，强调了 Lean Publishing 的理念，即读者可以在整个创作过程中提供反馈，不断优化作品。本书的核心部分包括以下几个关键模块： 1. 介绍：首先，作者会引导读者了解 QuantLib 的总体设计理念和其在量化金融中的重要性，让读者对整个框架有一个全面的认识。 2. 金融工具与定价引擎： - Instrument 类：这部分详细讲解 Instrument 类的接口和所需功能，它是构建金融产品模型的基础。作者解释了类的设计要求，如何通过继承和接口实现来确保灵活性和可扩展性。 - Pricing Engines：作者通过实例（如利息互换）来展示定价引擎的工作原理，展示了如何使用 QuantLib 来计算金融工具的价值。 3. 深入实践：进一步介绍了如何应用 QuantLib 实现具体功能，如 plain-vanilla 期权的定价，这将帮助读者理解如何在实际项目中操作这个库。 4. 后续发展：书中还讨论了 QuantLib 的未来发展方向和可能存在的局限性，以及如何应对这些挑战，体现了作者对于持续改进的重视。通过阅读本书，读者不仅可以学习到 QuantLib 的核心技术和实现方法，还能掌握金融工具建模的通用原则，以及如何利用它解决诸如随机模拟、参数校准和有限差分等金融工程问题。这本书不仅适用于金融专业人士，也适合软件工程师和对量化金融感兴趣的人士，特别是那些希望通过 C++ 实践金融工具编程的人。"

Financial instruments and pricing engines 9

calculation; derived classes can declare other data members to store specific results.⁴ The body of

the calculate method calls the virtual isExpired method to check whether the instrument is

an expired one. If this is the case, it calls another virtual method, namely, setupExpired, which

has the responsibility of giving meaningful values to the results; its default implementation sets

NPV_ to 0 and can be called by derived classes. The calculated_ flag is then set to true. If the

instrument is not expired, the calculate method of LazyObject is called instead, which in turn

will call performCalculations as needed. This imposes a contract on the latter method, namely, its

implementations in derived classes are required to set NPV_ (as well as any other instrument-specific

data member) to the result of the calculations. Finally, the NPV method ensures that calculate is

called before returning the answer.

2.1.3 Example: interest-rate swap

I end this section by showing how a specific financial instrument can be implemented based on the

described facilities.

The chosen instrument is the interest-rate swap. As you surely know, it is a contract which consists

in exchanging periodic cash flows. The net present value of the instrument is calculated by adding

or subtracting the discounted cash-flow amounts depending on whether the cash flows are paid or

received.

Not surprisingly, the swap is implemented⁵ as a new class deriving from Instrument. Its outline is

shown in the following listing.

Partial interface of the Swap class.

class Swap : public Instrument {

public:

Swap(const vector<shared_ptr<CashFlow> >& firstLeg,

const vector<shared_ptr<CashFlow> >& secondLeg,

const Handle<YieldTermStructure>& termStructure);

bool isExpired() const;

Real firstLegBPS() const;

Real secondLegBPS() const;

protected:

// methods

void setupExpired() const;

void performCalculations() const;

// data members

vector<shared_ptr<CashFlow> > firstLeg_, secondLeg_;

Handle<YieldTermStructure> termStructure_;

mutable Real firstLegBPS_, secondLegBPS_;

};

⁴The Instrument class also defines an errorEstimate_ member, which is omitted here for clarity of exposition. The discussion of

NPV_ applies to both.

⁵The implementation shown in this section is somewhat outdated. However, I’m still using it here since it provides a simpler example.

Financial instruments and pricing engines 12

calculate();

return firstLegBPS_;

}

Real Swap::secondLegBPS() const {

calculate();

return secondLegBPS_;

}

The first step is performed in the class constructor, which takes as arguments (and copies into the

corresponding data members) the two sequences of cash flows to be exchanged and the yield term

structure to be used for discounting their amounts. The step itself consists in registering the swap

as an observer of both the cash flows and the term structure. As previously explained, this enables

them to notify the swap and trigger its recalculation each time a change occurs.

The second step is the implementation of the required interface. The logic of the isExpired method

is simple enough; its body loops over the stored cash flows checking their payment dates. As soon as

it finds a payment which still has not occurred, it reports the swap as not expired. If none is found, the

instrument has expired. In this case, the setupExpired method will be called. Its implementation

calls the base-class one, thus taking care of the data members inherited from Instrument; it then

sets to 0 the swap-specific results.

Aside: handles and shared pointers.

You might wonder why the Swap constructor accepts the discount curve as a handle and the cash

flows as simple shared pointers. The reason is that we might decide to switch to a different curve

(which can be done by means of the handle) whereas the cash flows are part of the definition of the

swap and are thus immutable.

The last required method is performCalculations. The calculation is performed by calling two

external functions from the Cashflows class.⁶ The first one, namely, npv, is a straightforward

translation of the algorithm outlined above: it cycles on a sequence of cash flows adding the

discounted amount of its future cash flows. We set the NPV_ variable to the difference of the results

from the two legs. The second one, bps, calculates the basis-point sensitivity (BPS) of a sequence of

cash flows. We call it once per leg and store the results in the corresponding data members. Since the

result carries no numerical error, the errorEstimate_ variable is set to Null<Real>()—a specific

floating-point value which is used as a sentinel value indicating an invalid number.⁷

The third and final step only needs to be performed if—as in this case—the class defines additional

⁶If you happen to feel slightly cheated, consider that the point of this example is to show how to package calculations into a class—not to

show how to implement the calculations. Your curiosity will be satisfied in a later chapter devoted to cash flows and related functions.

⁷NaN might be a better choice, but the means of detecting it are not portable. Another possibility still to be investigated would be to use

boost::optional.

Financial instruments and pricing engines 13

results. It consists in writing corresponding methods (here, firstLegBPS and secondLegBPS) which

ensure that the calculations are (lazily) performed before returning the stored results.

The implementation is now complete. Having been written on top of the Instrument class, the Swap

class will benefit from its code. Thus, it will automatically cache and recalculate results according

to notifications from its inputs—even though no related code was written in Swap except for the

registration calls.

2.1.4 Further developments

You might have noticed a shortcoming in my treatment of the previous example and of the

Instrument class in general. Albeit generic, the Swap class we implemented cannot manage interest-

rate swaps in which the two legs are paid in different currencies. A similar problem would arise if

you wanted to add the values of two instruments whose values are not in the same currency; you

would have to convert manually one of the values to the currency of the other before adding them

together.

Such problems stem from a single weakness of the implementation: we used the Real type (i.e., a

simple floating-point number) to represent the value of an instrument or a cash flow. Therefore,

such results miss the currency information which is attached to them in the real world.

The weakness might be removed if we were to express such results by means of the Money class.

Instances of such class contain currency information; moreover, depending on user settings, they

are able to automatically perform conversion to a common currency upon addition or subtraction.

However, this would be a major change, affecting a large part of the code base in a number of ways.

Therefore, it will need some serious thinking before we tackle it (if we do tackle it at all).

Another (and more subtle) shortcoming is that the Swap class fails to distinguish explicitly between

two components of the abstraction it represents. Namely, there is no clear separation between the

data specifying the contract (the cash-flow specification) and the market data used to price the

instrument (the current discount curve).

The solution is to store in the instrument only the first group of data (i.e., those that would be in its

term sheet) and keep the market data elsewhere.⁸ The means to do this are the subject of the next

section.

2.2 Pricing engines

We now turn to the second of the requirements I stated in the previous section. For any given

instrument, it is not always the case that a unique pricing method exists; moreover, one might want

to use multiple methods for different reasons. Let’s take the classic textbook example—the European

equity option. One might want to price it by means of the analytic Black-Scholes formula in order to

⁸Beside being conceptually clearer, this would prove useful to external functions implementing serialization and deserialization of the

instrument—for instance, to and from the FpML format.

剩余95页未读，继续阅读

rockwood573

粉丝: 96
资源: 43

量化金融深度解析：QuantLib模块与实现详解

Implementing QuantLib

Implementing_QuantLib.rar_QuantLib_金融_金融 数据

introduction of quantlib

Implementing OpenShift

Implementing CIFS

Implementing Laravel

ImplementingNetScalerVPX.pdf 英文原版

ImplementingCloudStoragewithOpenStackSwift.pdf 英文原版

ImplementingSSLTLSUsingCryptographyAndPKI.pdf 英文原版

DesigningAndImplementingLinuxFirewallsAndQos.pdf 英文原版

最新资源

Implementing_QuantLib.rar_QuantLib_金融_金融数据