C++：实现量化european option欧式期权 测试实例

最新推荐文章于 2025-07-22 11:45:07 发布
最新推荐文章于 2025-07-22 11:45:07 发布
阅读量278 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： c++ 开发语言 quantification
不予转载，严禁转载，违者必纠。
本文链接：https://blog.csdn.net/it_xiangqiang/article/details/128360462
本文是一篇关于使用C++编程实现量化交易中欧洲期权的原创教程，详细讲解了相关测试实例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

C++：实现量化european option欧式期权 测试实例

#include "europeanoption.hpp"
#include "utilities.hpp"
#include <ql/time/calendars/target.hpp>
#include <ql/time/daycounters/actual360.hpp>
#include <ql/instruments/europeanoption.hpp>
#include <ql/math/randomnumbers/rngtraits.hpp>
#include <ql/math/interpolations/bicubicsplineinterpolation.hpp>
#include <ql/math/interpolations/bilinearinterpolation.hpp>
#include <ql/pricingengines/vanilla/analyticeuropeanengine.hpp>
#include <ql/pricingengines/vanilla/binomialengine.hpp>
#include <ql/pricingengines/vanilla/fdblackscholesvanillaengine.hpp>
#include <ql/experimental/variancegamma/fftvanillaengine.hpp>
#include <ql/pricingengines/vanilla/mceuropeanengine.hpp>
#include <ql/pricingengines/vanilla/integralengine.hpp>
#include <ql/termstructures/yield/flatforward.hpp>
#include <ql/termstructures/yield/zerocurve.hpp>
#include <ql/termstructures/yield/forwardcurve.hpp>
#include <ql/termstructures/volatility/equityfx/blackconstantvol.hpp>
#include <ql/termstructures/volatility/equityfx/blackvariancesurface.hpp>
#include <ql/utilities/dataformatters.hpp>
#include <map>

using namespace QuantLib;
using namespace boost::unit_test_framework;

#undef REPORT_FAILURE
#define REPORT_FAILURE(greekName, payoff, exercise, s, q, r, today, \
                       v, expected, calculated, error, tolerance) \
    BOOST_ERROR(exerciseTypeToString(exercise) << " " \
               << payoff->optionType() << " option with " \
               << payoffTypeToString(payoff) << " payoff:\n" \
               << "    spot value:       " << s << "\n" \
               << "    strike:           " << payoff->strike() << "\n" \
               << "    dividend yield:   " << io::rate(q) << "\n" \
               << "    risk-free rate:   " << io::rate(r) << "\n" \
               << "    reference date:   " << today << "\n" \
               << "    maturity:         " << exercise->lastDate() << "\n" \
               << "    volatility:       " << io::volatility(v) << "\n\n" \
               << "    expected " << greekName << ":   " << expected << "\n" \
               << "    calculated " << greekName << ": " << calculated << "\n"\
               << "    error:            " << error << "\n" \
               << "    tolerance:        " << tolerance);

namespace european_option_test {
   
   

    // utilities

    struct EuropeanOptionData {
   
   
        Option::Type type;
        Real strike;
        Real s;        // spot
        Rate q;        // dividend
        Rate r;        // risk-free rate
        Time t;        // time to maturity
        Volatility v;  // volatility
        Real result;   // expected result
        Real tol;      // tolerance
    };

    enum EngineType {
   
    Analytic,
                      JR, CRR, EQP, TGEO, TIAN, LR, JOSHI,
                      FiniteDifferences,
                      Integral,
                      PseudoMonteCarlo, QuasiMonteCarlo,
                      FFT };

    ext::shared_ptr<GeneralizedBlackScholesProcess>
    makeProcess(const ext::shared_ptr<Quote>& u,
                const ext::shared_ptr<YieldTermStructure>& q,
                const ext::shared_ptr<YieldTermStructure>& r,
                const ext::shared_ptr<BlackVolTermStructure>& vol) {
   
   
        return ext::make_shared<BlackScholesMertonProcess>(
           Handle<Quote>(u),
                                         Handle<YieldTermStructure>(q),
                                         Handle<YieldTermStructure>(r),
                                         Handle<BlackVolTermStructure>(vol));
    }

    ext::shared_ptr<VanillaOption>
    makeOption(const ext::shared_ptr<StrikedTypePayoff>& payoff,
               const ext::shared_ptr<Exercise>& exercise,
               const ext::shared_ptr<Quote>& u,
               const ext::shared_ptr<YieldTermStructure>& q,
               const ext::shared_ptr<YieldTermStructure>& r,
               const ext::shared_ptr<BlackVolTermStructure>& vol,
               EngineType engineType,
               Size binomialSteps,
               Size samples) {
   
   

        ext::shared_ptr<GeneralizedBlackScholesProcess> stochProcess =
            makeProcess(u,q,r,vol);

        ext::shared_ptr<PricingEngine> engine;
        switch (engineType) {
   
   
          case Analytic:
            engine = ext::shared_ptr<PricingEngine>(
                                    new AnalyticEuropeanEngine(stochProcess));
            break;
          case JR:
            engine = ext::shared_ptr<PricingEngine>(
                        new BinomialVanillaEngine<JarrowRudd>(stochProcess,
                                                              binomialSteps));
            break;
          case CRR:
            engine = ext::shared_ptr<PricingEngine>(
                 new BinomialVanillaEngine<CoxRossRubinstein>(stochProcess,
                                                              binomialSteps));
            break;
          case EQP:
            engine = ext::shared_ptr<PricingEngine>(
                 new BinomialVanillaEngine<AdditiveEQPBinomialTree>(
                                                              stochProcess,
                                                              binomialSteps));
            break;
          case TGEO:
            engine = ext::shared_ptr<PricingEngine>(
                        new BinomialVanillaEngine<Trigeorgis>(stochProcess,
                                                              binomialSteps));
            break;
          case TIAN:
            engine = ext::shared_ptr<PricingEngine>(
                new BinomialVanillaEngine<Tian>(stochProcess, binomialSteps));
            break;
          case LR:
            engine = ext::shared_ptr<PricingEngine>(
                      new BinomialVanillaEngine<LeisenReimer>(stochProcess,
                                                              binomialSteps));
            break;
          case JOSHI:
            engine = ext::shared_ptr<PricingEngine>(
              new BinomialVanillaEngine<Joshi4>(stochProcess, binomialSteps));
            break;
          case FiniteDifferences:
            engine = ext::shared_ptr<PricingEngine>(
                            new FdBlackScholesVanillaEngine(stochProcess,
                                                            binomialSteps,
                                                            samples));
            break;
          case Integral:
            engine = ext::shared_ptr<PricingEngine>(
                                            new IntegralEngine(stochProcess));
            break;
          case PseudoMonteCarlo:
            engine = MakeMCEuropeanEngine<PseudoRandom>(stochProcess)
                .withSteps(1)
                .withSamples(samples)
                .withSeed(42);
            break;
          case QuasiMonteCarlo:
            engine = MakeMCEuropeanEngine<LowDiscrepancy>(stochProcess)
                .withSteps(1)
                .withSamples(samples);
            break;
          case FFT:
              engine = ext::shared_ptr<PricingEngine>(
                                          new FFTVanillaEngine(stochProcess));
            break;
          default:
            QL_FAIL("unknown engine type");
        }

        ext::shared_ptr<VanillaOption> option(
            new EuropeanOption(payoff, exercise));
        option->setPricingEngine(engine);
        return option;
    }

}


void EuropeanOptionTest::testValues() {
   
   

    BOOST_TEST_MESSAGE("Testing European option values...");

    using namespace european_option_test;

    SavedSettings backup;

    /* The data below are from
       "Option pricing formulas", E.G. Haug, McGraw-Hill 1998
    */
    EuropeanOptionData values[] = {
   
   
      // pag 2-8
      //        type, strike,   spot,    q,    r,    t,  vol,   value,    tol
      {
   
    Option::Call,  65.00,  60.00, 0.00, 0.08, 0.25, 0.30,  2.1334, 1.0e-4},
      {
   
    Option::Put,   95.00, 100.00, 0.05, 0.10, 0.50, 0.20,  2.4648, 1.0e-4},
      {
   
    Option::Put,   19.00,  19.00, 0.10, 0.10, 0.75, 0.28,  1.7011, 1.0e-4},
      {
   
    Option::Call,  19.00,  19.00, 0.10, 0.10, 0.75, 0.28,  1.7011, 1.0e-4},
      {
   
    Option::Call,   1.60,   1.56, 0.08, 0.06, 0.50, 0.12,  0.0291, 1.0e-4},
      {
   
    Option::Put,   70.00,  75.00, 0.05, 0.10, 0.50, 0.35,  4.0870, 1.0e-4},
      // pag 24
      {
   
    Option::Call, 100.00,  90.00, 0.10, 0.10, 0.10, 0.15,  0.0205, 1.0e-4},
      {
   
    Option::Call, 100.00, 100.00, 0.10, 0.10, 0.10, 0.15,  1.8734, 1.0e-4},
      {
   
    Option::Call, 100.00, 110.00, 0.10, 0.10, 0.10, 0.15,  9.9413, 1.0e-4},
      {
   
    Option::Call, 100.00,  90.00, 0.10, 0.10, 0.10, 0.25,  0.3150, 1.0e-4},
      {
   
    Option::Call, 100.00, 100.00, 0.10, 0.10, 0.10, 0.25,  3.1217, 1.0e-4},
      {
   
    Option::Call, 100.00, 110.00, 0.10, 0.10, 0.10, 0.25, 10.3556, 1.0e-4},
      {
   
    Option::Call, 100.00,  90.00, 0.10, 0.10, 0.10, 0.35,  0.9474, 1.0e-4},
      {
   
    Option::Call, 100.00, 100.00, 0.10, 0.10, 0.10, 0.35,  4.3693, 1.0e-4},
      {
   
    Option::Call, 100.00, 110.00, 0.10, 0.10, 0.10, 0.35, 11.1381, 1.0e-4},
      {
   
    Option::Call, 100.00,  90.00, 0.10, 0.10, 0.50, 0.15,  0.8069, 1.0e-4},
      {
   
    Option::Call, 100.00, 100.00, 0.10, 0.10, 0.50, 0.15,  4.0232, 1.0e-4},
      {
   
    Option::Call, 100.00, 110.00, 0.10, 0.10, 0.50, 0.15, 10.5769, 1.0e-4},
      {
   
    Option::Call, 100.00,  90.00, 0.10, 0.10, 0.50, 0.25,  2.7026, 1.0e-4},
      {
   
    Option::Call, 100.00, 100.00, 0.10, 0.10, 0.50, 0.25,  6.6997, 1.0e-4},
      {
   
    Option::Call, 100.00, 110.00, 0.10, 0.10, 0.50, 0.25, 12.7857, 1.0e-4},
      {
   
    Option::Call, 100.00,  90.00, 0.10, 0.10, 0.50, 0.35,  4.9329, 1.0e-4},
      {
   
    Option::Call, 100.00, 100.00, 0.10, 0.10, 0.50, 0.35,  9.3679, 1.0e-4},
      {
   
    Option::Call, 100.00, 110.00, 0.10, 0.10, 0.50, 0.35, 15.3086, 1.0e-4},
      {
   
    Option::Put,  100.00,  90.00, 0.10, 0.10, 0.10, 0.15,  9.9210, 1.0e-4},
      {
   
    Option::Put,  100.00, 100.00, 0.10, 0.10, 0.10, 0.15,  1.8734, 1.0e-4},
      {
   
    Option::Put,  100.00, 110.00, 0.10, 0.10, 0.10, 0.15,  0.0408, 1.0e-4},
      {
   
    Option::Put,  100.00,  90.00, 0.10, 0.10, 0.10, 0.25, 10.2155, 1.0e-4},
      {
   
    Option::Put,  100.00, 100.00, 0.10, 0.10, 0.10, 0.25,  3.1217, 1.0e-4},
      {
   
    Option::Put,  100.00, 110.00, 0.10, 0.10, 0.10, 0.25,  0.4551, 1.0e-4},
      {
   
    Option::Put,  100.00,  90.00, 0.10, 0.10, 0.10, 0.35, 10.8479, 1.0e-4},
      {
   
    Option::Put,  100.00, 100.00, 0.10, 0.10, 0.10, 0.35,  4.3693, 1.0e-4},
      {
   
    Option::Put,  100.00, 110.00, 0.10, 0.10, 0.10, 0.35,  1.2376, 1.0e-4},
      {
   
    Option::Put,  100.00,  90.00, 0.10, 0.10, 0.50, 0.15, 10.3192, 1.0e-4},
      {
   
    Option::Put,  100.00, 100.00, 0.10, 0.10, 0.50, 0.15,  4.0232, 1.0e-4},
      {
   
    Option::Put,  100.00, 110.00, 0.10, 0.10, 0.50, 0.15,  1.0646, 1.0e-4},
      {
   
    Option::Put,  100.00,  90.00, 0.10, 0.10, 0.50, 0.25, 12.2149, 1.0e-4},
      {
   
    Option::Put,  100.00, 100.00, 0.10, 0.10, 0.50, 0.25,  6.6997, 1.0e-4},
      {
   
    Option::Put,  100.00, 110.00, 0.10, 0.10, 0.50, 0.25,  3.2734, 1.0e-4},
      {
   
    Option::Put,  100.00,  90.00, 0.10, 0.10, 0.50, 0.35, 14.4452, 1.0e-4},
      {
   
    Option::Put,  100.00, 100.00, 0.10, 0.10, 0.50, 0.35,  9.3679, 1.0e-4},
      {
   
    Option::Put,  100.00, 110.00, 0.10, 0.10, 0.50, 0.35,  5.7963, 1.0e-4},
      // pag 27
      {
   
    Option::Call,  40.00,  42.00, 0.08, 0.04, 0.75, 0.35,  5.0975, 1.0e-4}
    };

    DayCounter dc = Actual360();
    Date today = Date::todaysDate();

    ext::shared_ptr<SimpleQuote> spot(new SimpleQuote(0.0));
    ext::shared_ptr<SimpleQuote> qRate(new SimpleQuote(0.0));
    ext::shared_ptr<YieldTermStructure> qTS = flatRate(today, qRate, dc);
    ext::shared_ptr<SimpleQuote> rRate(new SimpleQuote(0.0));
    ext::shared_ptr<YieldTermStructure> rTS = flatRate(today, rRate, dc);
    ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
    ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);

    for (auto& value : values) {
   
   

        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, value.strike));
        Date exDate = today + timeToDays(value.t);
        ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));

        spot->setValue(value.s);
        qRate->setValue(value.q);
        rRate->setValue(value.r);
        vol->setValue(value.v);

        ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
            BlackScholesMertonProcess(Handle<Quote>(spot),
                                      Handle<YieldTermStructure>(qTS),
                                      Handle<YieldTermStructure>(rTS),
                                      Handle<BlackVolTermStructure>(volTS)));
        ext::shared_ptr<PricingEngine> engine(
                                    new AnalyticEuropeanEngine(stochProcess));

        EuropeanOption option(payoff, exercise);
        option.setPricingEngine(engine);

        Real calculated = option.NPV();
        Real error = std::fabs(calculated - value.result);
        Real tolerance = value.tol;
        if (error>tolerance) {
   
   
            REPORT_FAILURE("value", payoff, exercise, value.s, value.q, value.r, today, value.v,
                           value.result, calculated, error, tolerance);
        }

        engine = ext::shared_ptr<PricingEngine>(
                    new FdBlackScholesVanillaEngine(stochProcess,200,400));
        option.setPricingEngine(engine);

        calculated = option.NPV();
        error = std::fabs(calculated - value.result);
        tolerance = 1.0e-3;
        if (error>tolerance) {
   
   
            REPORT_FAILURE("value", payoff, exercise, value.s, value.q, value.r, today, value.v,
                           value.result, calculated, error, tolerance);
        }
    }
}



void EuropeanOptionTest::testGreekValues() {
   
   

    BOOST_TEST_MESSAGE("Testing European option greek values...");

    using namespace european_option_test;

    SavedSettings backup;

    /* The data below are from
       "Option pricing formulas", E.G. Haug, McGraw-Hill 1998
       pag 11-16
    */
    EuropeanOptionData values[] = {
   
   
      //        type, strike,   spot,    q,    r,        t,  vol,  value
      // delta
      {
   
    Option::Call, 100.00, 105.00, 0.10, 0.10, 0.500000, 0.36,  0.5946, 0 },
      {
   
    Option::Put,  100.00, 105.00, 0.10, 0.10, 0.500000, 0.36, -0.3566, 0 },
      // elasticity
      {
   
    Option::Put,  100.00, 105.00, 0.10, 0.10, 0.500000, 0.36, -4.8775, 0 },
      // gamma
      {
   
    Option::Call,  60.00,  55.00,
最低0.47元/天 解锁文章

200万优质内容无限畅学
十三、欧拉离散化计算期权定价期权定价
微信号：RunsenLiu
05-23 2258
import numpy as np import pandas as pd from pandas_datareader import data as wb from scipy.stats import norm %matplotlib inline ticker = 'PG' data = pd.DataFrame() data[ticker] = wb.DataReader(tic...
python代码改写_QuantLib 金融计算——C++ 代码改写成 Python 程序的一些经验
weixin_39765325的博客
01-29 596
QuantLib 金融计算——C++ 代码改写成 Python 程序的一些经验概述Python 在科学计算、数据分析和可视化等方面已经形成了非常强大的生态。而且，作为一门时尚的脚本语言，易学易用。因此，对于量化分析和风险管理的从业者来说，将某些 QuantLib 的历史代码转换成 Python 程序是一件值得尝试的工作。Python 本身的面向对象机制非常完善，借助 SWIG 的包装，由 C++ ...
binomial-european-option-r:R中的二项式欧洲期权树
04-30
欧洲二项式期权定价R 以par-binomial.R的并行CPU使用为例 快速开始： 提供以下功能： binomial_option( type , sigma , T , r , X , S , N ) 在哪里： type ：欧洲看跌期权为“放盘”，欧洲看涨期权为“看涨” sigma ：较低的波动率。 0.33表示33％的波动率 T ：时间段。 1 = 1年。 0.25 = 3个月。 X ：行使价 S ：流动资产价格 N ：周期数。 N =级别数-1。即3个周期的模拟将包含4个级别（请不要忘记根！） 例子 call = binomial_option( type = ' call ' , sigma = 0.2 , T = 1 , r = 0.1 , X = 100 , S = 100 , N = 4 ) $ q [ 1 ] 0.6013857 $ stock
black-sholes 公式蒙特卡洛模拟
03-01
期权的定价方法之一，最直观，最简便的方法
使用C++期权定价
suese的专栏
07-29 4423
单期二叉树期权定价： #include // standard mathematical library. #include // defining the max() operator using namespace std; double option_price_call_european_binomial_single_period(const double& S, // spo
C++：实现量化欧洲期权扩展树测试实例（附带源码）
欢迎来到我的博客！这里是一个专注于计算机技术的分享平台，涵盖编程开发、算法研究、系统架构、软件工程等多个领域。无论你是初学者还是资深开发者，都能在这里找到有价值的内容。
01-17 628
在金融市场中，期权定价是一个复杂的任务。对于许多衍生品，尤其是欧洲期权，计算其公允价值是非常重要的。传统的定价方法包括Black-Scholes模型，而在实际交易中，更多时候需要对期权进行更为精确的定价。树形方法（例如二叉树法）是一种常见的数值方法，它通过构建一个期权价格的树结构来递归地计算期权的价值。
C++实现BlackScholes期权定价模型
标题“blackScholes”指的是布莱克-斯科尔斯模型（Black-Scholes model），这是一个广泛应用于金融领域的数学模型，用于估算欧式期权（European option）的理论价格。该模型由费希尔·布莱克（Fischer Black）和迈伦...
【揭秘二叉树模型】：构建基础并应用于期权定价的10大策略
# 1. 二叉树模型基础概念 ## 1.1 二叉树的定义和构成 二叉树是一种重要的数据结构，广泛用于计算机科学中的搜索和排序算法。在更广泛的意义上，它是一种具有特定规则的图数据结构，其中每一个节点（称为树节点）...
欧美期权定价C++程序开发解析
Black-Scholes模型是一个用于估算欧式期权定价的数学模型，由Fischer Black和Myron Scholes于1973年提出。该模型假设股票价格遵循几何布朗运动，并且市场是无摩擦的，即不存在交易成本和税收，股票可以无限细分，且...
二叉树模型编程实现：代码到期权定价的全步骤指南
[二叉树模型与期权定价](https://www.redalyc.org/journal/840/84064925004/1982-7849-rac-25-01-e200093-gf01.jpg) # 1. 二叉树模型基础和金融市场理论 在探索金融工程的复杂世界时，二叉树模型作为一项重要的工具...
蒙特卡洛估值计算(欧式期权）
机器会学习的博客
07-27 2万+
蒙特卡洛模拟是金融学和数值计算科学中最重要的算法之一，它在期权的定价个风险的管理上有很重要的作用，蒙特卡洛方法很容易处理高维度问题，在这种问题上复杂度和计算需求通常以线性方式增长． 主要参考Black-Scholes-Merton(BSM)模型，在模型中到期的指数水平是一个随机变量，通过到期指数公式计算：
用python进行简单欧式期权定价
云金杞
11-05 1万+
python3.5版本 源代码： ###期权计算 from math import log,sqrt,exp from scipy.stats import norm def call_option_pricer(spot,strike,maturity,r,vol):     d1=(log(spot/strike)+(r+0.5*vol*vol)*maturity)/vol/sqr
QuantLib教程（三）BS模型、二叉树模型与欧式期权定价
热门推荐
lyx的专栏
05-11 2万+
1.风险中性（risk-netural）与无套利假设 风险中性与无套利假设是期权定价公式的基础理论，或者说基石。我们来简单说说这两个是怎么回事吧。 现在有一个股票，价格为S0，那么t时间之后的价格是多少呢？或者说，期望价格是多少呢？这两个理论告诉我们是S0 * exp（r * t），其中，r是无风险利率。在一个理想环境中，我们可以以无风险利率借钱，也可以以无风险利率借给别人钱。 所以说，如果
QuantLib 金融计算——案例之普通欧式期权分析
weixin_30352645的博客
07-14 1808
目录 QuantLib 金融计算——案例之普通欧式期权分析 概述 普通欧式期权公式法定价 1. 配置期权合约条款 2. 构建期权对象 3. 配置定价引擎 4. 计算 题外话：天数计算规则 Quote ...
一欧元滤波器(OneEuroFilter)
weixin_41967328的博客
05-06 7619
一欧元滤波器(OneEuroFilter)
【PTA数据结构 | C语言版】堆中的路径
等风来
07-20 675
将一系列给定数字插入一个初始为空的最小堆 h。随后对任意给定的下标 i，打印从第 i 个结点到根结点的路径。输入格式:每组测试第 1 行包含 2 个正整数 n 和 m (≤10^3)，分别是插入元素的个数、以及需要打印的路径条数。下一行给出区间 [−10^4,10^4] 内的 n 个要被插入一个初始为空的小顶堆的整数。最后一行给出 m 个下标。输出格式:对输入中给出的每个下标 i，在一行中输出从第 i 个结点到根结点的路径上的数据。数字间以 1 个空格分隔，行末不得有多余空格。
CCF编程能力等级认证GESP—C++6级—20250628
QD_Jason的博客
07-19 2314
CCF编程能力等级认证GESP—C++6级—20250628
vscode gdb调试c语言过程
最新发布
m0_63472758的博客
07-22 153
主要是配置一下两个文件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

源代码大师

赏点狗粮吧

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值