americanapprox.h

#ifndef stringify_defined
#define stringify_defined
#include <iostream>
#include <sstream>
#include <string>
#include <stdexcept>

inline std::string stringify(
                 const char *funcname,
                 const char* _file,
                 const char *_error_msg,
                 int _line,
                 int _erno)
{
  std::ostringstream o;
  o << _error_msg 
    <<  " in function " 
    << funcname 
    << " at line " 
    << _line << 
    " of file " 
    << _file;

  return o.str();
}
#endif

#ifndef AMERICANAPPROX_H
#define AMERICANAPPROX_H

#if defined( WIN32) && !defined(__NT__)
#define __NT__
#endif

#if defined( __NT__) && !defined(WIN32)
#define WIN32
#endif

#if defined(ALLSTATIC) && defined(AMERICANAPPROXDLL)
#error ALLSTATIC and AMERICANAPPROXDLL are mutually exclusive
#endif

#if defined(ALLSTATIC) || defined(AMERICANAPPROXSTATIC)
#undef  AMERICANAPPROXPTR
#define AMERICANAPPROXPTR 
#define AMERICANAPPROXFNC
#elif !defined(AMERICANAPPROXPTR)
   #ifdef  __NT__
      #ifdef AMERICANAPPROXDLL
         #define AMERICANAPPROXPTR __declspec(dllexport)
         #define AMERICANAPPROXFNC __declspec(dllexport)
      #else
         #define AMERICANAPPROXPTR __declspec(dllimport)
         #define AMERICANAPPROXFNC __declspec(dllimport)
      #endif
   #else
      #define AMERICANAPPROXFNC
      #define AMERICANAPPROXPTR
   #endif
#endif

#ifdef __GNUC__
  #ifdef  AMERICANAPPROXFNC
    #undef AMERICANAPPROXFNC
  #endif
  #define AMERICANAPPROXFNC
#endif

#ifdef WIN32
#define STDCALL __stdcall
#else
#define STDCALL
#endif

#ifdef WIN32
#pragma warning(disable : 4251) //4251=needs to have dll-interface
#endif

#include "simpleoption.h"

using namespace std;

typedef unsigned int uint;

class AMERICANAPPROXPTR american_option_approximation: public european_option_pair {
  protected:
    //key attributes

    //functional attributes
      double _vega_epsilon;
      uint _max_iter;

    //derived attributes
      mutable european_option_pair _optvar;
      mutable bool _call_early_exercise;
      mutable bool _put_early_exercise;
      mutable double _call_tau;
      mutable double _put_tau;

    //static data for error handling
      static const char *_error_msg;
      static int _erno;

  public:
    //static functions for getting error messages
      static const char *get_error_msg() { return _error_msg;}
      static int get_erno() { return _erno;}
virtual const char *get_class_name() { return "american_option_approximation";}

    static int check_attributes(
      double S,
      double K,
      double Tau,
      double Alpha,
      double R,
      double Sigma,
      double Vega_epsilon,
      uint Max_iter);

    void set_null() {
      european_option_pair::set_null();
      _vega_epsilon = 1e-5;
      _max_iter = 100;
      _optvar.set_null();
      _call_early_exercise = 0;
      _put_early_exercise = 0;
      _call_tau = 0;
      _put_tau = 0;
    }

    virtual void init_calc_derived_attributes() const;

    void init( const american_option_approximation& rhs) {
      _S = rhs._S;
      _K = rhs._K;
      _tau = rhs._tau;
      _alpha = rhs._alpha;
      _r = rhs._r;
      _sigma = rhs._sigma;
      _vega_epsilon = rhs._vega_epsilon;
      _max_iter = rhs._max_iter;
      _C = rhs._C;
      _P = rhs._P;
      _dC_dS = rhs._dC_dS;
      _dP_dS = rhs._dP_dS;
      _d2C_dS2 = rhs._d2C_dS2;
      _d2P_dS2 = rhs._d2P_dS2;
      _dC_dtau = rhs._dC_dtau;
      _dP_dtau = rhs._dP_dtau;
      _dC_dsigma = rhs._dC_dsigma;
      _dP_dsigma = rhs._dP_dsigma;
      _calc_call = rhs._calc_call;
      _calc_put = rhs._calc_put;
      _input_call_price = rhs._input_call_price;
      _input_put_price = rhs._input_put_price;
      _C_implied_sigma = rhs._C_implied_sigma;
      _P_implied_sigma = rhs._P_implied_sigma;
      _mu = rhs._mu;
      _sqrt_tau = rhs._sqrt_tau;
      _sigma_sqrt_tau = rhs._sigma_sqrt_tau;
      _log_S_K = rhs._log_S_K;
      _Zk = rhs._Zk;
      _dZk_dtau = rhs._dZk_dtau;
      _h = rhs._h;
      _dh_dtau = rhs._dh_dtau;
      _N_h = rhs._N_h;
      _N_Zk = rhs._N_Zk;
      _exp_alpha_r_t = rhs._exp_alpha_r_t;
      _exp_r_t = rhs._exp_r_t;
      _S_exp_alpha_r_t = rhs._S_exp_alpha_r_t;
      _K_exp_r_t = rhs._K_exp_r_t;
      _d3C_dS2_dtau = rhs._d3C_dS2_dtau;
      _d3P_dS2_dtau = rhs._d3P_dS2_dtau;
      _dh_dsigma = rhs._dh_dsigma;
      _dZ_dsigma = rhs._dZ_dsigma;
      _d2C_dsigma2 = rhs._d2C_dsigma2;
      _d2P_dsigma2 = rhs._d2P_dsigma2;
      _dC_dtau = rhs._dC_dtau;
      _dP_dtau = rhs._dP_dtau;
      _d2C_dtau2 = rhs._d2C_dtau2;
      _d2P_dtau2 = rhs._d2P_dtau2;
      _d2C_dS_dtau = rhs._d2C_dS_dtau;
      _d2P_dS_dtau = rhs._d2P_dS_dtau;
      _P_h = rhs._P_h;
      _optvar = rhs._optvar;
      _call_early_exercise = rhs._call_early_exercise;
      _put_early_exercise = rhs._put_early_exercise;
      _call_tau = rhs._call_tau;
      _put_tau = rhs._put_tau;
    }

    american_option_approximation& operator = ( const american_option_approximation& rhs) {
        init( rhs);
        return *this;
    }

    american_option_approximation( const american_option_approximation& rhs) { 
        init( rhs);
    }

    void init(
      double S,
      double K,
      double Tau,
      double Alpha = 0,
      double R = 0.05,
      double Sigma = 0.2,
      double Vega_epsilon = 1e-5,
      uint Max_iter = 100)
    {
      const char* funcname = "american_option_approximation::init";

      check_attributes(
        S,
        K,
        Tau,
        Alpha,
        R,
        Sigma,
        Vega_epsilon,
        Max_iter);

      if (_erno) {
        cerr << _error_msg << std::endl;
        throw std::domain_error( stringify(
          funcname,
          __FILE__,
          _error_msg,
          __LINE__,
          _erno   ));
      }

      //copy all_key attributes
      _S = S;
      _K = K;
      _tau = Tau;

      //copy all_functional attributes
      _alpha = Alpha;
      _r = R;
      _sigma = Sigma;
      _vega_epsilon = Vega_epsilon;
      _max_iter = Max_iter;

      init_calc_derived_attributes();
    }

    american_option_approximation(
      double S = 0,
      double K = 0,
      double Tau = 0,
      double Alpha = 0,
      double R = 0.05,
      double Sigma = 0.2,
      double Vega_epsilon = 1e-5,
      uint Max_iter = 100)
    {
      set_null();

      init(
        S,
        K,
        Tau,
        Alpha,
        R,
        Sigma,
        Vega_epsilon,
        Max_iter);
    }

    void deinit() { set_null();}

    virtual ~american_option_approximation() { deinit();}

    //data access functions

    double get_vega_epsilon() const { return _vega_epsilon;}
    const uint& get_max_iter() const { return _max_iter;}
    const european_option_pair& get_optvar() const { return _optvar;}
    bool get_call_early_exercise() const { return _call_early_exercise;}
    bool get_put_early_exercise() const { return _put_early_exercise;}
    double get_call_tau() const { return _call_tau;}
    double get_put_tau() const { return _put_tau;}

    //change data functions

    void put_vega_epsilon(double Vega_epsilon) {
      const char* funcname = "put_vega_epsilon";

      check_attributes(
        _S,
        _K,
        _tau,
        _alpha,
        _r,
        _sigma,
        Vega_epsilon,
        _max_iter);
      if (_erno) {
        cerr << _error_msg << std::endl;
        throw std::domain_error( stringify(
          funcname,
          __FILE__,
          _error_msg,
          __LINE__,
          _erno   ));
      }

      _vega_epsilon = Vega_epsilon;

      init_calc_derived_attributes();
    }

    void put_max_iter(uint Max_iter) {
      const char* funcname = "put_max_iter";

      check_attributes(
        _S,
        _K,
        _tau,
        _alpha,
        _r,
        _sigma,
        _vega_epsilon,
        Max_iter);
      if (_erno) {
        cerr << _error_msg << std::endl;
        throw std::domain_error( stringify(
          funcname,
          __FILE__,
          _error_msg,
          __LINE__,
          _erno   ));
      }

      _max_iter = Max_iter;

      init_calc_derived_attributes();
    }

    void init_simple_attributes( const american_option_approximation& rhs) {
       _vega_epsilon = rhs._vega_epsilon;
       _call_early_exercise = rhs._call_early_exercise;
       _put_early_exercise = rhs._put_early_exercise;
       _call_tau = rhs._call_tau;
       _put_tau = rhs._put_tau;
    }

    virtual double call_intrinsic_value() const;
    virtual double put_intrinsic_value() const;
    void set_call( const european_option_pair& rhs) const;
    void set_put( const european_option_pair& rhs) const;
    friend AMERICANAPPROXFNC ostream& STDCALL operator << (ostream& os, const american_option_approximation& rhs);
};


#endif

---