PROMETHUES delta irate 函数 delta means change

导航

• 风险对冲
• Delta对冲
• Theta对冲
• Gamma对冲
• Vega对冲
• Rho对冲
• 案例

• 解析

• 参考资料

风险对冲

风险对冲是指通过投资或者购买与标的资产收益波动负相关的某种资产或者衍生证券，来冲销标的资产潜在损失的一种策略.

Delta对冲

$\Delta$定义为其他变量不变时期权价格变化$\Delta c$与标的资产价格变化$\Delta S$的比率
$\Delta=\frac{\Delta c}{\Delta S}$
在使用Delta对冲风险时，需要定期调整对冲头寸，否则会承担头寸风险暴露风险.
不支付红利的股票欧式看涨期权的Delta为
$\Delta=N(d_1)$
在对一个看涨期权空头进行$\Delta$对冲时，在任何时候需要同时持有数量为$N(d_1)$的标的资产多头.
不支付红利的股票欧式看跌期权$\Delta$为
$\Delta=N(d_1)-1<0$
看跌期权的多头需要用标的资产的多头头寸来对冲风险.

Theta对冲

$\Theta$定义为在其他变量不变期间期权价格变化相对于权利期变化的比率
$\Theta=\frac{\partial c}{\partial(T-t)}$
不支付红利的股票欧式看涨期权的$\Theta$为
$\Theta=\frac{\partial c}{\partial(T-t)}=-Sn(d_1)\frac{1}{2}\sigma\frac{1}{\sqrt{T-t}}-rKe^{-r(T-t)}N(d_2)$
其中
$n(x)=\frac{1}{\sqrt{2\pi}}e^{-\frac{x^2}{2}}$
不支付红利的股票欧式看跌期权的$\Theta$为
$\Theta=\frac{\partial}{\partial (T-t)}=-Sn(d_1)\frac{1}{2}\sigma\frac{1}{\sqrt{T-t}}+rKe^{-r(T-t)}N(-d_2)$

Gamma对冲

$\Gamma$反映了资产价格变动对期权$\Delta$变动的影响程度
$\Gamma=\frac{\partial \Delta}{\partial S}$
$\Gamma$大小反映了为了保持$\Delta$中性而需要调整的头寸，不支付红利的欧式看涨期权和看跌期权的$\Gamma$均为
$\Gamma=\frac{n(d_1)}{S\sigma\sqrt{T-t}}$

Vega对冲

Vega定义为其他量不变时，期权价格$c$变化对标的资产波动率$\sigma$变化的比率
$Vega=\frac{\partial c}{\partial \sigma}$
投资组合管理者需要缩小期权的Vega，将波动率的变化造成的损失降低到最小
$Vega=Sn(d_1)\sqrt{T-t}$

Rho对冲

$\rho$定义为其他变量不变时，期权价格$c$变化与利率$r$变化之间的比率，即
$\rho=\frac{\partial c}{\partial r}$
一般看涨期权的$\rho$值大于零，看跌期权的$\rho$值小于零.
不支付红利股票的欧式看涨期权$\rho$值为
$\rho=K(T-t)N(d_2)e^{-r(T-t)}$
不支付红利股票的欧式看跌期权$\rho$值为
$\rho=-K(T-t)N(-d_2)e^{-r(T-t)}$

案例

考虑一个不支付红利股票的欧式看涨期权，其标的资产价格是$50$，行权价格是$50$，无风险利率是$10\%$，年波动利率是$30\%$，权利期间还有6个月，求相关参数

解析

预处理参数$d_1, d_2$和$n(x)$
$\begin{aligned} &d_1=\frac{\ln(S/K)+(r+\sigma^2/2)(T-t)}{\sigma\sqrt{T-t}}\\ &d_2=\frac{\ln(S/K)+(r-\sigma^2/2)(T-t)}{\sigma\sqrt{T-t}}=d_1-\sigma\sqrt{T-t}\\ &n(d_1)=\frac{1}{\sqrt{2\pi}}e^{-\frac{d_1^2}{2}} \end{aligned}$
根据公式计算对冲参数
$\begin{aligned} &\Delta=N(d_1)\\ &\Theta=-50n(d_1)*\frac{1}{2}*\sigma*\frac{1}{\sqrt{T-t}}-0.1*50*e^{-0.1*0.5}N(d_2)\\ &\Gamma=\frac{n(d_1)}{50*0.3*\sqrt{0.5}}\\ &V=50*n(d_1)*\sqrt{0.5}\\ &\rho=50*0.5*N(d_2)*e^{-0.1*0.5} \end{aligned}$
cpp计算对冲参数

#include<iostream>
#include<vector>
#include<cmath>
#include<cstring>
#include<cassert>
#include<iomanip>
#include<random>
#include<map>
using namespace std;

const double pi=3.1415926;

double N(const double &x){
    if(x>6.0) return 1.0;
    if(x<-6.0) return 0.0;
    double b1=0.31938153;
    double b2=-0.356563782;
    double b3=1.781477937;
    double b4=-1.821255978;
    double b5=1.330274429;
    double p=0.2316419;
    double c=1.0/sqrt(2*pi);
    double a=fabs(x);
    double k=1.0/(1+a*p);
    double b=c*exp(-pow(x, 2)/2.0);
    double n=((((b5*k+b4)*k+b3)*k+b2)*k+b1)*k;
    n=1.0-b*n;
    if(x<0.0) n=1.0-n;
    return n;
}

void hedge_parameters(const double &S, const double &K, const double &r, const double &sigma, const double &tm, double &Delta, double &Gamma, double &Theta, double &Vega, double &Rho){
    double d1=(log(S/K)+(r+pow(sigma, 2)/2)*tm)/(sigma*sqrt(tm));
    double d2=d1-sigma*sqrt(tm);
    double nd1=exp(-pow(d1, 2)/2)/(sqrt(2*pi));
    Delta=N(d1);
    Gamma=nd1/(S*sigma*sqrt(tm));
    Theta=-(S*sigma*nd1)/(2*sqrt(tm))-r*K*exp(-r*tm)*N(d2);
    Vega=S*sqrt(tm)*nd1;
    Rho=K*tm*exp(-r*tm)*N(d2);
}

int main(){
    double S=50, K=50, r=0.10, sigma=0.30, tm=0.5;
    double Delta, Gamma, Theta, Vega, Rho;
    hedge_parameters(S, K, r, sigma, tm, Delta, Gamma, Theta, Vega, Rho);
    cout<<"Delta: "<<Delta<<endl;
    cout<<"Gamma: "<<Gamma<<endl;
    cout<<"Theta: "<<Theta<<endl;
    cout<<"Vega: "<<Vega<<endl;
    cout<<"Rho: "<<Rho<<endl;
    
    return 0;
}

python计算对冲参数

from scipy.stats import norm as N
from scipy.stats import multivariate_normal as mvn
from math import log, exp, pi
import numpy as np

def hedge_p(S, K, r, sigma, tm):
    d1=(log(S/K)+(r+sigma**2/2)*(tm))/(sigma*sqrt(tm))
    d2=d1-sigma*sqrt(tm)
    nd1=exp(-d1**2/2)/sqrt(2*pi)
    
    Delta=N.cdf(d1)
    Gamma=nd1/(S*sigma*sqrt(tm))
    Theta=-(S*sigma*nd1)/(2*sqrt(tm))-r*K*exp(-r*tm)*N.cdf(d2)
    Vega=S*sqrt(tm)*nd1
    Rho=K*tm*exp(-r*tm)*N.cdf(d2)
    
    print('Delta: {}'.format(Delta))
    print('Gamma: {}'.format(Gamma))
    print('Theta: {}'.format(Theta))
    print('Vega: {}'.format(Vega))
    print('Rho: {}'.format(Rho))
    
hedge_p(50, 50, 0.1, 0.3, 0.5)