Indicator.cpp

Go to the documentation of this file.

#include "Indicator.h"
#include "Utils.h"

//only for gcc and ACLiC
// still needed, complains from libstock.so not known
// #ifndef __CINT__
Indicator const
Indicator::Null (Indicator::null_l),
Indicator::StockCSV (Indicator::csv_l),
Indicator::StockInst (Indicator::inst_l),
Indicator::Volume (Indicator::volume_l),
Indicator::SMA (Indicator::sma_l),
Indicator::EMA (Indicator::ema_l),
Indicator::WMA (Indicator::wma_l),
Indicator::MACD (Indicator::macd_l),
Indicator::BOLL (Indicator::boll_l),
Indicator::RSI (Indicator::rsi_l),
Indicator::AD (Indicator::ad_l), //accumulation/disribution use volume
Indicator::STOCHF (Indicator::stochf_l); //2 versions stock and stockf
// #endif


namespace 
{
 //std::string indicator_labels_[] = {"Null","StockCSV", "SimpleData", "Volume","SMA","EMA","WMA","MACD"};
 std::string indicator_labels_[] = {"Null","StockCSV", "StockInst", "Volume", "SMA","EMA","WMA", "MACD",    "BOLL","RSI", "AD","STOCHF"};
 //number of parameters for computing the TA
 int indicator_nb_param_[]       = {    0,        0,             0,       0,     1,    1,    1,      3,          3,    1,    0,       2};
// number of input
 int indicator_nb_input_[]       = {    0,        1,             1,       1,     1,    1,    1,      1,          1,    1,    4,       3};
 //number of output, used both b TAlib and ListData
 int indicator_nb_output_[]      = {    0 ,        4 ,          1 ,       1,     1,    1 ,   1,      3,          3,    1,    1,       2};
 bool bool_default_[]            = { false,     false,       false,   false, false,false,false,   true,       true, true,false,    true};
 //                                                                                                                  fast/low
 int default_value_[][3]         = {    {},        {},          {},      {},    {},   {},   {},{12,26,9},   {5,2,2},{14},{},    {5,3}};
                                                                                                 //BOLL expect double for 2
 // desription Candle,Line,Bar,Kollection, and color (Blue,Red,Violet)
 char descp_[][12]                = {   "",       "LC0",      "LC0",  "LBR", "P0B","P0B","P0B","KP0RP0BLBR","KP0VP0BP0V",  "P",  "P",    "PP"};
 //shift [0,..,nblabel) taken into account in function
 unsigned int nb_label=12;
}


const std::string Indicator::label () const
{
  return indicator_labels_[v_];
}

//compile finally, take example of GetIndicator
std::vector<std::string> Indicator::GetListAllIndicator()
{
 std::vector<std::string> tmp_vec;
 for(unsigned int i=1; i<nb_label; i++)
    {
     //std::cout << "Alllabel " << indicator_labels_[i] << std::endl;
     tmp_vec.push_back( indicator_labels_[i] );
    }
 return tmp_vec;
}
 
int Indicator::nb_param () const
{
 return indicator_nb_param_[v_];
}

int Indicator::nb_input () const
{
 return indicator_nb_input_[v_];
}

int Indicator::nb_output () const
{
 return indicator_nb_output_[v_];
}

bool Indicator::HasDefaultValues() const
{
  return bool_default_[v_];
}

std::vector<int> Indicator::GetDefaultValues() const
{
#ifdef DEBUG_UTIL
  std::cout << "nb_output in GetDefaultValues " << nb_output() << std::endl;
#endif

  std::vector<int> vec_return;
  vec_return.resize( nb_output() );
  for ( int i=0; i< nb_output(); i++ ) {
      vec_return[i] = default_value_[v_][i];
  }
  return vec_return;
}

std::string Indicator::GetDescription() const
{
#ifdef DEBUG_UTIL
  std::cout << "Entry Indicator::GetDescription " << Utils::toString<std::string>(descp_[v_]) << std::endl;
#endif
  //return Utils::toString<std::string>(descp_[v_]);
  return Utils::toString<char*>(descp_[v_]);
}

// new version, really use vector of string, each string LC0, P0R, "K"
std::vector<std::string> Indicator::parse_description() const
{
#ifdef DEBUG_UTIL
    std::cout << "\nEntry Indicator::parse_description\n" << std::endl;
#endif
    // in fact vector of character, stupid it is a string !
    std::vector<std::string> desc_string;
    std::string charact, charact2, charact3;

    std::string full_descp_str;
    std::string sub_string;
    full_descp_str = GetDescription();
#ifdef DEBUG_UTIL
    std::cout << "full descp " << full_descp_str << std::endl;
#endif
    for ( unsigned int i = 0; i < full_descp_str.size(); ++i) {
        charact.clear();
        charact2.clear();
        charact3.clear();


        // read L = List, K = Collection
        //if ( ( i == 0 ) ) {//& ( full_descp_str[0] == "K") ) {
        // very important '' and not "" !!
        if ( ( i == 0 ) && ( (full_descp_str[0]) == 'K') ) {
            std::string local_str;
            local_str = full_descp_str[0];
            //charact = descp_str[i];
#ifdef DEBUG_UTIL
            std::cout << "set special for K charact [0]" << full_descp_str[0] << std::endl;
#endif
            // trick for compilation

            //desc_string.push_back( full_descp_str[0] );
            desc_string.push_back( local_str );

        // read by two C = Candle, B = Bar, P = PStockLime
        // second color 0= default ( for Candle)
        // R = Red, B = Blue, M = Mauve
        } else {
            // read two obj and color
            //std::cout << " make something else " << std::endl;
                //string substr (size_t pos = 0, size_t len = npos) const;

                sub_string = full_descp_str.substr( i, 3 );
                /*
            charact = full_descp_str[i];
            charact2 = full_descp_str[++i];
            charact3 = full_descp_str[++i];
            std::cout << charact << std::endl;
            std::cout << charact2 << std::endl;
            std::cout << charact3 << std::endl;
            */
                //std::cout << " sub_string " << sub_string << std::endl;

                i += 2;
            //std::cout << " i " << i << std::endl;
            //if ( charact.size() > 0 ) desc_string.push_back( charact );
            //if ( charact2.size() > 0 ) desc_string.push_back( charact2 );
            //if ( charact3.size() > 0 ) desc_string.push_back( charact3 );
            //desc_string.push_back( charact + charact2 + charact3 );
                desc_string.push_back( sub_string );
        }

        // can regroup the push back after
        //if ( charact.size() > 0 ) desc_string.push_back( charact );
        //if ( charact2.size() > 0 ) desc_string.push_back( charact2 );
        //if ( charact3.size() > 0 ) desc_string.push_back( charact3 );
    }
#ifdef DEBUG_UTIL
    std::cout << " summary parse_description " << std::endl;
    for ( unsigned int i = 0; i < desc_string.size(); ++i ) {
        std::cout << " i " << i << " " << desc_string[i] << std::endl;
    }
#endif

 return desc_string;
}

// basic test, need to extend with a field: NULL, TA, Other (enum)
bool Indicator::NeedToComputeTA() const
{
        if ( ( indicator_nb_param_[v_] > 0 ) ||
                 ( indicator_labels_[v_] == "AD" ) )
                return true;

        return false;
}


//Bug with size of one indicator, should be 8 octets, not 4 !
//Replaced by similar GetIndicator, but still different
Indicator::Value Indicator::FindValue(std::string str_name) const
{
        //std::cout << "size labels" << sizeof(indicator_labels_) << std::endl;
        int size_int=sizeof(int(1)); //machine dependent
        //do not work, send back 4
        //Indicator indic (Indicator::StockCSV);
        //int size_int=sizeof( indic );

        //std::cout << "sizeof indicator " << sizeof( indicator_labels_) << std::endl;
        //need two times the size, do not know why !!!
        //different output from ordiwg and asus
        //if ordiwg 64 bits
        //int size=sizeof( indicator_labels_  ) / (2*size_int);
        //if asus ?? work at HITS ??
        int size=sizeof( indicator_labels_  ) / (size_int);
#ifdef DEBUG_UTIL
        std::cout << "machine dependent size_int " << size_int << "size value " << size << std::endl;
#endif
        for (int i=0;i<size;i++)
               {//std::cout << " str_name " << str_name << " labels " << indicator_labels_[i] << std::endl;
                if (str_name == indicator_labels_[i])
                        return Value(i);
               }
        
        //std::cout << "not found" << std::endl;
        //std::cout << "Value(0)" << Value(0) << std::endl;
        return Value(0);
}

// const what the point here ?? No it is a static function
Indicator Indicator::GetIndicator(const std::string& str_name)
{
  std::vector<std::string> vec_substr;
  Utils::splitline(str_name, "_", vec_substr);
  //std::cout << "GetIndicator 1 " << vec_substr[0] << std::endl;

  //intermadiate because want a integer for switch, to see later
  //switch better
  if ( vec_substr[0] == "StockCSV" ) {
         //std::cout << "GetIndicator StockCSV" << std::endl;
         return ( Indicator::StockCSV );
         }
  // to add Volume
  else if ( vec_substr[0] == "StockInst" ) {
         return ( Indicator::StockInst );
         }
  else if ( vec_substr[0] == "SMA" ) {
         //std::cout << "GetIndicator SMA" << std::endl;
         return ( Indicator::SMA );
         //return ( Indicator::StockCSV );
         }
  else if ( vec_substr[0] == "EMA" ) {
         //std::cout << "GetIndicator EMA" << std::endl;
         return ( Indicator::EMA );
         }
  else if ( vec_substr[0] == "WMA" ) {
         //std::cout << "GetIndicator EMA" << std::endl;
         return ( Indicator::WMA );
         } 
  //stupid name ?? used ?? to delete ?? to see later
  else if ( vec_substr[0] == "SimpleData" ) {
           //std::cout << "GetIndicator SimpleData" << std::endl;
           return ( Indicator::StockInst );
         }
  else if ( vec_substr[0] == "Volume" ) {
           //std::cout << "GetIndicator Volume" << std::endl;
           return ( Indicator::Volume );
         }
  else if ( vec_substr[0] == "MACD" ) {
           //std::cout << "GetIndicator MACD" << std::endl;
           return ( Indicator::MACD );
         }
  else if ( vec_substr[0] == "BOLL" ) {
           //std::cout << "GetIndicator Bollinger" << std::endl;
           return ( Indicator::BOLL );
         }
  else if ( vec_substr[0] == "RSI" ) {
           //std::cout << "GetIndicator RSI" << std::endl;
           return ( Indicator::RSI );
         }
  else if ( vec_substr[0] == "STOCHF" ) {
           //std::cout << "GetIndicator StochF" << std::endl;
           return ( Indicator::STOCHF );
         }
  else if ( vec_substr[0] == "AD" ) {
           //std::cout << "GetIndicator AD" << std::endl;
           return ( Indicator::AD );
         }
 else
         std::cout << "Error No Match in Indicator::GetIndicator, return Indicator::Null " << std::endl;
 
 return ( Indicator::Null );
}

std::ostream& operator<< (std::ostream& o, Indicator c)
{
  return o << c.label ();
}

// never used ?? no point ?
void Indicator::Set(std::string str_name, std::vector<int> & param )
{
#ifdef DEBUG_UTIL
  std::cout << "Indicator::Set " << str_name << std::endl;
#endif
  std::string str_indic;
  int tmp_int;
  std::string tmp_str;

  char delimiters='_';
  // Skip delimiters at beginning.
  std::string::size_type lastPos = str_name.find_first_not_of(delimiters, 0);
  // Find first "non-delimiter".
  std::string::size_type pos     = str_name.find_first_of(delimiters, lastPos);

  int count=0;
  while (std::string::npos != pos || std::string::npos != lastPos) {
            // Found a token, add it to the vector
            // tokens.push_back(str.substr(lastPos, pos - lastPos));
            if (count == 0) {
                std::cout << str_name.substr(lastPos, pos - lastPos) << std::endl;
                tmp_str=str_name.substr(lastPos, pos - lastPos);
                //this->v_=volume_l;
                //this->v_=Indicator::Value(2);
                v_=FindValue(tmp_str);
                //std::cout << "retour FindValue(" << tmp_str << ")" << v_ << std::endl;
            //else for param
            } else {
                std::cout << "param " << str_name.substr(lastPos, pos - lastPos) << std::endl;
                tmp_str=str_name.substr(lastPos, pos - lastPos);
                tmp_int= Utils::fromString<int>(tmp_str);
                param.push_back(tmp_int);
            }
            // Skip delimiters.  Note the "not_of"
            lastPos = str_name.find_first_not_of(delimiters, pos);
            // Find next "non-delimiter"
            pos = str_name.find_first_of(delimiters, lastPos);
            count++;
  }

}



//enum EColor { kWhite =0,   kBlack =1,   kGray=920,
//              kRed   =632, kGreen =416, kBlue=600, kYellow=400, kMagenta=616, kCyan=432,
//              kOrange=800, kSpring=820, kTeal=840, kAzure =860, kViolet =880, kPink=900 };
int Indicator::MakeEColor( const char str_color)
{
    //if ( str_color == "0" ) return 0;
    //else
    if ( str_color == 'B') return  600; //kBlue;
    else if ( str_color == 'R' ) return 632; //kRed;
    else if ( str_color ==  'V' ) return 880; //kViolet;
    else return 900;//1; // kBlackkPink;
}


int Indicator::MakeColor( const char str_color)
{
    //if ( str_color == "0" ) return 0;
    //else
    if ( str_color == 'B') return 255; //4;
    else if ( str_color == 'R' ) return 16711680; //2;
    else if ( str_color ==  'V' ) return 9568511; //9;
    else return 16711680; //0; // Blue, Black
}

// test can modify, so can register ??
void Indicator::Change( int new_value ) {

    std::cout << "v_ " << v_ << std::endl;
    indicator_nb_output_[v_] = new_value;
}


/* example d utilisation, to be in unit_test
using std::cerr;
using std::endl;

void f (Indicator)
{
  cerr << "color" << endl;
}

void f (int)
{
  cerr << "int" << endl;
}

int
main ()
{
  // 1
  {
    // Color c (red);   // error: red undeclared
    Indicator c (Indicator::StockCSV);
  }

  // 2
  {
    // Color c;         // error: no default c-tor
    Indicator c (Indicator::StockCSV);
    c = Indicator::StockdCSV;
  }

  // 3
  {
    Indicator c (Indicator::StockdCSV);
    cerr << c << " " << Indicator::Volume << endl;
  }

  // 4
  {
    Indicator c (Indicator::StockCSV);

    f (c);
    f (Indicator::Volume);

    // c + Color::red;  // error: no operator+

    // if (c) {}        // error: no conversion from Color to bool

    if (c == Indicator::StockCSV && c != Indicator::Volume)
    {
      cerr << "ok" << endl;
    }
  }

  // 5
  {
    Color c (Color::red);

    switch (c.integral ())
    {
    case Color::red_l:
      cerr << "r" << endl;
      break;

    case Color::green_l:
      cerr << "g" << endl;
      break;

    case Color::blue_l:
      cerr << "b" << endl;
      break;
    }
  }

}
*/