STK_DataFrame.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
 * Purpose:  Define the DataFrame class.
 * Author:   Serge Iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 *
 **/
 
#ifndef STK_DATAFRAME_H
#define STK_DATAFRAME_H
 
 
#include "STK_List1D.h"
#include "STK_IVariable.h"
#include <Arrays/include/STK_IContainer2D.h>
 
 
namespace STK
{
 
class DataFrame : protected List1D<IVariable* >, public IContainer2D<UnknownSize,UnknownSize>
{
  public:
    typedef IContainer2D<UnknownSize, UnknownSize > Base2D;
    typedef List1D<IVariable*> Base;
    typedef TRange<UnknownSize> RowRange;
    typedef TRange<UnknownSize> ColRange;
 
  public:
    DataFrame();
    DataFrame( DataFrame const& T, bool ref = false);
    virtual ~DataFrame();
 
    inline RowRange const& rows() const  { return Base2D::rows();}
    inline int beginRows() const { return Base2D::beginRows();}
    inline int endRows() const { return  Base2D::endRows();}
    inline int sizeRows() const  { return  Base2D::sizeRows();}
 
    inline ColRange cols() const { return ColRange(1);}
    inline int beginCols() const { return  Base2D::beginCols();}
    inline int endCols() const  { return  Base2D::endCols();}
    inline int sizeCols() const  { return  Base2D::sizeCols();};
 
    inline int lastIdxRows() const  { return this->lastIdx();}
    inline int lastIdxCols() const  { return baseIdx;}
 
 
     inline bool empty() const { return Base::empty();}
 
    void clear();
    inline IVariable*& elt(int const& i) { return Base::elt(i);}
    inline IVariable* const elt(int const& i) const { return Base::elt(i);}
 
    DataFrame& operator=(DataFrame const& T);
 
    void resize( Range const& I, Range const& J);
    void shift(int const& cbeg =1);
    void shift(int const& rbeg, int const& cbeg);
    void popBackCols(int const& n);
    void eraseCols( int pos, int const& n=1);
    inline void swapCols(int j1, int j2)
    { Base::swap(j1, j2);}
 
    void popBackRows(int const& n);
    void eraseRows( int pos, int const& n=1);
    void insertVariable( int pos, IVariable* const & V);
    void pushBackVariable( IVariable* const & V);
    inline void pushFrontVariable( IVariable* const & V)
    { insertVariable(beginCols(), V);}
    void merge( DataFrame const& D);
    void insertDataFrame( int pos, DataFrame const& D);
    void pushBackDataFrame( DataFrame const &D);
    inline void pushFrontDataFrame( DataFrame const &D)
    { insertDataFrame(beginCols(), D);}
    void writeDataFrame( ostream  &os, int const& left, int const& right) const;
 
  protected:
    void freeMem();
    void freeCols();
    void pushBackCols(int const& n=1);
    void insertCols( int pos, int const& n=1);
    void pushBackRows(int const& n=1);
    void insertRows( int pos, int const& n =1);
};
 
ostream& operator<< (ostream& s, DataFrame const& V);
 
} // namespace STK
 
#endif
//STK_DATAFRAME_H