trial_executor.hpp

Go to the documentation of this file.

#pragma once
 
#include <pineforge/pineforge.h>
 
#include <array>
#include <cstdint>
#include <limits>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
#include <pineforge/hpo/dataset.hpp>
#include <pineforge/hpo/return_stats.hpp>
#include <pineforge/hpo/strategy_plugin.hpp>
 
namespace pineforge {
namespace hpo {
 
using ParameterValues = std::map<std::string, std::string>;
 
struct BacktestConfiguration {
    std::string input_timeframe;
    std::string script_timeframe;
    std::string chart_timezone;
    bool bar_magnifier = false;
    int magnifier_samples = 4;
    pf_magnifier_distribution_t magnifier_distribution = PF_MAGNIFIER_ENDPOINTS;
 
    bool capture_equity_curve = true;
    bool capture_trades = false;
    bool return_stats_bar = false;
    bool return_stats_monthly = false;
    std::uint32_t pbo_blocks = 0;
    std::optional<SymbolInfo> symbol_info;
    std::shared_ptr<const SymbolFeeds> symbol_feeds;
};
 
void require_return_stats_identity();
 
struct ReturnStatsFields {
    bool computed = false;
    std::array<double, 9> values{{
        std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN(),
        std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN(),
        std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN(),
        std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN(),
        std::numeric_limits<double>::quiet_NaN()}};
};
 
struct ReportSnapshot {
    std::int32_t total_trades = 0;
    double net_profit = 0.0;
 
    std::int64_t input_bars_processed = 0;
    std::int64_t script_bars_processed = 0;
    std::int64_t security_feeds_total = 0;
    std::int64_t security_complete_total = 0;
    std::int64_t security_partial_total = 0;
    std::int64_t magnifier_sub_bars_total = 0;
    std::int64_t magnifier_sample_ticks_total = 0;
 
    std::int32_t input_tf_seconds = 0;
    std::int32_t script_tf_seconds = 0;
    std::int32_t script_tf_ratio = 0;
    bool needs_aggregation = false;
    bool bar_magnifier_enabled = false;
 
    pf_metrics_t metrics{};
    std::vector<pf_equity_point_t> equity_curve;
    std::vector<pf_trade_t> trades;
    ReturnStatsFields return_bar;
    ReturnStatsFields return_monthly;
    ReturnBlockLayout return_block_layout;
    ReturnBlockMoments return_blocks;
 
    std::optional<double> metric(std::string_view path) const noexcept;
};
 
namespace detail {
 
class TrialResources final {
public:
    TrialResources(const StrategyPlugin& plugin, pf_strategy_t strategy)
        : plugin_(plugin), strategy_(strategy) {}
    ~TrialResources() {
        plugin_.free_report(&report);
        plugin_.free_strategy(strategy_);
    }
    TrialResources(const TrialResources&) = delete;
    TrialResources& operator=(const TrialResources&) = delete;
    pf_strategy_t strategy() const noexcept { return strategy_; }
    pf_report_t report{};
 
private:
    const StrategyPlugin& plugin_;
    pf_strategy_t strategy_;
};
 
void apply_trial_settings(const StrategyPlugin& plugin, pf_strategy_t strategy,
                          const ParameterValues& inputs, const ParameterValues& overrides,
                          const BacktestConfiguration& configuration);
ReportSnapshot copy_report(const pf_report_t& report, const BacktestConfiguration& configuration,
                           bool reduce_blocks);
 
}  // namespace detail
 
enum class TrialExecutionStatus : std::uint8_t {
    kSucceeded = 0,   
    kEngineError = 1,  
};
 
struct TrialExecutionResult {
    TrialExecutionStatus status = TrialExecutionStatus::kEngineError;
    std::string error;
    std::optional<std::string> error_code;
    std::optional<std::string> error_args;
    ReportSnapshot report;
 
    bool succeeded() const noexcept { return status == TrialExecutionStatus::kSucceeded; }
};
 
class TrialExecutor final {
public:
    TrialExecutor(std::shared_ptr<const StrategyPlugin> plugin,
                  DatasetView view,
                  BacktestConfiguration configuration = {});
 
    TrialExecutor(std::shared_ptr<const StrategyPlugin> plugin,
                  std::shared_ptr<const Dataset> dataset,
                  BacktestConfiguration configuration = {});
 
    TrialExecutionResult execute(const ParameterValues& inputs,
                                 const ParameterValues& strategy_overrides = {}) const;
 
    TrialExecutionResult execute_prefix(const ParameterValues& inputs,
                                        const ParameterValues& strategy_overrides,
                                        std::size_t bar_count) const;
 
    const BacktestConfiguration& configuration() const noexcept { return configuration_; }
    const Dataset& dataset() const noexcept { return *view_.owner; }
    const DatasetView& view() const noexcept { return view_; }
    const StrategyPlugin& plugin() const noexcept { return *plugin_; }
 
private:
    std::shared_ptr<const StrategyPlugin> plugin_;
    DatasetView view_;
    BacktestConfiguration configuration_;
};
 
}  // namespace hpo
}  // namespace pineforge