Python 使用黑鞋查找看跌期权等于K-S的位置会抛出异常。为什么？_Python_Quantitative Finance_Computational Finance

Python 使用黑鞋查找看跌期权等于K-S的位置会抛出异常。为什么？

python

Python 使用黑鞋查找看跌期权等于K-S的位置会抛出异常。为什么？,python,quantitative-finance,computational-finance,Python,Quantitative Finance,Computational Finance,我试图在Python中找到S的值，其中卖出期权等于K-S，其中K是期权的履约价格，S是基础履约价格。此外，在Black Sholes的函数调用中，sigma是波动率，delta是支付的股息，T是到期时间，r是无风险利率我用K=75，r=0.05，T=1/12，sigma=0.35测试它此外，我知道我对Black Sholes的定价是有效的，因为我在以前的项目中使用过它，修改后的版本可能出现语法错误我尝试过使用scipy.optimize，但总是出错有没有其他方法，我应该用如果是，怎么做

我试图在Python中找到S
的值，其中卖出期权等于

K-S

，其中

是期权的履约价格，

是基础履约价格。此外，在Black Sholes的函数调用中，

sigma

是波动率，

delta

是支付的股息，

是到期时间，

是无风险利率

我用K=75，r=0.05，T=1/12，sigma=0.35测试它

此外，我知道我对Black Sholes的定价是有效的，因为我在以前的项目中使用过它，修改后的版本可能出现语法错误

我尝试过使用scipy.optimize，但总是出错

有没有其他方法，我应该用
如果是，怎么做

import numpy as np
import scipy.stats as ss
import time
import pylab as pl
import matplotlib.pyplot as plt
from prettytable import PrettyTable
import datetime
import scipy.optimize

from scipy.optimize import newton


# initial stock price
type = 'C'

def d1(S0, K, r, sigma, T, delta):
    return (np.log(float(S0) / K) + (r - delta + sigma ** 2 / 2) * T) / (sigma * np.sqrt(T))


def d2(S0, K, r, sigma, T,delta):
    return (d1(S0, K, r, sigma, T,delta)-sigma * np.sqrt(T))


def blackScholes(type, S0, K, r, sigma, T, delta):
    if type == "C":
        return S0 * np.exp(-delta * T)* ss.norm.cdf(d1(S0, K, r, sigma, T, delta)) - K * np.exp(-r * T) * ss.norm.cdf(d2(S0, K, r, sigma, T, delta))
    else:
        return K * np.exp(-r * T) * ss.norm.cdf(-d2(S0, K, r, sigma, T, delta)) - S0 * ss.norm.cdf(-d1(S0, K, r, sigma, T, delta))

# args is args = (type,K,r,sigma,T,delta)
# Modifying Black-Sholes function arguments for multivariate optimization
def d1Modified(S, args):

        type = args[0]
        K = args[1]
        r = args[2]
        sigma = args[3]
        T = args[4]
        delta = args[5]
        return (np.log(float(S) / K) + (r - delta + sigma ** 2 / 2) * T) / (sigma * np.sqrt(T))

def d2Modified(S, args):
    type = args[0]
    K = args[1]
    r = args[2]
    sigma = args[3]
    T = args[4]
    delta = args[5]
    return (d1Modified(S,args) - sigma * np.sqrt(T))

def blackScholesModified(S, args):
    type = args[0]
    print("print args")
    print(args)
    K = args[1]
    r = args[2]
    sigma = args[3]
    T = args[4]
    delta = args[5]
    if type == "C":
        return S * np.exp(-delta * T) * ss.norm.cdf(d1Modified(S, args)) - K * np.exp(
            -r * T) * ss.norm.cdf(d2Modified(S,args))
    else:
        return K * np.exp(-r * T) * ss.norm.cdf(-d2Modified(S, args)) - S * ss.norm.cdf(
               -d1Modified(S,args))


print("Pricing a European Put Option")

p = "P"

#Note: at is the tuple with the inputs into the black-sholes equation
# Where p is a string indicating a put option, K is the strike price
# r is the risk free rate of interest, sigma is volatility, T is time to
# expiration and delta is dividends
ar = (p,K,r,sigma,T,delta)


putOptionPriceList = []
for i in range(1,74):
    stockPriceList.append(i)

for x in stockPriceList:
    price = blackScholes("P",x,K,r,sigma,T,delta)
    print(price)
    putOptionPriceList.append(price)



# Constraints for multivariate optimization where price = K-S
def con(S,ar):
    k= 75
    return blackScholesModified(S, ar) -(k-S)


cons = {'type':'eq', 'fun': con(S,ar)}


sPrice = scipy.optimize.minimize(blackScholesModified, 0.1, args=ar, constraints=cons)

print("Value sought")
print(sPrice)

我不断得到以下错误：

Traceback (most recent call last):

    sPrice = scipy.optimize.minimize(blackScholesModified, 0.1, args=ar, constraints=cons)
  File "C:\Users\user\Anaconda3\lib\site-packages\scipy\optimize\_minimize.py", line 458, in minimize
    constraints, callback=callback, **options)
  File "C:\Users\user\Anaconda3\lib\site-packages\scipy\optimize\slsqp.py", line 311, in _minimize_slsqp
    meq = sum(map(len, [atleast_1d(c['fun'](x, *c['args'])) for c in cons['eq']]))
  File "C:\Users\user\Anaconda3\lib\site-packages\scipy\optimize\slsqp.py", line 311, in <listcomp>
    meq = sum(map(len, [atleast_1d(c['fun'](x, *c['args'])) for c in cons['eq']]))
TypeError: 'numpy.float64' object is not callable

回溯（最近一次呼叫最后一次）：
sPrice=scipy.optimize.minimize（blackScholesModified，0.1，args=ar，constraints=cons）
文件“C:\Users\user\Anaconda3\lib\site packages\scipy\optimize\\u minimize.py”，最小化中第458行
约束，回调=回调，**选项）
文件“C:\Users\user\Anaconda3\lib\site packages\scipy\optimize\slsqp.py”，第311行，在\u minimize\u slsqp中
meq=和（图（len，[c['fun']（x，*c['args']）中的c在cons['eq']]中的最小值）
文件“C:\Users\user\Anaconda3\lib\site packages\scipy\optimize\slsqp.py”，第311行，在
meq=和（图（len，[c['fun']（x，*c['args']）中的c在cons['eq']]中的最小值）
TypeError:“numpy.float64”对象不可调用

我想应该仔细遵循0.18指定的调用接口：

   cons = { 'type': 'eq',
            'fun':   con,       # con( S, ar ) here'd yield float64, not callable
            'args':  ( S, ar )  #    ( ^__^__)_ passed to a fun == con()-callable
             }

我想应该仔细遵循0.18指定的调用接口：

   cons = { 'type': 'eq',
            'fun':   con,       # con( S, ar ) here'd yield float64, not callable
            'args':  ( S, ar )  #    ( ^__^__)_ passed to a fun == con()-callable
             }

谢谢你的回复！当我更改时，我得到以下错误：

文件“C:\Users\user\Anaconda3\lib\site packages\scipy\optimize\slsqp.py”，第311行，在meq=sum（对于cons['eq']]中的C，map（len，[至少_1d（C['fun']（x，*C['args']））类型错误：con接受2个位置参数，但给出了3个

如果您阅读

slsqp.py

+稍微仔细地解码调用接口（使用间接组装的参数来满足规范），则用户提供的约束函数（

con（…）

）应具有与上述定义不同的调用接口。从

slsqp.py

源代码中可以看出，

scipy.optimize.minimize（）

期望约束函数始终接收

，因为它是第一个参数（从

scipy

内部自动传递），接下来，通过单个“packing”元组

cons['args'，迭代，不管参数的数量如何，间接定义

def con（x，S，ar）：

感谢您的回复！当我更改时，我得到以下错误：

文件“C:\Users\user\Anaconda3\lib\site packages\scipy\optimize\slsqp.py”，第311行，在meq=sum（对于cons['eq']]中的C，map（len，[至少_1d（C['fun']（x，*C['args']））类型错误：con接受2个位置参数，但给出了3个