def testify_CFS_IV(S0, strike, T, r, q, fixVol, N1, N2, quantile):
import BlackScholesOption
import matplotlib.pyplot as plt
numLoop = 10
(a, b) = preprocessing.calculateToleranceInterval(S0, strike, T, r, q,
fixVol, quantile)
coeffs_var = calculateImpliedVarianceCoefficientArray(
S0, strike, T, r, q, fixVol, N1, N2, quantile, a, b)
inverse_coeffs = series_reversion.inverseSeries(coeffs_var)
# V0 = BlackScholesOption.putOptionPriceBSM(S0, strike, T, r, q, sigma)
targetSigma = np.array([(i + 1) * 0.1 for i in range(10)])
target_vars = np.power(targetSigma, 2)
var_estimations = np.zeros(numLoop)
for i in range(numLoop):
target_sigma_i = targetSigma[i]
V_i = BlackScholesOption.putOptionPriceBSM(S0, strike, T, r, q,
target_sigma_i)
var_i = target_sigma_i**2
Vi_List = [(V_i - coeffs_var[0])**l
for l in range(len(inverse_coeffs))]
var_estimations[i] = np.exp(-r * T) * np.dot(inverse_coeffs, Vi_List)
print("CFS: target var", target_vars)
print("CFS: var estimation", var_estimations)
return
def testifyExchangeSumOrder(S0, strike, T, r, q, sigma, a, b, N1, N2,
quantile):
import BlackScholesOption
chfk_IV = calculateChfkIV_CFS(S0, strike, T, r, q, sigma, a, b, N1, N2)
chfk = calculate_chfk_BSM_CFS(S0, strike, T, r, q, sigma, a, b, N1)
# coeffs_volT = calculateIVCoefficientArray(S0,strike,T,r,q,sigma,N1,N2,quantile)
coeffs_var = calculateImpliedVarianceCoefficientArray(
S0, strike, T, r, q, sigma, N1, N2, quantile, a, b)
Vk = calculate_Vk_put_CFS(a, b, N1, strike)
print("Vk", Vk)
print("coeffs of var", coeffs_var)
V0 = BlackScholesOption.putOptionPriceBSM(S0, strike, T, r, q, sigma)
V1 = np.exp(-r * T) * np.dot(chfk, Vk)
V2 = np.exp(-r * T) * np.dot(chfk_IV, Vk)
varl = [(sigma**2)**l for l in range(N2)]
V3 = np.exp(-r * T) * np.dot(coeffs_var, varl)
print("Black Scholes Value:", V0)
print("put price using original chf in CFS method:", V1)
print("chf represented as a w power series:", V2)
print(
"exchange summation order, and let V represented as a var power series:",
V3)
inverse_coeffs = series_reversion.inverseSeries(coeffs_var)
print("inverse coeffs:", inverse_coeffs)
var_true = sigma**2
y = V0 * np.exp(r * T) - coeffs_var[0]
yl = [y**l for l in range(11)]
var_est = np.dot(inverse_coeffs, yl)
print("compare", var_est, var_true)
return
def calculateImpliedVolatilityByPutOptionPrice(S0,
strike,
T,
r,
q,
price,
quantile,
N1,
N2,
fixPoint,
showDuration=False):
(a, b) = preprocessing.calculateToleranceInterval(S0, strike, T, r, q,
fixPoint, quantile)
m = preprocessing.calculateConstantTerm(S0, strike, T, r, q, a)
tick = time.time()
# coeffs = calculateCoefficientList(strike, m, a, b, numGrid=N1, truncationOrder=N2)
# inverseCoeffs = inverseSeries(coeffs)
# y = price * np.exp(r * T) - coeffs[0]
# omega = polyval(y, inverseCoeffs)
# # print(omega,T)
# volEstimation = np.sqrt(omega/T)
coeffs = calculateCoefficientList(strike,
m,
a,
b,
numGrid=N1,
truncationOrder=N2)
# print("coeff for COS:", coeffs)
# inverseCoeffs_old = inverseSeries_old(coeffs)
inverseCoeffs = inverseSeries(coeffs)
print("new", inverseCoeffs)
# print("old", inverseCoeffs_old)
# print(inverseCoeffs)
y = price * np.exp(r * T) - coeffs[0]
w = polyval(y, inverseCoeffs)
print("w", w)
# print("T*sigmaBSM**2", sigmaBSM ** 2 * T)
# print("absolute error:", (w - sigmaBSM ** 2 * T))
volEstimation = np.sqrt(w / T)
tack = time.time()
if (showDuration == True):
print("consuming time for calculating implied volatility:",
tack - tick)
return volEstimation
def testify_IV(S0, strike, T, r, q, a, b, N1, N2, quantile, fixVol):
# import matplotlib.pyplot as plt
sigmaList = np.array([(i + 1) * 0.1 for i in range(10)])
varEstimation = np.zeros(10)
# wEstimation = np.zeros(10)
# (a,b)=preprocessing.calculateToleranceInterval(S0,strike,T,r,q,fixVol,quantile)
# (a,b)=(-5,5)
m = preprocessing.calculateConstantTerm(S0, strike, T, r, q, a)
coeffs = calculateCoefficientList(strike, m, a, b, N1, N2)
inverseCoeffs = inverseSeries(coeffs)
putPriceTrue = []
putPriceIV = []
for i in range(10):
sigma = sigmaList[i]
putPrice = BlackScholesOption.putOptionPriceBSM(
S0, strike, T, r, q, sigma)
putPriceTrue.append(putPrice)
w = [(sigma**2 * T)**l for l in range(len(coeffs))]
putPriceIV.append(np.dot(coeffs, w) * np.exp(-r * T))
y = putPrice * np.exp(r * T) - coeffs[0]
yList = [y**l for l in range(len(inverseCoeffs))]
# todo: cann't use len(coeffs)
w = np.dot(yList, inverseCoeffs)
varEstimation[i] = w / T
# wEstimation[i] = w
# print(sigmaEstimation-sigmaList)
print("COS: fixVol", fixVol)
print("COS: sigma list", sigmaList)
print("COS: target price", putPriceTrue)
print("COS: price estimations", putPriceIV)
print("COS: target vars", sigmaList**2)
print("COS: var estimations", varEstimation)
# plt.plot(-sigmaList+sigmaEstimation)
# plt.plot(wEstimation-sigmaList**2*T)
# plt.plot((-sigmaList+sigmaEstimation)/sigmaList)
# plt.show()
return
def testifyVarSeries(S0, strike, T, r, q, sigma, N1, N2, quantile, a, b):
import BlackScholesOption
import matplotlib.pyplot as plt
coeffs_var = calculateImpliedVarianceCoefficientArray(
S0, strike, T, r, q, sigma, N1, N2, quantile, a, b)
inverse_coeffs = series_reversion.inverseSeries(coeffs_var)
# V0 = BlackScholesOption.putOptionPriceBSM(S0, strike, T, r, q, sigma)
V_BSM_list = []
V_CFSIV_list = []
for sigma_i in np.linspace(0.1, 0.8, 8):
V_i = BlackScholesOption.putOptionPriceBSM(S0, strike, T, r, q,
sigma_i)
var_i = sigma_i**2
var_list = [var_i**l for l in range(len(coeffs_var))]
V_i_CFSIV = np.exp(-r * T) * np.dot(coeffs_var, var_list)
V_BSM_list.append(V_i)
V_CFSIV_list.append(V_i_CFSIV)
plt.plot(V_BSM_list)
plt.plot(V_CFSIV_list)
print("sigma_i", np.linspace(0.1, 0.8, 8))
print("V_BSM_LIST", V_BSM_list)
print("V_CFSIV_LIST", V_CFSIV_list)
plt.show()
return
print("priory error estimation:",errorUpperBound)
putPriceCOS = COS_expansion_utils.putOptionPriceCOS(S0,strike,T,r,q,sigmaBSM,quantile=quantile,numGrid=N1,showDuration=True)
print("put price:", putPriceCOS)
print("absolute error:", np.abs(putPriceCOS-putPriceBSM))
callPriceCOS = COS_expansion_utils.callOptionPriceCOS(S0,strike,T,r,q,sigmaBSM,quantile,numGrid=N1,showDuration=True)
print("call price:", callPriceCOS)
print("absolute error:", np.abs(callPriceCOS-callPriceBSM))
print("***************************************************************************")
print("calculate put option price using CFS method:")
print("N1:",N1)
putPriceCFS = CFS_expansion_utils.putOptionPriceCFS(S0,strike,T,r,q,sigmaBSM,quantile,numGrid=N1,showDuration=True)
print("put price:", putPriceCFS)
print("absolute error:", np.abs(putPriceCFS-putPriceBSM))
coeffsCFS = CFS_expansion_utils.calculateIVCoefficientArray(S0,strike,T,r,q,sigmaBSM,N1,N2,quantile)
print("coeff for CFS:",coeffsCFS)
inverseCoeffsCFS = series_reversion.inverseSeries(coeffsCFS)
print("inverse coeffs for CFS:",inverseCoeffsCFS)
targetVolCFS = 0.25
putPriceBSM_2 = float(BlackScholesOption.putOptionPriceBSM(S0,strike,T,r,q,targetVolCFS))
yCFS = putPriceBSM_2*np.exp(r*T) - coeffsCFS[0]
wCFS = polyval(yCFS,inverseCoeffsCFS)
print("w",wCFS)
print("absolute error for implied volatility:",np.abs(wCFS-sigmaBSM**2*T))
print("***************************************************************************")
print("calculate put option price using IV expansion method:")
print("N1:",N1,"N2:",N2)
putPriceIV=IV_expansion_utils.putOptionPriceIV(S0,strike,T,r,q,sigmaBSM,quantile,numGrid=N1,truncationOrder=N2,showDuration=True)
print("put price:", putPriceIV)
print("absolute error:", np.abs(putPriceIV-putPriceBSM))
print("***************************************************************************")
print("same volatility:")
def testify_IV_iteration(S0, strike, T, r, q, quantile, N1, N2, fixVol, n_iter,
testSigma):
# import matplotlib.pyplot as plt
# sigma=fixVol
len_coeffs = 2 * (N2 // 2)
sigmaList = np.array(testSigma)
varEstimation = np.zeros(10)
sigmaEstimation = np.zeros(len(testSigma))
# wEstimation = np.zeros(10)
# m = preprocessing.calculateConstantTerm(S0,strike,T,r,q,a)
# coeffs = calculateCoefficientList(strike, m, a, b, N1, N2)
# inverseCoeffs = inverseSeries(coeffs)
putPriceTrue = []
putPriceIV = []
for i in range(len(sigmaList)):
sigma = fixVol
putPriceEstimation = 0
target_sigma = sigmaList[i]
putPrice = BlackScholesOption.putOptionPriceBSM(
S0, strike, T, r, q, target_sigma)
putPriceTrue.append(putPrice)
targit_w = [(target_sigma**2 * T)**l for l in range(len_coeffs)]
for j in range(n_iter):
(a,
b) = preprocessing.calculateToleranceInterval(S0,
strike,
T,
r,
q,
sigmaBSM=sigma,
quantile=quantile)
# print("a,b",a,b)
m = preprocessing.calculateConstantTerm(S0, strike, T, r, q, a)
coeffs = calculateCoefficientList(strike, m, a, b, N1, N2)
inverseCoeffs = inverseSeries(coeffs)
w = [(target_sigma**2 * T)**l for l in range(len(coeffs))]
y = putPrice * np.exp(r * T) - coeffs[0]
yList = [y**l for l in range(len(inverseCoeffs))]
# todo: cann't use len(coeffs)
w2 = np.dot(yList, inverseCoeffs)
# if w2<0:
# w2=-w2
sigma = np.sqrt(w2 / T)
# print("n_iter:", j, "var:", w2,"sigma",sigma)
putPriceEstimation = np.dot(coeffs, w) * np.exp(-r * T)
putPriceIV.append(putPriceEstimation)
sigmaEstimation[i] = sigma
varEstimation[i] = sigma**2
# wEstimation[i] = w
# print(sigmaEstimation-sigmaList)
print("COS_it: fixVol", fixVol)
print("COS_it: sigma list", sigmaList)
print("COS_it: target price", putPriceTrue)
print("COS_it: price estimations", putPriceIV)
print("COS_it: target sigmas", sigmaList)
print("COS_it: sigma estimations", sigmaEstimation)
# plt.plot(-sigmaList+sigmaEstimation)
# plt.plot(wEstimation-sigmaList**2*T)
# plt.plot((-sigmaList+sigmaEstimation)/sigmaList)
# plt.show()
return