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 81 of file exprtk_bsm_benchmark.cpp.

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

271{
272 using namespace std;
273
274 const T d1 = (std::log(s / k) + (r + (v * v) / 2) * t) / (v * sqrt(t));
275 const T d2 = d1 - v * sqrt(t);
276
277 if (callput_flag == "call")
278 return s * exprtk::details::numeric::ncdf(d1) - k * exp(-r * t) * exprtk::details::numeric::ncdf(d2);
279 else if (callput_flag == "put")
280 return k * exp(-r * t) * exprtk::details::numeric::ncdf(-d2) - s * exprtk::details::numeric::ncdf(-d1);
281 else
282 return T(0);
283}
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

References exprtk::details::numeric::ncdf().

Referenced by bsm_native().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ bsm_native()

template<typename T >
void bsm_native ( )

Definition at line 286 of file exprtk_bsm_benchmark.cpp.

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

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
65 const T d1 = (std::log(s / k) + (r + (v * v) / 2) * t) / (v * sqrt(t));
66 const T d2 = d1 - v * sqrt(t);
67 return s * exprtk::details::numeric::ncdf(d1) - k * exp(-r * t) * exprtk::details::numeric::ncdf(d2);
68}

References exprtk::details::numeric::ncdf().

Referenced by black_scholes_merton_model().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ main()

int main ( )

Definition at line 319 of file exprtk_bsm_benchmark.cpp.

320{
321 black_scholes_merton_model<double>();
322 bsm_native<double>();
323 return 0;
324}

◆ put_bsm_model()

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

Definition at line 71 of file exprtk_bsm_benchmark.cpp.

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

References exprtk::details::numeric::ncdf().

Referenced by black_scholes_merton_model().

Here is the call graph for this function:
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