Update dist.cpp

MoQuant · web-flow · commit 61b00434e605 · 2025-05-15T14:20:38.000-04:00
diff --git a/Distribution/dist.cpp b/Distribution/dist.cpp
@@ -22,12 +22,14 @@ std::string address(std::string ticker){
     return url;
 }
 
+// Takes part in decrypting bytes to be transferred into a string result
 size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* response) {
     size_t totalSize = size * nmemb;
     response->append((char*)contents, totalSize);
     return totalSize;
 }
 
+// Sends a rest request to polygon to fetch the stock data
 std::string RequestData(const std::string& url) {
     CURL* curl;
     CURLcode res;
@@ -55,16 +57,21 @@ std::string RequestData(const std::string& url) {
     return response; // Return the response
 }
 
+// Sleep timer
 void Sleep(int wait_time){
     std::this_thread::sleep_for(std::chrono::seconds(wait_time));
 }
 
+// Imports historical stock price data from Polygon.io and sorts them into a map with the key being the stock ticker 
+// and the value being the vector of close prices
 std::map<std::string, std::vector<double>> ImportHistoricalData(std::vector<std::string> tickers, int wait_time){
     std::map<std::string, std::vector<double>> result;
     std::cout << "Stock data is loading" << std::endl;
     for(auto & stock : tickers){
         Sleep(wait_time);
         std::cout << stock << " is imported" << std::endl;
+
+        // Fetch stock price data and parse string result as JSON with Boost
         std::string response = RequestData(address(stock));
         ptree data;
         std::stringstream ss(response);
@@ -74,6 +81,7 @@ std::map<std::string, std::vector<double>> ImportHistoricalData(std::vector<std:
                 for(ptree::const_iterator jt = it->second.begin(); jt != it->second.end(); ++jt){
                     for(ptree::const_iterator kt = jt->second.begin(); kt != jt->second.end(); ++kt){
                         if(kt->first == "l"){
+                            // Pull close prices for the stock into the map
                             result[stock].push_back(atof(kt->second.get_value<std::string>().c_str()));
                         }
                     }
@@ -85,7 +93,10 @@ std::map<std::string, std::vector<double>> ImportHistoricalData(std::vector<std:
     return result;
 }
 
+// Calculates the distribution charts per ticker and stores the results in the modify map
 void ComputeData(std::vector<double> close, std::string ticker, std::map<std::string, std::map<std::string, std::vector<double>>> & modify){
+
+    // Computes the average of a given vector of values
     auto average = [](std::vector<double> x){
         double total = 0;
         for(auto & i : x){
@@ -95,6 +106,7 @@ void ComputeData(std::vector<double> close, std::string ticker, std::map<std::st
         return total;
     };
 
+    // Computes the standard deviation of a given vector of values
     auto volatility = [&](std::vector<double> x){
         double mu = average(x);
         double total = 0;
@@ -105,23 +117,30 @@ void ComputeData(std::vector<double> close, std::string ticker, std::map<std::st
         return pow(total, 0.5);
     };
 
+    // Stochastic parameter in Geometric Brownian Motion which returns a value between -10 to 10 percent
     auto dWT = [](){
         int num = 10;
         double dw = (rand() % (2*num + 1)) - num;
         return dw/100.0;
     };
 
+    // Takes in the stock returns and the number of bins and generates a histogram
     auto histogram = [](std::vector<double> returns, int bins){
         std::map<std::string, std::vector<double>> res;
+
+        // Sort the returns and set the bounds of the histogram
         std::sort(returns.begin(), returns.end());
         double m0 = returns[0];
         double m1 = returns[returns.size() - 1];
         double dm = (m1 - m0)/((double) bins);
+
+        // Count the frequency of each return group occuring, return group is between 'a' and 'b'
         for(int i = 0; i < bins; ++i){
             double a = m0 + i*dm;
             double b = m0 + (i+1)*dm;
             int count = 0;
             for(auto & r : returns){
+                // Counts the frequency
                 if(i == bins - 1){
                     if(r >= a && r <= b){
                         count += 1;
@@ -132,17 +151,22 @@ void ComputeData(std::vector<double> close, std::string ticker, std::map<std::st
                     }
                 }
             }
+            // Pushes x and y parameters in histogram map
             double mid = 0.5*(a + b);
             res["x"].push_back(mid);
             res["y"].push_back(count);
         }
         return res;
     };
-
+    
     std::vector<double> ror, ror_predict, stock_paths;
+    
+    // Calculates the rate of return of the current selected stock
     for(int i = 1; i < close.size(); ++i){
         ror.push_back(close[i]/close[i-1] - 1.0);
     }
+
+    // Sets the parameters for the Geometric Brownian Motion equation
     double S = close[close.size() - 1];
     double mu = average(ror);
     double t = 1.0/12.0;
@@ -151,9 +175,12 @@ void ComputeData(std::vector<double> close, std::string ticker, std::map<std::st
     int P = 100;
     double dt = t / (double) N;
 
-    // mu*S*dt + v*S*dWT()
+    // Formula = mu*S*dt + v*S*dWT()
+
+    // Makes sure each run is random
     srand(time(NULL));
 
+    // Running the GBM simulation
     for(int p = 0; p < P; ++p){
         double S0 = S;
         for(int t = 0; t < N; ++t){
@@ -162,13 +189,18 @@ void ComputeData(std::vector<double> close, std::string ticker, std::map<std::st
         stock_paths.push_back(S0);
     }
 
+    // Computing the rate of return from the predicted stock paths
     for(int i = 1; i < stock_paths.size(); ++i){
         ror_predict.push_back(stock_paths[i]/stock_paths[i-1] - 1.0);
     } 
 
+    // Generating the histogram with 30 bins for both groups (historical and predicted)
     std::map<std::string, std::vector<double>> RHist = histogram(ror, 30);
     std::map<std::string, std::vector<double>> RPred = histogram(ror_predict, 30);
 
+    // Storing everything in the modify result map which has the first key being a stock ticker
+    // and the second key being x,y hist/pred
+    
     modify[ticker]["xhist"] = RHist["x"];
     modify[ticker]["yhist"] = RHist["y"];
     modify[ticker]["xpred"] = RPred["x"];
@@ -179,27 +211,35 @@ void ComputeData(std::vector<double> close, std::string ticker, std::map<std::st
 
 int main()
 {
+    // Selected stocks to be examined
     std::vector<std::string> tickers = {"MSFT","AAPL","NVDA","AMZN","IBM","ORCL"};
+
+    // Building the plot grid for the histograms
     std::vector<PyObject*> plots;
     std::vector<int> pnum = {231, 232, 233, 234, 235, 236};
     for(auto & number : pnum){
         plots.push_back(plt::chart2D(number));
     }
 
+    // Set sleep time
     int sleep_for_time = 10;
 
+    // Import the historical data and declare storage map
     std::map<std::string, std::vector<double>> close = ImportHistoricalData(tickers, sleep_for_time);
     std::map<std::string, std::map<std::string, std::vector<double>>> modify;
-    
+
+    // Build a vector of threads to calculate all inputted stocks simulations at the same time
     std::vector<std::thread> items;
     for(auto & ticker : tickers){
         items.emplace_back(ComputeData, close[ticker], ticker, std::ref(modify));
     }
 
+    // Join the threads upon completion to end each thread
     for(auto & plane : items){
         plane.join();
     }
 
+    // Plot the distributions 
     for(int i = 0; i < plots.size(); ++i){
         PyObject * ax = plots[i];
         std::string tick = tickers[i];
@@ -211,4 +251,4 @@ int main()
     plt::show();
 
     return 0;
-}
+}
