FDM/evaluation.h at master · hanxixuana/FDM · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
//
// Created by xixuan on 4/3/17.
//

#ifndef EVAL_H
#define EVAL_H

#include "model.h"
#include "vsr.h"

#ifndef _OMP
	#define _OMP
#endif

#define _MAX_RAND_SEED 1000000

#define IDX(i, j, ld_i) (((j)*(ld_i))+(i))
#define IDXX(i, j, k, ld_i, ld_j) (((k)*((ld_i)*(ld_j)))+((j)*(ld_i))+(i))

class Derivative {

private:

	double const_mu_k;
	double const_sigma_k;

protected:

	double slop_sigma_f;
	double corr_coef;

	// for evaluation
	int num_threads;
	int *gpu_indices;

	int num_evals_in_each_thread;
	int *random_seeds;
	double *vsr_array;
	double *discounted_payoff_array;

	// strikes
	int num_K;
	double min_K;
	double max_K;
	double delta_K;

	// maturities
	int num_T;
	double min_T;
	double max_T;
	double delta_T;

	int roi_left_T_index;								// start from 0
	int roi_right_T_index;								// start from 0

	Vsr **vsrs;

	// initial surface
	int num_q_0_taus;
	double *q_0_taus;
	double *q_0;

	// parameter c
	double c;

	// results
	double average;
	double std_dev;

	// for internal uses
	virtual double fun_mu_k(double t, double tau);
	virtual double fun_sigma_k(double tau);
	virtual double fun_sigma_f(double k, double tau);
	virtual double fun_corr(double k_0, double k_1);
	virtual double fun_q_0(double k, double tau);

	virtual double payoff(double vsr);
	virtual double discounting();

public:

	Derivative(	int num_K_val,
				double min_K_val,
				double max_K_val,

				int num_T_val,
				double min_T_val,
				double max_T_val,

				int roi_left_T_index_val,
				int roi_right_T_index_val,

				int num_threads_val,
				int const * gpu_indices_val,

				int num_evals_in_each_thread_val,

				int input_num_q_0_taus,
				double const *input_q_0_taus,
				double const *input_q_0);

	virtual ~Derivative();

	void set_params(double const_mu_k_val,
					double const_sigma_k_val,
					double slop_sigma_f_val,
					double corr_coef_val,
					double c_val);

	double evaluate(double init_vsr);

	double get_sd();

};

class VixOpt : public Derivative {

private:

	double slop_mu_k;

	int num_rf_rates;
	double *rf_rates_taus;
	double *rf_rates;

	double slop_sigma_k;
	double intercept_sigma_k;

	char opt_type;
	double strike;

	int num_div_rates;
	double *div_rates_taus;
	double *div_rates;

protected:

	double fun_rf_rate(double tau);

	double fun_mu_k(double t, double tau);
	double fun_sigma_k(double tau);

	double payoff(double vsr);
	double discounting();

public:

	VixOpt(	int num_K_val,
			double min_K_val,
			double max_K_val,

			int num_T_val,
			double min_T_val,
			double max_T_val,

			int roi_left_T_index_val,
			int roi_right_T_index_val,

			int num_threads_val,
			int const * gpu_indices_val,

			int num_evals_in_each_thread_val,

			int input_num_q_0_taus,
			double const *input_q_0_taus,
			double const *input_q_0,

			int num_rf_rates_val,
			double const *rf_rates_taus_val,
			double const *rf_rates_val,

			int num_div_rates_val,
			double const *div_rates_taus_val,
			double const *div_rates_val);

	virtual ~VixOpt();

	void simulate(	double slop_mu_k_val,
					double slop_sigma_k_val,
					double intercept_sigma_k_val,
					double slop_sigma_f_val,
					double corr_coef_val,

					double c_val,
					double init_vsr,

					bool save_to_file = false);

	double evaluate(char opt_type_val, double strike_val);

};


#endif //EVAL_H