Hướng dẫn option pricing using python - định giá tùy chọn bằng python

Tôi mới bắt đầu chọn Python và đã xây dựng các mô hình nhị thức và ba lần chỉ để kiểm tra sự hiểu biết của tôi, đặc biệt là về các mảng.

Nội phân Chính showShow

• Cây trinomial trong các tùy chọn định giá
• Mô hình ba bộ ba: Tam giác Auld
• Cây trinomial tĩnh trong C ++
• Cây trinomial động trong C ++
• Tốc độ ước tính sử dụng colab cho mã C ++ tĩnh và động
• Ước tính mô hình định giá tùy chọn ba trong Google Colab bằng thiết kế C ++ tĩnh và động
• Về mối quan hệ giữa các mô hình định giá tùy chọn nhị thức và ba lần
• Thực hiện mô hình trinomial bằng mã MATLAB trong Google Colab
• Bert Excel Thêm vào để triển khai chức năng do người dùng R định nghĩa trong bảng tính Excel

Đối với mảng giá cổ phiếu đầu cuối, tôi đã từ chức từ đầu tiên*u ** [ISTEPS - i] cho tôi đi từ 0 đến 2*ISTEPS+ 1. tức là. Tôi bắt đầu ở mức giá đầu cuối cùng hàng đầu tiên khởi đầu*U ** [ISTEP] và đi xuống cho đến khi tôi đến Initalstock*U ** [-ISTEPS] và điền vào mảng Terminalstock từ 0 đến 2*ISTEPS+1 [tức là lần cuối cùng. Phần tử mảng là khởi đầu*u ** [-isteps]. Bởi vì tôi đến từ vùng đất của VBA, tôi chưa chọn được tài hùng biện [và do đó, phong cách Python ngắn gọn và đôi khi khó đọc], vẻ ngoài của tôi trông như thế này:

for i in range[0, 2*iSteps+1] :

    # Terminal stock is initial with up staps and down steps
    dblStockTerminal = dblStock * u ** float[iSteps - i]

    # compute intrinsic values at terminal stock value
    dblTrinOpt[i][iSteps] = max[ dblSwitch * [dblStockTerminal - dblStrike], 0 ]

Tôi đã khởi tạo mảng dbltrinopt dưới dạng dbltrinopt = np.ndarray [[2*isteps+1, isteps+1], float] để nó có các yếu tố giá 2*ISTEPS ở giá cổ phiếu đầu cuối và các bước thời gian ISTEP, trong đó ISTEPS . Vâng, xin lỗi cho mã Python cồng kềnh của tôi! [Nhưng tôi phải đọc nó].

Sau đó, tùy chọn của tôi calc như sau [vâng, một lần nữa mã không phù hợp]:

#------------------------------------------
# steps in time from Terminal to Initial Stock price
#------------------------------------------
for i in range[iSteps-1, -1, -1] :

    #------------------------------------------
    # steps in price range from highest to lowest
    #------------------------------------------
    for j in range[0, 2*i+1] :

        #------------------------------------------
        # discount average of future option value
        # as usual, trinomial averages three values
        #------------------------------------------
        dblTrinOpt[j][i] = dblDisc * [pu * dblTrinOpt[j][i+1] + pm * \
            dblTrinOpt[j+1][i+1] + pd * dblTrinOpt[j+2][i+1]]

Sau đó, chức năng trinomial của tôi vượt qua dbltrinopt [0] [0] là giá tùy chọn chiết khấu cuối cùng.

Tôi muốn viết nó ở dạng dễ đọc hơn để thêm hai thành phần hơn: [a] một cơ sở tùy chọn của Mỹ, do đó theo dõi giá cổ phiếu ở mỗi nút cây [và sau đó những thứ như rào cản và bermudans sẽ là một sự bổ sung dễ dàng và [b] thêm hai giá thiết bị đầu cuối bổ sung ở mỗi đầu và do đó tại thời điểm 0, tôi có ba giá trị cổ phiếu và tùy chọn để tôi có thể tính toán delta và gamma mà không cần phải tính toán lại cây tùy chọn [tức là tránh Cách tiếp cận va chạm và nhận được]. Tôi hy vọng điều đó sẽ giúp, mặc dù tôi không sửa mã cụ thể của bạn, nhưng giải thích logic.

Cây trinomial trong các tùy chọn định giá

Mô hình ba bộ ba: Tam giác Auld

Cây trinomial tĩnh trong C ++

def setup_parameters[self]:    """ Required calculations for the model """    self.u = math.exp[self.sigma*math.sqrt[2.*self.dt]]    self.d = 1/self.u    self.m = 1    self.qu = [[math.exp[[self.r-self.div] *                         self.dt/2.] -                math.exp[-self.sigma *                         math.sqrt[self.dt/2.]]] /               [math.exp[self.sigma *                         math.sqrt[self.dt/2.]] -                math.exp[-self.sigma *                         math.sqrt[self.dt/2.]]]]**2    self.qd = [[math.exp[self.sigma *                         math.sqrt[self.dt/2.]] - math.exp[[self.r-self.div] ...

Mô hình ba bộ ba: Tam giác Auld

Cây trinomial tĩnh trong C ++ two-jump process for the asset price over each discrete time step was developed in the binomial lattice. Boyle expanded this frame of reference and explored the feasibility of option valuation by allowing for an extra jump in the stochastic process. In keeping with Black Scholes, Boyle examined an asset [S] with a lognormal distribution of returns. Over a small time interval, this distribution can be approximated by a three-point jump process in such a way that the expected return on the asset is the riskless rate, and the variance of the discrete distribution is equal to the variance of the corresponding lognormal distribution. The three point jump process was introduced by Phelim Boyle[1986] as a trinomial tree to price options and the effect has been momentous in the finance literature. Perhaps shamrock mythology or the well-known ballad associated with Brendan Behan inspired the Boyle insight to include a third jump in lattice valuation. His trinomial paper has spawned a huge amount of ground breaking research. In the trinomial model, the asset price S is assumed to jump uS or mS or dS after one time period [dt = T/n], where u > m > d. Joshi [2008] point out that the trinomial model is characterized by the following five parameters: [1] the probability of an up move pu, [2] the probability of an down move pd, [3] the multiplier on the stock price for an up move u, [4] the multiplier on the stock price for a middle move m, [5] the multiplier on the stock price for a down move d. A recombining tree is computationally more efficient so we require

ud = m*m

M = exp [r∆T],

V = exp [σ 2∆T],

dt hoặc ∆t = t/n

trong đó n là tổng số các bước của cây trinomial. Đối với một cây là trung tính rủi ro, giá trị trung bình và phương sai trong mỗi bước thời gian phải đúng về mặt không đối xứng. Boyle [1986] đã chọn các tham số là:

m = 1, u = exp [λσém t], d = 1/u

pu = [md - m [m + d] + [m^2]*v]/ [u - d] [u - m],

pd = [um - m [u + m] + [m^2]*v]/ [u - d] [m - d]

Boyle cho rằng việc lựa chọn giá trị cho λ nên vượt quá 1 và kết quả tốt nhất thu được khi λ là khoảng 1,20. Một cách tiếp cận để xây dựng các cây trinomial là phát triển hai bước của một nhị thức kết hợp như một bước duy nhất của cây ba. Điều này có thể được thiết kế với nhiều nhị thức CRR [1979], JR [1979] và Tian [1993] trong đó biến động là không đổi. Ví dụ, một bài thuyết trình hai bước của CRR [1979] được trình bày dưới đây trong C ++:develop two steps of a binomial in combination as a single step of a trinomial tree. This can be engineered with many binomials CRR[1979], JR[1979] and Tian [1993] where the volatility is constant. For example, a two-step presentation of the CRR[1979] is presented below in C++:

b = r - q;

dt = t/n;

u = exp [v*sqrt [2.0*dt]];

d = 1.0/u;

pu = pow [[exp [0,5*b*dt] - exp [-v*sqrt [0,5*dt]]] / [exp [v*sqrt [0,5*dt]] - exp [-v*sqrt [0,5* dt]]], 2];

pd = pow [[exp [v*sqrt [0,5*dt]] - exp [0,5*b*dt]] / [exp [v*sqrt [0,5*dt]] - exp ]]], 2];

PM = 1.0 - PU - PD;

hoặc trong r sử dụng google colabR using Google Colab

# Khoảng thời gian:

dt = thời gian/n

# Kích thước nhảy lên xuống:

u = exp [+sigma * sqrt [2 * dt]]2*dt]]

d = exp [-sigma * sqrt [2 * dt]]2*dt]]

# Xác suất đi lên và xuống:

pu = [[exp [b * dt/2] - exp [-sigma * sqrt [dt/2]]]/[exp [sigma * sqrt [dt/2]] - exp [-sigma * sqrt [dt/2 ]]]] ^ 22] - exp[ -sigma * sqrt[dt/2]]] / [exp[sigma * sqrt[dt/2]] - exp[-sigma * sqrt[dt/2]]]] ^ 2

pd = [[exp [sigma * sqrt [dt/2]] - exp [b * dt/2]]/[exp [sigma * sqrt [dt/2]] - exp [-sigma * sqrt [dt/2] ]]] ^ 22]] - exp[ b * dt/2]] / [exp[sigma * sqrt[dt/2]] - exp[-sigma * sqrt[dt/2]]]] ^ 2

# Xác suất ở cùng mức giá tài sản:

PM = 1 - PU - PD1 - pu - pd

Chúng tôi ban đầu trình bày dưới đây hai đoạn mã C ++ được nghiên cứu về hiệu quả. Với tính chất chuyên sâu về số lượng của các mạng, chúng tôi đề xuất sử dụng các kỹ thuật bộ nhớ động trong ước tính mạng. Chúng tôi so sánh hiệu suất của bộ nhớ động và bộ nhớ động được thiết lập trong các mô hình định giá không giống như cách tiếp cận được điều chỉnh cho ESO trong trang trước và phù hợp với các kỹ thuật được nêu trước đây để ước tính nhị thức trong đó việc sử dụng bộ nhớ được tối ưu hóa. Mã tĩnh được trích xuất từ ​​Volopta.com được phát triển bởi Fabrice Rouah. Đại diện năng động được chuyển từ cây trinomial VBA Excel của Espen Haug. Thiết kế cây động của Espen dường như hiệu quả hơn và có thể đạt kích thước bước cao hơn trên các trình biên dịch C ++ trực tuyến. Chúng tôi cũng trình bày cách thiết lập cây trinomial theo cách thủ công trong một sổ làm việc excel để độc giả/người xem có thể so sánh biểu diễn trực quan cơ bản với mã C ++ thực tế được trình bày dưới đây.

Cây trinomial tĩnh trong C ++

// Cây trinomial tĩnh C ++

// của Fabrice Douglas Rouah, Frouah.com và Volopta.com

//#bao gồm "stdafx.h"

#bao gồm

#bao gồm

#bao gồm

#bao gồm

#bao gồm

#include

#bao gồm

#bao gồm

sử dụng không gian tên std;

Double Trinomial [Double Spot, Double K, Double R, Double Q, Double V, Double T, Char Putcall, Char Euroamer, Int N]

{

int i, j;

Double B = R - Q;

kép dt = t/n;

Double u = exp [v*sqrt [2.0*dt]];

gấp đôi d = 1.0/u;

Double pu = pow [[exp [0,5*b*dt] - exp [-v*sqrt [0,5*dt]]] / [exp [v*sqrt [0,5*dt]] - exp [-v*sqrt [0,5 *dt]]], 2];

Double pd = pow [[exp [v*sqrt [0,5*dt]] - exp [0,5*b*dt]] / [exp [v*sqrt [0,5*dt]] - exp [-v*sqrt [0,5* dt]]], 2];

gấp đôi PM = 1.0 - PU - PD;

// Xây dựng cây ba màu cho sự phát triển giá cổ phiếu

vector s [2*n+1, vector [n+1]];

for [j = 0; j

for [i = 0; i

S [i] [j] = spot*pow [u, double [j-i]];

// không tăng ma trận cho các cuộc gọi Euro và Mỹ

vector v [2*n+1, vector [n+1]];

// Tính toán số tiền chi trả thiết bị đầu cuối

for [i = 0; i

S [i] [j] = spot*pow [u, double [j-i]];

// không tăng ma trận cho các cuộc gọi Euro và Mỹ

vector v [2*n+1, vector [n+1]];

// Tính toán số tiền chi trả thiết bị đầu cuối

if [putcall == 'c']

V [i] [n] = max [s [i] [n] - k, 0,0];

khác nếu [putcall == 'p']

for [i = 0; i

S [i] [j] = spot*pow [u, double [j-i]];

// không tăng ma trận cho các cuộc gọi Euro và Mỹ

vector v [2*n+1, vector [n+1]];

S [i] [j] = spot*pow [u, double [j-i]];

// không tăng ma trận cho các cuộc gọi Euro và Mỹ

vector v [2*n+1, vector [n+1]];

// Tính toán số tiền chi trả thiết bị đầu cuối

if [putcall == 'c']

if [putcall == 'c']

if [putcall == 'c']

V [i] [n] = max [s [i] [n] - k, 0,0];

khác nếu [putcall == 'p']

V [i] [n] = max [k - s [i] [n], 0,0];

}

// đệ quy ngược qua cây

for [j = n-1; j> = 0; j--] {

if [euroamer == 'e']

V [i] [j] = exp [-r*dt]*[pu*v [i] [j+1]+pm*v [i+1] [j+1]+pd*v [i+2 ] [J+1]];

khác nếu [euroamer == 'a'] {

V [i] [j] = max [s [i] [j] - k, exp [-r*dt]*[pu*v [i] [j+1]+pm*v [i+1] [ j+1]+pd*v [i+2] [j+1]]];

V [i] [j] = max [k - s [i] [j], exp [-r*dt]*[pu*v [i] [j+1]+pm*v [i+1] [ j+1]+pd*v [i+2] [j+1]]];

// đưa ra kết quả

trả về v [0] [0];

}

int main [] {

clock_t start_time, end_time;

start_time = clock [];

// Giá cổ phiếu, đình công, đáo hạn, biến động, tỷ lệ miễn phí rủi ro, tỷ lệ cổ tức

// Double S = 40.0;

// Double k = 40.0;

gấp đôi t = 3; // năm đến ngày đáo

char putcall = 'c';

char euroamer = 'e';

int n = 3000;

cout