TSAPosition.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_POSITION__INCLUDED
#define TSA_POSITION__INCLUDED

#include <map>
#include <list>
#include <vector>
#include <ostream>

#include "TSATypeDef.h"
#include "TSATime.h"
#include "TSAOrder.h"
#include "TSAMemTable.h"
#include "TSASimBaseSeries.h"
#include "TSAString.h"
#include "TSAMetrics.h"
#include "TSAMetrics2.h"

namespace tsa {

    /*
    ** ====================================================
    ** > > >         class position_manager           < < <
    ** ====================================================
    */
    // Internal
    class dll_export position_manager : public object {
        tsa_declare_testable;
    private:
        position_t m_curr_position;
        position_t m_prev_position;
    public:
        position_manager(void);
        virtual ~position_manager(void);
        position_t position(void) const;
        position_t inverse_position(void) const;
        quantity_t position_size(void) const;
        position_t previous_position(void) const;
        POSITION::state position_state() const;
        bool position_is_long(void) const;
        bool position_is_short(void) const;
        bool position_is_flat(void) const;
        bool position_direction_has_changed(void) const;
        void notify_long_transaction(quantity_t units);
        void notify_short_transaction(quantity_t units);
        POSITION::state long_trade_new_dir_state(quantity_t size) const;
        POSITION::state short_trade_new_dir_state(quantity_t size) const;
    };

    /*
    ** ====================================================
    ** > > >           class trade_leg                < < <
    ** ====================================================
    */

    struct dll_export trade_leg {
    public:
        quantity_t          quantity; 
        double              price; 
        order::action       action; 
        tsa::date_time      timestamp; 
        order::type         order_type; 
        bool                had_slippage; 
    public:
        trade_leg(void) :
            quantity(0), price(0.0), action(order::oa_undefined) {}
    };

    /*
    ** ====================================================
    ** > > >           class trade_manager            < < <
    ** ====================================================
    */
    // Internal
    class dll_export trade_manager : public position_manager {
        tsa_declare_testable;
    private:
        date_time m_prev_trade_value_timestamp;
        date_time m_latest_trade_value_timestamp;
        quantity_t m_max_num_units_in_position = 0;
        size_t m_bar_count = 0;
        double m_latest_trade_value = 0.0;
        double m_min_trade_value = 0.0;
        double m_max_trade_value = 0.0;
        double m_prev_trade_value = 0.0;
        double m_big_point_value = 1.0;
        double m_trade_entry_leg_price = 0.0;
        double m_furthest_price = 0;
        double m_last_interval_price = 0.0;
        std::vector<trade_leg> m_trade_legs;
    public:
        double m_closed_out_PL = 0.0;
        double m_avg_entry_price = 0.0;
        position_t m_open_position_size = 0;
        POSITION::state m_open_position_dir = POSITION::is_flat;
        size_t m_leg_count__no_slippage = 0;
    public:
        quantity_t m_stats__total_num_units = 0;
        quantity_t m_stats__num_units__no_slippage = 0;
        quantity_t m_stats__num_units__at_market = 0;
        quantity_t m_stats__num_units__on_stop = 0;
        quantity_t m_stats__num_units__at_limit = 0;
        quantity_t m_stats__num_units__other = 0;
    private:
        void clear_leg_array(void);
    public:
        const std::vector<trade_leg>& current_trade_legs(void)const;
    public:
        trade_manager(void);
        virtual ~trade_manager(void);
        void set_big_point_value__base_ccy(double big_point_value);
        double get_big_point_value__base_ccy(void) const;
        void set_latest_instrument_price(double);
    public:
        double best_price_since_trade_entry(void) const;
        double initial_trade_leg_price(void) const;
        double current_trade_value(void) const;
        double max_trade_value(void) const;
        double min_trade_value(void) const;
        size_t bar_count_since_trade_entry(void) const;
        double most_recent_change_in_position_value(void);
        const date_time& most_recent_bar_timestamp(void) const;
        const date_time& initial_trade_leg_timestamp(void) const;
        size_t position_leg_count(void) const;
    public:
        void notify__long_transaction(quantity_t units, double price,
            const date_time&, bool incurred_slippage, order::type);
        void notify__short_transaction(quantity_t units, double price,
            const date_time&, bool incurred_slippage, order::type);
        void increment_bar_count(void);
        void add_trade_leg(order::action dir, quantity_t units, double price,
            const date_time&, bool incurred_slippage, order::type type);
    public:
        double position_value__fast(double mkt_price)const;//new
        double most_recent_bar_price(void) const;
        bool try_long_transaction_will_change_position_state(quantity_t);
        bool try_short_transaction_will_change_position_state(quantity_t);
        void update_position_value_and_increment_bar(double price, const date_time& timestamp);
        quantity_t max_position_size(void) const;
        void reset_position(void);
        quantity_t units_required_to_close_out_trade(void);
    public:
        size_t leg_count__no_slippage(void)const;
        void trade_metrics(quantity_t& total_quantity,
            quantity_t& units__no_slippage, quantity_t& units_at_market,
            quantity_t& units_on_stop, quantity_t& units_at_limit, quantity_t& units_other);
    public:
        static double calculate_rounded_quantity_from_cash_amount(double unit_price, double cash_amount);
    public:
        void print_position_info(std::ostream&) const;
    public:
        position_t test__calculate_net_position_from_legs(void) const;
    private:
        void test__calculate_trade_metrics(double& total_quantity,
            double& units__no_slippage, double& units_at_market,
            double& units_on_stop, double& units_at_limit, double& units_other) const;
        size_t test__calc_position_leg_count__no_slippage(void) const;
        quantity_t test__calculate_total_num_units_from_legs(void) const;
        bool test__check_all_trade_legs_have_same_direction(void) const;
        void test__notify_long_transaction(quantity_t units, double price);
        void test__notify_short_transaction(quantity_t units, double price);
        double test__calc_position_value_base_ccy(double price) const;
        double test__calc_position_val_and_incr_interval__base_ccy_TEST(double price);
        void test__calculate_position_value(double mkt_price, double& pos_val) const;
    };

    struct trade_info {
        size_t trade_ID; 
        POSITION::state direction;
        date_time entry_timestamp;
        date_time close_timestamp;
        double net_profit;
        double gross_profit;
        size_t num_bars;
        double slippage;
        double commission;
        position_t max_position;
        size_t num_transactions;
        size_t num_transactions__no_slippage;
        double positive_excursion;
        double negative_excursion;
        quantity_t units_traded;
        quantity_t units_traded__no_slippage;
        quantity_t units_traded__at_market;
        quantity_t units_traded__on_stop;
        quantity_t units_traded__at_limit;
        quantity_t units_traded__other_trade_type;
        bool is_open;
    };

    /*
    ** ====================================================
    ** >>>           class trade_metrics                <<<
    ** ====================================================
    */

    // Internal
    // Keeps list of all trades, and once the strategy has ended
    // runns a series of analytics to determine trade metrics.
    
    class dll_export trade_metrics : public object {
    private:
        struct trade_stats : public metrics_container {
            int64_t trade_count = 0;
            int64_t loser_count = 0;
            int64_t winner_count = 0;
            double  percent_profitable = 0;
            double  avg_net_trade_pl = 0;
            double  avg_gross_trade_pl = 0;
            double  avg_winner = 0;
            double  avg_loser = 0;
            double  avg_trade_bar_count = 0;
            int64_t num_bars_in_trade = 0;
            double  percent_bars_in_trade = 0;
            int64_t total_winner_bar_count = 0;
            int64_t total_loser_bar_count = 0;
            double  winners_net = 0;
            double  losers_net = 0;
            double  max_loser = 0;
            double  max_winner = 0;
            double  net_profit = 0;
            double  gross_profit = 0;
            double  max_closed_out_runup = 0;
            double  max_closed_out_rundown = 0;
            double  total_slippage = 0;
            double  total_commission = 0;
            double  total_transaction_cost = 0;
            double  avg_winner_bar_count = 0;
            double  avg_loser_bar_count = 0;
            double  stddev_trade_pl = 0;
            int64_t max_consec_winners = 0;
            int64_t max_consec_losers = 0;
            int64_t max_trade_transaction_count = 0;
            int64_t max_trade_position_size = 0;
            double  avg_trade_transaction_count = 0;
            double  avg_trade_position_size = 0;
            double  avg_transaction_size = 0;
            double  max_pos_excursion = 0;
            double  max_neg_excursion = 0;
            double  avg_pos_excursion = 0;
            double  avg_neg_excursion = 0;
            int64_t num_units_traded = 0;
            int64_t num_units_traded_without_slippage = 0;
            int64_t num_units_traded_at_market = 0;
            int64_t num_units_traded_on_stop = 0;
            int64_t num_units_traded_at_limit = 0;
            int64_t num_units_traded_other = 0;
            double  avg_trade_commission = 0;
            double  avg_trade_slippage = 0;
            double  avg_trade_cost = 0;
            double  avg_slippage_per_unit = 0;
            double  avg_cost_per_unit = 0;
            double  percent_units_without_slippage = 0;
            double  avg_net_profit_per_unit = 0;
            double  avg_gross_profit_per_unit = 0;
            double  avg_gain_to_avg_loss_ratio = 0;
            double  profit_factor = 0;
            bool    last_trade_is_open = 0;
        };
        trade_stats trade_stats__all;
        trade_stats trade_stats__long;
        trade_stats trade_stats__short;
        trade_stats* m_stats[3];
        size_t m_num_bars__strategy;
    protected:
        std::vector<basic_trade_info> m_basic_trade_info_arr;
        std::vector<trade_info> m_trades;
        bool m_trade_log_disabled;
        bool m_is_finalized;
        void populate_basic_trade_info(void);
        void finalize_group(trade_grouping);
        void DEBUG_POST_FINALIZE_CHECKS(void) const;
    public:
        bool last_trade_is_open(trade_grouping gr = all_trades) const;
        const std::vector<trade_info>& get_trade_vector(void)const { return m_trades; }
        const std::vector<basic_trade_info>& get_basic_trade_vector(void)const { return m_basic_trade_info_arr; }
    public:
        trade_metrics(void);
        virtual ~trade_metrics(void);
        void notify_trade(const trade_info&);
        void disable_internal_log(bool _b);
        bool internal_log_disabled(void) const;
        // Notify a new bar in the strategy
        void notify_bar(void);
        void finalize(void);
    public:
        const trade_info& operator[](size_t) const;
        size_t trade_count(void) const;
        size_t num_bars_processed(void)const { return m_num_bars__strategy; }
    public:
        template<typename T>
        T metric(perf_metric_type _metric_type, trade_grouping t = all_trades) const {
            return get_metric(_metric_type, _aggr).get<T>();
        }

        variant get_metric(perf_metric_type _metric_type, trade_grouping gr = all_trades) const;
        variant get_metric(const std::string& metric_name, trade_grouping gr = all_trades) const;

        const trade_stats& get_trade_stats(trade_grouping);
    public:
        void Print(std::ostream& Stream) const;
    };

    /*
    ** ====================================================
    ** > > >         class equity_state               < < <
    ** ====================================================
    */

    // Internal
    class dll_export equity_state {
        tsa_declare_testable;
    private:
        double m_max_equity;
        double m_current_equity;
        double m_prev_equity;
        bool   m_in_drawdown;
        double m_current_drawdown;
        double m_current_drawdown_watermark;
        size_t m_current_drawdown_length;
        size_t m_drawdown_count;
        size_t m_prev_drawdown_count;
        double m_avg_drawdown;
        double m_max_drawdown;
        double m_avg_drawdown_length;
        size_t m_max_drawdown_length;
    private:
        void notify_drawdown_completed(double ddn_value, size_t length);
    public:
        equity_state(void);
        virtual ~equity_state(void);
    public: 
        void notify_new_cash_flow(double);
        void notify_bar_completed(void);
    public:
        double current_drawdown_watermark(void) const;
        double current_drawdown(void) const;
        size_t max_completed_drawdown_length_in_bars(void) const;
        double avg_completed_drawdown_length_in_bars(void) const;
        double avg_completed_drawdown(void) const;
        double max_completed_drawdown(void) const;
        size_t num_completed_drawdowns(void) const;
        bool in_drawdown(void) const;
    };

    /*
    ** ====================================================
    ** > > >         class equity_metrics             < < <
    ** ====================================================
    */

    // Internal
    class dll_export equity_metrics : public object , public metrics_container{
        tsa_declare_testable;
    private:
        equity_state m_equity_state;
        double  m_cumulative_equity;
        double  m_strategy_equity_high;
        double  m_strategy_equity_low;
        bool    m_is_finalized;
        bool    m_lasts_drawdown_is_open;
        double  m_current_drawdown;
    public:
        equity_metrics(void);
        virtual ~equity_metrics(void);
        void notify_cash_flow(double cash_flow);
        void notify_bar_completed(void);
        void finalize(void);
        bool is_finalized(void) const;
    public:
        double cummulative_equity(void) const;
        double max_account_balance(double account_start_balance) const;
        double min_account_balance(double account_start_balance) const;
        double current_drawdown(void) const;
        size_t max_drawdown_length_in_bars(void) const;
        double avg_drawdown_length_in_bars(void) const;
        double avg_drawdown(void) const;
        double max_drawdown(void) const;
        size_t num_drawdowns(void) const;
        bool in_drawdown(void) const;
    };

    /*
    ** ====================================================
    ** > > >           testing support                < < <
    ** ====================================================
    */
    // Internal
    class dll_export test__trade_state {
        size_t m_nTotalNumberTrades;
        size_t m_nTotalNumberLosers;
        size_t m_nTotalNumberWinners;
        double m_dPercentWinners;
        double m_dAveTradeSize;
        double m_dAveWinnerSize;
        double m_dAveLoserSize;
        double m_dAveBarsInTrade;
        size_t m_nNumBarsInATrade;
        double m_dNetWinners;
        double m_dNetLosers;
        double m_dCumTradeVal;
        double m_dMaxLoser;
        double m_dMaxWinner;
        double m_dCumulativePL;
    private:
        void UpdateTotalNumberTrades(void);
        void UpdateTotalNumberLosers(double dTradeVal);
        void UpdateTotalNumberWinners(double dTradeVal);
        void UpdatePercentWinners(void);
        void UpdateCumWinnersVal(double dTradeVal);
        void UpdateCumLosersVal(double dTradeVal);
        void UpdateCumTradeVal(double dTradeVal);
        void UpdateAveTradeSize(void);
        void UpdateAveWinnerSize(void);
        void UpdateAveLoserSize(void);
        void UpdateLargestLoser(double dTradeVal);
        void UpdateLargestWinner(double dTradeVal);
        void UpdateAveTradeBars(size_t nLen);
        void UpdateCumulativePL(double dTradeVal);
    public:
        test__trade_state(void);
        virtual ~test__trade_state(void);
        void CopyState(test__trade_state* pTradeStats);
        void notify_new_trade(double dTradeVal, size_t nLen);
    public:
        size_t GetTradeCount(void) const;
        size_t GetLoserCount(void) const;
        size_t GetWinnerCount(void) const;
        double GetPercentProfitable(void) const;
        double GetAveTrade(void) const;
        double GetAveWinner(void) const;
        double GetAveLoser(void) const;
        double GetMaxLoser(void) const;
        double GetMaxWinner(void) const;
        double GetAveTradeBarCount(void) const;
        double GetStrategyIncome(void) const;
    };

    //Internal
    class dll_export test__trade_stats : public object {
        tsa_declare_testable;
    private:
        test__trade_state m_CurrState;
        test__trade_state m_SavedState;
        bool m_bStateIsVirtual;
    public:
        test__trade_stats(void);
        virtual ~test__trade_stats(void);
        void NotifyVirtualTrade(double _dTradePnL, size_t nLen);
        void NotifyTrade(double _dTradePnL, size_t nLen);
        bool TradeStateIsVirtual(void) const;
        void BeginVirtualTrade(void);
        void RollbackVirtualTrade(void);
    public:
        size_t GetTradeCount(void) const;
        size_t GetLoserCount(void) const;
        size_t GetWinnerCount(void) const;
        double GetPercentProfitable(void) const;
        double GetAveTrade(void) const;
        double GetAveWinner(void) const;
        double GetAveLoser(void) const;
        double GetMaxLoser(void) const;
        double GetMaxWinner(void) const;
        double GetAveTradeBarCount(void) const;
        double GetStrategyIncome(void) const;
    };
} //tsa

#endif