backtest.h File Reference

#include <span>
#include <string_view>
#include <utility>
#include <vector>

Include dependency graph for backtest.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
using	trade_t
	Summary of a trade: file, epoch, entry, exit, profit, duration.

Functions
std::vector< trade_t >	to_summary (std::span< const std::string_view >)

Typedef Documentation

trade_t

using trade_t

Initial value:

 
    std::tuple<std::string_view, size_t, double, double, double, size_t>

Summary of a trade: file, epoch, entry, exit, profit, duration.

Definition at line 9 of file backtest.h.

Function Documentation

to_summary()

std::vector< trade_t > to_summary

(

std::span< const std::string_view >

files

)

Take a vector of files to backtest with testing params, and return a summary of trades across all files

Definition at line 10 of file backtest.cxx.

                                                                   {
 
  // Results container and access mutex
  std::vector<trade_t> results;
  auto &&results_mutex = std::mutex{};
 
  // For each file
  std::ranges::for_each(files, [&](auto &&csv) {
    using namespace std::views;
 
    // Get price data from disk
    auto &&contents = file_read(csv);
    auto &&series = to_series3(contents);
 
    // Calculate all trade windows, remove non trades and
    // fold each window into a single price
    auto &&entries = series | slide(fx::win) | filter(fx::is_entry2) |
                     transform(fx::to_last);
 
    // Evaluate each trade
    for (auto &&x : entries) {
 
      // Find the entry iterator
      auto &&entry_it = std::ranges::find_if(
          series, [&](auto y) { return fx::to_time(x) == fx::to_time(y); });
 
      // Calculate index into series
      auto &&offset = std::ranges::distance(std::cbegin(series), entry_it);
 
      // Calculate trade window size but don't run off the end
      auto trade_window_size =
          std::min(std::size(series) - offset, static_cast<size_t>(fx::win));
 
      // Create trade window by dropping everything before the entry
      // iterator
      auto &&trade = std::vector<std::vector<double>>{
          std::cbegin(series) + offset,
          std::cbegin(series) + offset + trade_window_size};
 
      // Calculate profit
      auto &&entry = fx::to_first(trade);
      auto &&exit = fx::to_exit(trade);
      auto &&profit = fx::to_profit(fx::to_spot(entry), fx::to_spot(exit));
 
      // Calculate duration of trade
      auto &&entry_time = fx::to_time(entry);
      auto &&exit_time = fx::to_time(exit);
      auto &&duration = exit_time - entry_time;
 
      // Trim file name for reporting
      auto &&to_token = csv | take(std::ranges::size(csv) - 4uz) | drop(12uz);
 
      // Store results
      std::scoped_lock lock(results_mutex);
      results.push_back({to_token, entry_time, fx::to_spot(entry),
                         fx::to_spot(exit), profit, duration});
    }
  });
 
  // Sort results
  std::ranges::sort(
      results, [](auto a, auto b) { return std::get<1>(a) > std::get<1>(b); });
 
  return results;
}

Here is the call graph for this function:

Here is the caller graph for this function: