TAlibAPI.cpp

Go to the documentation of this file.

#include "TAlibAPI.h"
#include "ListDataStock.h"

#include "TALibException.h"
#include "../utils/Indicator.h"

#include <algorithm>
using namespace std;

TAlibAPI::TAlibAPI() {
#ifdef DEBUG_TALIB
        cout << "Constructor TAlibAPI " << endl;
#endif
        // associate the resource, res_ptr is a shared pointer
        res_ptr = TAResource::CreateResource();

#ifdef DEBUG_TALIB
        cout << "res_ptr.use_count() " << res_ptr.use_count() << endl;
        cout << "res_ptr " << res_ptr << endl;
#endif
}

TAlibAPI::~TAlibAPI() {
#ifdef DEBUG_TALIB
        cout << "Destructor TAlibAPI " << endl;
        // not updated yet
        cout << "res_ptr use_count() "  << res_ptr.use_count() << endl;
#endif
        // res_ptr is deleted, but not necessarely the ressource
}

bool TAlibAPI::TAResource::Init()
{
#ifdef DEBUG_TALIB
 std::cout << "TAResource init()" << std::endl;
#endif

 TA_RetCode rc = TA_Initialize();
 if ( rc == TA_SUCCESS ) {
#ifdef DEBUG_TALIB
    std::cout << "Ok TA_Initialize" << std::endl;
#endif
    return true;

 } else {
    std::cout << "Error in TA_Initialize: " << rc << std::endl;
    return false;
 }
}

bool TAlibAPI::TAResource::Shutdown()
{
#ifdef DEBUG_TALIB
  std::cout << "TAResource Shutdown()" << endl;
#endif

  TA_RetCode rc = TA_Shutdown();
  if (rc != TA_SUCCESS) {
      std::cout << "TALib Error on TA_Shutdown" << rc << std::endl;
      return false;

  }  else {
#ifdef DEBUG_TALIB
      std::cout << "Ok TALIB TA_Shutdown properly" << std::endl;
#endif
      return true;
  }
}

TAlibAPI::TAResource::TAResource()
{
#ifdef DEBUG_TALIB
        cout << "Constructor TAResource, init TAlib" << endl;
#endif
        TAResource::Init();
}

TAlibAPI::TAResource::~TAResource()
{
#ifdef DEBUG_TALIB
        cout << "Destructor TAResource" << endl;
#endif
        TAResource::Shutdown();
}

// maybe not thread-safe mutex to add.  Phoenix working
std::shared_ptr<TAlibAPI::TAResource> TAlibAPI::TAResource::CreateResource()
{
#ifdef DEBUG_TALIB
        cout << "TAResource CreateResource " << endl;
#endif
        // cannot do this
        // http://stackoverflow.com/questions/19147588/shared-pointers-to-a-singleton-do-not-recognize-each-other
        //static TARessource instance;
        //return TAResPtr( instance );

        // first solution, but get use_count == 2 after and never delete. It seems they point to different object
        //static TAResPtr instance = std::make_shared<TARessource>();
        //cout << "instance.use_count() " << instance.use_count() << endl;
        //return instance;

        // second solution, weak pointer does not increase the counter, need lock to convert to shared_ptr
        // keep a static weak pointer, same instance for different call
        static std::weak_ptr<TAResource> instance;

        // uncomment (a) (b) for thread-safe
        //static std::mutex mutex; // (a)
        //const std::lock_guard< std::mutex > lock( mutex ); // (b)
        // Lock convert a weak_ptr into a shared_ptr, or nullptr, it has to be copied into a shared_ptr before usage
        if( const auto result = instance.lock() ) return result;

        // case nullptr create (or recreate) the object, same use lock
        // here need tricks to get private constructor, destructor private
        // http://stackoverflow.com/questions/8147027/how-do-i-call-stdmake-shared-on-a-class-with-only-protected-or-private-const
        //return ( instance = std::make_shared<TAResource>() ).lock();

        // still needs public destructor
        return ( instance = std::shared_ptr<TAResource>( new TAResource() ) ).lock();
}

// idea vector for input CSV and volume, always send vec<ListDataBase *>
//
// Main entry for running a computation with TAlib, should be the only public function
// Will transform Lists to to C Array, always chronological order for computation
// and fill the ldata_out...in...the correct order
//
// Need to add tmscl for dynamic_cast or test if dynamic_cast works or return nullptr.
// Timescale present in input/output lists.
bool TAlibAPI::Compute( const ETime tmscl, const Indicator new_indic, const std::vector<int>& vec_param,
                const std::vector< ListDataStockBase *>& vec_ldata_in, ListDataStockBase *ldata_out) const
        throw (TALibException)
{
#ifdef DEBUG_TALIB
  std::cout << "\nEntry TALib::Compute new_indic " << new_indic.label() << std::endl;
  std::cout << "Name of out " << ldata_out->GetName() << " " << ldata_out->Capacity() << std::endl;
  //std::cout << "size of vec_ldata_in " << vec_ldata_in.size() << std::endl;
#endif

  int retour;
  unsigned int size_data_in;

  // array of array for input/output [list][data]
  // could choose now, float or double
  float **arraydata_c_in = 0;
  // needed for a proper delete, nb of input indices
  int nb_array_in = 0;
  // output always double in ta-lib
  double **arraydata_c_out = 0;
  // nb of returned indices
  int nb_array_out = 0;

  // value to be returned when going back to listdata
  int offset_begin=0;
  int out_nb_data=0;
  
  //always a link to dataCSV or SimpleData, always first in the vector
  ListDataStockBase  *ldata_csv_in = 0;
  // volume needed for some indicator : AD, but never set correctly !
  ListDataStockBase  *ldata_volume_in = 0;

  // assign ldata_csv to the first list input, and get size of the input
  // always CSV/INST then Volume ?
#ifdef DEBUG_TALIB
  std::cout << "Size vec_ldata_in " << vec_ldata_in.size() << std::endl;
#endif
  if ( vec_ldata_in.size() >= 1 ) {

      // CSV always first and gives the size
      ldata_csv_in = vec_ldata_in[0];
      //ldata_csv_in = dynamic_cast<ldata_candle *>(vec_ldata_in[0]);
      size_data_in = (unsigned int) ldata_csv_in->GetSize();

      // add new, if two in input it is the volume
      if ( vec_ldata_in.size() >= 2 ) {
          ldata_volume_in = vec_ldata_in[1];
          std::cout << "Volume is present as input " << std::endl;
      }

  } else {
      std::cout << "Error in size of vec_ldata_in in TAlibAPI::Compute, throw Exception" << std::endl;
      throw ( TALibException( new_indic, vec_param, "TALibException: Size of Lists input is null") );
  }

  //make creation of array for general purpose
  // can also  get this info from TA_FuncInfo
  nb_array_in = new_indic.nb_input();
  nb_array_out = new_indic.nb_output();
#ifdef DEBUG_TALIB
  std::cout << "nb array in/out " << nb_array_in << " " << nb_array_out << std::endl;
#endif

  // can add a test if max vec_param > size will be problems, or let exception
  if ( (unsigned int)*std::max_element(vec_param.cbegin(), vec_param.cend())  > size_data_in )
          throw TALibException( new_indic, vec_param, "Size of the input data is too small for theses parameters");

  // allocate memory for output, always double fom  TA-lib
  // test if > 0, maybe in some case...
  arraydata_c_out = new double*[ nb_array_out ];
  for ( int i = 0; i< nb_array_out; i++ ) {
      arraydata_c_out[i] = new double[size_data_in];
      //init all to zero, not needed
      for ( unsigned int j = 0; j < size_data_in; j++ )
          arraydata_c_out[i][j] = 0.;
  }

  //allocate nb_array_in, size could be allocated in GetCArray with initalizer list as well
  arraydata_c_in = new float*[ nb_array_in ];

  // case with 3 outputs, 1 entry
  if ( ( new_indic.label().compare("MACD") == 0 ) || ( new_indic.label().compare("BOLL") == 0 ) || 
       ( new_indic == Indicator::RSI )  || ( new_indic.label().compare("STOCHF") == 0 ) ) {

#ifdef DEBUG_TALIB
      std::cout << "Compute MACD/BOLL/STOCHF/RSI: " << new_indic.label() << std::endl;
      // RSI only one param
      //std::cout << "param " << " vec_param " << vec_param[0] << " " << vec_param[1] << std::endl;//" " << vec_param[2] << std::endl;
#endif
      // fill the inpput array, method of ListDataStock, will make chronologic for TAlib
      if ( ( new_indic == Indicator::MACD ) || ( new_indic == Indicator::BOLL ) || ( new_indic == Indicator::RSI ) ) {

          //ldata_csv_in->GetCArray( &(arraydata_c_in[0]), "Close");
          if ( tmscl == ETime::INST )
                  //ldata_csv_in->GetCArray( &(arraydata_c_in[0]), "Close");
              //(dynamic_cast<ldata_dcsv *>(ldata_csv_in))->GetCArray( &(arraydata_c_in[0]), EPChrono::CHRONO, 0 );
                  ldata_csv_in->GetCArray( &(arraydata_c_in[0]), EPChrono::CHRONO, 0 );
          else
                  //(dynamic_cast<ldata_candle *>(ldata_csv_in))->GetCArray( &(arraydata_c_in[0]), EPChrono::CHRONO, as_uint( EDS::ECSV::CLOSE ));
                  ldata_csv_in->GetCArray( &(arraydata_c_in[0]), EPChrono::CHRONO, as_uint( EDS::ECSV::CLOSE ));

      // case STOCHF, need more entry, but only CSV. Not possible with INST.
          } else if ( new_indic == Indicator::STOCHF ) {
#ifdef DEBUG_TALIB
          std::cout << "new indic STOCHF nb_array_int" << nb_array_in << std::endl;
#endif
          if ( tmscl == ETime::INST )
                  throw TALibException( new_indic, vec_param, "Cannot compute STOCHF with a TimeScale INST");

          ldata_csv_in->GetCArray( &(arraydata_c_in[0]), EPChrono::CHRONO, as_uint( EDS::ECSV::HIGH) );
          ldata_csv_in->GetCArray( &(arraydata_c_in[1]), EPChrono::CHRONO, as_uint( EDS::ECSV::LOW) );
          ldata_csv_in->GetCArray( &(arraydata_c_in[2]), EPChrono::CHRONO, as_uint( EDS::ECSV::CLOSE) );


      // error
          } else {
          std::cout << "\n\tCompute indicator not implemented !!\n" << std::endl;
          throw TALibException( new_indic, vec_param, "Indicator no implemented");
          }

      retour = ComputeMACD ( arraydata_c_in ,size_data_in, new_indic.label(),
                             vec_param, arraydata_c_out, nb_array_out, offset_begin, out_nb_data);
#ifdef DEBUG_TALIB
      std::cout << "\n\tRetour ComputeMACD" << std::endl;
      std::cout << "out_nb_data " << out_nb_data << " offset_begin " << offset_begin << std::endl;
      std::cout << "arraydata_c_out " << arraydata_c_out[0][0] << " " << arraydata_c_out[1][0] << " " << arraydata_c_out[2][0] << std::endl;
      std::cout << "arraydata_c_out " << arraydata_c_out[0][1] << " " << arraydata_c_out[1][1] << " " << arraydata_c_out[2][1] << std::endl;
      //std::cout << "arraydata_c_out[23] " << arraydata_c_out[0][23] << " " << arraydata_c_out[1][23] << " " << arraydata_c_out[2][23] << std::endl;
#endif

  } // End MACD/RSI

  // Case SMA, EMA, WMA, can be computed for INST
  else if ( new_indic.label().compare(1,2,"MA",0,2) == 0 ) {
#ifdef DEBUG_TALIB
      std::cout << "Compute a MA: " << new_indic.label() << std::endl;
      //std::cout << " size_data_in: " << ldata_csv_in->GetSize() << std::endl;
#endif

      // Can compute XMA with CSV or INST
      if ( tmscl == ETime::INST )
          //ldata_csv_in->GetCArray( &(arraydata_c_in[0]), "Close");
          ldata_csv_in->GetCArray( &(arraydata_c_in[0]), EPChrono::CHRONO, 0 );
      else
          ldata_csv_in->GetCArray( &(arraydata_c_in[0]), EPChrono::CHRONO, as_uint( EDS::ECSV::CLOSE ));

/*
      std::cout << "After copy in TAlib" << std::endl;
      for (int j=0;j<ldata_csv_in->GetSize();j++)
        std::cout << arraydata_c_in[0][j] << std::endl;

      std::cout << "&arraydata_c_in " << &arraydata_c_in << std::endl;
      std::cout << "arraydata_c_in " << arraydata_c_in << std::endl;
      std::cout << "arraydata_c_in[0] " << arraydata_c_in[0] << std::endl;
      std::cout << "&arraydata_c_in[0] " << &(arraydata_c_in[0]) << std::endl;
*/
      retour = ComputeMA ( arraydata_c_in ,size_data_in, new_indic.label(),
                          vec_param[0], arraydata_c_out, offset_begin, out_nb_data);
#ifdef DEBUG_TALIB
      std::cout << "offset begin " << offset_begin << std::endl;
#endif


  //case use volume and no parameter.
  } else if ( new_indic == Indicator::AD ) {
#ifdef DEBUG_TALIB
      std::cout << "In TAlib::Compute Compute AD " << std::endl;
      std::cout << "new indic AD nb_array_in " << nb_array_in << std::endl;
#endif

      if ( tmscl == ETime::INST )
          throw TALibException( new_indic, vec_param, "Cannot compute AD with a TimeScale INST");

      // fill input array
      ldata_csv_in->GetCArray( &(arraydata_c_in[0]), EPChrono::CHRONO, as_uint( EDS::ECSV::HIGH) );
          ldata_csv_in->GetCArray( &(arraydata_c_in[1]), EPChrono::CHRONO, as_uint( EDS::ECSV::LOW) );
          ldata_csv_in->GetCArray( &(arraydata_c_in[2]), EPChrono::CHRONO, as_uint( EDS::ECSV::CLOSE) );
          ldata_volume_in->GetCArray( &(arraydata_c_in[3]), EPChrono::CHRONO, 0 );
      retour = ComputeMACD ( arraydata_c_in ,size_data_in, new_indic.label(),
                             vec_param, arraydata_c_out, nb_array_out, offset_begin, out_nb_data);
  }

  else {
      std::cout << "Not found this indicator in computeTA " << std::endl;
      throw TALibException( new_indic, vec_param, "Indicator no implemented");
  }

  //Check if retour is ok, ComputeX does not throw exception
  if (!retour) {
#ifdef DEBUG_TALIB
      std::cout << "Ok for ComputeMA or other offset_begin " << offset_begin << " copy back data " << std::endl;
      std::cout << "Call PutCArray nb_array_out " << nb_array_out << std::endl;
#endif

      // Fill ldata_out with results, works for all ListdataStock
      ldata_out->PutCArray( *ldata_csv_in, out_nb_data, nb_array_out, arraydata_c_out,
                                          offset_begin, 0, EPChrono::CHRONO, false );
      //std::cout << "return PutCArray = 0" << std::endl;

  } else {
#ifdef DEBUG_CPP
      std::cout << "Error in computation, delete the listdatastock " << std::endl;
#endif

      // why error appears now ,not before ? did not test well valgrind ?
      for ( int i = 0; i< nb_array_in; i++ ) {
            delete[] arraydata_c_in[i];
      }
      delete[] arraydata_c_in; arraydata_c_in = 0;
      //std::cout << " nb_array_out " << nb_array_out << std::endl;
      for ( int i = 0; i< nb_array_out; i++ ) {
          delete[] arraydata_c_out[i];
      }
      delete[] arraydata_c_out; arraydata_c_out = 0;

      throw TALibException( new_indic, vec_param, "Error in TA-lib calculation");
  }

  //delete temporary arrays, never called ! because of retour !
  for ( int i = 0; i< nb_array_in; i++ ) {
      delete[] arraydata_c_in[i];
  }
  delete[] arraydata_c_in; arraydata_c_in = 0;

  for ( int i = 0; i< nb_array_out; i++ ) {
      delete[] arraydata_c_out[i];
  }
  delete[] arraydata_c_out; arraydata_c_out = 0;

#ifdef DEBUG_TALIB
  std::cout << "return from TAlib:compute ok" << std::endl;
#endif
  return retour;
}

int TAlibAPI::ComputeMA( float **arraydata_c_in, unsigned int size_input, std::string str_label,
                int param, double **arraydata_c_out, int & offset_begin, int & out_nb_data) const
{
#ifdef DEBUG_TALIB
 std::cout << "Entry ComputeMA str_label " << str_label << std::endl;
#endif
 // for valgrind
 TA_RetCode rc = TA_SUCCESS;
 //label already exist in TA-lib, need abstract class for better

 //by default all available data
 int startIdx=0; //index of the entry tabular to treat
 int endIdx=size_input-1;

#ifdef DEBUG_TALIB
 std::cout << "startIdx " << startIdx << std::endl;
 std::cout << "endIdx " << endIdx << std::endl;
 std::cout << "array[0[0] " << arraydata_c_in[0][0] << std::endl;
 std::cout << "array[0][size_input-1]" << arraydata_c_in[0][size_input-1] << std::endl;
 std::cout << "param " << param << std::endl;
 std::cout << "str_label " << str_label << std::endl;
 std::cout << "arraydata_c_out[0] " <<  arraydata_c_out[0] << " " << arraydata_c_out[0][0] << std::endl;
#endif

 //test just need to change Enum MAType
 //MAType = TA_MAType_SMA;

 if ( str_label == "SMA" ) {
     // by default take all the data
         // theses function use float as entry and return double
     rc = TA_S_MA( startIdx, endIdx, arraydata_c_in[0], param,TA_MAType_SMA, &offset_begin, &out_nb_data, arraydata_c_out[0]);

 } else if ( str_label == "EMA" ) {
     rc = TA_S_MA( startIdx, endIdx, arraydata_c_in[0], param,TA_MAType_EMA, &offset_begin, &out_nb_data, arraydata_c_out[0]);

 } else if ( str_label == "WMA" ) {
     rc = TA_S_MA( startIdx, endIdx, arraydata_c_in[0], param,TA_MAType_WMA, &offset_begin, &out_nb_data, arraydata_c_out[0]);

 } else {
     std::cout << "Not defined, error "  << std::endl;
     return 1;
 }

 if (rc != TA_SUCCESS) {
       std::cout << "error in TA_S_MA rc: " << rc << std::endl;
       // all set to zero
       std::cout << "offset_begin " << offset_begin <<", out_nb_data " << out_nb_data << std::endl;
       return 1;
 }
 return 0;
}

//make specialized for first
int TAlibAPI::ComputeMACD( float **arraydata_c_in, unsigned int size_input, std::string str_label, 
std::vector<int> param, double **arraydata_c_out, unsigned int nb_array_out, int & offset_begin, int & out_nb_data ) const
{
#ifdef DEBUG_TALIB
  std::cout << "Entry ComputeMACD str_label " << str_label << std::endl;
  //std::cout << "param " << param[0] << " " << param[1] << " " << 3 << " " << std::endl;
  std::cout << "size_input " << size_input << " nb_array_out " << nb_array_out << std::endl;
#endif
  // init for valgrind
  TA_RetCode rc = TA_SUCCESS;
  int startIdx=0; //index of the entry tabular to treat
  int endIdx=size_input-1; // 12;

#ifdef DEBUG_TALIB
 std::cout << "startIdx " << startIdx << std::endl;
 std::cout << "endIdx " << endIdx << std::endl;
#endif

  /*
  TA_RetCode TA_MACD( int startIdx,
                      int endIdx,
                      const double inReal[],
                      int optInFastPeriod,
                      int optInSlowPeriod,
                      int optInSignalPeriod,
                      int *outBegIdx,
                      int *outNBElement,
                      double outMACD[],
                      double outMACDSignal[],
                      double outMACDHist[] );
  */
  //rc = TA_MACD ( startIdx, endIdx, arraydata_c_in[0], param,TA_MAType_SMA, &offset_begin, &out_nb_data, arraydata_c_out[0]);
  // why here const double ?? no in MA ?? (const double*) needed ? ok use S_MACD for float see /usr/local/ta-lib/ta-lib/c/include/ta_func.h

  if ( str_label.compare("MACD") == 0 ) {
#ifdef DEBUG_TALIB
      std::cout << "Compute MACD " << std::endl;
#endif
      rc = TA_S_MACD ( startIdx, endIdx, arraydata_c_in[0], param[0], param[1], param[2], &offset_begin, &out_nb_data, 
                       arraydata_c_out[0], arraydata_c_out[1], arraydata_c_out[2] );
  } else if ( str_label.compare("BOLL") == 0 ) {
#ifdef DEBUG_TALIB
      std::cout << "Compute BOLL " << std::endl;
#endif
      rc = TA_S_BBANDS ( startIdx, endIdx, arraydata_c_in[0], param[0], (double)param[1], (double)param[2], TA_MAType_SMA,
                       &offset_begin, &out_nb_data, 
                       arraydata_c_out[0], arraydata_c_out[1], arraydata_c_out[2] );

  } else if ( str_label.compare("STOCHF") == 0 ) {
#ifdef DEBUG_TALIB
      std::cout << "Compute STOCHF" << std::endl;
#endif
      rc = TA_S_STOCHF ( startIdx, endIdx, arraydata_c_in[0], arraydata_c_in[1], arraydata_c_in[2], param[0], param[1], TA_MAType_SMA,
                         &offset_begin, &out_nb_data, arraydata_c_out[0], arraydata_c_out[1] );

  } else if ( str_label.compare("RSI") == 0 ) {
#ifdef DEBUG_TALIB
      std::cout << "Compute RSI" << std::endl;
#endif
      rc = TA_S_RSI ( startIdx, endIdx, arraydata_c_in[0], param[0], 
                      &offset_begin, &out_nb_data, arraydata_c_out[0] );

  } else if ( str_label.compare("AD") == 0 ) {
#ifdef DEBUG_TALIB
      std::cout << "TAlib::ComputeMACD Compute AD" << std::endl;
#endif
      rc = TA_S_AD ( startIdx, endIdx, arraydata_c_in[0], arraydata_c_in[1], arraydata_c_in[2], arraydata_c_in[3],
                     &offset_begin, &out_nb_data, arraydata_c_out[0] );  
  //else error
  } else {
      std::cout << "label not known " << std::endl;
      return 1;
  }

#ifdef DEBUG_TALIB
  std::cout << "rc " << rc << std::endl;
  std::cout << " offset " << offset_begin << " out_nb_data " << out_nb_data << std::endl;
  //std::cout << "array[0[0] " << arraydata_c_out[0][0] << " " << arraydata_c_out[0][0] << std::endl;
  /*
  for ( int i=out_nb_data-1;i>=0;i--) {
      //for ( unsigned int k=0; k< size_indic_out; k++ )
          //tmp_vec_value[k] = (float)arraydata_c_out[k][i];
      std::cout << "tmp_vec_value " << arraydata_c_out[0][i] << " " << arraydata_c_out[1][i] << " " << arraydata_c_out[2][i] << std::endl;
  }
  */
#endif

  if (rc != TA_SUCCESS) {
      std::cout << "error in TA_MACD or other: " << rc << std::endl;
      std::cout <<"offset_begin " << offset_begin <<", out_nb_data " << out_nb_data << std::endl;
      return 1;
  }
  return 0;
}

void TAlibAPI::GetListFunctions()
{
#ifdef DEBUG_TALIB
  std::cout << "Entry getListFunctions " << std::endl;
#endif

  // could belong to the class, fill at init
  typedef std::map< std::string, std::vector<std::string> > type_map_func;
  typedef type_map_func::iterator it_map;
  type_map_func map_func;

  // direct code from talib abstract.h
  // /usr/local/ta-lib/ta-lib/c/include
  TA_StringTable *table;
  TA_RetCode retCode;
  unsigned int i;

  retCode = TA_GroupTableAlloc( &table );

  if( retCode == TA_SUCCESS ) {
      for( i=0; i < table->size; i++ )
          //printf( "%s\n", table->string[i] );
          map_func.insert( std::pair<std::string,
                std::vector<std::string> >(table->string[i], std::vector<std::string>() ));

      TA_GroupTableFree( table );
  }

  for (it_map it = map_func.begin(); it != map_func.end(); ++it ) {

      retCode = TA_FuncTableAlloc( ((*it).first).c_str(), &table );

      if( retCode == TA_SUCCESS ) {
          for( i=0; i < table->size; i++ )
              //printf( "%s\n", table->string[i] );
              (*it).second.push_back( table->string[i] );

          TA_FuncTableFree( table );
      }

      //std::cout << "Group " << (*it).first << std::endl;
  }
  //std::cout

  for (it_map it = map_func.begin(); it != map_func.end(); ++it ) {

      std::cout << "Group  " << (*it).first << std::endl;
      std::vector<std::string>::iterator it_v;
      for ( it_v = (*it).second.begin(); it_v != (*it).second.end(); ++it_v ) {
          std::cout <<  "      " << *it_v << std::endl;
      }
  }

  const TA_FuncHandle *handle;
  const TA_FuncInfo *theInfo;

  retCode = TA_GetFuncHandle( "CDL2CROWS", &handle );

  if( retCode == TA_SUCCESS ) {
     retCode = TA_GetFuncInfo( handle, &theInfo );
     if( retCode == TA_SUCCESS ) {
         printf( "Nb Input = %d\n", theInfo->nbInput );
         printf( "flags = %d\n", theInfo->flags );
         //if ( theInfo->flags == TA_FUNC_FLG_CANDLESTICK ) {

         if ( theInfo->flags &  TA_FUNC_FLG_CANDLESTICK ) {
           std::cout << "I am a CandleStick " << std::endl;
         } else {
           std::cout << "I am not a CandleStick " << std::endl;
         }

         if ( theInfo->flags == TA_FUNC_FLG_OVERLAP ) {
           std::cout << "I also scale with input " << std::endl;
         }
     }
  }
  /*
  typedef struct TA_FuncInfo
  {
     // Constant information about the function. The
     //  information found in this structure is guarantee
     // to not change at runtime.
     //
     const char * name;
     const char * group;

     const char * hint;          //
     const char * camelCaseName;
     TA_FuncFlags flags;

     unsigned int nbInput;
     unsigned int nbOptInput;
     unsigned int nbOutput;

     const TA_FuncHandle *handle;
  } TA_FuncInfo;
  */

#ifdef DEBUG_TALIB
  std::cout << "End GetListFunctions" << std::endl;
#endif
  return;
}