exprtk_vectorized_binomial_model.cpp File Reference

#include <cstdio>
#include <string>
#include "exprtk.hpp"

Include dependency graph for exprtk_vectorized_binomial_model.cpp:

Go to the source code of this file.

Functions
template<typename T >
void	vectorized_binomial_option_pricing_model ()
int	main ()

Function Documentation

main()

int main

(

)

Definition at line 152 of file exprtk_vectorized_binomial_model.cpp.

{
   vectorized_binomial_option_pricing_model<double>();
   return 0;
}

vectorized_binomial_option_pricing_model()

template<typename T >

void vectorized_binomial_option_pricing_model

(

)

Definition at line 27 of file exprtk_vectorized_binomial_model.cpp.

{
   typedef exprtk::symbol_table<T> symbol_table_t;
   typedef exprtk::expression<T>   expression_t;
   typedef exprtk::parser<T>       parser_t;
 
   const std::string european_option_binomial_model_program =
      " var dt     := t / n;                                           "
      " var z      := exp(r * dt);                                     "
      " var z_inv  := 1 / z;                                           "
      " var u      := exp(v * sqrt(dt));                               "
      " var u_inv  := 1 / u;                                           "
      " var p_up   := (z - u_inv) / (u - u_inv);                       "
      " var p_down := 1 - p_up;                                        "
      "                                                                "
      " var option_price[n + 1] := [0];                                "
      "                                                                "
      " for (var i := 0; i <= n; i += 1)                               "
      " {                                                              "
      "    var base_price  := s * u^(n - 2i);                          "
      "    option_price[i] :=                                          "
      "       switch                                                   "
      "       {                                                        "
      "          case callput_flag == 'call' : max(base_price - k, 0); "
      "          case callput_flag == 'put'  : max(k - base_price, 0); "
      "       };                                                       "
      " };                                                             "
      "                                                                "
      " var p_u_zinv := z_inv * p_up;                                  "
      " var p_d_zinv := z_inv * p_down;                                "
      "                                                                "
      " for (var j := n - 1; j >= 0; j -= 1)                           "
      " {                                                              "
      "    /* y_i <- a * x_i + b * y_(i+1) i:[0,j] */                  "
      "    axpbsy(p_u_zinv,    option_price,                           "
      "           p_d_zinv, 1, option_price,                           "
      "           0, j);                                               "
      " };                                                             "
      "                                                                "
      " option_price[0];                                               ";
 
 
   T s = T( 100.00); // Spot / Stock / Underlying / Base price
   T k = T( 110.00); // Strike price
   T v = T(   0.30); // Volatility
   T t = T(   2.22); // Years to maturity
   T r = T(   0.05); // Risk free rate
   T n = T(2000.00); // Number of time steps
 
   std::string callput_flag;
 
   exprtk::rtl::vecops::package<T> vecops_package;
 
   symbol_table_t symbol_table;
   symbol_table.add_variable("s",s);
   symbol_table.add_variable("k",k);
   symbol_table.add_variable("t",t);
   symbol_table.add_variable("r",r);
   symbol_table.add_variable("v",v);
   symbol_table.add_constant("n",n);
   symbol_table.add_stringvar("callput_flag",callput_flag);
   symbol_table.add_package(vecops_package);
 
   expression_t expression;
   expression.register_symbol_table(symbol_table);
 
   parser_t parser;
   parser.compile(european_option_binomial_model_program,expression);
 
   const std::size_t rounds = 2000;
 
   T binomial_call_option_price = T(0);
   T binomial_put_option_price  = T(0);
 
   {
      callput_flag = "call";
 
      exprtk::timer timer;
      timer.start();
 
      for (std::size_t r = 0; r < rounds; ++r)
      {
         binomial_call_option_price = expression.value();
      }
 
      timer.stop();
 
      printf("BinomialOptionPrice(Type: %4s, BasePx: %5.3f, Strike: %5.3f, Time: %5.3f, RFR: %5.3f, Vol: %5.3f, Steps: %4.1f) = %10.6f "
             "total time: %6.3fsec rate: %6.3fcalc/sec\n",
             callput_flag.c_str(),
             s, k, t, r, v, n,
             binomial_call_option_price,
             timer.time(),
             rounds / timer.time());
   }
 
   {
      callput_flag = "put";
 
      exprtk::timer timer;
      timer.start();
 
      for (std::size_t r = 0; r < rounds; ++r)
      {
         binomial_put_option_price = expression.value();
      }
 
      timer.stop();
 
      printf("BinomialOptionPrice(Type: %4s, BasePx: %5.3f, Strike: %5.3f, Time: %5.3f, RFR: %5.3f, Vol: %5.3f, Steps: %4.1f) = %10.6f "
             "total time: %6.3fsec rate: %6.3fcalc/sec\n",
             callput_flag.c_str(),
             s, k, t, r, v, n,
             binomial_put_option_price,
             timer.time(),
             rounds / timer.time());
   }
 
   const T put_call_parity_diff =
      (binomial_call_option_price - binomial_put_option_price) -
      (s - k * std::exp(-r * t));
 
   printf("Put-Call parity difference: %20.17f\n", put_call_parity_diff);
}

References rounds, exprtk::timer::start(), exprtk::timer::stop(), and exprtk::timer::time().

Here is the call graph for this function: