import numpy as np
from math import sqrt, log
from scipy import stats
#
# 欧式期权BSM定价公式
def bsm_call_value(S0, K, T, r, sigma):
    """
    Parameters:
    ==========
    S0: float
        标的物初始价格水平
    K: float
       行权价格
    T: float
       到期日
    r: float
       固定无风险短期利率
    sigma: float
       波动因子
       
    Returns
    ==========
    value: float
    """
    S0 = float(S0)
    d1 = (np.log(S0 /K) + (r + 0.5 * sigma**2) * T )/(sigma * np.sqrt(T))
    d2 = (np.log(S0 /K) + (r - 0.5 * sigma**2) * T )/(sigma * np.sqrt(T))
    value = (S0 * stats.norm.cdf(d1, 0, 1) - K * np.exp(-r * T) * stats.norm.cdf(d2, 0, 1))
    return value
    
def bsm_vega(S0, K, T, r, sigma):
    """
    Vega 计算
    """
    S0 = float(S0)
    d1 = (np.log(S0/K)) + (r+0.5*sigma**2)*T /(sigma*sqrt(T))
    vega = S0 * stats.norm.cdf(d1, 0, 1) * np.sqrt(T)
    return vega

def bsm_call_imp_vol(S0, K, T, r, C0, sigma_est, it=100):
    for i in range(it):
        sigma_est -= ((bsm_call_value(S0, K, T, r, sigma_est) - C0)
                     / bsm_vega(S0, K, T, r, sigma_est))
    return sigma_est

S0 = 1
K = 2
T = 2
r = 0.01
sigma = 0.1
C0 = 0.01
bsm_call_imp_vol(S0, K, T, r, C0, sigma, it=100) 
# 牛顿迭代的收敛性很好 一般几步就能收敛了，牛顿迭代的关键是初值的选取，选不好很容易发散

import pandas as pd
h5 = pd.HDFStore('./vstoxx_data_31032014.h5','r') #使用 pandas.HDFStore 创建 
futures_data = h5['futures_data'] 
options_data = h5['options_data']
# 源文件中‘Data' 是 datetime64[ns] 时间类型，但是直接读取成了int64，因此将他的数据类型转换一下
futures_data['DATE'] = pd.to_datetime(futures_data['DATE']) 
options_data['DATE'] = pd.to_datetime(options_data['DATE'])
futures_data['MATURITY'] = pd.to_datetime(futures_data['MATURITY'])
options_data['MATURITY'] = pd.to_datetime(options_data['MATURITY'])
h5.close()
options_data.info() # 看一下期权数据的整体情况

options_data.head() # 看一下头几行长什么样

futures_data.head() # 看一下期货的头几行

V0 = 17.6639
r = 0.01
# imp_vol  -> implied volality
options_data['IMP_VOL'] = 0.0 # new colum for implied volatilities
tol = 0.5 # tolerance level for moneyness 
for option in options_data.index:
    # iterating over all option quotes
    item = options_data.loc[option] 
    forward = futures_data[futures_data['MATURITY']== \
                           item['MATURITY']]['PRICE'].values[0]
    # picking the right futures value
    if (forward * (1 - tol) < item['STRIKE'] 
        < forward*(1 + tol)):
        # only for options with moneyness tolerness 
        imp_vol = bsm_call_imp_vol(V0,
                                  item['STRIKE'],
                                  item['TTM'],
                                  r,
                                  item['PRICE'],
                                  sigma_est=2.,
                                  it=100)
        options_data['IMP_VOL'].loc[option] = imp_vol

plot_data = options_data[options_data['IMP_VOL']>0]
maturies = sorted(set(options_data['MATURITY'])) #到期日排序和去重 
matures # 可以看一下到期日情况

import matplotlib.pyplot as plt
plt.figure(figsize=(8, 6))
for maturity in maturies:
    data = plot_data[options_data.MATURITY==maturity]
    plt.plot(data['STRIKE'], data['IMP_VOL'], label=maturity.date(), lw=1.5
            )
    plt.plot(data['STRIKE'], data['IMP_VOL'], 'r.')
plt.grid(True)
plt.xlabel('strike')
plt.ylabel('implied volatility of volatility')
plt.legend()
plt.show()

S0 = 100
K = 105
T = 1.0
r = 0.05
sigma = 0.2
bsm_call_value(S0, K, T, r, sigma)

from time import time
from math import exp, sqrt, log
from random import gauss, seed
seed(20000)
t0 = time()
# 参数设定
S0 = 100.
K = 105.
T = 1.
r = 0.05
sigma = 0.2
M = 50 # 时间步长
dt = T / M
I = 250000
S = []

# M步循环
for i in range(I):
    path = []
    for t in range(M+1):
        if t == 0 :
            path.append(S0)
        else:
            z = gauss(0, 1)
            St = path[t-1] * exp((r - 0.5 * sigma **2) * dt 
                                + sigma * sqrt(dt) * z)
            path.append(St)
    S.append(path)
C0 = exp(-r * T) * sum([max(path[-1] - K, 0) for path in S])/ I
print(f'欧式期权定价 {C0}.')
print(f'共计花费时间 {np.round(time()-t0,1) }s.')

import math
import numpy as np
from time import time

np.random.seed(20000)
t0 = time()
# Parameters
S0 = 100.; K = 105.; T = 1.0; r = 0.05; sigma = 0.2
M = 50; dt = T/M; I = 250000

# Simulating I paths with M time steps
S = np.zeros((I, M+1))
S[:,0] = S0
for t in range(1,M+1):
    z = np.random.standard_normal(I) # pseudorandom numbers
    S[:,t] = S[:,t-1] * np.exp((r - 0.5 * sigma **2) * dt + sigma * math.sqrt(dt) *z)
C0 = math.exp(-r * T) *np.sum(np.maximum(S[:,-1]-K,0)) / I
tnp1 = time() - t0
print('Europen Option Value %7.3f' % C0)
print('Duration in Seconds %7.3F' % tnp1)

import math
import numpy as np
np.random.seed(20000)
t0 = time()
# Parameters
S0 = 100; K=105; T=1.; r=0.05; sigma=0.2
# Simulating I paths with M time steps
S = S0 * np.exp(np.cumsum((r-0.5*sigma**2)*dt + sigma * math.sqrt(dt)
                       * np.random.standard_normal((M+1, I)), axis=0
                      ))
S[0] = S0
C0 = math.exp(-r*T) * np.sum(np.maximum(S[-1]-K, 0))/I

print(f'欧式期权定价 {C0}.')
print(f'共计花费时间 {np.round(time()-t0,1) }s.')

import matplotlib.pyplot as plt
plt.plot(S[:, : 30])
plt.grid(True)
plt.xlabel('time step')
plt.ylabel('index level')
plt.show()

plt.hist(S[-1], bins=50)
plt.grid(True)
plt.xlabel('index level')
plt.ylabel('frequency')
plt.show()

plt.hist(np.maximum(S[-1] - K,0),bins = 50)
plt.grid()
plt.xlabel('option inner value')
plt.ylabel('frequency')
plt.ylim(0,50000)
plt.show()

import numpy as np
import pandas as pd
import pandas_datareader.data as web

sp500 = web.DataReader('^GSPC', data_source='yahoo',
                      start='3/14/2009', end='4/14/2014')
sp500.index.name = 'Date'
sp500.head()

sp500['42d'] = np.round(pd.Series.rolling(sp500['Close'],window=42).mean()) # 42日均线
sp500['252d'] = np.round(pd.Series.rolling(sp500['Close'],window=252).mean()) #252日均线
sp500[['Close','42d','252d']].plot(grid = True,figsize=(8,5))

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import tushare as ts

ts.set_token('tushare码')
pro = ts.pro_api()

pd.set_option('display.max_columns', 100)  # 设置显示数据的最大列数，防止出现省略号…，导致数据显示不全
pd.set_option('expand_frame_repr', False)  # 当列太多时不自动换行

df = pro.daily(ts_code='600000.SH', start_date='20200401', end_date='20200630')
df.head()

import pandas as pd
import pymysql
pymysql.install_as_MySQLdb() #为了兼容mysqldb
from sqlalchemy import create_engine
conn=create_engine('mysql+pymysql://用户名:密码@localhost:本地端口/mysql数据库名?charset=utf8')

# 股票每日交易数据入库
def daily_to_mysql():
    ts.set_token('token码')#设置token
    pro = ts.pro_api()
    df = pro.daily(ts_code='000001.SZ', start_date='20180701', end_date='20180718')
    df.to_sql('stock_daily_basic',con=conn,if_exists='append',index=False)
        

if __name__ == "__main__":
    daily_to_mysql()