├── src
    ├── readme.md
    ├── config.cfg
    ├── Backtester.cpp
    ├── DataWarehouse.cpp
    ├── SignalGenerator.cpp
    ├── constants.h
    ├── gamma.hpp
    ├── typedefs.h
    ├── configuration.hpp
    ├── main.cpp
    ├── SignalGenerator.hpp
    ├── gamma.cpp
    ├── MathUtility.h
    ├── configuration.cpp
    ├── Options.cpp
    ├── Backtester.hpp
    ├── DataWarehouse.hpp
    ├── PortfolioEngine.hpp
    ├── Options.hpp
    └── PortfolioEngine.cpp
├── README.md
└── data
    └── pgsql_command.sql


/src/readme.md:
--------------------------------------------------------------------------------
1 | This folder contains source code.
2 | 


--------------------------------------------------------------------------------
/src/config.cfg:
--------------------------------------------------------------------------------
1 | strategyName=GammaScalping
2 | movingWindow=20
3 | entryVol=0.15
4 | exitVol=0.25


--------------------------------------------------------------------------------
/src/Backtester.cpp:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Backtester.cpp
 3 | //  pgsql
 4 | //
 5 | //  Created by FuYongrui on 5/1/16.
 6 | //  Copyright © 2016 FuYongrui. All rights reserved.
 7 | //
 8 | 
 9 | #include "Backtester.hpp"
10 | 


--------------------------------------------------------------------------------
/src/DataWarehouse.cpp:
--------------------------------------------------------------------------------
 1 | //
 2 | //  DataWarehouse.cpp
 3 | //  pgsql
 4 | //
 5 | //  Created by FuYongrui on 5/1/16.
 6 | //  Copyright © 2016 FuYongrui. All rights reserved.
 7 | //
 8 | 
 9 | #include "DataWarehouse.hpp"
10 | 


--------------------------------------------------------------------------------
/src/SignalGenerator.cpp:
--------------------------------------------------------------------------------
 1 | //
 2 | //  SignalGenerator.cpp
 3 | //  pgsql
 4 | //
 5 | //  Created by FuYongrui on 5/1/16.
 6 | //  Copyright © 2016 FuYongrui. All rights reserved.
 7 | //
 8 | 
 9 | #include "SignalGenerator.hpp"
10 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # GammaScalping
2 | This is a volatility trading strategy. Buying the straddle when implied vol is subsided, at the hope that it will spike in the near future. At the same time, we delta hedge our portfolio to remove the affect of underlying movement on portfolio.
3 | 
4 | You will need PostgreSQL C++ library libpqxx and QuantLib to compile. You will also need include Boost library header file on search path, and link libboost_filesystem.a and libboost_system.a.
5 | 


--------------------------------------------------------------------------------
/src/constants.h:
--------------------------------------------------------------------------------
 1 | //
 2 | //  constants.h
 3 | //  pgsql
 4 | //
 5 | //  Created by FuYongrui on 5/6/16.
 6 | //  Copyright © 2016 FuYongrui. All rights reserved.
 7 | //
 8 | 
 9 | #ifndef constants_h
10 | #define constants_h
11 | 
12 | #include <string>
13 | 
14 | 
15 | static const string STRAT_NAME = "strategyName";
16 | static const string MOVING_WINDOW = "movingWindow";
17 | static const string ENTRY_VOL = "entryVol";
18 | static const string EXIT_VOL = "exitVol";
19 | 
20 | 
21 | #endif /* constants_h */
22 | 


--------------------------------------------------------------------------------
/data/pgsql_command.sql:
--------------------------------------------------------------------------------
 1 | drop table if exists spyoptions;
 2 | 
 3 | create table spyoptions
 4 | 	(
 5 | 		cur_date date not null,
 6 | 		ex_date date not null,
 7 | 		flag char(1) not null,
 8 | 		k numeric(12,5) not null,
 9 | 		bid numeric(12,5) not null,
10 | 		offer numeric(12,5) not null,
11 | 		price numeric(12,5),
12 | 		primary key (cur_date, ex_date, flag, k)
13 | 	);
14 | 
15 | copy spyoptions (cur_date, ex_date, flag, k, bid, offer)
16 | from '/Users/alanfu/Documents/Codes/cpp/GammaScalping/data/op_SPY.csv'
17 | delimiter ',' csv header;
18 | 
19 | 


--------------------------------------------------------------------------------
/src/gamma.hpp:
--------------------------------------------------------------------------------
 1 | //
 2 | //  gamma.hpp
 3 | //  pgsql
 4 | //
 5 | //  Created by FuYongrui on 5/1/16.
 6 | //  Copyright © 2016 FuYongrui. All rights reserved.
 7 | //
 8 | 
 9 | #ifndef gamma_hpp
10 | #define gamma_hpp
11 | 
12 | #include <iostream>
13 | #include <stdio.h>
14 | #include <pqxx/pqxx>
15 | #include <boost/shared_ptr.hpp>
16 | #include <boost/make_shared.hpp>
17 | #include <typeinfo>
18 | #include <ql/time/all.hpp>
19 | #include <string>
20 | using namespace std;
21 | 
22 | typedef boost::shared_ptr<pqxx::connection> Conn_Ptr;
23 | 
24 | void make_conn();
25 | 
26 | 
27 | #endif /* gamma_hpp */
28 | 


--------------------------------------------------------------------------------
/src/typedefs.h:
--------------------------------------------------------------------------------
 1 | //
 2 | //  typedefs.h
 3 | //  pgsql
 4 | //
 5 | //  Created by FuYongrui on 5/6/16.
 6 | //  Copyright © 2016 FuYongrui. All rights reserved.
 7 | //
 8 | 
 9 | #ifndef typedefs_h
10 | #define typedefs_h
11 | 
12 | #include <string>
13 | #include <vector>
14 | #include <map>
15 | #include <boost/tokenizer.hpp>
16 | using namespace std;
17 | 
18 | static const boost::char_separator<char> sep("#;,=");
19 | typedef vector<vector<string>> TwoDStringVector;
20 | typedef multimap<string, string> StringToStringMap;
21 | typedef boost::tokenizer<boost::char_separator<char>> Tokenizer;
22 | typedef StringToStringMap::const_iterator MapIter;
23 | 
24 | 
25 | #endif /* typedefs_h */
26 | 


--------------------------------------------------------------------------------
/src/configuration.hpp:
--------------------------------------------------------------------------------
 1 | //
 2 | //  configuration.hpp
 3 | //  pgsql
 4 | //
 5 | //  Created by FuYongrui on 5/6/16.
 6 | //  Copyright © 2016 FuYongrui. All rights reserved.
 7 | //
 8 | 
 9 | #ifndef configuration_hpp
10 | #define configuration_hpp
11 | 
12 | #include <stdio.h>
13 | 
14 | #include "typedefs.h"
15 | #include <boost/tokenizer.hpp>
16 | #include <iostream>
17 | #include <fstream>
18 | #include "constants.h"
19 | 
20 | using namespace std;
21 | 
22 | 
23 | 
24 | struct AppConfig
25 | {
26 | private:
27 |     //=========== configuration parameters ==========//
28 |     
29 |     string strategyName;
30 |     int movingWindow;
31 |     double entryVol;
32 |     double exitVol;
33 |     
34 | public:
35 |     void setConfigParams(const StringToStringMap& configMap);
36 |     
37 |     void createAppConfig(const string& fileName);
38 |     
39 |     StringToStringMap readConfigFile(const string& fileName);
40 |     
41 |     const string& getStratName() const
42 |     {
43 |         return strategyName;
44 |     }
45 |     
46 | private:
47 |     
48 |     //=========== utility functions ==========//
49 |     
50 |     TwoDStringVector parse(const string fileName);
51 |     
52 |     inline vector<string> parseLine(const string& line);
53 | };
54 | 
55 | #endif /* configuration_hpp */
56 | 


--------------------------------------------------------------------------------
/src/main.cpp:
--------------------------------------------------------------------------------
 1 | //
 2 | //  main.cpp
 3 | //  pgsql
 4 | //
 5 | //  Created by FuYongrui on 12/10/15.
 6 | //  Copyright © 2015 FuYongrui. All rights reserved.
 7 | //
 8 | 
 9 | #include <iostream>
10 | 
11 | #include "gamma.hpp"
12 | #include "DataWarehouse.hpp"
13 | #include "Options.hpp"
14 | #include "SignalGenerator.hpp"
15 | #include "Backtester.hpp"
16 | #include "configuration.hpp"
17 | #include <boost/filesystem.hpp>
18 | 
19 | using namespace std;
20 | 
21 | int main(int argc, const char * argv[]) {
22 |     
23 |     boost::filesystem::path cd(__FILE__);
24 |     
25 |     cd.remove_leaf();
26 |     const string filename = cd.string() + "/config.cfg";
27 |     AppConfig config;
28 |     
29 |     config.createAppConfig(filename);
30 |     auto StockData_ptr = boost::make_shared<GammaScalping::StockDataWarehouse>();
31 |     auto OptionData_ptr = boost::make_shared<GammaScalping::OptionDataWarehouse>();
32 |     
33 |     GammaScalping::Volatility entry_signal = 0.2;
34 |     GammaScalping::Volatility exit_signal = 0.3;
35 | 
36 |     GammaScalping::Backtester my_backtest(OptionData_ptr,
37 |                                           StockData_ptr,
38 |                                           entry_signal,
39 |                                           exit_signal);
40 |     
41 |     my_backtest.start_backtest();
42 |     
43 |     //make_conn();
44 |     
45 |     
46 | }
47 | 
48 | 
49 | 


--------------------------------------------------------------------------------
/src/SignalGenerator.hpp:
--------------------------------------------------------------------------------
 1 | //
 2 | //  SignalGenerator.hpp
 3 | //  pgsql
 4 | //
 5 | //  Created by FuYongrui on 5/1/16.
 6 | //  Copyright © 2016 FuYongrui. All rights reserved.
 7 | //
 8 | 
 9 | #ifndef SignalGenerator_hpp
10 | #define SignalGenerator_hpp
11 | 
12 | #include <stdio.h>
13 | 
14 | #include "DataWarehouse.hpp"
15 | #include "Options.hpp"
16 | #include <list>
17 | //#include <numeric>
18 | #include <boost/range/numeric.hpp>
19 | 
20 | namespace GammaScalping
21 | {
22 |     enum Signal {ENTER,KEEP,EXIT};//Signals
23 |     
24 |     class SignalGenerator
25 |     {
26 |     public:
27 |         
28 |         SignalGenerator(Volatility entry = 0.2, Volatility exit = 0.3)
29 |         {
30 |             entry_vol = entry;
31 |             exit_vol = exit;
32 |         }
33 |         
34 |         Signal generate_signal()
35 |         {
36 |             Signal signal = Signal::KEEP;
37 |             
38 |             //=========== please use your own trading idea :) ==========//
39 |             
40 |             return signal;
41 |         }
42 |         
43 |         void update_option(Option_Sptr option_call, Option_Sptr option_put)
44 |         {
45 |             CallOption = option_call;
46 |             PutOption = option_put;
47 |         }
48 |         
49 |     private:
50 |         list<Volatility> vol_queue;
51 |         int window_size = 20;
52 |         Volatility entry_vol;
53 |         Volatility exit_vol;
54 |         Option_Sptr CallOption;
55 |         Option_Sptr PutOption;
56 |     };
57 | }
58 | #endif /* SignalGenerator_hpp */
59 | 


--------------------------------------------------------------------------------
/src/gamma.cpp:
--------------------------------------------------------------------------------
 1 | //
 2 | //  gamma.cpp
 3 | //  pgsql
 4 | //
 5 | //  Created by FuYongrui on 5/1/16.
 6 | //  Copyright © 2016 FuYongrui. All rights reserved.
 7 | //
 8 | 
 9 | #include "gamma.hpp"
10 | using namespace std;
11 | 
12 | string stocktable="SPYSTOCKS";
13 | string optiontable="SPYOPTIONS";
14 | string recordtable="RECORDS";
15 | 
16 | void make_conn()
17 | {
18 |     Conn_Ptr conn;
19 |     try{
20 |         conn = boost::make_shared<pqxx::connection>("dbname=mydb user=alanfu hostaddr=127.0.0.1 port=5432");
21 |         
22 |         if (conn->is_open()) {
23 |             cout << "Opened database successfully: " << conn->dbname() << endl;
24 |         } else {
25 |             throw runtime_error("Cannot connect to database!");
26 |         }
27 |         
28 |         pqxx::work W(*conn);
29 |         
30 |         string temp = "SELECT * FROM "+stocktable+";";
31 |         const char* sql=temp.c_str();
32 |         
33 |         pqxx::result R = W.exec(sql);
34 |         
35 |         pqxx::result::const_iterator iter=R.begin();
36 |         
37 |         for(auto tup : R)
38 |         {
39 |             cout << tup[1].as<int>() << endl;
40 |             cout << stoi(tup[0].as<string>().substr(5,2)) + 1 << endl;
41 |         }
42 |         
43 |         string cur_date = "2011-01-03";
44 |         string ex_date = "2011-01-07";
45 |         string callput = "C";
46 |         temp = "select price from " + optiontable + " where cur_date = date \'" + cur_date + "\' and ex_date = date \'" + ex_date + "\' and flag = \'" + callput + "\' and k = 113;";
47 |         sql=temp.c_str();
48 |         
49 |         R = W.exec(sql);
50 |         cout << stof(R.begin()[0].as<string>()) + 1 << endl;
51 |         W.commit();
52 |         conn->disconnect ();
53 |         
54 |     }catch (runtime_error &e){
55 |         cerr << e.what() << std::endl;
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/MathUtility.h:
--------------------------------------------------------------------------------
 1 | //
 2 | //  MathUtility.h
 3 | //  pgsql
 4 | //
 5 | //  Created by FuYongrui on 5/1/16.
 6 | //  Copyright © 2016 FuYongrui. All rights reserved.
 7 | //
 8 | 
 9 | #ifndef MathUtility_h
10 | #define MathUtility_h
11 | 
12 | namespace GammaScalping
13 | {
14 |     inline double R(const double z)
15 |     {
16 |         const std::vector<const double>
17 |         a = { 0.319381530 , -0.356563782 , 1.781477937 , -1.821255978 , 1.330274429 };
18 |         
19 |         return z*(z*(z*(z*( a.at(4)*z+a.at(3) ) + a.at(2) ) + a.at(1) ) + a.at(0));
20 |     }
21 |     
22 |     inline double
23 |     normal_cdf (const double x){
24 |         if ( x > 0 ){
25 |             double result = 0.0 ;
26 |             result = 1.0 - 1.0/sqrt(2.0*M_PI)*exp(-x*x/2.0)*R(1.0/(1.0 + 0.2316419*x));
27 |             return result;
28 |         }
29 |         else{
30 |             return 1.0-normal_cdf(-x) ;
31 |         }
32 |     }
33 |     
34 |     inline double
35 |     normal_pdf (const double x){
36 |         return (1.0/sqrt(2.0*M_PI)*exp(-x*x/2.0));
37 |     }
38 |     
39 |     template <typename T>
40 |     double root_newton(T &func, const double x1 = 0.0, const double x2 = 2.0, const double acc = 0.00001) {
41 |         // input a functor & range( x1 , x2 ) in which you believe there is a root & accuracy level
42 |         // the functor provided must have a dff() method
43 |         
44 |         const int MAX_NUM_TRIAL = 50000 ;
45 |         double rtn = 0.5 * ( x1 + x2 ) ;
46 |         
47 |         for ( size_t i = 0 ; i < MAX_NUM_TRIAL ; ++i ){
48 |             
49 |             double  f = func( rtn );
50 |             double df = func.diff( rtn );
51 |             double dx = f/df;
52 |             
53 |             rtn -= dx;
54 |             if ( (x1-rtn) * (rtn-x2) < 0.0 )
55 |                 
56 |                 throw std::runtime_error
57 |                 (" Jumped out of brackets in root_newton method, check your range! ");
58 |             
59 |             if ( fabs(dx) < acc )
60 |                 return rtn;
61 |             
62 |         }
63 |         
64 |         throw std::runtime_error
65 |         (" Maximum number of iterations exceeded in rtnewt, may caused by accuracy level ");
66 |         
67 |     }
68 | }
69 | 
70 | #endif /* MathUtility_h */
71 | 


--------------------------------------------------------------------------------
/src/configuration.cpp:
--------------------------------------------------------------------------------
  1 | //
  2 | //  configuration.cpp
  3 | //  pgsql
  4 | //
  5 | //  Created by FuYongrui on 5/6/16.
  6 | //  Copyright © 2016 FuYongrui. All rights reserved.
  7 | //
  8 | 
  9 | #include "configuration.hpp"
 10 | #include <boost/lexical_cast.hpp>
 11 | #include <stdio.h>
 12 | 
 13 | using namespace std;
 14 | 
 15 | void AppConfig::setConfigParams(const StringToStringMap& configMap)
 16 | {
 17 |     MapIter e = configMap.end();
 18 |     MapIter it;
 19 |     
 20 |     it = configMap.find(STRAT_NAME);
 21 |     if (it != e)
 22 |         strategyName = static_cast<string>(it->second);
 23 |     else
 24 |         cerr << "Failed to config strategy name." << endl;
 25 |     
 26 |     it = configMap.find(MOVING_WINDOW);
 27 |     if (it != e)
 28 |         movingWindow = boost::lexical_cast<int>(it->second);
 29 |     else
 30 |         cerr << "Failed to config moving window." << endl;
 31 |     
 32 |     it = configMap.find(ENTRY_VOL);
 33 |     if (it != e)
 34 |         entryVol = boost::lexical_cast<double>(it->second);
 35 |     else
 36 |         cerr << "Failed to config entry vol." << endl;
 37 |     
 38 |     it = configMap.find(EXIT_VOL);
 39 |     if (it != e)
 40 |         exitVol = boost::lexical_cast<double>(it->second);
 41 |     else
 42 |         cerr << "Failed to config exit vol." << endl;
 43 | }
 44 | 
 45 | void AppConfig::createAppConfig(const string& fileName)
 46 | {
 47 |     auto a = readConfigFile(fileName);
 48 |     setConfigParams(a);
 49 | }
 50 | 
 51 | StringToStringMap AppConfig::readConfigFile(const string& fileName)
 52 | {
 53 |     TwoDStringVector cfgFileData = parse(fileName);
 54 |     
 55 |     vector<string> row;
 56 |     StringToStringMap ret;
 57 |     
 58 |     for (auto it = cfgFileData.begin(); it != cfgFileData.end(); it++)
 59 |     {
 60 |         row = *it;
 61 |         string key = row[0];
 62 |         string val = row[1];
 63 |         
 64 |         if (key[0] == '#' || key.empty())
 65 |             continue;
 66 |         
 67 |         ret.insert(pair<string, string>(key, val));
 68 |     }
 69 |     
 70 |     
 71 |     return ret;
 72 | }
 73 | 
 74 | 
 75 | TwoDStringVector AppConfig::parse(const string fileName)
 76 | {
 77 |     ifstream file(fileName.c_str());
 78 |     
 79 |     TwoDStringVector ret;
 80 |     string line;
 81 |     ret.clear();
 82 |     
 83 |     if (file.is_open())
 84 |         while (file.good())
 85 |         {
 86 |             getline(file, line);
 87 |             ret.push_back(parseLine(line));
 88 |         }
 89 |     
 90 |     return ret;
 91 | }
 92 | 
 93 | vector<string> AppConfig::parseLine(const string& line)
 94 | {
 95 |     Tokenizer token(line, sep);
 96 |     vector<string> tokens;
 97 |     tokens.clear();
 98 |     
 99 |     for (auto it = token.begin(); it != token.end(); it++)
100 |     {
101 |         tokens.push_back(*it);
102 |     }
103 |     return tokens;
104 | }
105 | 
106 | 


--------------------------------------------------------------------------------
/src/Options.cpp:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Options.cpp
 3 | //  pgsql
 4 | //
 5 | //  Created by FuYongrui on 5/1/16.
 6 | //  Copyright © 2016 FuYongrui. All rights reserved.
 7 | //
 8 | 
 9 | #include "Options.hpp"
10 | 
11 | namespace GammaScalping
12 | {
13 |     
14 |     PriceType BS_CALL_PRICE(const PriceType stock_price,
15 |                             const PriceType strike,
16 |                             const RateType rate,
17 |                             const Volatility vol,
18 |                             const YearFraction time_to_maturity)
19 |     {
20 |         double d1 = ( log(stock_price/strike) + (rate + 0.5*vol*vol)*time_to_maturity ) / ( vol*sqrt(time_to_maturity) ) ;
21 |         double d2 = ( log(stock_price/strike) + (rate - 0.5*vol*vol)*time_to_maturity ) / ( vol*sqrt(time_to_maturity) ) ;
22 |         return ( stock_price*normal_cdf(d1) - strike*exp(-rate*time_to_maturity)*normal_cdf(d2) );
23 |     }
24 |     
25 |     PriceType BS_PUT_PRICE(const PriceType stock_price,
26 |                            const PriceType strike,
27 |                            const RateType rate,
28 |                            const Volatility vol,
29 |                            const YearFraction time_to_maturity)
30 |     {
31 |         double d1 = ( log(stock_price/strike) + (rate + 0.5*vol*vol)*time_to_maturity ) / ( vol*sqrt(time_to_maturity) ) ;
32 |         double d2 = ( log(stock_price/strike) + (rate - 0.5*vol*vol)*time_to_maturity ) / ( vol*sqrt(time_to_maturity) ) ;
33 |         return ( -stock_price*normal_cdf(-d1) + strike*exp(-rate*time_to_maturity)*normal_cdf(-d2) );
34 |     }
35 |     
36 |     Volatility BS_VEGA(const PriceType stock_price,
37 |                        const PriceType strike,
38 |                        const RateType rate,
39 |                        const Volatility vol,
40 |                        const YearFraction time_to_maturity)
41 |     {
42 |         double d1 = ( log(stock_price/strike) + (rate + 0.5*vol*vol)*time_to_maturity ) / ( vol*sqrt(time_to_maturity) ) ;
43 |         return stock_price * sqrt(time_to_maturity) * normal_pdf(d1);
44 |     }
45 |     
46 |     void Find_Root_Helper::set_params(const PriceType _stock_price,
47 |                                       const StrikeType _strike,
48 |                                       const YearFraction _time_to_maturity,
49 |                                       const CallPut _call_put,
50 |                                       const PriceType _option_price)
51 |     {
52 |         stock_price = _stock_price;
53 |         strike = _strike;
54 |         time_to_maturity = _time_to_maturity;
55 |         call_put = _call_put;
56 |         option_price = _option_price;
57 |     }
58 |     
59 |     Volatility Find_Root_Helper::operator()(Volatility vol)
60 |     {
61 |         if (call_put == CallPut::CALL)
62 |             return BS_CALL_PRICE(stock_price,
63 |                                  strike,
64 |                                  rate,
65 |                                  vol,
66 |                                  time_to_maturity) - option_price;
67 |         else
68 |             return BS_PUT_PRICE(stock_price,
69 |                                 strike,
70 |                                 rate,
71 |                                 vol,
72 |                                 time_to_maturity) - option_price;
73 |     }
74 |     
75 |     Volatility Find_Root_Helper::diff(Volatility vol)
76 |     {
77 |         return BS_VEGA(stock_price,
78 |                        strike,
79 |                        rate,
80 |                        vol,
81 |                        time_to_maturity);
82 |     }
83 |     
84 |     
85 | }
86 | 


--------------------------------------------------------------------------------
/src/Backtester.hpp:
--------------------------------------------------------------------------------
  1 | //
  2 | //  Backtester.hpp
  3 | //  pgsql
  4 | //
  5 | //  Created by FuYongrui on 5/1/16.
  6 | //  Copyright © 2016 FuYongrui. All rights reserved.
  7 | //
  8 | 
  9 | #ifndef Backtester_hpp
 10 | #define Backtester_hpp
 11 | 
 12 | #include <stdio.h>
 13 | 
 14 | #include "DataWarehouse.hpp"
 15 | #include "Options.hpp"
 16 | #include "SignalGenerator.hpp"
 17 | //#include "PortfolioEngine.hpp"
 18 | 
 19 | 
 20 | namespace GammaScalping
 21 | {
 22 |     
 23 |     
 24 |     class Backtester
 25 |     {
 26 |     public:
 27 |         Backtester(OptionDataWarehouse_Sptr op_data_ptr, StockDataWarehouse_Sptr stk_data_ptr, Volatility entry, Volatility exit) :
 28 |         OptionData_ptr(op_data_ptr),
 29 |         StockData_ptr(stk_data_ptr),
 30 |         Signal_Generator(entry, exit)/*,
 31 |                                       Portfolio_Engine(PortfolioEngine(op_data_ptr))*/
 32 |         {
 33 |             StockPriceTimeSeries = StockData_ptr->make_query();
 34 |         }
 35 |         
 36 |         void start_backtest()
 37 |         {
 38 |             for(auto tup : StockPriceTimeSeries)
 39 |             {
 40 |                 auto current_date = tup[0].as<Date>();
 41 |                 auto stock_price = tup[1].as<PriceType>();
 42 |                 auto expiry_date = get_expiry(current_date);
 43 |                 auto strike = get_strike(stock_price);
 44 |                 cout << current_date << ' ' << stock_price << ' ' << expiry_date << ' ' << strike << endl;
 45 |                 
 46 |                 auto CallOption = boost::make_shared<Option>(current_date,
 47 |                                                              expiry_date,
 48 |                                                              stock_price,
 49 |                                                              strike,
 50 |                                                              CallPut::CALL,
 51 |                                                              OptionData_ptr);
 52 |                 cout << CallOption->get_impv() << " ";
 53 |                 auto PutOption = boost::make_shared<Option>(current_date,
 54 |                                                             expiry_date,
 55 |                                                             stock_price,
 56 |                                                             strike,
 57 |                                                             CallPut::PUT,
 58 |                                                             OptionData_ptr);
 59 |                 cout << PutOption->get_impv() << endl;
 60 |                 Signal_Generator.update_option(CallOption, PutOption);
 61 |                 
 62 |                 //auto signal = Signal_Generator.generate_signal();
 63 |                 
 64 |                 /*Portfolio_Engine.update_portfolio(signal,
 65 |                  current_date,
 66 |                  expiry_date,
 67 |                  stock_price,
 68 |                  strike);*/
 69 |             }
 70 |         }
 71 |         
 72 |     private:
 73 |         pqxx::result StockPriceTimeSeries;
 74 |         
 75 |         OptionDataWarehouse_Sptr OptionData_ptr;
 76 |         StockDataWarehouse_Sptr StockData_ptr;
 77 |         SignalGenerator Signal_Generator;
 78 |         //PortfolioEngine Portfolio_Engine;
 79 |         
 80 |         Date get_expiry(const Date& curr_date)
 81 |         {
 82 |             auto curr_month = curr_date.substr(5,2);
 83 |             Date expiry = "2011-01-19";
 84 |             
 85 |             const vector<Date> expiry_calendar = {
 86 |                 "2011-01-19",
 87 |                 "2011-02-19",
 88 |                 "2011-03-19",
 89 |                 "2011-04-16",
 90 |                 "2011-05-21",
 91 |                 "2011-06-18",
 92 |                 "2011-07-16",
 93 |                 "2011-08-20",
 94 |                 "2011-09-17",
 95 |                 "2011-10-22",
 96 |                 "2011-11-19",
 97 |                 "2011-12-17",
 98 |                 "2012-01-21"};
 99 |             
100 |             
101 |             
102 |             if (stoi(curr_month) < 12)
103 |                 expiry = expiry_calendar.at(stoi(curr_month));
104 |             else
105 |                 expiry = expiry_calendar.at(12);
106 |             
107 |             return expiry;
108 |         }
109 |         
110 |         StrikeType get_strike(const PriceType& stock_price)
111 |         {
112 |             StrikeType strk = (int)(stock_price + 0.5);
113 |             
114 |             return strk;
115 |         }
116 |         
117 |     };
118 | }
119 | #endif /* Backtester_hpp */
120 | 


--------------------------------------------------------------------------------
/src/DataWarehouse.hpp:
--------------------------------------------------------------------------------
  1 | //
  2 | //  DataWarehouse.hpp
  3 | //  pgsql
  4 | //
  5 | //  Created by FuYongrui on 5/1/16.
  6 | //  Copyright © 2016 FuYongrui. All rights reserved.
  7 | //
  8 | 
  9 | #ifndef DataWarehouse_hpp
 10 | #define DataWarehouse_hpp
 11 | 
 12 | #include <stdio.h>
 13 | 
 14 | #include <iostream>
 15 | #include <pqxx/pqxx>
 16 | #include <boost/shared_ptr.hpp>
 17 | #include <boost/make_shared.hpp>
 18 | #include <ql/time/all.hpp>
 19 | 
 20 | #define DEBUG = false
 21 | 
 22 | using namespace std;
 23 | 
 24 | namespace GammaScalping
 25 | {
 26 |     
 27 |     typedef double PriceType;
 28 |     typedef int StrikeType;
 29 |     typedef double ShareType;
 30 |     typedef double RateType;
 31 |     typedef double PNLType;
 32 |     typedef string Date;
 33 |     
 34 |     enum CallPut {CALL, PUT};
 35 |     
 36 |     typedef boost::shared_ptr<pqxx::connection> Conn_Ptr;
 37 |     
 38 |     class OptionDataWarehouse;
 39 |     typedef boost::shared_ptr<OptionDataWarehouse> OptionDataWarehouse_Sptr;
 40 |     
 41 |     class StockDataWarehouse;
 42 |     typedef boost::shared_ptr<StockDataWarehouse> StockDataWarehouse_Sptr;
 43 |     
 44 |     class DataWarehouse
 45 |     {
 46 |     public:
 47 |         
 48 |         DataWarehouse()
 49 |         {
 50 |             try{
 51 |                 conn = boost::make_shared<pqxx::connection>("dbname=mydb user=alanfu hostaddr=127.0.0.1 port=5432");
 52 |                 
 53 |                 if (conn->is_open()) {
 54 |                     cout << "Opened database successfully: " << conn->dbname() << endl;
 55 |                 } else {
 56 |                     throw runtime_error("Cannot connect to database!");
 57 |                 }
 58 |             }catch (runtime_error &e){
 59 |                 cerr << e.what() << std::endl;
 60 |             }
 61 |         }
 62 |         
 63 |     protected:
 64 |         Conn_Ptr conn;
 65 |         Date current_date;
 66 |     private:
 67 |         
 68 |     };// class DataWarehouse
 69 |     
 70 |     class StockDataWarehouse : public DataWarehouse
 71 |     {
 72 |     public:
 73 |         StockDataWarehouse() : DataWarehouse()
 74 |         {
 75 |             cout << "Connect to stock database successfully." << endl;
 76 |         }
 77 |         
 78 |         void update_date(const Date& curr_date)
 79 |         {
 80 |             current_date = curr_date;
 81 |         }
 82 |         
 83 |         pqxx::result make_query()
 84 |         {
 85 |             pqxx::work W(*conn);
 86 |             
 87 |             string temp = "SELECT * FROM spystocks;";
 88 |             const char* sql=temp.c_str();
 89 |             
 90 |             pqxx::result R = W.exec(sql);
 91 |             //W.commit();
 92 |             return R;
 93 |         }
 94 |         
 95 |     protected:
 96 |         
 97 |     private:
 98 |         
 99 |     };//class StockDataWarehouse
100 |     
101 |     class OptionDataWarehouse : public DataWarehouse
102 |     {
103 |     public:
104 |         OptionDataWarehouse() : DataWarehouse()
105 |         {
106 |             cout << "Connect to option database successfully." << endl;
107 |         }
108 |         /*
109 |         inline void set_params(const Date& curr_date,
110 |                                const Date& ex_date,
111 |                                const StrikeType& stk,
112 |                                const CallPut& c_p)
113 |         {
114 |             current_date = curr_date;
115 |             expiry_date = ex_date;
116 |             strike = stk;
117 |             call_put = c_p;
118 |         }
119 |         */
120 |         PriceType make_query(const Date& curr_date,
121 |                              const Date& ex_date,
122 |                              const StrikeType& stk,
123 |                              const CallPut& c_p)
124 |         {
125 |             pqxx::work W(*conn);
126 |             string optiontable = "spyoptions";
127 |             string call_put = (c_p == CallPut::CALL) ? "C" : "P";
128 |             string temp = "select price from spyoptions where cur_date = date \'" + curr_date + "\' and ex_date = date \'" + ex_date + "\' and flag = \'" + call_put + "\' and k = " + to_string(stk) + ";";
129 |             const char* sql = temp.c_str();
130 |         
131 |             pqxx::result R = W.exec(sql);
132 |             PriceType ret = stof(R.begin()[0].as<string>());
133 |             return ret;
134 |         }
135 |         
136 |     private:
137 |         /*
138 |         Date expiry_date;
139 |         StrikeType strike;
140 |         CallPut call_put;
141 |         */
142 |     };// class OptionDataWarehouse
143 | }
144 | 
145 | #endif /* DataWarehouse_hpp */
146 | 


--------------------------------------------------------------------------------
/src/PortfolioEngine.hpp:
--------------------------------------------------------------------------------
  1 | //
  2 | //  PortfolioEngine.hpp
  3 | //  pgsql
  4 | //
  5 | //  Created by FuYongrui on 5/1/16.
  6 | //  Copyright © 2016 FuYongrui. All rights reserved.
  7 | //
  8 | 
  9 | #ifndef PortfolioEngine_hpp
 10 | #define PortfolioEngine_hpp
 11 | 
 12 | #include <stdio.h>
 13 | #include <vector>
 14 | #include <boost/shared_ptr.hpp>
 15 | #include <tuple>
 16 | #include <pqxx/pqxx>
 17 | #include "DataWarehouse.hpp"
 18 | #include "Options.hpp"
 19 | #include "SignalGenerator.hpp"
 20 | using namespace std;
 21 | using boost::shared_ptr;
 22 | 
 23 | 
 24 | namespace GammaScalping
 25 | {
 26 |     using namespace pqxx;
 27 |     
 28 |     enum LongShort {LONG, SHORT};
 29 |     enum DeltaHedgeSignal {BUY_TO_HEDGE, SELL_TO_HEDGE, NONE};
 30 |     
 31 |     struct stock_transaction
 32 |     {
 33 |         Date current_date;
 34 |         ShareType num_shares;
 35 |         PriceType price;
 36 |         LongShort long_short;
 37 |     };
 38 |     
 39 |     typedef typename std::vector<stock_transaction> stock_portfolio;
 40 |     typedef typename std::tuple<Option_Sptr,Option_Sptr> option_portfolio;
 41 |     typedef typename std::tuple<DeltaHedgeSignal,ShareType> dh_transaction;
 42 |     
 43 |     class PortfolioEngine
 44 |     {
 45 |     private:
 46 |         
 47 |         struct portfolio_total
 48 |         {
 49 |             portfolio_total():delta(0) {}
 50 |             stock_portfolio Stock_Portfolio;
 51 |             option_portfolio Option_Portfolio;
 52 |             double delta;
 53 |         };
 54 |         
 55 |         portfolio_total Portfolio_All;
 56 |         vector<PNLType> PNL;
 57 |         OptionDataWarehouse_Sptr OptionData_ptr;
 58 |         bool is_gamma_scalp = false;
 59 |         
 60 |     public:
 61 |         
 62 |         PortfolioEngine(OptionDataWarehouse_Sptr op_data_ptr) : OptionData_ptr(op_data_ptr) {}
 63 |         
 64 |         void update_portfolio(const Signal& sig,
 65 |                               const Date& curr_date,
 66 |                               const Date& expiry_date,
 67 |                               const PriceType& st_price,
 68 |                               const StrikeType& strk);
 69 |         
 70 |     private:
 71 |         
 72 |         dh_transaction init_option_portfolio(const Date& curr_date,
 73 |                                              const Date& ex_date,
 74 |                                              const PriceType& st_price,
 75 |                                              const StrikeType& strike);
 76 |         
 77 |         void init_stock_portfolio(const dh_transaction& dh_t,
 78 |                                   const Date& curr_date,
 79 |                                   const PriceType& stock_price);
 80 |         
 81 |         dh_transaction update_option_portfolio(const Date& curr_date,
 82 |                                                const PriceType& st_price);
 83 |         
 84 |         PNLType update_stock_portfolio(const dh_transaction& dht,
 85 |                                        const Date& curr_date,
 86 |                                        const PriceType& stock_price);
 87 |         
 88 |         PNLType close_option_portfolio(const Date& curr_date);
 89 |         
 90 |         PNLType close_stock_portfolio(const PriceType& stock_price);
 91 |         
 92 |         
 93 |         
 94 |         /************ Utility functions ************/
 95 |         void update_price_n_delta(const Date& curr_date, const PriceType& stock_price)
 96 |         {
 97 |             get<0>(Portfolio_All.Option_Portfolio)->latest_mkt_price(curr_date,
 98 |                                                                      stock_price);
 99 |             get<1>(Portfolio_All.Option_Portfolio)->latest_mkt_price(curr_date,
100 |                                                                      stock_price);
101 |             get<0>(Portfolio_All.Option_Portfolio)->update_delta();
102 |             get<1>(Portfolio_All.Option_Portfolio)->update_delta();
103 |         }
104 |         
105 |         dh_transaction delta_hedge_signal()
106 |         {
107 |             auto temp_call = get<0>(Portfolio_All.Option_Portfolio);
108 |             auto temp_put = get<1>(Portfolio_All.Option_Portfolio);
109 |             auto delta_total = temp_call->get_delta() + temp_put->get_delta();
110 |             
111 |             DeltaHedgeSignal dhs = DeltaHedgeSignal::NONE;
112 |             
113 |             if (delta_total > 0.15)
114 |                 dhs = DeltaHedgeSignal::SELL_TO_HEDGE;
115 |             else if(delta_total < -0.15)
116 |                 dhs = DeltaHedgeSignal::BUY_TO_HEDGE;
117 |             
118 |             ShareType shares = abs(delta_total);// shares *= 100
119 |             
120 |             dh_transaction dh_t = std::make_tuple(dhs,shares);
121 |             
122 |             return dh_t;
123 |         }
124 |         
125 |         inline void add_stock_trade(const dh_transaction& dh_t,
126 |                                     const Date& curr_date,
127 |                                     const PriceType& stock_price)
128 |         {
129 |             // add trade to empty vector || existing trade and new trade has same direction
130 |             stock_transaction new_stock;
131 |             new_stock.current_date = curr_date;
132 |             new_stock.num_shares = get<1>(dh_t);
133 |             new_stock.price = stock_price;
134 |             new_stock.long_short = (get<0>(dh_t) == DeltaHedgeSignal::BUY_TO_HEDGE) ? LongShort::LONG : LongShort::SHORT;
135 |             Portfolio_All.Stock_Portfolio.push_back(new_stock);
136 |         }
137 |         
138 |     };
139 | }
140 | 
141 | #endif /* PortfolioEngine_hpp */
142 | 


--------------------------------------------------------------------------------
/src/Options.hpp:
--------------------------------------------------------------------------------
  1 | //
  2 | //  Options.hpp
  3 | //  pgsql
  4 | //
  5 | //  Created by FuYongrui on 5/1/16.
  6 | //  Copyright © 2016 FuYongrui. All rights reserved.
  7 | //
  8 | 
  9 | #ifndef Options_hpp
 10 | #define Options_hpp
 11 | 
 12 | #include <stdio.h>
 13 | #include "DataWarehouse.hpp"
 14 | #include "MathUtility.h"
 15 | #include <ql/utilities/dataparsers.hpp>
 16 | 
 17 | static const QuantLib::Calendar   calendar = QuantLib::UnitedStates();
 18 | static const QuantLib::DayCounter day_counter  = QuantLib::Business252(calendar);
 19 | 
 20 | namespace GammaScalping
 21 | {
 22 |     typedef double Volatility;
 23 |     typedef double YearFraction;
 24 |     
 25 |     PriceType BS_CALL_PRICE(const PriceType stock_price,
 26 |                             const PriceType strike,
 27 |                             const RateType rate,
 28 |                             const Volatility vol,
 29 |                             const YearFraction time_to_maturity);
 30 |     
 31 |     PriceType BS_PUT_PRICE(const PriceType stock_price,
 32 |                            const PriceType strike,
 33 |                            const RateType rate,
 34 |                            const Volatility vol,
 35 |                            const YearFraction time_to_maturity);
 36 |     
 37 |     Volatility BS_VEGA(const PriceType stock_price,
 38 |                        const PriceType strike,
 39 |                        const RateType rate,
 40 |                        const Volatility vol,
 41 |                        const YearFraction time_to_maturity);
 42 |     
 43 |     class Option;
 44 |     typedef boost::shared_ptr<Option> Option_Sptr;
 45 |     
 46 |     struct Find_Root_Helper
 47 |     {
 48 |         PriceType stock_price;
 49 |         StrikeType strike;
 50 |         YearFraction time_to_maturity;
 51 |         CallPut call_put;
 52 |         PriceType option_price;
 53 |         RateType rate = 0.05;
 54 |         void set_params(const PriceType _stock_price,
 55 |                         const StrikeType _strike,
 56 |                         const YearFraction _time_to_maturity,
 57 |                         const CallPut _call_put,
 58 |                         const PriceType _option_price);
 59 |         Volatility operator()(Volatility vol);
 60 |         Volatility diff(Volatility vol);
 61 |     };
 62 |     
 63 |     class Option
 64 |     {
 65 |     public:
 66 |         Option(const Date& curr_date,
 67 |                const Date& ex_date,
 68 |                const PriceType& _stock_price,
 69 |                const StrikeType& stk,
 70 |                const CallPut& c_p,
 71 |                OptionDataWarehouse_Sptr op_data_ptr) :
 72 |         current_date(curr_date),
 73 |         expiry_date(ex_date),
 74 |         stock_price(_stock_price),
 75 |         strike(stk),
 76 |         call_put(c_p),
 77 |         option_data_ptr(op_data_ptr)
 78 |         {
 79 |             latest_mkt_price(curr_date, _stock_price);
 80 |         }
 81 |         
 82 |         // this function not only update the options price, but also update all other related metrics
 83 |         void latest_mkt_price(const Date& curr_date, const PriceType& stock_price)
 84 |         {
 85 |             update_date(curr_date);
 86 |             /*
 87 |             option_data_ptr->set_params(current_date,
 88 |                                         expiry_date,
 89 |                                         strike,
 90 |                                         call_put);
 91 |             */
 92 |             option_price = option_data_ptr->make_query(current_date,
 93 |                                                        expiry_date,
 94 |                                                        strike,
 95 |                                                        call_put);
 96 |             
 97 |             auto d1 = QuantLib::DateParser::parseFormatted(current_date, "%Y-%m-%d");
 98 |             auto d2 = QuantLib::DateParser::parseFormatted(expiry_date, "%Y-%m-%d");
 99 |             time_to_maturity = day_counter.yearFraction(d1, d2);
100 |             
101 |             frh.set_params(stock_price,
102 |                            strike,
103 |                            time_to_maturity,
104 |                            call_put,
105 |                            option_price);
106 |             
107 |             calc_impv();
108 |         }
109 |         
110 |         void update_delta()
111 |         {
112 |             double d1 = ( log(option_price/strike) + (rate + 0.5*vol*vol)*time_to_maturity ) / ( vol*sqrt(time_to_maturity) ) ;
113 |             if (call_put == CallPut::CALL)
114 |                 delta = normal_cdf(d1);
115 |             else
116 |                 delta = normal_cdf(d1) - 1;
117 |         }
118 |         
119 |         void calc_impv()
120 |         {
121 |             vol = root_newton(frh);
122 |         }
123 |         
124 |         double get_delta()
125 |         {
126 |             return delta;
127 |         }
128 |         
129 |         Volatility get_impv()
130 |         {
131 |             return vol;
132 |         }
133 |         
134 |         PNLType option_pnl(const Date& curr_date)
135 |         {
136 |             PNLType pnl = 0;
137 |             
138 |             return pnl;
139 |         }
140 |         
141 |         
142 |     protected:
143 |         Date current_date;
144 |         Date expiry_date;
145 |         PriceType stock_price;
146 |         StrikeType strike;
147 |         CallPut call_put;
148 |         OptionDataWarehouse_Sptr option_data_ptr;
149 |         YearFraction time_to_maturity;
150 |         PriceType option_price;
151 |         Volatility vol;
152 |         RateType rate = 0.05;
153 |         double delta;
154 |         Find_Root_Helper frh;
155 |         
156 |     private:
157 |         inline void update_date(const Date& curr_date)
158 |         {
159 |             current_date = curr_date;
160 |         }
161 |     };// class Option
162 |     
163 | }
164 | #endif /* Options_hpp */
165 | 


--------------------------------------------------------------------------------
/src/PortfolioEngine.cpp:
--------------------------------------------------------------------------------
  1 | //
  2 | //  PortfolioEngine.cpp
  3 | //  pgsql
  4 | //
  5 | //  Created by FuYongrui on 5/1/16.
  6 | //  Copyright © 2016 FuYongrui. All rights reserved.
  7 | //
  8 | 
  9 | #include "PortfolioEngine.hpp"
 10 | 
 11 | namespace GammaScalping
 12 | {
 13 |     void PortfolioEngine::update_portfolio(const Signal& sig,
 14 |                                            const Date& curr_date,
 15 |                                            const Date& expiry_date,
 16 |                                            const PriceType& st_price,
 17 |                                            const StrikeType& strk)
 18 |     {
 19 |         
 20 |         PriceType stock_price = st_price;
 21 |         StrikeType atm = strk;
 22 |         Date ex_date = expiry_date;
 23 |         PNLType pnl = 0;
 24 |         
 25 |         switch (sig) {
 26 |                 
 27 |             case Signal::ENTER:
 28 |             {
 29 |                 if (!is_gamma_scalp){
 30 |                     
 31 |                     // init option position and generate delta hedge signal
 32 |                     dh_transaction init_trade = init_option_portfolio(curr_date,
 33 |                                                                       ex_date,
 34 |                                                                       stock_price,
 35 |                                                                       atm);
 36 |                     
 37 |                     if(get<0>(init_trade) != DeltaHedgeSignal::NONE)
 38 |                         init_stock_portfolio(init_trade, curr_date, stock_price);
 39 |                     // update stock position
 40 |                     is_gamma_scalp = true;
 41 |                     break;
 42 |                 }
 43 |             }
 44 |                 
 45 |             case Signal::KEEP:
 46 |             {
 47 |                 dh_transaction dh_trade = update_option_portfolio(curr_date,
 48 |                                                                   stock_price);// generate delta hedge signal
 49 |                 if(get<0>(dh_trade) != DeltaHedgeSignal::NONE)
 50 |                     pnl += update_stock_portfolio(dh_trade, curr_date, stock_price);// update stock position and calculate pnl
 51 |                 break;
 52 |             }
 53 |                 
 54 |             case Signal::EXIT:
 55 |             {
 56 |                 pnl += close_option_portfolio(curr_date);// calculate option pnl
 57 |                 pnl += close_stock_portfolio(stock_price);// calculate stock pnl
 58 |                 break;
 59 |             }
 60 |         }
 61 |         
 62 |         PNL.push_back(pnl);
 63 |     }
 64 |     
 65 |     dh_transaction PortfolioEngine::init_option_portfolio(const Date& curr_date,
 66 |                                                           const Date& ex_date,
 67 |                                                           const PriceType& stock_price,
 68 |                                                           const StrikeType& strike)
 69 |     {
 70 |         auto new_call = boost::make_shared<Option>(curr_date,
 71 |                                                    ex_date,
 72 |                                                    stock_price,
 73 |                                                    strike,
 74 |                                                    CallPut::CALL,
 75 |                                                    OptionData_ptr);
 76 |         
 77 |         auto new_put = boost::make_shared<Option>(curr_date,
 78 |                                                   ex_date,
 79 |                                                   stock_price,
 80 |                                                   strike,
 81 |                                                   CallPut::PUT,
 82 |                                                   OptionData_ptr);
 83 |         
 84 |         Portfolio_All.Option_Portfolio = std::make_tuple(new_call,new_put);
 85 |         
 86 |         update_price_n_delta(curr_date, stock_price);
 87 |         
 88 |         return delta_hedge_signal();
 89 |     }
 90 |     
 91 |     void PortfolioEngine::init_stock_portfolio(const dh_transaction& dh_t,
 92 |                                                const Date& curr_date,
 93 |                                                const PriceType& stock_price)
 94 |     {
 95 |         add_stock_trade(dh_t, curr_date, stock_price);
 96 |     }
 97 |     
 98 |     dh_transaction PortfolioEngine::update_option_portfolio(const Date& curr_date,
 99 |                                                             const PriceType& stock_price)
100 |     {
101 |         update_price_n_delta(curr_date, stock_price);
102 |         
103 |         return delta_hedge_signal();
104 |         
105 |     }
106 |     
107 |     PNLType PortfolioEngine::update_stock_portfolio(const dh_transaction& dht,
108 |                                                     const Date& curr_date,
109 |                                                     const PriceType& stock_price)
110 |     {
111 |         PNLType realized_pnl = 0;
112 |         //PNLType unrealized_pnl;
113 |         auto dh_signal = get<0>(dht);
114 |         auto stock_port_tmp = Portfolio_All.Stock_Portfolio;
115 |         
116 |         if(stock_port_tmp.empty()) // if there is no transaction record
117 |             add_stock_trade(dht, curr_date, stock_price);
118 |         else // if there are transaction records
119 |         {
120 |             auto curr_direction = stock_port_tmp[0].long_short;
121 |             
122 |             // if existing direction is long and we need to buy to hedge
123 |             if(curr_direction == LongShort::LONG && dh_signal == DeltaHedgeSignal::BUY_TO_HEDGE)
124 |                 add_stock_trade(dht, curr_date, stock_price);
125 |             
126 |             // if existing direction is short and we need to sell to hedge
127 |             else if(curr_direction == LongShort::SHORT && dh_signal == DeltaHedgeSignal::SELL_TO_HEDGE)
128 |                 add_stock_trade(dht, curr_date, stock_price);
129 |             
130 |             // if direction is different
131 |             else
132 |             {
133 |                 auto new_shares = get<1>(dht);
134 |                 
135 |                 // we close existing positions from most recent
136 |                 for(auto it = stock_port_tmp.rbegin(); it != stock_port_tmp.rend(); it++)
137 |                 {
138 |                     if(it->num_shares > new_shares)
139 |                     {
140 |                         PNLType pnl_abs = new_shares * (stock_price - it->price);
141 |                         
142 |                         if(dh_signal == DeltaHedgeSignal::BUY_TO_HEDGE)
143 |                             realized_pnl -= pnl_abs;
144 |                         else
145 |                             realized_pnl += pnl_abs;
146 |                         
147 |                         it->num_shares -= new_shares;
148 |                         
149 |                         break;
150 |                     }
151 |                     else
152 |                     {
153 |                         auto pnl_abs = it->num_shares * (stock_price - it->price);
154 |                         
155 |                         if(dh_signal == DeltaHedgeSignal::BUY_TO_HEDGE)
156 |                             realized_pnl -= pnl_abs;
157 |                         else
158 |                             realized_pnl += pnl_abs;
159 |                         
160 |                         new_shares -= it->num_shares;
161 |                         
162 |                         stock_port_tmp.pop_back(); // *it has been close by new trade
163 |                         
164 |                     }
165 |                 }
166 |                 
167 |                 // all the existing portfolio have been close
168 |                 if(new_shares > 0)
169 |                 {
170 |                     auto dh_new = std::make_tuple(dh_signal, new_shares);
171 |                     add_stock_trade(dh_new, curr_date, stock_price);
172 |                 }
173 |             }
174 |         }
175 |         
176 |         return realized_pnl;
177 |     }
178 |     
179 |     PNLType PortfolioEngine::close_option_portfolio(const Date& curr_date)
180 |     {
181 |         PNLType realized_pnl = 0;
182 |         
183 |         realized_pnl += get<0>(Portfolio_All.Option_Portfolio)->option_pnl(curr_date);
184 |         realized_pnl += get<1>(Portfolio_All.Option_Portfolio)->option_pnl(curr_date);
185 |         
186 |         return realized_pnl;
187 |     }
188 |     
189 |     PNLType PortfolioEngine::close_stock_portfolio(const PriceType& stock_price)
190 |     {
191 |         PNLType realized_pnl = 0;
192 |         
193 |         auto stock_port_tmp = Portfolio_All.Stock_Portfolio;
194 |         
195 |         if(!stock_port_tmp.empty())
196 |         {
197 |             PNLType pnl_abs = 0;
198 |             
199 |             for(auto it = stock_port_tmp.rbegin(); it != stock_port_tmp.rend(); it++)
200 |                 pnl_abs += stock_price - it->price;
201 |             
202 |             auto curr_direction = stock_port_tmp[0].long_short;
203 |             
204 |             if(curr_direction == LongShort::SHORT)
205 |                 realized_pnl -= pnl_abs;
206 |             else
207 |                 realized_pnl += pnl_abs;
208 |         }
209 |         
210 |         return realized_pnl;
211 |     }
212 |     
213 | }


--------------------------------------------------------------------------------