[区块链] 多种期权知识点介绍与损益结构模拟

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 区块链 -> 多种期权知识点介绍与损益结构模拟 -> 正文阅读

[区块链]多种期权知识点介绍与损益结构模拟

多种期权知识点介绍与损益结构模拟

前言

期权是人们为了规避市场风险而创造出来的一种金融衍生工具（属于衍生品投资），理论和实践辨明，只要投资者合理地选择其手中证券和相应的衍生物比例，就可以获得无风险收益。期权这一类衍生品定价规则从上世纪70年代诞生出，为金融衍生市场提供了更大的繁荣与保证。

本篇文章将先介绍些期权的各种基本知识，剩下主要是学习下多种期权的payoff知识以及模拟它们的过程。

在这里插入图片描述

一：期权基础知识介绍

期权定义

1：买入期权：又称看涨期权（敲入期权），它是赋予期权持有者在给定的时间内（或在此时间的任意时刻）按规定价格买入一定数量某些资产的权利的一种法律合同
2：卖出期权：又称看跌期权（敲出期权），它是赋予期权持有者在给定的时间内（或在此时间的任意时刻）按规定价格卖出一定数量某些资产的权利的一种法律合同

行权方式

1：欧式行权：当行权观察日仅为到期日，该期权为欧式期权
2：美式行权：当期权期限内的每一天都为可提前行权观察日时，该期权变为美式期权
3：百慕大期权：一种可以在到期日前所规定的一系列时间行权的期权，其到期支付结构与欧式期权行相同

期权种类

根据期权交易场所不同分为场内期权和场外期权
1：场内期权：有标准化合约如商品期权白糖、豆粕期权等等、金融期权如50ETF等等
2：场外期权：非标准化合约如中证500指数期权、个股期权等等

根据标的资产不同有金融期权和实物期权
1：金融期权：普通期权如股票期权、外汇期权、利率期权、股票指数期权等等，嵌入式期权如可赎回证券、可退还证券、可转换证券等都包含有期权等等
2：实物期权：实物期权的标的资产是各种实物资产如铜、煤等等

根据期权种类可分为普通香草期权和奇异期权
1：普通香草期权：就是我们经常遇见的最标准的欧式、美式期权等等
2：奇异期权：奇异期权是比常规期权更复杂的衍生证券，这些产品通常是场外交易或嵌入结构债券，如二元期权、障碍期权、双鲨期权、雪球期权、凤凰期权等等

期权的平价组合

买入期权、卖出期权和标的资产三者之间存在一种价格的依赖关系，这种依赖关系就称为买入、卖出期权平价。以普通欧式期权为例，考察一下这种平价关系。
设 $S$ 为股票价格， $C$ 为买入期权价格， $P$ 为卖出期权价格， $E$ 为行权价， $S_T$ 为到期日股票价格， $t$ 为到行权日时间， $r$ 为市场利率。假设某投资者现在以价格 $C$ 出售一单位买入期权，以价格 $P$ 购入一单位卖出期权，以 $S$ 价格购入一单位期权标的股票，以利率 $r$ 借入一笔借期为 $t$ 的现金，按照贴现公式有金额为 $Ee^{-rt}$ 。以上的权利义务在到期日全部结清，在不考虑交易成本和税收情况下，投资者的现金在到期日的现金流量表如下：
在这里插入图片描述
由上表发现无论价格如何变化，组合价值为0。由于上述组合为无风险投资组合，所以期末价值为0。假设市场无套利机会，那么它的期初价值必然为0。即 $C+S=P+Ee^{-rt}$ 。这就是期权的平价公式。

二：期权定价理论简介期权定价要素

由于此篇文章重点在payoff理论学习，这里只做简单总结。但我们开始还是不得不对著名的伊藤公式做些介绍与推理。

对于布朗运动 $\{B_t,t\geq0\}$ 和伊藤过程 $dx_t=a(x,t)dt+b(x,t)dB_t$ ，

设 $f (x, t)$ 为定义在 $[0,\infty]\times R$ 上的二元连续可微函数，那么对于连续

不可微的 $dB_t$ 而言，由泰勒展开我们有

$df(x,t)=\frac{\partial f}{\partial t}dt+\frac{\partial f}{\partial x}dx_t+\frac{1}{2}\frac{\partial^2f}{\partial x^2}(dx_t)^2+o(|dx_t|dt)(1)$ ，

对于微分 $dx_t)^2$ 我们变形有

$dx_t)^2=a^2dtdt+2abdtdB_t+b^2dB_tdB_t$ ,再由伊藤等距性质有

$dx_t)^2=b^2(x_t,t)dt+o(dt)$ ，

带入上式 $（ 1 ）$ 式最终有

$df(x,t)=\left( \frac{\partial f}{\partial x}a+\frac{\partial f}{\partial t}+\frac{1}{2}\frac{\partial^2f}{\partial x^2}b^2 \right)dt+\frac{\partial f}{\partial x}bdB_t+o(|dx_t|dt)$ #。

期权定价要素

在这里插入图片描述

影响期权价格和对冲策略的因素

在介绍这个内容之前，我们再介绍下期权（价格为 $C$ ）受到当前标的价格 $S$ 、执行价格 $K$ 、期权的期限 $T$ 、标的资产价格波动率 $\sigma^2$ 以及无风险利率 $r$ 这五个因素影响，期权对这五个因素的敏感程度称为期权的 $G r e e k s$ ，由上述 $（ 1 ）$ 式的伊藤公式，我们得知其计算公式有如下表示：

1：期权 $\delta(Delta)$ 是考察期权价格随标的资产价格变化的关系，从数学角度看， $\delta$ 是期权价格对标的资产价格的偏导，有 $\delta=\frac{\partial C}{\partial S}$

2：期权 $\theta(Theta)$ 表示价格对于到期日的敏感程度，称为期权的时间损耗，有 $\theta=\frac{\partial C}{\partial\tau}$ ， $\theta>0$ 表示随着时间的推移带来盈利

3：期权 $\upsilon(Vega)$ 表示方差对期权价格的影响，有 $\upsilon=\frac{\partial C}{\partial\sigma}$ ，若 $\upsilon>0$ 表示随着方差率的增大，期权价格增大

4：期权 $\rho(Rho)$ 表示期权的价值随利率波动的敏感度，有 $\rho=\frac{\partial C}{\partial r}$ ，若利率增大，那么期权价值变大

5：期权 $\Gamma(Gamma)$ 表示 $\delta$ 与标的资产价格的变动关系，有 $\Gamma=\frac{\partial^2C}{\partial S^2}$ ，由于是平方项，没有方向性

期权的定价主要方法（简单罗列）

1：公式法：基于Black-Scholes推导的求解相关期权的解析法，优点在于比较直接，计算量小，但无解析解的无能为力，而且要很高深的数学理论支持

2：二叉树法：对于路径依赖或者没解析法的期权，此法优点在于简单直观，无需太深的数学知识，但计算量比较大

3：蒙特卡洛（包括最小二乘蒙特卡洛）：依据风险中性定价原则，尽可能模拟风险中性时间中标的资产的多种运动途径，计算每一条路径下的期权回报均值，再贴现就可以得到期权价值，虽比较“万能”，但要想精确，计算量是相当大的，尤其对于场外奇异期权的定价，很多时候都以此法作为根基

三：普通香草期权的payoff组合

对于香草期权，我们以欧式期权为例，对于到期持有者收益为

看涨期权： $m a x (S ? K ? c, ? c)$ （注：这里的 $c$ 为期权合约价格，一般简化 $c = 0$ ）

看跌期权： $m a x (K ? S ? c, ? c)$

我们用代码模拟上述结构收益与组合收益

import matplotlib.pyplot as plt
import pylab as mpl
import numpy as np
mpl.rcParams['font.sans-serif']=['SimHei']##中文乱码问题！
plt.rcParams['axes.unicode_minus']=False#横坐标负号显示问题！

s = list(range(0,200))##价格列表
x = [i for i in range(1,len(s)+1)]
ref = [0 for i in range(1,len(s))]
loc = max(s) / 2
k1 = 100
k2 = 120
p = 1###参与率
c1 = -0##期权价格
c2 = -0
def makefigure(l,text,k,loc,c,ref):
    plt.figure(figsize=(15, 8))
    plt.plot(x,l)
    plt.plot(ref)
    plt.ylabel('Payoff',fontsize=18)
    plt.xlabel('S',fontsize=18)
    plt.title(text,fontsize=18)
    plt.tick_params(labelsize=15)
    plt.annotate('行权价：%s（c1=%s,c2=-5）'%(k,c), xy=(k,c), xytext=(k,loc),arrowprops=dict(arrowstyle="fancy"),fontsize=15)
    return plt.show()

def call_Vanillaoption(k,s,c=0):
    ls = []
    for i in s:
        res = max(p * (i - k),0)
        ls.append(res + c)
    return ls
resc = call_Vanillaoption(k1,s,c1)
#makefigure(resc,'Call',k1,loc/2,c1,ref)

def put_Vanillaoption(k,s,c=0):
    ls = []
    for i in s:
        res = max(p * (k - i),0)
        ls.append(res + c)
    print(ls)
    return ls
resp = put_Vanillaoption(k2,s,c2)
#makefigure(resp,'Put',k1,loc/2,c2,ref)

我们先出入一个最简单的看跌期权结果

在这里插入图片描述

图1

当行权价为100，执行价为120，期权合约价格0，参与率为1的看跌期权收益如上图1，当我们调整参与率为0.8，期权价格为-10时，图像变为如下图2，在这里插入图片描述

图2

注：参与率就是参与这项交易的量的比例，如行权价格100，现资产价格120，正常一张欧式看跌期权赚20，但现在只有0.8张期权参与，即16，再减去合约价格10，最后净赚6！也就是 K-S 的斜率！

我们再来看欧式看跌与看涨期权的组合收益结构

###买入一张看涨一张看跌，行权价不同相同时（相同也同样如此）
res = np.array(resc) + np.array(resp)
makefigure(res,'Call+Put',k1,loc/2,c1,ref)

我们选择购买一张看涨期权的行权价为100，同时买一涨看跌期权行权价为120，合约价格为-20，参与率为1（如下不说明，正常都为1），看下payoff组合结果，

在这里插入图片描述

图3

解释：比如期权到期标的价格为0，那我们买入的看涨期权将作废，但买期权已经损失20，可是买入的看跌期权盈利120块，再减去两张合约价格为120-20-20=80；又比如到期标的价格为108，那么看涨期权将行权以100块买入108的标的资产，赚8元，看跌期权将以行权价120卖出资产赚12，但两张期权价格为40，则净赚20-40=-20（实际这种情况期权费远没这么高，这里只是出于模拟给的数值）。

我们再来看看同时买入一张期权价格为100和卖出一张期权价格为120，期权合约为10的payoff组合情况，

##买一张看涨，卖一张看涨期权的收益结构图
tr1 = np.array(call_Vanillaoption(k1,s,c1))
tr2 = - np.array(call_Vanillaoption(k2,s,c1))
bsres = tr1 + tr2
makefigure(bsres,'Call1-Call2',k1,max(bsres)/5,c1,ref)

在这里插入图片描述

图4

解释：由于是同时买入卖出，那么其实期权价格一出一入将抵消，那么当标的价格为50时，由于我们买入的期权将作废，但卖出的期权给了别人，行权价是120，所以别人也不会行权，两张期权其实都是虚值存在，没任何意义；若此时的标的价格为105，那么买入的行权价100的期权将赚5，但卖出的期权行权价为120，别人依旧不会行权。

最后我们买入一张行权价为100的看跌期权和卖出行权价为120的看跌期权，其中买的看跌期权价格为5，卖出的看涨期权为10，这种比较复杂的payoff组合如下图，

tr1 = np.array(put_Vanillaoption(k1,s,c2))
tr2 = - np.array(call_Vanillaoption(k2,s,c1))
bsres = tr1 + tr2
makefigure(bsres,'Put1-Call2',k1,max(bsres)/5,c1,ref)

在这里插入图片描述

图5

四：障碍奇异期权的payoff

奇异期权种类很多，前面的内容也提到过一些，我们这里主要是对障碍期权做一些介绍。

障碍期权是指在其生效过程中受到一定限制的期权，其目的是把投资者的收益或损失控制在一定范围之内。单障碍期权一般归为两类，即敲出期权和敲入期权。敲出期权是指当标的资产价格达到一个特定障碍水平时，该期权作废；敲入期权当只有当标的资产价格达到一个特定障碍水平时，该期权才有效。

同理还有多障碍期权，那就对应多个障碍价格，触及多个障碍条件来对应期权行权情况。

我们以欧式单障碍期权说起，来模拟对应的payoff，并根据图来写出payoff公式，这样更方便理解！

对于看涨期权，向下敲入和向上敲出本质是一样的！B<K没意义

在这里插入图片描述

图6

图6所示给的障碍价格为130，执行价格为100，合约价格为10的看涨期权，对于向下敲入（向上敲出）看涨期权，我们有payoff结构如下：

$payoff=max(S-K-c,-c),S<H;payoff=-c,S\geq H$

对于看涨期权，向上敲入和向下敲出本质是一样的！B和K的大小没有要求！

在这里插入图片描述

图7

图7所示给的障碍价格为120，执行价格为100，合约价格为10的看涨期权，对于向上敲入（向下敲出）看涨期权，我们有payoff结构如下：

$payoff=max(S-K-c,-c),S\geq H;payoff=-c,S< H$

对于看跌期权，向下敲入和向上敲出本质是一样的，B和K的大小没有要求！

在这里插入图片描述

图8

图8所示给的障碍价格为180，执行价格为150，合约价格为10的看跌期权，对于向下敲入（向上敲出）看跌期权，我们有payoff结构如下：

$H;payoff=-c,S\geq H$

对于看跌期权，向上敲入和向下敲出本质是一样的，B和K的大小没有要求！B>K没意义！

在这里插入图片描述

图9

图9所示给的障碍价格为50，执行价格为150，合约价格为10的看跌期权，对于向上敲入（向下敲出）看跌期权，我们有payoff结构如下：

$payoff=max(K-S-c,-c),S\geq H;payoff=-c,S< H$

给出模拟代码如下：

import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']##中文乱码问题！
plt.rcParams['axes.unicode_minus']=False#横坐标负号显示问题！

class barrieroption:

    def __init__(self, s, k, pc, pp, c):  # 定义内置初始化函数
        self.s = s
        self.k = k
        self.pc = pc
        self.pp = pp
        self.c = c
        self.x = [i for i in range(1, len(s) + 1)]
        self.ref = [0 for i in range(len(s))]

    def makefigure(self,l,text,k,b,ly):
        plt.figure(figsize=(15, 8))
        plt.plot(self.x,l)
        plt.plot(self.ref)
        plt.ylabel('Payoff', fontsize=18)
        plt.xlabel('S', fontsize=18)
        plt.title(text, fontsize=18)
        plt.tick_params(labelsize=15)
        plt.annotate('行权价（K）：%s（c=%s）' % (k,c), xy=(k,c), xytext=(k,ly), arrowprops=dict(arrowstyle="fancy"),
                     fontsize=15)
        plt.annotate('障碍价（B）：%s（c=%s）' % (b,c), xy=(b-1,c), xytext=(b,ly/2.5),
                     arrowprops=dict(arrowstyle='->'), fontsize=15)
        return plt.show()

    ###Call
    def call_Vanillaoption(self):
        ls = []
        for i in s:
            res = max(pc * (i - k),0)
            ls.append(res + c)
        return ls
    #向上敲出call（向下敲入call）##b<k没意义
    def upoutcall(self,tls,b):
        for i in range(len(tls)):
            if s[i] > b:
                tls[i] = c
            else:
                pass
        return tls
    ##向上敲入call（向下敲出call）
    def upincall(self,tls,b):
        for i in range(len(tls)):
            if s[i] <= b:
                tls[i] = c
            else:
                pass
        return tls

    #######Put
    def put_Vanillaoption(self):
        ls = []
        for i in s:
            res = max(pp * (k - i),0)
            ls.append(res + c)
        return ls
    ##向下敲入put（向上敲出put）
    def downinput(self,tls,b):
        for i in range(len(tls)):
            if s[i] >= b:
                tls[i] = c
            else:
                pass
        return tls
    # 向下敲出put(向上敲入put)b>k没意义
    def downoutput(self,tls,b):
        for i in range(len(tls)):
            if s[i] < b:
                tls[i] = c
            else:
                pass
        return tls

s = list(range(1,200))
k = 150
b1 = 130
b2 = 120
b3 = 180
b4 = 50
pc = 1###参与率
pp = 1###参与率
c = -10
res = barrieroption(s, k, pc, pp, c)
res11 = barrieroption.call_Vanillaoption(res)
# res12 = barrieroption.upoutcall(res,res11,b1)
# res13 = barrieroption.makefigure(res,res12,'Up-out-call&Down-in-call',k,b1,max(res12)/5)
# res14 = barrieroption.upincall(res,res11,b2)
# res15 = barrieroption.makefigure(res,res14,'Up-in-call&Down-out-call',k,b2,max(res14)/5)
####################################
res21 = barrieroption.put_Vanillaoption(res)
# res22 = barrieroption.downinput(res,res21,b3)
# res23 = barrieroption.makefigure(res,res22,'Down-in-put&Up-out-put',k,b3,max(res22)/5)
res24 = barrieroption.downoutput(res,res21,b4)
res25 = barrieroption.makefigure(res,res24,'Down-out-put&Up-in-put',k,b4,max(res24)/5)