精华内容
下载资源
问答
  • 用Python快速计算隐含波动

    千次阅读 2021-02-11 01:53:15
    你必须意识到隐含波动计算计算成本很高,如果你想要实时数据,也许python不是最好的解决方案。这里是一个你需要的函数的例子。import numpy as npfrom scipy.stats import normN = norm.cdfdef bs_call(S, K, T,...

    你必须意识到隐含波动率计算的计算成本很高,如果你想要实时数据,也许python不是最好的解决方案。

    这里是一个你需要的函数的例子。

    import numpy as np

    from scipy.stats import norm

    N = norm.cdf

    def bs_call(S, K, T, r, vol):

    d1 = (np.log(S/K) + (r + 0.5*vol**2)*T) / (vol*np.sqrt(T))

    d2 = d1 - vol * np.sqrt(T)

    return S * norm.cdf(d1) - np.exp(-r * T) * K * norm.cdf(d2)

    def bs_vega(S, K, T, r, sigma):

    d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))

    return S * norm.pdf(d1) * np.sqrt(T)

    def find_vol(target_value, S, K, T, r, *args):

    MAX_ITERATIONS = 200

    PRECISION = 1.0e-5

    sigma = 0.5

    for i in range(0, MAX_ITERATIONS):

    price = bs_call(S, K, T, r, sigma)

    vega = bs_vega(S, K, T, r, sigma)

    diff = target_value - price # our root

    if (abs(diff) < PRECISION):

    return sigma

    sigma = sigma + diff/vega # f(x) / f'(x)

    return sigma # value wasn't found, return best guess so far

    计算一个单一的值是足够快的

    S = 100

    K = 100

    T = 11

    r = 0.01

    vol = 0.25

    V_market = bs_call(S, K, T, r, vol)

    implied_vol = find_vol(V_market, S, K, T, r)

    print ('Implied vol: %.2f%%' % (implied_vol * 100))

    print ('Market price = %.2f' % V_market)

    print ('Model price = %.2f' % bs_call(S, K, T, r, implied_vol))

    隐含波动率:25.00%

    市场价格=35.94

    模型价格=35.94

    但如果你试着计算很多,你会发现需要一些时间......

    %%time

    size = 10000

    S = np.random.randint(100, 200, size)

    K = S * 1.25

    T = np.ones(size)

    R = np.random.randint(0, 3, size) / 100

    vols = np.random.randint(15, 50, size) / 100

    prices = bs_call(S, K, T, R, vols)

    params = np.vstack((prices, S, K, T, R, vols))

    vols = list(map(find_vol, *params))

    墙时间:10.5秒

    展开全文
  • 1. 请问股票波动率如何计算波动率的计算: 江恩理论认为,波动率分上升趋势的波动率计算方法和下降趋势的波动率计算方法。1、上升趋势的波动率计算方法是:在上升趋势中,底部与底部的距离除以底部与底部的相隔时间...

    1. 请问股票波动率如何计算

    波动率的计算: 江恩理论认为,波动率分上升趋势的波动率计算方法和下降趋势的波动率计算方法。

    1、上升趋势的波动率计算方法是:在上升趋势中,底部与底部的距离除以底部与底部的相隔时间,取整。 上升波动率=(第二个底部-第一个底部)/两底部的时间距离 2、下降趋势的波动率计算方法是:在下降趋势中,顶部与顶部的距离除以顶部与顶部的相隔时间,取整。

    并用它们作为坐标刻度在纸上绘制。 下降波动率=(第二个顶部-第一个顶部)/两顶部的时间距离 拓展资料: 股市波动率的类型: 1、实际波动率 实际波动率又称作未来波动率,它是指对期权有效期内投资回报率波动程度的度量,由于投资回报率是一个随机过程,实际波动率永远是一个未知数。

    或者说,实际波动率是无法事先精确计算的,人们只能通过各种办法得到它的估计值。 2、历史波动率 历史波动率是指投资回报率在过去一段时间内所表现出的波动率,它由标的资产市场价格过去一段时间的历史数据(即St的时间序列资料)反映。

    这就是说,可以根据{St}的时间序列数据,计算出相应的波动率数据,然后运用统计推断方法估算回报率的标准差,从而得到历史波动率的估计值。 显然,如果实际波动率是一个常数,它不随时间的推移而变化,则历史波动率就有可能是实际波动率的一个很好的近似。

    3、预测波动率 预测波动率又称为预期波动率,它是指运用统计推断方法对实际波动率进行预测得到的结果,并将其用于期权定价模型,确定出期权的理论价值。 因此,预测波动率是人们对期权进行理论定价时实际使用的波动率。

    这就是说,在讨论期权定价问题时所用的波动率一般均是指预测波动率。需要说明的是,预测波动率并不等于历史波动率。

    4、隐含波动率 隐含波动率是期权市场投资者在进行期权交易时对实际波动率的认识,而且这种认识已反映在期权的定价过程中。从理论上讲,要获得隐含波动率的大小并不困难。

    由于期权定价模型给出了期权价格与五个基本参数(St,X,r,T-t和σ)之间的定量关系,只要将其中前4个基本参数及期权的实际市场价格作为已知量代入期权定价模型,就可以从中解出惟一的未知量σ,其大小就是隐含波动率。因此,隐含波动率又可以理解为市场实际波动率的预期。

    参考链接:百度百科:波动率指数。

    2. 请问股票波动率如何计算

    波动率的计算:

    江恩理论认为,波动率分上升趋势的波动率计算方法和下降趋势的波动率计算方法。

    1、上升趋势的波动率计算方法是:在上升趋势中,底部与底部的距离除以底部与底部的相隔时间,取整。

    上升波动率=(第二个底部-第一个底部)/两底部的时间距离

    2、下降趋势的波动率计算方法是:在下降趋势中,顶部与顶部的距离除以顶部与顶部的相隔时间,取整。并用它们作为坐标刻度在纸上绘制。

    下降波动率=(第二个顶部-第一个顶部)/两顶部的时间距离

    拓展资料:

    股市波动率的类型:

    1、实际波动率

    实际波动率又称作未来波动率,它是指对期权有效期内投资回报率波动程度的度量,由于投资回报率是一个随机过程,实际波动率永远是一个未知数。或者说,实际波动率是无法事先精确计算的,人们只能通过各种办法得到它的估计值。

    2、历史波动率

    历史波动率是指投资回报率在过去一段时间内所表现出的波动率,它由标的资产市场价格过去一段时间的历史数据(即St的时间序列资料)反映。这就是说,可以根据{St}的时间序列数据,计算出相应的波动率数据,然后运用统计推断方法估算回报率的标准差,从而得到历史波动率的估计值。

    显然,如果实际波动率是一个常数,它不随时间的推移而变化,则历史波动率就有可能是实际波动率的一个很好的近似。

    3、预测波动率

    预测波动率又称为预期波动率,它是指运用统计推断方法对实际波动率进行预测得到的结果,并将其用于期权定价模型,确定出期权的理论价值。

    因此,预测波动率是人们对期权进行理论定价时实际使用的波动率。这就是说,在讨论期权定价问题时所用的波动率一般均是指预测波动率。需要说明的是,预测波动率并不等于历史波动率。

    4、隐含波动率

    隐含波动率是期权市场投资者在进行期权交易时对实际波动率的认识,而且这种认识已反映在期权的定价过程中。从理论上讲,要获得隐含波动率的大小并不困难。

    由于期权定价模型给出了期权价格与五个基本参数(St,X,r,T-t和σ)之间的定量关系,只要将其中前4个基本参数及期权的实际市场价格作为已知量代入期权定价模型,就可以从中解出惟一的未知量σ,其大小就是隐含波动率。因此,隐含波动率又可以理解为市场实际波动率的预期。

    参考链接:百度百科:波动率指数

    3. 如何用matlab计算期权价格

    参考论文 期权定价理论是现代金融学中最为重要的理论之一,也是衍生金融工具定价中最复杂的。

    本文给出了欧式期权定价过程的一个简单推导,并利用Matlab对定价公式给出了数值算例及比较静态分析,以使读者能更直观地理解期权定价理论。 关键词:Matlab;教学实践 基金项目:国家自然科学基金项目(70971037);教育部人文社科青年项目(12YJCZH128) 中图分类号:F83 文献标识码:A 收录日期:2012年4月17日 现代金融学与传统金融学最主要的区别在于其研究由定性分析向定量分析的转变。

    数理金融学即可认为是现代金融学定量分析分支中最具代表性的一门学科。定量分析必然离不开相应计算软件的应用,Matlab就是一款最为流行的数值计算软件,它将高性能的数值计算和数据图形可视化集成在一起,并提供了大量内置函数,近年来得到了广泛的应用,也为金融定量分析提供了强有力的数学工具。

    一、Black-Scholes-Merton期权定价模型 本节先给出B-S-M期权定价模型的简单推导,下节给出B-S-M期权定价模型的Matlab的实现。设股票在时刻t的价格过程S(t)遵循如下的几何Brown运动: dS(t)=mS(t)dt+sS(t)dW(t) (1) 无风险资产价格R(t)服从如下方程: dR(t)=rR(t)dt (2) 其中,r,m,s>0为常量,m为股票的期望回报率,s为股票价格波动率,r为无风险资产收益率且有0 lnS(T):F[lnS(t)+(m-s2/2)(T-t),s■] (3) 欧式看涨期权是一种合约,它给予合约持有者以预定的价格(敲定价格)在未来某个确定的时间T(到期日)购买一种资产(标的资产)的权力。

    在风险中性世界里,标的资产为由式(1)所刻画股票,不付红利的欧式看涨期权到期日的期望价值为:■[max(S(T)-X,0)],其中■表示风险中性条件下的期望值。根据风险中性定价原理,不付红利欧式看涨期权价格c等于将此期望值按无风险利率进行贴现后的现值,即: c=e-r(T-1)■[max{S(T)-X,0}] (4) 在风险中性世界里,任何资产将只能获得无风险收益率。

    因此,lnS(T)的分布只要将m换成r即可: lnS(T):F[lnS(t)+(r-s2/2)(T-t),s■] (5) 由式(3)-(4)可得欧式看涨期权价格: c=S(t)N(d1)-Xe-r(T-1)N(d2) (6) 这里: d1=■ (7) d2=■=d1-s■ (8) N(x)为均值为0标准差为1的标准正态分布变量的累积概率分布函数。S(t)为t时刻股票的价格,X为敲定价格,r为无风险利率,T为到期时间。

    欧式看跌期权也是一种合约,它给予期权持有者以敲定价格X,在到期日卖出标的股票的权力。 下面推导欧式看涨期权c与欧式看跌期权p的联系。

    考虑两个组合,组合1包括一个看涨期权加上Xe-r(T-1)资金,组合2包含一个看跌期权加上一股股票。于是,在到期时两个组合的价值必然都是: max{X,S(T)} (9) 欧式期权在到期日之前是不允许提前执行的,所以当前两个组合的价值也必相等,于是可得欧式看涨期权与看跌期权之间的平价关系(put-call parity): c+Xe-r(T-t)=p+S(t) (10) 由式(10)可得,不付红利欧式看跌期权的价格为: p=Xe-r(T-t)N(-d2)-S(t)N(-d1) (11) 二、Black-Scholes-Merton模型的Matlab实现 1、欧式期权价格的计算。

    由式(6)可知,若各参数具体数值都已知,计算不付红利的欧式看涨期权的价格一般可以分为三个步骤:先算出d1,d2,涉及对数函数;其次计算N(d1),N(d2),需要查正态分布表;最后再代入式(6)及式(11)即可得欧式期权价格,涉及指数函数。不过,欧式期权价格的计算可利用Matlab中专有blsprice函数实现,显然更为简单: [call,put]=blsprice(Price,Strike,Rate,Time,Volatility) (12) 只需要将各参数值直接输入即可,下面给出一个算例:设股票t时刻的价格S(t)=20元,敲定价格X=25,无风险利率r=3%,股票的波动率s=10%,到期期限为T-t=1年,则不付红利的欧式看涨及看跌期权价格计算的Matlab实现过程为: 输入命令为:[call,put]= blsprice(20,25,0.03,0.1,1) 输出结果为:call=1.0083 put=5.9334 即购买一份标的股票价格过程满足式(1)的不付红利的欧式看涨和看跌期权价格分别为1.0083元和5.9334元。

    2、欧式期权价格的比较静态分析。也许纯粹计算欧式期权价格还可以不利用Matlab软件,不过在授课中,教师要讲解期权价格随个参数的变化规律,只看定价公式无法给学生一个直观的感受,此时可利用Matlab数值计算功能及作图功能就能很方便地展示出期权价格的变动规律。

    下面笔者基于Matlab展示欧式看涨期权价格随各参数变动规律: (1)看涨期权价格股票价格变化规律 输入命令:s=(10∶1∶40);x=25;r=0.03;t=1;v=0.1; c=blsprice(s,x,r,t,v); plot(s,c,'r-.') title('图1看涨期权价格股票价格变化规律'); xlabel('股票价格');ylabel('期权价值');grid on (2)看涨期权价格随时间变化规律 输入命令:s=20;x=25;r=0.03;t=(0.1∶0.1∶2);v=0.1;c=blsprice(s,x,r,t,v); plot(t,c,'r-.') title('图2看涨期权价格随时间变化规律'); xlabel('到期时间');ylabel('期权价值');grid on (3)看涨期权价格随无风险利率变化规律 s=20;x=25;r=(0.01∶0.01∶0.5);t=1;v=0.1;c=blsprice(s,x,r,t,v); plot(r,c,'r-.') title('图3看涨期权价格随无风险利率变化规律'); xlabel('无风险利率');ylabel('期权价值');grid on (4)看涨期权价格随波动率变化规律 s=20;x=25;r=0.03;。

    4. matlab 如何从wind中获取股票数据 收盘 开盘 最高 最低 交易量

    所有的股市及时数据信息都在交易所或证监会,他们不开放数据给自己,自己是无法获取的。

    收市价又称收盘价,通常指某种证券在证券交易所每个交易日里的最后一笔买卖成交价格。如果某种证券当日没有成交,则采用Recently一成交价作为收盘价。初次上市的证券,以其上市前公开销售的平均价格作为收盘价。如果证券交易所每日开前、后两市,则会出现前市收盘价和后市收盘价,一般来说,证券交易所后市收盘价为当日收盘价。在我国深圳证券交易所和上海证券交易所,股票收市价的确定有所不同,深圳证券交易所股票收市价是以每个交易日最后一分钟内的所有成交加权平均计算得出的,而上海证券交易所则以最后一笔成交价格作为收盘价。

    开盘价又称开市价,是指某种证券在证券交易所每个交易日开市后的第一笔每股买卖成交价格。世界上大多数证券交易所都采用成交额最大原则来确定开盘价。

    如果开市后一段时间内(通常为半小时)某种证券没有买卖或没有成交,则取前一日的收盘价作为当日证券的开盘价。如果某证券连续数日未成交,则由证券交易所的场内中介经纪人根据客户对该证券买卖委托的价格走势提出指导价,促使成交后作为该证券的开盘价。在无形化交易市场中,如果某种证券连续数日未成交,以前一日的收盘价作为它的开盘价。

    股市成交量为股票买卖双方达成交易的数量,是单边的,例如,某只股票成交量为十万股,这是表示以买卖双方意愿达成的,在计算时成交量是十万股,即:买方买进了十万股,同时卖方卖出十万股。而计算交易量则双边计算,例如买方十万股加卖方十万股,计为二十万股。股市成交量反映成交的数量多少。一般可用成交股数和成交金额两项指标来衡量。目前深沪股市两项指标均能显示出来。

    5. 实际波动率的背景及算法简介

    实际波动率的理论背景主要是基于收益分解和二次变动理论。

    假定N*1对数价格向量Pt,遵循如下多变量连续时间随机波动扩散模型:

    dPt = μtdt + ΩtdWt (1)

    Wt表示N维布朗运动过程,Ωt为N*N维正定扩散矩阵,且严格平稳。条件于样本路径特征μt和Ωt下,在[t,t+h]上连续复合收益为:

    rt + h,h = Pt + h − Pt (2)

    展开全文
  • 《欧式期权定价(BS方法delta和隐含波动计算)》由会员分享,可在线阅读,更多相关《欧式期权定价(BS方法delta和隐含波动计算)(20页珍藏版)》请在人人文库网上搜索。1、简单使用Matlab financial toolbox,...

    《欧式期权定价(BS方法delta值和隐含波动率计算)》由会员分享,可在线阅读,更多相关《欧式期权定价(BS方法delta值和隐含波动率计算)(20页珍藏版)》请在人人文库网上搜索。

    1、简单使用Matlab financial toolbox,演示者:最帅的联系人:1517992897邮箱:ustncuishuai,简单使用Matlab financial toolbox,Financial toolbox Financial derivatives toolbox Financial time series toolbox fixed-income toolbox GARCH,1 .欧洲期权定价,1.1二叉树定价函数;1.2欧洲期权定价函数;1.3计算欧洲选项delta值;1.4欧洲选项的隐含波动率;1、了解和掌握欧洲期权定价功能的使用。2、完成PPT实例运算;3、填写并提。

    2、交实验报告。(报告要求:独立完成,提供截图程序操作过程和练习问题答案;命名方法:班级学号名称报告标题,学习要求,1.2欧洲选项价格函数,调用方法:call,put=输入bls price (price,strike,rate,time,volatity,yifield)%:callCall%欧洲货币选项价格Put%欧洲价格,如何调用欧洲选项定价功能,股价100,股价波动标准偏差0.5,无风险利率10%,期权执行价格95,持有期限0.25年,试图计算此股票欧洲期权价格。示例1,在MATLAB中,运行以下命令:call,put=bls price (100,95,0.1,0.25,0.5)的结果:。

    3、call=13.6953 put=6.3497如以上结果所示,该股票的欧洲长款期权价格为110,1.3计算欧洲选项delta值,call Delta,put delta=bls delta (price,strike,rate,time,volatiility,yield),调用欧洲选项Delta值函数的方式CallDelta%欧洲未来选项价格PutDelta%欧洲汇兑选项价格,尝试股票价格为50,股票波动性标准偏差为0.3,无风险利率为10%,期权执行价格为50,有效期为0.25年,期权delta值。,示例2,在Matlab中,运行以下命令:call Delta,put Delta=bls 。

    4、delta (50,50,0.1,0.25,0.3,0)call Delta=0.5955 put Delta=-0.4045扩展选项Delta值0.5955,1.4推导欧洲期权隐含波动率、已知欧洲期权价格、隐含波动率的标准偏差,然后将隐含波动率与实际波动率进行比较,并用作投资决策的参考。volatity=blsimpv (price,strike,rate,time,value,limit,yield,tolerance,Type),隐式可变性,示例3,一家无股息股票的强势期权的市值为2.5美元,股价为15美元,执行价为13美元,期限为3个月,无风险利率为每年5%,隐含波动率是多少?在Mat。

    5、lab中,运行以下命令:volatiility=blsimpv (15,13,0.05,0.25,2.5,0,call) volatity=0.3964在这些条件下计算的所有隐式可变性为0,实验问题1,计算以下无股息股票的欧式强势期权价格:其中股价为52美元,执行价格为50美元,无风险利率为12%,波动性为30%,期限为3个月。实验问题2,计算以下无股息股票的欧式判官期权价格。其中,股价为69美元,执行价为70美元,无风险利率为每年5%,波动性为35%,期限为6个月。实验问题3,分别计算实验1的欧洲购物车选项delta值和实验2的欧洲足球选项delta值,并说明其表达的意义。假设实验4,股价为100美元,执行价为95美元,该目标资产的欧式长龙期权价格为10美元,生存时间为3个月,无风险利率为7.5%,并且隐含波动率不大于0.5的兴趣(每年50%)。隐含波动率是多少?而且。

    展开全文
  • 前段时间在项目里写了一个计算投资风险指标的计算工具类,包含夏普比率,波动率,Var,最大回撤率四个指标。 计算全部采用BigDecimal类型,开方计算采用牛顿迭代法计算。 其计算公式如下: 工具类实现: /** * @...

    去年在项目里写了一个计算投资风险指标的计算工具类,包含夏普比率,波动率,Var值,最大回撤率四个指标。
    计算全部采用BigDecimal类型,开方计算采用牛顿迭代法计算。
    其计算公式如下:
    在这里插入图片描述
    工具类实现:

    /**
     * @describe 投资分析数学计算工具类
     */
    public class MathUtil {
        /**
         * 默认保留小数位数
         */
        private final static Integer DECIMAL_SCALE = 15;
        /**
         * 默认牛顿迭代法计算平方根时迭代次数
         */
        private final static Integer PRECISION = 20;
        private final static Integer COUNT = 0;
    
        /**
         * @describe 计算收益率     *  @params   startNav  期初单位净值  endNav  期末单位净值
         */
        public static BigDecimal dayYield(BigDecimal startNav, BigDecimal endNav) {
            return dayYield(startNav, endNav, DECIMAL_SCALE);
        }
    
        public static BigDecimal dayYield(BigDecimal startNav, BigDecimal endNav, int decimalScale) {
            return dayYield(startNav, endNav, decimalScale, BigDecimal.ROUND_HALF_UP);
        }
    
        public static BigDecimal dayYield(BigDecimal startNav, BigDecimal endNav, int decimalScale, int roundingMode) {
            BigDecimal dValue = endNav.subtract(startNav);
            return dValue.divide(startNav, decimalScale, roundingMode);
        }
    
        /**
         * @describe 计算累计求和
         */
        public static BigDecimal sum(BigDecimal[] dataArray) {
            BigDecimal sum = BigDecimal.ZERO;
            for (BigDecimal data : dataArray) {
                sum = sum.add(data);
            }
            return sum;
        }
    
        /**
         * @describe 计算算术平均值
         */
        public static BigDecimal avg(BigDecimal[] dataArray) {
            return avg(dataArray, DECIMAL_SCALE);
        }
    
        public static BigDecimal avg(BigDecimal[] dataArray, int decimalScale) {
            return avg(dataArray, decimalScale, BigDecimal.ROUND_HALF_UP);
        }
    
        public static BigDecimal avg(BigDecimal[] dataArray, int decimalScale, int roundingMode) {
            BigDecimal sum = sum(dataArray);
            BigDecimal count = new BigDecimal(dataArray.length);
            return sum.divide(count, decimalScale, roundingMode);
        }
    
        /**
         * @describe 计算样本方差
         */
        public static BigDecimal variance(BigDecimal[] dataArray) {
            return variance(dataArray, DECIMAL_SCALE);
        }
    
        public static BigDecimal variance(BigDecimal[] dataArray, int decimalScale) {
            return variance(dataArray, decimalScale, BigDecimal.ROUND_HALF_UP);
        }
    
        public static BigDecimal variance(BigDecimal[] dataArray, int decimalScale, int roundingMode) {
            BigDecimal avg = avg(dataArray, decimalScale, roundingMode);
            BigDecimal[] resultArray = new BigDecimal[dataArray.length];
            for (int i = 0; i < dataArray.length; i++) {
                BigDecimal dValue = dataArray[i].subtract(avg);
                resultArray[i] = dValue.multiply(dValue);
            }
            BigDecimal sum = sum(resultArray);
            BigDecimal count = new BigDecimal(resultArray.length - 1);
            return sum.divide(count, decimalScale, roundingMode);
        }
    
        /**
         * @describe 计算平方根
         */
        public static BigDecimal standardDeviation(BigDecimal data) {
            return standardDeviation(data, DECIMAL_SCALE);
        }
    
        public static BigDecimal standardDeviation(BigDecimal data, int decimalScale) {
            return standardDeviation(data, decimalScale, BigDecimal.ROUND_HALF_UP);
        }
    
        public static BigDecimal standardDeviation(BigDecimal data, int decimalScale, int roundingMode) {
            BigDecimal result = data;
            int count = COUNT;
            while (count < PRECISION && result.compareTo(BigDecimal.ZERO) != 0) {
                result = (result.add(data.divide(result, decimalScale, roundingMode))).divide(BigDecimal.valueOf(2), decimalScale, roundingMode);
                count++;
            }
            return result;
        }
    
        /**
         * @describe 计算夏普比率
         */
        public static BigDecimal sharpeRatio(BigDecimal[] yieldArray, BigDecimal drVal, BigDecimal vol) {
            return sharpeRatio(yieldArray, drVal, vol, DECIMAL_SCALE);
        }
    
        public static BigDecimal sharpeRatio(BigDecimal[] yieldArray, BigDecimal drVal, BigDecimal vol, int decimalScale) {
            return sharpeRatio(yieldArray, drVal, vol, decimalScale, BigDecimal.ROUND_HALF_UP);
        }
    
        public static BigDecimal sharpeRatio(BigDecimal[] yieldArray, BigDecimal drVal, BigDecimal vol, int decimalScale, int roundingMode) {
            BigDecimal avg = avg(yieldArray, decimalScale, roundingMode);
            BigDecimal variance = variance(yieldArray, decimalScale, roundingMode);
            BigDecimal standardDeviation = standardDeviation(variance, decimalScale, roundingMode);
            return avg.subtract(drVal).divide(standardDeviation, decimalScale, roundingMode).multiply(vol).setScale(decimalScale, roundingMode);
        }
    
        /**
         * @describe 计算波动率
         */
        public static BigDecimal yieldVar(BigDecimal[] yieldArray, BigDecimal vol) {
            return yieldVar(yieldArray, vol, DECIMAL_SCALE);
        }
    
        public static BigDecimal yieldVar(BigDecimal[] yieldArray, BigDecimal vol, int decimalScale) {
            return yieldVar(yieldArray, vol, decimalScale, BigDecimal.ROUND_HALF_UP);
        }
    
        public static BigDecimal yieldVar(BigDecimal[] yieldArray, BigDecimal vol, int decimalScale, int roundingMode) {
            BigDecimal variance = variance(yieldArray, decimalScale, roundingMode);
            BigDecimal standardDeviation = standardDeviation(variance, decimalScale, roundingMode);
            return standardDeviation.multiply(vol).setScale(decimalScale, roundingMode);
        }
    
        /**
         * @describe 计算Var
         */
        public static BigDecimal var(BigDecimal[] yieldArray, BigDecimal zVal) {
            return var(yieldArray, zVal, DECIMAL_SCALE);
        }
    
        public static BigDecimal var(BigDecimal[] yieldArray, BigDecimal zVal, int decimalScale) {
            return var(yieldArray, zVal, decimalScale, BigDecimal.ROUND_HALF_UP);
        }
    
        public static BigDecimal var(BigDecimal[] yieldArray, BigDecimal zVal, int decimalScale, int roundingMode) {
            BigDecimal variance = variance(yieldArray, decimalScale, roundingMode);
            BigDecimal standardDeviation = standardDeviation(variance, decimalScale, roundingMode);
            return standardDeviation.multiply(zVal).setScale(decimalScale, roundingMode);
        }
    
        /**
         * @describe 计算最大回撤率
         */
        public static BigDecimal maxRetracement(BigDecimal[] dataArray) {
            return maxRetracement(dataArray, DECIMAL_SCALE);
        }
    
        public static BigDecimal maxRetracement(BigDecimal[] dataArray, int decimalScale) {
            return maxRetracement(dataArray, decimalScale, BigDecimal.ROUND_HALF_UP);
        }
    
        public static BigDecimal maxRetracement(BigDecimal[] yieldArray, int decimalScale, int roundingMode) {
            BigDecimal maxRetracement = BigDecimal.ZERO;
            BigDecimal maxTotalYield = BigDecimal.ZERO;
            BigDecimal totalDayYield = BigDecimal.ZERO;
            for (int i = 1; i < yieldArray.length; i++) {
                totalDayYield = (totalDayYield.add(BigDecimal.ONE)).multiply(yieldArray[i].add(BigDecimal.ONE)).subtract(BigDecimal.ONE);
                if (totalDayYield.compareTo(maxTotalYield) >= 0) {
                    maxTotalYield = totalDayYield;
                } else {
                    BigDecimal retracement = maxTotalYield.subtract(totalDayYield).divide(BigDecimal.ONE.add(maxTotalYield), decimalScale, roundingMode);
                    maxRetracement = retracement.compareTo(maxRetracement) > 0 ? retracement : maxRetracement;
                }
            }
            return maxRetracement;
        }
    
        /**
         * @describe 用资产净值计算日收益率数组
         */
        public static BigDecimal[] yieldArray(BigDecimal[] assetArray, BigDecimal[] cashFlowArray) {
            //日收益率数组
            BigDecimal[] yieldArray = new BigDecimal[assetArray.length - 1];
            for (int i = 0; i < assetArray.length - 1; i++) {
                yieldArray[i] = dayYield(assetArray[i], assetArray[i + 1].subtract(cashFlowArray[i + 1]));
            }
            return yieldArray;
        }
    
        /**
         * @describe 用单位净值计算日收益率数组
         */
        public static BigDecimal[] yieldArray(BigDecimal[] navArray) {
            // 日收益率数组
            BigDecimal[] yieldArray = new BigDecimal[navArray.length - 1];
            for (int i = 0; i < navArray.length - 1; i++) {
                yieldArray[i] = dayYield(navArray[i], navArray[i + 1]);
            }
            return yieldArray;
        }
    }
    
    
    展开全文
  • 在Black-Scholes期权定价模型中,不能直接观察到的参数只有股票价格的波动率。波动率可以由历史数据进行估计,这是历史波动率。隐含波动率也是交易员非常关心的,隐含波动率是期权的市场价格中所包含的波动率,即由...
  • luckzpz - 像爱惜自己生命一样保护本金 赞同来自: import easyquotation import pandas as pd import numpy as np import ...['name']+'的年化波动率估算为%.3f%%' %(std*100)) calculate_volatility('601199')
  • 什么是隐含波动率_隐含波动率的计算公式及平稳性什么是隐含波动率隐含波动率是将市场上的权证交易价格代入权证理论价格模型,反推出来的波动率数值。香港市场称为“引伸波幅”。从理论上讲,要获得隐含波动率的大小...
  • ​​ 数量技术宅团队在CSDN学院推出了量化投资系列课程 ... 量化投资速成营(入门课程) Python股票量化投资 ...隐含波动率概述 ...Black-Scholes 将期权...在本文中,我们使用的波动是对未来已实现价格波动率的估计.
  • 投资组合收益率、波动率的计算
  • python计算上证50ETF的已实现波动

    千次阅读 2021-03-24 20:02:51
    本文使用某个交易日内的上证50ETF的5分钟收盘价(原始数据:),计算该交易日的已实现波动率。日度已实现波动率的计算公式如下: 同时,周度已实现波动率和月度已实现波动率的计算公式如下: import pandas as pd ...
  • 那么期权交易者又怎么知道IV是高还是低呢?IV对于不同属性的标的物来说是不同的。对于指数来说,25算是较高的IV,对于大型股票而言,30是低,然而对于高度波动的小型股票来说,IV达到80也不算太高。那么,如何判断...
  • 相关题目与解析计算机工作电压的波动范围允许为15%。()计算机逻辑电路的工作电压为()。一般电动机允许电压波动范围为额定电压的()。硅整流器的电源电压波动范围允许()。计算机的工作电压应为:()EI32-JD型计算机联锁...
  • 最方便的方法,去这个网址:http://www.soarcorp.com/black_scholes_calculator.jsp 可以计算价格和各种Greeks。 已知价格想倒退隐含波动率去这里:...
  • 附件中三个文件,一个是DFA.m,是用来计算对应给定时间间隔n的F(n);另一个是runDFA.m,用来执行计算的,其中调用了前面的DFA函数,这个要根据你的需要自己稍作修改,其中我在这里将时间取值设置为log坐标下等距...
  • [MATLAB] BS期权隐含资产(implied asset)和隐含波动率(implied volatility)计算 迭代法 源码程序
  • 本文主要是关于PT1000的相关介绍,并着重对PT1000电阻转化为温度计算公式进行了详尽的阐述。PT1000PT1000是铂热电阻,它的阻值会随着温度的变化而改变。原理PT后的1000即表示它在0℃时阻值为1000欧姆,在300℃...
  • 下图绘制了1990-2019年标准普尔500指数收益率相对于VIX指数的滚动平均(VIX指数衡量了标准普尔100指数平价期权的隐含波动率)。它说明了股票收益率和这种波动率的度量如何反向变化,在此期间负相关系数为-0.54。 ...
  • 均值、方差、均方、均方差计算

    千次阅读 2021-02-05 09:23:37
    3、均方均方表示信号平方后的均值,用E(x^2)表示。均方表示信号的平均功率。信号的平均功率=信号交流分量功率信号直流分量功率例如:x、y、z3项求均方。均方=(x的平方y的平方z的平方)/34、...
  • 【转自半美人】matlab 实现 garch 模型波动率估计代码高亮问题数据获取数据处理描述性统计时间序列平稳性检验相关和偏自相关arch效应检验建立 garch 模型波动率估计代码及文档地址代码高亮问题这边首先说一个问题,...
  • Matlab求解資产隐含波动率及无风险利率初探Matlab求解资产隐含波动率及无风险利率初探A Primary Explore into Fluctuation Standard Deviation and Non-risk Interest of an Asset Via Matlab吴义能本文发表于《武汉...
  • 基金:波动率、收益率、贝塔系数、最大回撤率、夏普比率一、波动率与收益率1.基金波动率2.波动率的应用 一、波动率与收益率 价格波动会产生价差,价差能创造收益。基金市场的价格波动相对平稳,但下述两个指标依然...
  • 摘要:基于不同的波动率,对香草期权进行delta对冲,并检验对冲收益的统计性质。对于单个期权或相同标的的期权组合,作者推导了对冲收益的均值和方差的形式。 文章目录读书笔记1. 前言1.1假设条件1.2 符号表示2. ...
  • 二维波动方程matlab

    2021-04-27 01:35:44
    MATLAB编辑一维波动方程的模拟的程序_数学_自然科学_专业资料。Fpg 一维波动方程の模拟 程序:...实验环境(所用软件、硬件等)及实验数据文件 Matlab %二维波动方程数值计算(关键:怎么运用 i,j,k 三个指标建立循环) cl...
  • 一、知识点介绍1.1 历史模拟法我们在之前有用到Delta-Normal的GARCH和RiskMetrics方法来计算VaR和ES,假设的是残差满足正态分布,对残差进行二次相关序列的建模并拟合残差,能够得到未来的预测。而这里说的历史...
  • 更简单地说,我们经常看到在高波动性或低波动性时期的聚类,因此我们可以利用近期的波动性来预测近期的波动性。 我们将使用SPY价格来说明波动率的模型。下面的图显示了SPY收益率。 colnames(SPYRet) <- c('...
  • 摘要:该文研究波动数据的处理与分析方法。波动性数据在各个行业的应用实践中,经常出现,对该类数据的处理方法的研究,具有重要的理论与实用价值。波动数据有的很有周期规律性,例如复合周期函数型的电子信号;有的...
  • 一维波动方程matlab

    2021-04-23 12:56:28
    一维波动方程的有限差分法 实验项目类型 验证 演示 综合 设计 其他 指导教 师 曾芳 成绩 是 一.实验目的 通过该实验,要求学生掌握求解一维波动方程的有限差分法......第七章 一维波动方程的解题方法及习题答案_数学_...
  • 在使用Ta-lib计算MACD与KDJ 篇中给出了使用python talib模块计算MACD 和 KDJ的方法,除了这两个指标,本篇再结合该模块,取下BOLL 布林线、RSI 强弱指数、OBV成交量三个指标。一、BOLL布林线布林线指标,即BOLL...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,338
精华内容 18,935
关键字:

如何计算波动值