trial_executor.hpp

Go to the documentation of this file.

#pragma once
 
#include <pineforge/pineforge.h>
 
#include <cstdint>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
#include <pineforge/hpo/dataset.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;
};
 
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::optional<double> metric(std::string_view path) const noexcept;
};
 
enum class TrialExecutionStatus : std::uint8_t {
    kSucceeded = 0,   
    kEngineError = 1,  
};
 
struct TrialExecutionResult {
    TrialExecutionStatus status = TrialExecutionStatus::kEngineError;
    std::string error;
    ReportSnapshot report;
 
    bool succeeded() const noexcept { return status == TrialExecutionStatus::kSucceeded; }
};
 
class TrialExecutor final {
public:
    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;
 
    const BacktestConfiguration& configuration() const noexcept { return configuration_; }
    const Dataset& dataset() const noexcept { return *dataset_; }
    const StrategyPlugin& plugin() const noexcept { return *plugin_; }
 
private:
    std::shared_ptr<const StrategyPlugin> plugin_;
    std::shared_ptr<const Dataset> dataset_;
    BacktestConfiguration configuration_;
};
 
}  // namespace hpo
}  // namespace pineforge