STK_DataHandler.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2016  Serge Iovleff, Université Lille 1, Inria
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as
    published by the Free Software Foundation; either version 2 of the
    License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
    License along with this program; if not, write to the
    Free Software Foundation, Inc.,
    59 Temple Place,
    Suite 330,
    Boston, MA 02111-1307
    USA
 
    Contact : S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
*/
 
/*
 * Project:  stkpp::DManager
 * created on: 15 nov. 2013
 * Author:   iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 **/
 
#ifndef STK_DATAHANDLER_H
#define STK_DATAHANDLER_H
 
#include <vector>
#include <Arrays/include/STK_Array2D.h>
 
#include "STK_DataHandlerBase.h"
#include "STK_ReadWriteCsv.h"
 
namespace STK
{
// forward declaration
class DataHandler;
 
namespace hidden
{
template<typename Type>
struct DataHandlerTraits<DataHandler, Type>
{
  typedef Array2D<Type> Data;
};
 
} // namespace hidden
 
class DataHandler: public DataHandlerBase<DataHandler>
{
  public:
    typedef DataHandlerBase<DataHandler> Base;
    typedef DataHandlerBase<DataHandler>::InfoMap InfoMap;
    inline DataHandler(): Base(), withNames_(false)
    { data_.setWithNames(false); descriptor_.setWithNames(false);}
    inline ~DataHandler() {}
    inline ReadWriteCsv const& data() const { return data_;}
    inline ReadWriteCsv const& descriptor() const { return descriptor_;}
    inline int nbSample() const { return data_.sizeRows();}
    inline int nbVariable() const { return data_.size();}
 
    inline void setWithNames(bool withNames) { withNames_ = withNames;}
    bool readDataFromCsvFile(std::string const& datafile, std::string descriptorfile);
    bool readDataFromCsvFile(std::string const& datafile, std::string const& idData, std::string const& idModel);
    template<typename Type>
    bool readDataFromArray2D(Array2D<Type> const& data, std::string const& idData, std::string const& idModel);
    template<typename Array>
    bool readDataFromArray(ExprBase<Array> const& data, std::string const& idData, std::string const& idModel);
    template<typename Type>
    void getData(std::string const& idData, Array2D<Type>& data) const;
    void removeData(std::string const& idData);
 
  protected:
    std::vector<int> colIndex(std::string const& idData) const;
 
  private:
    bool withNames_;
    ReadWriteCsv data_;
    ReadWriteCsv descriptor_;
};
 
 
 
template<typename Type>
void DataHandler::getData(std::string const& idData, Array2D<Type>& data) const
{
  std::vector<int> indexes = colIndex(idData);
#ifdef STK_MIXTURE_VERY_VERBOSE
  stk_cout << _T("In DataHandler::getData, idData = ") << idData << _T("\n");
  stk_cout << _T("columns found = ");
  for (std::vector<int>::const_iterator it = indexes.begin(); it != indexes.end(); ++it)
  { stk_cout << (*it) << _T(" ");}
  stk_cout << _T("\n");
#endif
  int nbVariable = indexes.size();
  data.resize(nbSample(), nbVariable);
  int j= data.beginCols();
  for (std::vector<int>::const_iterator it = indexes.begin(); it != indexes.end(); ++it, ++j)
  {
    for (int i = data_.firstRow(*it); i <= data_.lastRow(*it); ++i)
    { data(i, j) = stringToType<Type>(data_(i,*it));}
  }
}
 
template<typename Type>
bool DataHandler::readDataFromArray2D( Array2D<Type> const& data
                                     , std::string const& idData
                                     , std::string const& idModel)
{
  // add descriptor
  Variable<std::string> desc(2, stringNa);
  desc[baseIdx] = idModel ; desc[baseIdx+1] = idData;
  if (!addInfo(idData, idModel)) return false;
  // store data at the end of the ReadWriteCsv array in a string format
  for (int j=data.beginCols(); j<= data.lastIdxCols(); ++j)
  {
    data_.push_back();
    data_.back().resize(data.rows());
    for (int i= data.beginRows(); i < data.endRows(); ++i)
    { data_.back()[i] = typeToString(data(i,j), std::scientific);}
    // store descriptor : this is the same for all the columns added
    descriptor_.push_back(desc);
  }
  return true;
}
 
template<typename Array>
bool DataHandler::readDataFromArray( ExprBase<Array> const& data
                                   , std::string const& idData
                                   , std::string const& idModel)
{
  // add descriptor
  Variable<std::string> desc(2, stringNa);
  desc[baseIdx] = idModel ; desc[baseIdx+1] = idData;
  if (!addInfo(idData, idModel)) return false;
  // store data at the end of the ReadWriteCsv array in a string format
  for (int j=data.beginCols(); j<= data.lastIdxCols(); ++j)
  {
    data_.push_back();
    data_.back().resize(data.rows());
    for (int i= data.beginRows(); i < data.endRows(); ++i)
    { data_.back()[i] = typeToString(data.elt(i,j), std::scientific);}
    // store descriptor : this is the same for all the columns added
    descriptor_.push_back(desc);
  }
  return true;
}
 
 
} // namespace STK
 
#endif /* STK_DATAHANDLER_H */