C++ Mathematical Expression Toolkit (ExprTk) release
Loading...
Searching...
No Matches
Classes | Functions | Variables
exprtk_bsm_benchmark.cpp File Reference
#include <cstdio>
#include <string>
#include "exprtk.hpp"
Include dependency graph for exprtk_bsm_benchmark.cpp:

Go to the source code of this file.

Classes

struct  bsm_parameters< T >
 

Functions

template<typename T >
T call_bsm_model (T s, T k, T t, T r, T v)
 
template<typename T >
T put_bsm_model (T s, T k, T t, T r, T v)
 
template<typename T >
void black_scholes_merton_model ()
 
template<typename T >
T bsm_model (const std::string &callput_flag, const T s, const T k, const T t, const T r, const T v)
 
template<typename T >
void bsm_native ()
 
int main ()
 

Variables

static const std::size_t rounds = 20000000
 
const bsm_parameters< double > bsm_list []
 
const std::size_t bsm_list_size = sizeof (bsm_list) / sizeof(bsm_parameters<double>)
 

Function Documentation

◆ black_scholes_merton_model()

template<typename T >
void black_scholes_merton_model ( )

Definition at line 83 of file exprtk_bsm_benchmark.cpp.

84{
85 typedef exprtk::symbol_table<T> symbol_table_t;
86 typedef exprtk::expression<T> expression_t;
87 typedef exprtk::parser<T> parser_t;
88
89 const std::string bsm_model_program =
90 " var d1 := (log(s / k) + (r + v^2 / 2) * t) / (v * sqrt(t)); "
91 " var d2 := d1 - v * sqrt(t); "
92 " "
93 " if (callput_flag == 'call') "
94 " s * ncdf(d1) - k * e^(-r * t) * ncdf(d2); "
95 " else if (callput_flag == 'put') "
96 " k * e^(-r * t) * ncdf(-d2) - s * ncdf(-d1); "
97 " ";
98
99 const std::string bsm_model_program_opt1 =
100 " var v_sqrtt := (v * sqrt(t)); "
101 " var d1 := (log(s / k) + (r + v * v / 2) * t) / v_sqrtt; "
102 " var d2 := d1 - v_sqrtt; "
103 " var kert := k * exp(-r * t); "
104 " "
105 " if (callput_flag == 'call') "
106 " s * ncdf(d1) - kert * ncdf(d2); "
107 " else if (callput_flag == 'put') "
108 " kert * ncdf(-d2) - s * ncdf(-d1); "
109 " ";
110
111 const std::string bsm_model_program_opt2 =
112 " var v_sqrtt := (v * sqrt(t)); "
113 " var d1 := (log(s / k) + (r + v * v / 2) * t) / v_sqrtt; "
114 " var d2 := d1 - v_sqrtt; "
115 " "
116 " if (callput_flag == 'call') "
117 " s * ncdf(d1) - (k * exp(-r * t)) * ncdf(d2); "
118 " else if (callput_flag == 'put') "
119 " (k * exp(-r * t)) * ncdf(-d2) - s * ncdf(-d1); "
120 " ";
121
122 const std::string bsm_model_program_opt3 =
123 " if (callput_flag == 'call') "
124 " call_bsm_model(s, k, t, r, v); "
125 " else if (callput_flag == 'put') "
126 " put_bsm_model(s, k, t, r, v); "
127 " ";
128
129 bsm_parameters<T> parameters;
130
131 std::string callput_flag;
132
133 static const T e = exprtk::details::numeric::constant::e;
134
135 symbol_table_t symbol_table;
136 symbol_table.add_variable ( "s", parameters.s );
137 symbol_table.add_variable ( "k", parameters.k );
138 symbol_table.add_variable ( "t", parameters.t );
139 symbol_table.add_variable ( "r", parameters.r );
140 symbol_table.add_variable ( "v", parameters.v );
141 symbol_table.add_constant ( "e", e );
142 symbol_table.add_stringvar( "callput_flag" , callput_flag );
143 symbol_table.add_function ( "call_bsm_model", call_bsm_model );
144 symbol_table.add_function ( "put_bsm_model" , put_bsm_model );
145
146 expression_t bsm_expression (symbol_table);
147 expression_t bsm_expression_opt1(symbol_table);
148 expression_t bsm_expression_opt2(symbol_table);
149 expression_t bsm_expression_opt3(symbol_table);
150
151 parser_t parser;
152
153 parser.compile(bsm_model_program , bsm_expression );
154 parser.compile(bsm_model_program_opt1, bsm_expression_opt1);
155 parser.compile(bsm_model_program_opt2, bsm_expression_opt2);
156 parser.compile(bsm_model_program_opt3, bsm_expression_opt3);
157
158 {
159 exprtk::timer timer;
160 timer.start();
161
162 T total = T(0);
163
164 for (std::size_t i = 0; i < rounds; ++i)
165 {
166 const bsm_parameters<T>& current_parameters = bsm_list[i % bsm_list_size];
167
168 parameters = current_parameters;
169
170 callput_flag = "call";
171 total += bsm_expression.value();
172
173 callput_flag = "put";
174 total += bsm_expression.value();
175 }
176
177 timer.stop();
178
179 printf("[exprtk0] Total: %13.5f Time:%6.3fsec Rate:%13.3fbsm/sec execrt: %6.3fns\n",
180 total,
181 timer.time(),
182 (2.0 * rounds) / timer.time(),
183 1e9 / ((2.0 * rounds) / timer.time()));
184 }
185
186 {
187 exprtk::timer timer;
188 timer.start();
189
190 T total = T(0);
191
192 for (std::size_t i = 0; i < rounds; ++i)
193 {
194 const bsm_parameters<T>& current_parameters = bsm_list[i % bsm_list_size];
195
196 parameters = current_parameters;
197
198 callput_flag = "call";
199 total += bsm_expression_opt1.value();
200
201 callput_flag = "put";
202 total += bsm_expression_opt1.value();
203 }
204
205 timer.stop();
206
207 printf("[exprtk1] Total: %13.5f Time:%6.3fsec Rate:%13.3fbsm/sec execrt: %6.3fns\n",
208 total,
209 timer.time(),
210 (2.0 * rounds) / timer.time(),
211 1e9 / ((2.0 * rounds) / timer.time()));
212 }
213
214 {
215 exprtk::timer timer;
216 timer.start();
217
218 T total = T(0);
219
220 for (std::size_t i = 0; i < rounds; ++i)
221 {
222 const bsm_parameters<T>& current_parameters = bsm_list[i % bsm_list_size];
223
224 parameters = current_parameters;
225
226 callput_flag = "call";
227 total += bsm_expression_opt2.value();
228
229 callput_flag = "put";
230 total += bsm_expression_opt2.value();
231 }
232
233 timer.stop();
234
235 printf("[exprtk2] Total: %13.5f Time:%6.3fsec Rate:%13.3fbsm/sec execrt: %6.3fns\n",
236 total,
237 timer.time(),
238 (2.0 * rounds) / timer.time(),
239 1e9 / ((2.0 * rounds) / timer.time()));
240 }
241
242 {
243 exprtk::timer timer;
244 timer.start();
245
246 T total = T(0);
247
248 for (std::size_t i = 0; i < rounds; ++i)
249 {
250 const bsm_parameters<T>& current_parameters = bsm_list[i % bsm_list_size];
251
252 parameters = current_parameters;
253
254 callput_flag = "call";
255 total += bsm_expression_opt3.value();
256
257 callput_flag = "put";
258 total += bsm_expression_opt3.value();
259 }
260
261 timer.stop();
262
263 printf("[exprtk3] Total: %13.5f Time:%6.3fsec Rate:%13.3fbsm/sec execrt: %6.3fns\n",
264 total,
265 timer.time(),
266 (2.0 * rounds) / timer.time(),
267 1e9 / ((2.0 * rounds) / timer.time()));
268 }
269}
exprtk::symbol_table
Definition exprtk.hpp:20010
exprtk::timer::time
double time() const
Definition exprtk.hpp:43995
put_bsm_model
T put_bsm_model(T s, T k, T t, T r, T v)
Definition exprtk_bsm_benchmark.cpp:72
rounds
static const std::size_t rounds
Definition exprtk_bsm_benchmark.cpp:26
bsm_list_size
const std::size_t bsm_list_size
Definition exprtk_bsm_benchmark.cpp:58
call_bsm_model
T call_bsm_model(T s, T k, T t, T r, T v)
Definition exprtk_bsm_benchmark.cpp:61
bsm_list
const bsm_parameters< double > bsm_list[]
Definition exprtk_bsm_benchmark.cpp:38
bsm_parameters
Definition exprtk_bsm_benchmark.cpp:30
bsm_parameters::r
T r
Definition exprtk_bsm_benchmark.cpp:35
bsm_parameters::t
T t
Definition exprtk_bsm_benchmark.cpp:34
bsm_parameters::k
T k
Definition exprtk_bsm_benchmark.cpp:32
bsm_parameters::v
T v
Definition exprtk_bsm_benchmark.cpp:33
bsm_parameters::s
T s
Definition exprtk_bsm_benchmark.cpp:31

References exprtk::symbol_table< T >::add_constant(), exprtk::symbol_table< T >::add_function(), exprtk::symbol_table< T >::add_stringvar(), exprtk::symbol_table< T >::add_variable(), bsm_list, bsm_list_size, call_bsm_model(), exprtk::parser< T >::compile(), exprtk::details::numeric::constant::e, bsm_parameters< T >::k, put_bsm_model(), bsm_parameters< T >::r, rounds, bsm_parameters< T >::s, exprtk::timer::start(), exprtk::timer::stop(), bsm_parameters< T >::t, exprtk::timer::time(), and bsm_parameters< T >::v.

Here is the call graph for this function:

◆ bsm_model()

template<typename T >
T bsm_model ( const std::string &  callput_flag,
const T  s,
const T  k,
const T  t,
const T  r,
const T  v 
)
inline

Definition at line 272 of file exprtk_bsm_benchmark.cpp.

273{
274 using namespace std;
275 using namespace exprtk::details::numeric;
276
277 const T d1 = (log(s / k) + (r + (v * v) / 2) * t) / (v * sqrt(t));
278 const T d2 = d1 - v * sqrt(t);
279
280 if (callput_flag == "call")
281 return s * ncdf(d1) - k * exp(-r * t) * ncdf(d2);
282 else if (callput_flag == "put")
283 return k * exp(-r * t) * ncdf(-d2) - s * ncdf(-d1);
284 else
285 return T(0);
286}
cmplx::log
complex_t log(const complex_t v)
Definition complex_type.hpp:184
cmplx::exp
complex_t exp(const complex_t v)
Definition complex_type.hpp:182
cmplx::sqrt
complex_t sqrt(const complex_t v)
Definition complex_type.hpp:191

Referenced by bsm_native().

Here is the caller graph for this function:

◆ bsm_native()

template<typename T >
void bsm_native ( )

Definition at line 289 of file exprtk_bsm_benchmark.cpp.

290{
291 bsm_parameters<T> parameters;
292
293 std::string callput_flag;
294
295 exprtk::timer timer;
296 timer.start();
297
298 T total = T(0);
299
300 for (std::size_t i = 0; i < rounds; ++i)
301 {
302 const bsm_parameters<T>& current_parameters = bsm_list[i % bsm_list_size];
303
304 parameters = current_parameters;
305
306 callput_flag = "call";
307 total += bsm_model(callput_flag, parameters.s, parameters.k, parameters.t, parameters.r, parameters.v);
308
309 callput_flag = "put";
310 total += bsm_model(callput_flag, parameters.s, parameters.k, parameters.t, parameters.r, parameters.v);
311 }
312
313 timer.stop();
314
315 printf("[native ] Total: %13.5f Time:%6.3fsec Rate:%13.3fbsm/sec execrt: %6.3fns\n",
316 total,
317 timer.time(),
318 (2.0 * rounds) / timer.time(),
319 1e9 / ((2.0 * rounds) / timer.time()));
320}
bsm_model
T bsm_model(const std::string &callput_flag, const T s, const T k, const T t, const T r, const T v)
Definition exprtk_bsm_benchmark.cpp:272

References bsm_list, bsm_list_size, bsm_model(), bsm_parameters< T >::k, bsm_parameters< T >::r, rounds, bsm_parameters< T >::s, exprtk::timer::start(), exprtk::timer::stop(), bsm_parameters< T >::t, exprtk::timer::time(), and bsm_parameters< T >::v.

Here is the call graph for this function:

◆ call_bsm_model()

template<typename T >
T call_bsm_model ( T  s,
T  k,
T  t,
T  r,
T  v 
)
inline

Definition at line 61 of file exprtk_bsm_benchmark.cpp.

62{
63 using namespace std;
64 using namespace exprtk::details::numeric;
65
66 const T d1 = (log(s / k) + (r + (v * v) / 2) * t) / (v * sqrt(t));
67 const T d2 = d1 - v * sqrt(t);
68 return s * ncdf(d1) - k * exp(-r * t) * ncdf(d2);
69}

Referenced by black_scholes_merton_model().

Here is the caller graph for this function:

◆ main()

int main ( )

Definition at line 322 of file exprtk_bsm_benchmark.cpp.

323{
324 black_scholes_merton_model<double>();
325 bsm_native<double>();
326 return 0;
327}

◆ put_bsm_model()

template<typename T >
T put_bsm_model ( T  s,
T  k,
T  t,
T  r,
T  v 
)
inline

Definition at line 72 of file exprtk_bsm_benchmark.cpp.

73{
74 using namespace std;
75 using namespace exprtk::details::numeric;
76
77 const T d1 = (log(s / k) + (r + (v * v) / 2) * t) / (v * sqrt(t));
78 const T d2 = d1 - v * sqrt(t);
79 return k * exp(-r * t) * ncdf(-d2) - s * ncdf(-d1);
80}

Referenced by black_scholes_merton_model().

Here is the caller graph for this function:

Variable Documentation

◆ bsm_list

const bsm_parameters<double> bsm_list[]
Initial value:
=
{
{ 60.11, 65.11, 0.31, 0.25, 0.08 },
{ 60.22, 65.22, 0.32, 0.35, 0.07 },
{ 60.33, 65.33, 0.33, 0.45, 0.06 },
{ 60.44, 65.44, 0.34, 0.55, 0.05 },
{ 60.55, 65.55, 0.35, 0.65, 0.04 },
{ 60.66, 65.66, 0.36, 0.75, 0.03 },
{ 60.77, 65.77, 0.37, 0.85, 0.08 },
{ 60.88, 65.88, 0.38, 0.95, 0.07 },
{ 60.11, 65.11, 0.31, 0.25, 0.06 },
{ 60.22, 65.22, 0.32, 0.35, 0.05 },
{ 60.33, 65.33, 0.33, 0.45, 0.04 },
{ 60.44, 65.44, 0.34, 0.55, 0.03 },
{ 60.55, 65.55, 0.35, 0.65, 0.08 },
{ 60.66, 65.66, 0.36, 0.75, 0.07 },
{ 60.77, 65.77, 0.37, 0.85, 0.06 },
{ 60.88, 65.88, 0.38, 0.95, 0.05 }
}

Definition at line 38 of file exprtk_bsm_benchmark.cpp.

39 {
40 { 60.11, 65.11, 0.31, 0.25, 0.08 },
41 { 60.22, 65.22, 0.32, 0.35, 0.07 },
42 { 60.33, 65.33, 0.33, 0.45, 0.06 },
43 { 60.44, 65.44, 0.34, 0.55, 0.05 },
44 { 60.55, 65.55, 0.35, 0.65, 0.04 },
45 { 60.66, 65.66, 0.36, 0.75, 0.03 },
46 { 60.77, 65.77, 0.37, 0.85, 0.08 },
47 { 60.88, 65.88, 0.38, 0.95, 0.07 },
48 { 60.11, 65.11, 0.31, 0.25, 0.06 },
49 { 60.22, 65.22, 0.32, 0.35, 0.05 },
50 { 60.33, 65.33, 0.33, 0.45, 0.04 },
51 { 60.44, 65.44, 0.34, 0.55, 0.03 },
52 { 60.55, 65.55, 0.35, 0.65, 0.08 },
53 { 60.66, 65.66, 0.36, 0.75, 0.07 },
54 { 60.77, 65.77, 0.37, 0.85, 0.06 },
55 { 60.88, 65.88, 0.38, 0.95, 0.05 }
56 };

Referenced by black_scholes_merton_model(), and bsm_native().

◆ bsm_list_size

const std::size_t bsm_list_size = sizeof (bsm_list) / sizeof(bsm_parameters<double>)

Definition at line 58 of file exprtk_bsm_benchmark.cpp.

Referenced by black_scholes_merton_model(), and bsm_native().

◆ rounds

const std::size_t rounds = 20000000
static

Definition at line 26 of file exprtk_bsm_benchmark.cpp.

Referenced by black_scholes_merton_model(), bsm_native(), function_call_benchmark01(), main(), main(), perform_file_based_benchmark(), pgo_primer(), run_parse_benchmark(), run_test00(), run_test01(), run_test02(), run_test03(), run_test08(), run_test09(), run_test10(), run_test11(), run_test12(), run_test13(), run_test14(), run_test19(), and vectorized_binomial_option_pricing_model().

Generated by doxygen 1.9.8