TSAMetrics.h

/*  ===================================================================
*
*                 T R A D I N G   S Y S T E M   A P I ™
*    Copyright © 1999 - 2014 by Peter Ritter ( TradingSystemAPI.com )
*                A L L   R I G H T S   R E S E R V E D
*
*     Consult your license regarding permissions and restrictions.
*             You may obtain a copy of the License at:
*     http://www.TradingSystemAPI.com/licenses/LICENSE-TSAPI-3.0.html
*
*  ====================================================================
*/

#ifndef TSA_METRICS__INCLUDED
#define TSA_METRICS__INCLUDED

#include <string>
#include <map>

#include "TSATypeDef.h"
#include "TSAMemTable.h"
#include "TSAJSON.h"

namespace tsa {

    class metrics_source;
    class contract;
    class strategy;

    namespace os {
        class path;
    }

    /*
    ** ====================================================
    ** >>>          class metrics_source                <<<
    ** ====================================================
    */

    class dll_export metrics_source {
    public:
        virtual variant metric(const std::string& metric_name, trade_grouping gr = all_trades) const = 0;
        virtual variant get_metric(perf_metric_type, trade_grouping gr = all_trades) const = 0;
        virtual void daily_cash_flow(mem_table& mt) const = 0;
        virtual bool is_finalized(void) const = 0;

        virtual const date_time& metrics_source__begin_timestamp(void) const = 0;
        virtual const date_time& metrics_source__end_timestamp(void) const = 0;
        virtual bool is_contract(void) const = 0;
        virtual std::string metric_source_name(void) const = 0;
    };


    class metrics_source;
    class contract;
    class strategy;

    namespace os {
        class path;
    }

    /*
    ** ====================================================
    ** >>>          class metrics_container             <<<
    ** ====================================================
    */

    class metrics_container
    {
    protected:
        std::map<std::string, variant> m_map;
    public:
        metrics_container(void);
        metrics_container(metrics_container&& other);
        bool operator==(const metrics_container& other);
        void copy(const metrics_container& other);
        void operator=(const metrics_container& other);
        bool is_equal(const metrics_container& other)const;
        bool verify_equal(const metrics_container& other)const;
        bool has_metric(const std::string& metric_name)const;
        bool get_value(const std::string& metric_name, variant& _value)const;
        const variant& get(const std::string& metric_name)const;
        template<typename T> T get(const std::string& _metric_name)const {
            return get(_metric_name).get<T>();
        }
        auto_cast_variant get_auto_cast(const std::string& name)const { return auto_cast_variant(get(name)); }

        variant& operator[](const std::string& key);
        const variant& operator[](const std::string& key)const;
        void merge(const metrics_container& other);
        void update_values_from(const metrics_container& other);
        void update_value(const std::string& metric_name, const variant& value);
        void create_if_missing(const std::string& metric_name, const variant& value);
        void create_if_missing(const std::vector<std::string>& metric_name, const variant& value);
        bool check_has_all(const std::vector<std::string>& metric_name, const variant& value);
        void clear(void);
        size_t size(void)const;
        void print(std::ostream&)const;
    public:
        tsa::json to_json(void)const;
        void from_json(const json&);
        std::string to_string(void);
        void from_string(const std::string&);
    public:
        template <class Archive>
        void serialize(Archive & ar) {
            ar(m_map);
        }

        std::ostream& write(std::ostream&) const;
        std::istream& read(std::istream&);
    public:

        int64_t trade_count(void) const  { return get_auto_cast(metric::trade_count); }
        int64_t loser_count(void) const { return get_auto_cast(metric::loser_count); }
        int64_t winner_count(void) const { return get_auto_cast(metric::winner_count); }
        double  percent_profitable(void) const { return get_auto_cast(metric::percent_profitable); }
        double  avg_net_trade_pl(void) const { return get_auto_cast(metric::avg_net_trade_pl); }
        double  avg_gross_trade_pl(void) const { return get_auto_cast(metric::avg_gross_trade_pl); }
        double  avg_winner(void) const { return get_auto_cast(metric::avg_winner); }
        double  avg_loser(void) const { return get_auto_cast(metric::avg_loser); }
        double  max_loser(void) const { return get_auto_cast(metric::max_loser); }
        double  max_winner(void) const { return get_auto_cast(metric::max_winner); }
        int64_t max_consec_winners(void) const { return get_auto_cast(metric::max_consec_winners); }
        int64_t max_consec_losers(void) const { return get_auto_cast(metric::max_consec_losers); }
        double  sum_pos_excursion(void) const { return get_auto_cast(metric::sum_pos_excursion); }
        double  sum_neg_excursion(void) const { return get_auto_cast(metric::sum_neg_excursion); }
        double  max_pos_excursion(void) const { return get_auto_cast(metric::max_pos_excursion); }
        double  max_neg_excursion(void) const { return get_auto_cast(metric::max_neg_excursion); }
        double  avg_pos_excursion(void) const { return get_auto_cast(metric::avg_pos_excursion); }
        double  avg_neg_excursion(void) const { return get_auto_cast(metric::avg_neg_excursion); }
        double  stddev_trade_pl(void) const { return get_auto_cast(metric::stddev_trade_pl); }
        double  avg_winner_bar_count(void) const { return get_auto_cast(metric::avg_winner_bar_count); }
        int64_t total_winner_bar_count(void) const { return get_auto_cast(metric::total_winner_bar_count); }
        int64_t total_loser_bar_count(void) const { return get_auto_cast(metric::total_loser_bar_count); }
        double  avg_loser_bar_count(void) const { return get_auto_cast(metric::avg_loser_bar_count); }
        double  avg_trade_bar_count(void) const { return get_auto_cast(metric::avg_trade_bar_count); }
        int64_t num_bars_in_trade(void) const { return get_auto_cast(metric::num_bars_in_trade); }
        int64_t total_num_bars_processed(void) const { return get_auto_cast(metric::total_num_bars_processed); }
        double  percent_bars_in_trade(void) const { return get_auto_cast(metric::percent_bars_in_trade); }
        double  net_profit(void) const { return get_auto_cast(metric::net_profit); }
        double  gross_profit(void) const { return get_auto_cast(metric::gross_profit); }
        double  winners_net(void) const { return get_auto_cast(metric::winners_net); }
        double  losers_net(void) const { return get_auto_cast(metric::losers_net); }
        double  total_commission(void) const { return get_auto_cast(metric::total_commission); }
        double  total_slippage(void) const { return get_auto_cast(metric::total_slippage); }
        double  total_transaction_cost(void) const { return get_auto_cast(metric::total_transaction_cost); }
        double  profit_factor(void) const { return get_auto_cast(metric::profit_factor); }
        double  avg_gain_to_avg_loss_ratio(void) const { return get_auto_cast(metric::avg_gain_to_avg_loss_ratio); }
        double  max_closed_out_runup(void) const { return get_auto_cast(metric::max_closed_out_runup); }
        double  max_closed_out_rundown(void) const { return get_auto_cast(metric::max_closed_out_rundown); }
        int64_t max_trade_transaction_count(void) const { return get_auto_cast(metric::max_trade_transaction_count); }
        int64_t max_trade_position_size(void) const { return get_auto_cast(metric::max_trade_position_size); }
        double  avg_trade_transaction_count(void) const { return get_auto_cast(metric::avg_trade_transaction_count); }
        double  avg_trade_position_size(void) const { return get_auto_cast(metric::avg_trade_position_size); }
        double  avg_trade_commission(void) const { return get_auto_cast(metric::avg_trade_commission); }
        double  avg_trade_slippage(void) const { return get_auto_cast(metric::avg_trade_slippage); }
        double  avg_trade_cost(void) const { return get_auto_cast(metric::avg_trade_cost); }
        double  avg_slippage_per_unit(void) const { return get_auto_cast(metric::avg_slippage_per_unit); }
        double  avg_cost_per_unit(void) const { return get_auto_cast(metric::avg_cost_per_unit); }
        double  percent_units_without_slippage(void) const { return get_auto_cast(metric::percent_units_without_slippage); }
        double  avg_net_profit_per_unit(void) const { return get_auto_cast(metric::avg_net_profit_per_unit); }
        double  avg_gross_profit_per_unit(void) const { return get_auto_cast(metric::avg_gross_profit_per_unit); }
        //double last_trade_is_open(void) const { return get_auto_cast(metric::); }             


        //double in_drawdown(void) const { return get_auto_cast(metric::); }                        
        double  current_drawdown(void) const { return get_auto_cast(metric::current_drawdown); }
        int64_t num_drawdowns(void) const { return get_auto_cast(metric::num_drawdowns); }
        double  max_drawdown(void) const { return get_auto_cast(metric::max_drawdown); }
        int64_t max_drawdown_length(void) const { return get_auto_cast(metric::max_drawdown_length); }
        double  avg_drawdown_length(void) const { return get_auto_cast(metric::avg_drawdown_length); }
        double  avg_drawdown(void) const { return get_auto_cast(metric::avg_drawdown); }
        double  max_account_balance(void) const { return get_auto_cast(metric::max_account_balance); }
        double  min_account_balance(void) const { return get_auto_cast(metric::min_account_balance); }

        double  max_drawdown__eod(void) const { return get_auto_cast(metric::max_drawdown__eod); }
        int64_t max_drawdown_length__eod(void) const { return get_auto_cast(metric::max_drawdown_length__eod); }
        double  avg_drawdown_length__eod(void) const { return get_auto_cast(metric::avg_drawdown_length__eod); }
        double  avg_drawdown__eod(void) const { return get_auto_cast(metric::avg_drawdown__eod); }
        int64_t num_drawdowns__eod(void) const { return get_auto_cast(metric::num_drawdowns__eod); }

        int64_t num_transactions(void) const { return get_auto_cast(metric::num_transactions); }
        int64_t num_transactions_at_market(void) const { return get_auto_cast(metric::num_transactions_at_market); }
        int64_t num_transactions_on_stop(void) const { return get_auto_cast(metric::num_transactions_on_stop); }
        int64_t num_transactions_at_limit(void) const { return get_auto_cast(metric::num_transactions_at_limit); }
        double  avg_transaction_size(void) const { return get_auto_cast(metric::avg_transaction_size); }

        int64_t num_units_traded(void) const { return get_auto_cast(metric::num_units_traded); }
        int64_t num_units_traded_without_slippage(void) const { return get_auto_cast(metric::num_units_traded_without_slippage); }
        int64_t num_units_traded_at_market(void) const { return get_auto_cast(metric::num_units_traded_at_market); }
        int64_t num_units_traded_on_stop(void) const { return get_auto_cast(metric::num_units_traded_on_stop); }
        int64_t num_units_traded_at_limit(void) const { return get_auto_cast(metric::num_units_traded_at_limit); }
        int64_t num_units_traded_other(void) const { return get_auto_cast(metric::num_units_traded_other); }

        double  drawdown_multiplier(void) const { return get_auto_cast(metric::drawdown_multiplier); }
        double  sharpe_ratio(void) const { return get_auto_cast(metric::sharpe_ratio); }
        double  sortino_ratio(void) const { return get_auto_cast(metric::sortino_ratio); }
        int64_t basket_num_instruments(void) const { return get_auto_cast(metric::basket_num_instruments); }
        int64_t basket_num_strategies(void) const { return get_auto_cast(metric::basket_num_strategies); }
        int64_t basket_instrument_num_bars_processed(void) const { return get_auto_cast(metric::basket_instrument_num_bars_processed); }
        int64_t basket_strategy_num_bars_processed(void) const { return get_auto_cast(metric::basket_strategy_num_bars_processed); }
        double  annual_risk_free_rate_of_return(void) const { return get_auto_cast(metric::annual_risk_free_rate_of_return); }
        date_time begin_timestamp(void) const { return get_auto_cast(metric::begin_timestamp); }
        date_time end_timestamp(void) const { return get_auto_cast(metric::end_timestamp); }
        //duration  total_strategy_duration(void) const { return get_auto_cast(metric::total_strategy_duration); }
        //duration  total_instrument_duration(void) const { return get_auto_cast(metric::total_instrument_duration); }
        std::string source_name(void) const { return get_auto_cast(metric::source_name); }
        bool        source_is_instrument(void) const { return get_auto_cast(metric::source_is_instrument); }

    };


    /*
    ** ====================================================
    ** >>>          class equity_metrics                <<<
    ** ====================================================
    */
    struct basic_trade_info {
        date_time   timestamp;
        double      net_profit;
        double      cost;
        int64_t     bars;
        int64_t     units;
        bool        is_long;
        bool operator==(const basic_trade_info& other)const { return timestamp == other.timestamp; }
        bool operator<(const basic_trade_info& other) const { return timestamp < other.timestamp; }
        bool operator<=(const basic_trade_info& other) const { return timestamp <= other.timestamp; }
    public:
        template<class Archive>
        void save(Archive & ar) const {
            ar.saveBinary((const char*)(this), sizeof(basic_trade_info));
        }
        template<class Archive>
        void load(Archive & ar) {
            ar.loadBinary((char*)(this), sizeof(basic_trade_info));
        }
    };

    /*
    ** ====================================================
    ** >>>        class basic_trade_metrics             <<<
    ** ====================================================
    */

    // This class retains and aggregates 'basic' trade info
    // to recalculate difficult metrics after metrics merger
    class tiny_trade_metrics : public object {
        std::vector<basic_trade_info> m_trades;
        metrics_container m_metrics[3];
    public:
        tiny_trade_metrics(void);
        void populate_trades(const std::vector<basic_trade_info>&);
        void operator=(const tiny_trade_metrics&);
        bool operator==(const tiny_trade_metrics&);
        void merge(const tiny_trade_metrics&);
        const metrics_container& metrics(tsa::trade_grouping)const;
    protected:
        struct base_metrics {
            double  sum_net_profit = 0.0;
            double  sum_cost = 0.0;
            int64_t sum_bars = 0;
            int64_t num_trades = 0;
            int64_t sum_units = 0;
            int64_t winner_count = 0;
            int64_t loser_count = 0;
            int64_t sum_winner_bar_count = 0;
            int64_t sum_loser_bar_count = 0;
            int64_t max_consec_winners = 0;
            int64_t max_consec_losers = 0;
            double  max_closed_out_runnup = 0.0;
            double  max_closed_out_rundown = 0.0;
            std::vector<double> profits_arr;
        };
        void calculate_base_metrics(tsa::trade_grouping, base_metrics&);
        void calculate_metrics(tsa::trade_grouping);
    public:
        template <class Archive>
        void serialize(Archive & ar) {
            ar(m_metrics[tsa::all_trades]);
            ar(m_metrics[tsa::long_only]);
            ar(m_metrics[tsa::short_only]);
            ar(m_trades);
        }
    };

    /*
    ** ====================================================
    ** >>>          class daily_equity                  <<<
    ** ====================================================
    */
    class daily_equity_container
        : public metrics_container, public object
    {
        struct daily_record {
            tsa::date date;
            double value;
        };
    private:
        std::map<date, double> m_daily_cash_flows;
        void merge_daily_cash_flows(const std::map<date, double>&);
        void calculate_equity_metrics(void);
    public:
        daily_equity_container(void);
        void operator=(const daily_equity_container&);
        bool operator==(const daily_equity_container&);
        void merge(const daily_equity_container&);
        size_t num_cash_flows(void)const;
    public:
        void set_daily_cash_flow_series(mem_table& _daily_cash_flow_series);
    public:
        double calculate_cumulative_cash_flow(void) const;
        double average_daily_cash_flow(const std::vector<double>& daily_cash_flows)const;
        double get_max_drawdown(void)const;
        void create_cumulative_equity_series(mem_table& _mt);
        std::vector<daily_record> daily_equity_history(void) const;
        std::vector<daily_record> daily_cash_flow_history(void) const;
        std::vector<double> _daily_cash_flow_history(void) const;
        std::vector<double> _daily_equity_history(void) const;
    public:
        void print_daily_cash_flow(std::ostream& stream, bool with_date)const;
        void print_daily_equity(std::ostream& stream, bool with_date)const;
        void print_equity_graph(std::ostream&) const;
    public:
        template <class Archive>
        void serialize(Archive & ar) {
            ar(m_map);
            ar(m_daily_cash_flows);
        }
    };

    /*
    ** ====================================================
    ** >>>              class metrics                   <<<
    ** ====================================================
    */

    class dll_export metrics : public tsa::object {
        tsa_declare_testable
    public:
        static unsigned int STREAM_DELIMITER;
    private:
        bool m_is_instrument;
        std::string m_source_name;
        size_t m_num_instruments;
        size_t m_num_strategies;
        struct sub_metrics {
            uint64_t trade_count = 0;
            uint64_t loser_count = 0;
            uint64_t winner_count = 0;
            double percent_profitable = 0.0;
            double avg_net_trade_PL = 0.0;
            double avg_gross_trade_PL = 0.0;
            double avg_winner = 0.0;
            double avg_loser = 0.0;
            double max_loser = 0.0;
            double max_winner = 0.0;
            double stdev_trade_PL = 0.0;
            double avg_trade_bar_count = 0.0;
            uint64_t num_bars_in_trade = 0;
            double percent_bars_in_trade = 0.0;
            double net_profit = 0.0;
            double gross_profit = 0.0;
            double winners_net = 0.0;
            double losers_net = 0.0;
            double total_commission = 0.0;
            double total_slippage = 0.0;
            double total_transaction_cost = 0.0;
            double profit_factor = 0.0;
            double avg_gain_to_avg_loss_ratio = 0.0;
            uint64_t max_trade_transaction_count = 0;
            double max_trade_position_size = 0.0;
            double avg_trade_transaction_count = 0.0;
            double avg_trade_position_size = 0.0;
            double avg_trade_cost = 0.0;
            double avg_trade_commission = 0.0;
            double avg_trade_slippage = 0.0;
            double avg_slippage_per_unit = 0.0;
            double avg_cost_per_unit = 0.0;
            double percent_units_without_slippage = 0.0;
            double avg_net_profit_per_unit = 0.0;
            double avg_gross_profit_per_unit = 0.0;
            double m_dNumUnitsTraded = 0.0;
            double m_dNumUnitsTradedWithoutSlippage = 0.0;
            double m_dNumUnitsTraded_AtMarket = 0.0;
            double m_dNumUnitsTraded_OnStop = 0.0;
            double m_dNumUnitsTraded_AtLimit = 0.0;
        public:
            sub_metrics(void);
            void init(void);
            void copy(const sub_metrics&);
            bool is_equal(const sub_metrics&);
        public:
            void write(out_storage_stream&) const;
            void read(in_storage_stream&);
        };
        sub_metrics m_metrics_all;
        sub_metrics m_metrics_long;
        sub_metrics m_metrics_short;
        static void aggregate_sub_metrics(sub_metrics& aggregate,
            const sub_metrics&, const sub_metrics&, size_t total_basket_num_bars_processed);
    private:
        int64_t total_num_bars_processed = 0;
        int64_t max_drawdown_length = 0;
        double avg_drawdown_lengths = 0.0;
        double avg_drawdown = 0.0;
        double max_drawdown = 0.0;
        int64_t num_drawdowns = 0;
        int64_t m_nNumTransactions = 0;
        int64_t m_nNumTransactions_AtMarket = 0;
        int64_t m_nNumTransactions_OnStop = 0;
        int64_t m_nNumTransactions_AtLimit = 0;
        duration m_total_duration = 0;
        date_time m_begin;
        date_time m_end;

        //not part of aggregation routines
        double m_sharpe_ratio = 0.0;
        double m_sortino_ratio = 0.0;
        double m_start_capital = 0.0;
        double m_drawdown_multiplier = 2.0;
        double m_annual_risk_free_rate_of_return = 0.0;
    public:
        std::map<date, double> m_daily_cash_flows;
    public:
        struct daily_record {
            tsa::date date;
            double value;
        };
        std::vector<daily_record> daily_equity_history(void) const;
        std::vector<daily_record> daily_cash_flow_history(void) const;
        std::vector<double> _daily_cash_flow_history(void) const;
        double average_daily_cash_flow(const std::vector<double>& daily_cash_flows)const;
        std::vector<double> _daily_equity_history() const;

        double daily_risk_free_return(void)const;

        double average_trading_days_per_year(void)const;
        void calculate_equity_metrics(void);
        void calculate_equity_ratios(void);
        void print_daily_cash_flow(std::ostream&, bool with_date = false)const;
        void print_daily_equity(std::ostream&, bool with_date = false)const;
    protected:
        void set_sub_metrics(const metrics_source& _s, sub_metrics& _m, trade_grouping _t);
        void merge_daily_cash_flows(const std::map<date, double>&);
        static void aggregate_metrics(metrics& combo, const metrics& a, const metrics& b);
        void calculate_drawdown_metrics(void);
        void create_cumulative_equity_series(mem_table&);
        double calculate_cumulative_cash_flow(void) const;
    protected:
        static void test__check_performance_aggregation(const metrics&, const metrics&, const metrics&);
    public:

        metrics(void);
    private:
        metrics(const metrics_source&);
        metrics(const strategy&);
        void init(void);
    public:
        metrics(const metrics&);
    public:
        ~metrics(void);
        void copy(const metrics&);
        bool is_equal(const metrics&);
        void source_name(const std::string& _n);
        void source_is_instrument(bool _b);
        std::string source_name(void) const;
        bool source_is_instrument(void) const;
        void annual_risk_free_rate_of_return(double annual_rf_ror);
        double annual_risk_free_rate_of_return(void)const;
        void drawdown_multiplier(double multipler);
        double drawdown_multiplier(void)const;
    public:
        void write(out_storage_stream&) const;
        void read(in_storage_stream&);
    private:
    public:
        // Aggregates @b self metrics object with @b other.
        void merge(const metrics& other);
        // Aggregates metrics of @b other strategy to @b self metrics instance.
        void merge(const strategy& other);
        void init_from_metrics_source(const metrics_source&);
        void set_strategy_count(size_t);
        void set_instrument_count(size_t);
        //void evaluate_equity_metrics(void);
    protected:
        void add_as_first(const metrics_source&);
    protected:
        void print_equity_graph(std::ostream&) const;
    public:
        virtual void daily_cash_flow(mem_table& mt) const;
    public:
        virtual const date_time& GetStartDateTime(void) const;
        date_time GetEndDateTime(void) const;
    public:
        /*IU*/
        size_t num_strategies(void) const;
        size_t num_instruments(void) const;
        variant _get_metric(const sub_metrics&, perf_metric_type, trade_grouping) const;
        variant _get_metric(const sub_metrics&, const std::string&, trade_grouping) const;
    public:
        variant get_metric(perf_metric_type metric_type, trade_grouping group = all_trades) const;

        variant get_metric(const std::string& metric_type, trade_grouping group = all_trades) const;

        template<typename T>
        T get(perf_metric_type metric_type, trade_grouping trade_aggr_type = all_trades) const {
            return get_metric(metric_type, trade_aggr_type).get<T>();
        }
    private:
        size_t GetTradeCount(trade_grouping direction = all_trades) const;
        size_t GetLoserCount(trade_grouping direction = all_trades) const;
        size_t GetWinnerCount(trade_grouping direction = all_trades) const;
        double GetPercentProfitable(trade_grouping direction = all_trades) const;
        double GetAveNetTradePL(trade_grouping direction = all_trades) const;
        double GetAveGrossTradePL(trade_grouping direction = all_trades) const;
        double GetAveWinner(trade_grouping direction = all_trades) const;
        double GetAveLoser(trade_grouping direction = all_trades) const;
        double GetMaxLoser(trade_grouping direction = all_trades) const;
        double GetMaxWinner(trade_grouping direction = all_trades) const;
        double GetStDevTradePL(trade_grouping direction = all_trades) const;
        //Bar Count
        double GetAveTradeBarCount(trade_grouping direction = all_trades) const;
        size_t GetNumBarsInTrade(trade_grouping direction = all_trades) const;
        size_t GetNumBarsProcessed() const;
        double GetPercentBarsInTrade(trade_grouping direction = all_trades) const;
        // PL
        double GetNetProfit(trade_grouping direction = all_trades) const;
        double GetGrossProfit(trade_grouping direction = all_trades) const;
        double GetWinnersNet(trade_grouping direction = all_trades) const;
        double GetLosersNet(trade_grouping direction = all_trades) const;
        double GetTotalCommission(trade_grouping direction = all_trades) const;
        double GetTotalSlippage(trade_grouping direction = all_trades) const;
        double GetTotalTransactionCosts(trade_grouping direction = all_trades) const;
        double GetProfitFactor(trade_grouping direction = all_trades) const;
        double GetAveGainToAveLossRatio(trade_grouping direction = all_trades) const;
        //Position Metrics
        size_t GetMaxTransactionCount(trade_grouping direction = all_trades) const;
        double GetMaxPositionSize(trade_grouping direction = all_trades) const;
        double GetAveTransactionCount(trade_grouping direction = all_trades) const;
        double GetAvePositionSize(trade_grouping direction = all_trades) const;
        double GetAveCostsPerTrade(trade_grouping direction = all_trades) const;
        double GetAveCommissionPerTrade(trade_grouping direction = all_trades) const;
        double GetAveSlippagePerTrade(trade_grouping direction = all_trades) const;
        double GetAveSlippagePerUnit(trade_grouping direction = all_trades) const;
        double GetAveCostsPerUnit(trade_grouping direction = all_trades) const;
        double GetPercentUnitsWithoutSlippage(trade_grouping direction = all_trades) const;
        double GetAveNetProfitPerUnit(trade_grouping direction = all_trades) const;
        double GetAveGrossProfitPerUnit(trade_grouping direction = all_trades) const;
        size_t GetMaxDrawdownLength(void) const;
        double GetAveDrawdownLength(void) const;
        double GetAveDrawdown(void) const;
        double GetMaxDrawdown(void) const;
        size_t GetNumDrawdowns(void) const;
        size_t GetNumTransactions(void) const;
        size_t GetNumTransactions_AtMarket(void) const;
        size_t GetNumTransactions_OnStop(void) const;
        size_t GetNumTransactions_AtLimit(void) const;
        double GetNumUnitsTraded(trade_grouping direction = all_trades) const;
        double GetNumUnitsTradedWithoutSlippage(trade_grouping direction = all_trades) const;
        double GetNumUnitsTraded_AtMarket(trade_grouping direction = all_trades) const;
        double GetNumUnitsTraded_OnStop(trade_grouping direction = all_trades) const;
        double GetNumUnitsTraded_AtLimit(trade_grouping direction = all_trades) const;
        double GetSimulationPeriodInYears(void) const;
        double GetSimulationPeriodInDays(void) const;
        double total_instrument_period_in_years(void) const;
        double total_instrument_period_in_days(void) const;
    public:
        void save_report_html(const os::path& file_name) const;
        //void save_report_html_2(const os::path& file_name) const;
    };







}//tsa

#endif
#pragma once