二叉树期权定价

1. 以两步二叉树欧式看涨期权定价为例

2. 代码实现

（1）欧式看涨期权

import numpy as np
#二叉树法为欧式看涨期权定价
def binarytree_europcall(S,K,r,sigma,t,steps):
    '''
    S: 标的资产初始价格；
    K: 期权的执行价格；
    r: 年化无风险利率；
    sigma: 标的资产连续复利收益率的标准差；
    t:以年表示的时间长度；
    steps:二叉树的步长。
    '''
    u = np.exp(sigma*np.sqrt(t/steps))#时间间隔为△t=t/steps
    d = 1/u
    P = (np.exp(r*t/steps)-d)/(u-d)
    prices = np.zeros(steps+1)
    c_values = np.zeros(steps+1)
    prices[0] = S*d**steps#生成最后一列的股票价格空数组
    c_values[0] = np.maximum(prices[0]-K,0)#生成最后一列的期权价值空数组
    for i in range(1,steps+1):
        prices[i] = prices[i-1]*(u**2)#计算最后一列的股票价格
        c_values[i] = np.maximum(prices[i]-K,0)#计算最后一列的期权价值
    for j in range(steps,0,-1):#逐个节点往前计算
        for i in range(0,j):
            c_values[i] = (P*c_values[i+1]+(1-P)*c_values[i])*np.exp(-r*t/steps)
    return c_values[0]
A1 = binarytree_europcall(S=810,K=800,r=0.05,sigma=0.2,t=0.5,steps=2)
print('二叉树法为欧式看涨期权定价：',round(A1,2))

 

（2）美式看涨期权

       相比欧式期权，美式期权需要先计算提前行权的收益判断是否提前行权。提前行权的收益为本节点上股票的预期价格减执行价格。如果收益大于期权价值，说明提前行权获利更多，因此会提前行权；反之则不会。

#二叉树法为美式看涨期权定价
def binarytree_ameripcall(S,K,r,sigma,t,steps):
    '''
    S: 标的资产初始价格；
    K: 期权的执行价格；
    r: 年化无风险利率；
    sigma: 标的资产连续复利收益率的标准差；
    t:以年表示的时间长度；
    steps:二叉树的步长。
    '''
    u = np.exp(sigma*np.sqrt(t/steps))#时间间隔为△t=t/steps
    d = 1/u
    P = (np.exp(r*t/steps)-d)/(u-d)
    prices = np.zeros(steps+1)
    c_values = np.zeros(steps+1)
    prices[0] = S*d**steps#生成最后一列的股票价格空数组
    c_values[0] = np.maximum(prices[0]-K,0)#生成最后一列的期权价值空数组
    for i in range(1,steps+1):
        prices[i] = prices[i-1]*(u**2)#计算最后一列的股票价格
        c_values[i] = np.maximum(prices[i]-K,0)#计算最后一列的期权价值
    for j in range(steps,0,-1):#逐个节点往前计算
        for i in range(0,j):
            prices[i] = prices[i+1]*d#判断是否提前行权
            c_values[i] = np.maximum((P*c_values[i+1]+(1-P)*c_values[i])*np.exp(-r*t/steps),prices[i]-K)
    return c_values[0]
A2 = binarytree_ameripcall(S=810,K=800,r=0.05,sigma=0.2,t=0.5,steps=2)
print('二叉树法为美式看涨期权定价：',round(A2,2))

（3）欧式看跌期权

#二叉树法为欧式看跌期权定价
def binarytree_europcall(S,K,r,sigma,t,steps):
    '''
    S: 标的资产初始价格；
    K: 期权的执行价格；
    r: 年化无风险利率；
    sigma: 标的资产连续复利收益率的标准差；
    t:以年表示的时间长度；
    steps:二叉树的步长。
    '''
    u = np.exp(sigma*np.sqrt(t/steps))#时间间隔为△t=t/steps
    d = 1/u
    P = (np.exp(r*t/steps)-d)/(u-d)
    prices = np.zeros(steps+1)
    c_values = np.zeros(steps+1)
    prices[0] = S*d**steps#生成最后一列的股票价格空数组
    c_values[0] = np.maximum(K-prices[0],0)#生成最后一列的期权价值空数组
    for i in range(1,steps+1):
        prices[i] = prices[i-1]*(u**2)#计算最后一列的股票价格
        c_values[i] = np.maximum(K-prices[i],0)#计算最后一列的期权价值
    for j in range(steps,0,-1):#逐个节点往前计算
        for i in range(0,j):
            c_values[i] = (P*c_values[i+1]+(1-P)*c_values[i])*np.exp(-r*t/steps)
    return c_values[0]
B1 = binarytree_europcall(S=29,K=30,r=0.03,sigma=0.25,t=1,steps=2)
print('二叉树法为欧式看跌期权定价：',round(B1,2))

（4）美式看跌期权

#二叉树法为美式看跌期权定价
def binarytree_ameripcall(S,K,r,sigma,t,steps):
    '''
    S: 标的资产初始价格；
    K: 期权的执行价格；
    r: 年化无风险利率；
    sigma: 标的资产连续复利收益率的标准差；
    t:以年表示的时间长度；
    steps:二叉树的步长。
    '''
    u = np.exp(sigma*np.sqrt(t/steps))#时间间隔为△t=t/steps
    d = 1/u
    P = (np.exp(r*t/steps)-d)/(u-d)
    prices = np.zeros(steps+1)
    c_values = np.zeros(steps+1)
    prices[0] = S*d**steps#生成最后一列的股票价格空数组
    c_values[0] = np.maximum(K-prices[0],0)#生成最后一列的期权价值空数组
    for i in range(1,steps+1):
        prices[i] = prices[i-1]*(u**2)#计算最后一列的股票价格
        c_values[i] = np.maximum(K-prices[i],0)#计算最后一列的期权价值
    for j in range(steps,0,-1):#逐个节点往前计算
        for i in range(0,j):
            prices[i] = prices[i+1]*d#判断是否提前行权
            c_values[i] = np.maximum((P*c_values[i+1]+(1-P)*c_values[i])*np.exp(-r*t/steps),K-prices[i])
    return c_values[0]
B2 = binarytree_ameripcall(S=29,K=30,r=0.03,sigma=0.25,t=1,steps=2)
print('二叉树法为美式看涨期权定价：',round(B2,2))