dmitry_env/ATP/robotrader/robotrader/RTPosition.h

/***************************************************************************
*    
*                       Copyright (c) 2007-2010  Argo SE, Inc. All rights reserved. 
*
* The following source code, and the ideas, expressions and concepts
* incorporated therein, as well as the ideas, expressions and concepts of
* any other material (whether tangible or intangible) disclosed in
* conjunction with this source code, are the exclusive and proprietary
* property, and constitutes confidential information, of Argo SE, Inc.
* Accordingly, the user of this source code
* agrees that it shall continue to be bound by the terms and conditions of
* any and all confidentiality agreements executed with Argo SE, Inc.
* concerning the disclosure of the source code and any other materials in 
* conjunction therewith. 
*
*/

#pragma once

#include "RTOrder.h"
#include "RTExchangeType.h"

namespace RT
{
enum PositionType
{
        enShort,
        enLong
};

static char* PositionTypeStr[] =
{
        "Short",
        "Long"
};


class RTPosition
{
public:

RTPosition():
symbol_("") 
,qty_(0) 
,type_(enShort) 
,average_price_(0)
,realized_pnl_(0)
,old_average_price (0) 
,old_qty (0) 
{
}
RTPosition(RTOrder *order):
symbol_(order->sec_id()) 
,qty_(order->original_qty())
,average_price_(0)
,realized_pnl_(0)
{
        if(order->side() == OS_Buy)
                type_ = enLong;
        else
                type_ = enShort;
}
RTPosition(const RTExecutionReport * report): 
symbol_("") 
,qty_(0) 
,type_(enShort) 
,average_price_(0)
,realized_pnl_(0)
{
        symbol_ =report->symbol ;
        qty_    = 0;
        type_   = enShort;
        
        update(report->side , 0, 0);
}
RTPosition(const std::string& symbol, int qty,int type):
symbol_(symbol) 
,type_(enShort) 
,average_price_(0)
,qty_(qty) 
,realized_pnl_(0)
{
        if(type > 1 || type < 0) 
                type_ =(PositionType) 0;
        else
                type_ =(PositionType) type;
}

void update (OrderSide side, int qty, double last_px)
{
        bool   old_long_or_short = (qty_ > 0) ? true : false;
    double realized_pnl_incremental = 0;
                
        old_qty = qty_;
        old_average_price = average_price_;

        if( side == OS_Buy)
                update(qty);
        else
                update(-qty);

        bool new_long_or_short = (qty_ > 0) ? true : false;

        if (qty_ == 0) // full_close
    {              
         realized_pnl_incremental = old_qty * (last_px - old_average_price); 
                 average_price_ = 0;
    }
        else
        if (old_long_or_short != new_long_or_short) //for example: we  where buy 100, but now we sell 110, the position sweep the side       
        {
                if( old_qty > 0)
                        realized_pnl_incremental = (qty - old_qty) * (last_px - old_average_price);
                average_price_ = last_px;
        }
        else if (       (old_long_or_short == true &&  side == OS_Buy) //for example: if we where buy, and now we buy too
             || (old_long_or_short == false && side == OS_Sell))
    {
                if( (side == OS_Buy &&  type_== enLong) ||
                        (side == OS_Sell && type_== enShort))
                {
                        average_price_ = (double)( average_price_*abs(old_qty)+ last_px*abs(qty) )/(double)abs(qty_);
                }
                else
                {
                        average_price_ = (double)( average_price_*abs(old_qty)- last_px*abs(qty) )/(double)abs(qty_);
                }
    }
    else if (old_long_or_short == new_long_or_short)//for example: if we where buy 100 , and now we sell 50
    {
                if (old_average_price!=0 &&last_px !=0 )
                {
                        if (side == OS_Buy)
                           realized_pnl_incremental = qty * (old_average_price - last_px);                
                        else
                           realized_pnl_incremental = qty * (last_px -old_average_price);    
                }
                else {
                        //std::cerr<< "Position update, error old_long_or_short == new_long_or_short\n";
                }
    }

        realized_pnl_ +=realized_pnl_incremental;
}
void update (int qty)
{
        qty_ += qty;
        
        if(qty_>0)
                type_= enLong;
        else
                type_= enShort;
}

void update (const RTExecutionReport * report, int denominator = 1)
{
        if(denominator ==0)
                denominator = 1;

        switch(report->ord_status)
        {
                case os_partially_filled :
                case os_filled :
                        update(report->side, report->last_shares,  (double)report->last_px / (double)denominator);
                break;
                default :
                                
                break;
        }
}
        ~RTPosition(){}

        const std::string& symbol() const{return symbol_;}      
        void symbol(const std::string& symbol){symbol_ = symbol;}

        const int& qty() const{return qty_;}
        double average_price(){ return average_price_;} 
        double realized_pnl(){return realized_pnl_;}
        

        const int type() {return (int)type_;}
        void to_xml(std::ostream& stream)
        {
                stream<<"<Position>";
                stream<<"<Symbol>"<<symbol_.c_str()<<"</Symbol>";
                stream<<"<PositionType>"<<PositionTypeStr[(int)type_]<<"</PositionType>";
                stream<<"<Quantity>"<<qty_<<"</Quantity>";
                stream<<"<Value></Value>";
                stream<<"<Profit_Loss></Profit_Loss>";
                stream<<"</Position>";
        }
        
private:
        void realized_pnl(const double realized_pnl) {realized_pnl_=realized_pnl;}
        void type (const int type) 
        {
                if(type > 1 || type < 0) 
                        type_ =(PositionType) 0;
                else
                        type_ =(PositionType) type;
        }

        void qty(const int qty){qty_ = qty;}

        std::string             symbol_;
        int                             qty_;
        double                  average_price_;
        PositionType    type_;
        double                  realized_pnl_;

        double old_average_price ;
        int old_qty;

};
typedef std::list<RTPosition> PositionList; 
}

---