exprtk_ornstein_uhlenbeck_process.cpp File Reference

#include <algorithm>
#include <array>
#include <cstdio>
#include <random>
#include <string>
#include "exprtk.hpp"

Include dependency graph for exprtk_ornstein_uhlenbeck_process.cpp:

Go to the source code of this file.

Classes
struct	normal_distribution< T >

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

Function Documentation

main()

int main

(

)

Definition at line 105 of file exprtk_ornstein_uhlenbeck_process.cpp.

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

References ornstein_uhlenbeck_process().

Here is the call graph for this function:

ornstein_uhlenbeck_process()

template<typename T>

void ornstein_uhlenbeck_process

(

)

Definition at line 54 of file exprtk_ornstein_uhlenbeck_process.cpp.

{
   typedef exprtk::symbol_table<T> symbol_table_t;
   typedef exprtk::expression<T>   expression_t;
   typedef exprtk::parser<T>       parser_t;
 
   const std::string ornstein_uhlenbeck_process_program =
      " const var mu        := 1;                                                        "
      " const var sigma     := 0.4;                                                      "
      " const var theta     := 2;                                                        "
      " const var tau       := 1 / theta;                                                "
      " const var T         := 10 * tau;                                                 "
      " const var dt        := 0.01 * tau;                                               "
      " const var num_steps := floor(T / dt);                                            "
      " const var stddev    := sqrt(sigma^2 / (2 * theta) * (1 - exp(-2 * theta * dt))); "
      " const var x_0       := 1.0;                                                      "
      "                                                                                  "
      " var x[num_steps] := [0];                                                         "
      "                                                                                  "
      " x[0] := x_0;                                                                     "
      "                                                                                  "
      " for (var i := 0; i < num_steps - 1; i += 1)                                      "
      " {                                                                                "
      "    var mean := x[i] * exp(-theta * dt) + mu * (1 - exp(-theta * dt));            "
      "                                                                                  "
      "    x[i + 1] := normal(mean,stddev);                                              "
      " };                                                                               "
      "                                                                                  "
      "                                                                                  "
      " for (var i := 0; i < x[]; i += 1)                                                "
      " {                                                                                "
      "    println(i * dt, '\t', x[i]);                                                  "
      " }                                                                                ";
 
 
   exprtk::rtl::io::println<T> println;
   normal_distribution<T>      normal;
 
   symbol_table_t symbol_table;
   symbol_table.add_function("println", println);
   symbol_table.add_function("normal" , normal );
 
   expression_t expression;
   expression.register_symbol_table(symbol_table);
 
   parser_t parser;
   parser.compile(ornstein_uhlenbeck_process_program,expression);
 
   expression.value();
}

Referenced by main().

Here is the caller graph for this function: