STK_Variable.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
 * Author:   Serge Iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 **/
 
#ifndef STK_VARIABLE_H
#define STK_VARIABLE_H
 
#include <Arrays/include/STK_IArray1D.h>
#include "STK_IVariable.h"
 
namespace STK
{
 
template< class Type_> class Variable;
 
namespace hidden
{
template<class Type_>
struct Traits< Variable<Type_> >
{
  typedef Variable<Type_> Row;
  typedef Variable<Type_> Col;
  typedef Variable<Type_> SubRow;
  typedef Variable<Type_> SubCol;
  typedef Variable<Type_> SubArray;
  typedef Variable<Type_> SubVector;
 
  typedef Type_          Type;
  typedef typename RemoveConst<Type_>::Type const& TypeConst;
 
  enum
  {
    structure_ = Arrays::vector_,
    orient_    = Arrays::by_col_,
    sizeCols_  = 1,
    sizeRows_  = UnknownSize,
    size_      = UnknownSize,
    storage_   = Arrays::dense_ // always dense
  };
 
  typedef MemAllocator<Type_, UnknownSize> Allocator;
 
  typedef TRange<size_> RowRange;
  typedef TRange<1>     ColRange;
 
  typedef int Index;
 
  typedef DenseRandomIterator<Variable<Type_> > Iterator;
  typedef ConstDenseRandomIterator<Variable<Type_> > ConstIterator;
 
  typedef std::reverse_iterator<Iterator> ReverseIterator;
  typedef std::reverse_iterator<ConstIterator> ConstReverseIterator;
};
 
} // namespace hidden
template<class Type_>
class Variable: public IVariable
              , public IArray1D< Variable<Type_> >
{
  public:
    typedef Variable<Type_> Row;
    typedef Variable<Type_> Col;
    typedef Variable<Type_> SubRow;
    typedef Variable<Type_> SubCol;
    typedef Variable<Type_> SubArray;
    typedef Variable<Type_> SubVector;
 
    typedef typename hidden::Traits<Variable<Type_> >::Type Type;
    typedef typename hidden::Traits<Variable<Type_> >::TypeConst TypeConst;
 
    enum
    {
      structure_ = hidden::Traits< Variable<Type_> >::structure_,
      orient_    = hidden::Traits< Variable<Type_> >::orient_,
      size_      = hidden::Traits< Variable<Type_> >::size_,
      sizeCols_  = hidden::Traits< Variable<Type_> >::sizeCols_,
      sizeRows_  = hidden::Traits< Variable<Type_> >::sizeRows_,
      storage_   = hidden::Traits< Variable<Type_> >::storage_
    };
 
    typedef typename hidden::Traits< Variable<Type_> >::Allocator Allocator;
 
    //typedef MemAllocator<Type_, size_> Allocator;
    typedef IArray1D< Variable<Type_> > Base;
 
    using Base::elt;
    explicit Variable( String const& name = stringNa)
                     : IVariable(IdTypeImpl<Type_>::returnType(), name)
                     , Base()
    {}
    explicit Variable( int size, String const& name = stringNa)
                     : IVariable(IdTypeImpl<Type_>::returnType(), name)
                     , Base(size)
    {}
    explicit Variable( Range const& I, String const& name = stringNa)
                     : IVariable(IdTypeImpl<Type_>::returnType(), name)
                     , Base(I)
    {}
    Variable( Range const& I, Type_ const& v, String const& name)
            : IVariable(IdTypeImpl<Type_>::returnType(), name)
            , Base(I)
    { this->setValue(v);}
    explicit Variable( Variable const& V, bool ref = false)
                     : IVariable(V)
                     , Base(V, ref)
    {}
    explicit Variable( Variable const& V, Range const& I, bool ref = true)
                     : IVariable(V), Base(V, I, true)
    {}
    template<class OtherArray>
    Variable( IArray1D<OtherArray> const& T)
            : IVariable(IdTypeImpl<Type_>::returnType(), stringNa)
            , Base(T, T.range(), true)
    {}
    ~Variable() {}
    virtual Variable* clone( bool ref = false) const
    { return new Variable(*this, ref);}
    void shift1D(int rbeg) { Base::shift(rbeg, this->beginCols());}
    inline Variable<Type_>& resize1D(Range const& I)
    { Base::resize(I, this->cols()); return *this;}
 
    virtual void popBack(int n =1) { Base::popBack(n);}
    void pushBack( int n=1) { Base::pushBack(n);}
    void push_back( Type_ const& v)
    { Base::pushBack();
      this->back() = v;
    }
    void insertElt(int pos, int n =1)
    { Base::insertElt(pos, n);}
    inline Variable& operator=(Variable const& V)
    { // copy IVariable part
      this->name_ = V.name_;
      return Base::assign(V);
    }
    inline Variable& operator=(Type_ const& v) { this->setValue(v); return *this;}
 
    inline void move(Variable const& V)
    { Base::move(V);
      name_ = V.name_;
    }
    void encode()
    { int code = baseIdx;
      std::pair< typename std::map<Type_, int>::iterator, bool> ret;
      for (int i=this->begin(); i< this->end(); i++)
      { ret=coding_.insert(std::pair<Type_, int>(this->elt(i), i));
        if (ret.second==true) { code++;}
      }
    }
    int maxLength(bool with_name) const
    {
      typename String::size_type maxlength = with_name ? this->name().size() : 0;
      // loop over the values
      for (int i=this->begin(); i<this->end(); i++)
      { maxlength = std::max(maxlength, this->template eltAsString<Type_>(i).size() );}
      return int(maxlength);
    }
    int nbMiss() const;
 
    // IVariable part
    virtual int size() const { return Base::size();}
    virtual void clear() { Base::clear();}
    virtual void erase(int pos, int n=1) { Base::erase(pos,n);}
    virtual void shift(int beg) { Base::shift(beg);}
    virtual inline void pushBackNAValues(int n=1);
    virtual inline void exportAsString( Variable< String >& V) const;
    virtual inline Variable& operator<<( Variable< String > const& V);
    virtual inline Variable<Type_> const& operator>>(Variable< String >& V) const;
 
    inline int importFromString( Variable< String > const& V
                               , std::ios_base& (*f)(std::ios_base&) = std::dec
                               );
  protected:
    std::map<Type_, int> coding_;
};
 
template<class Type_>
int Variable<Type_>::nbMiss() const
{
  int nbMiss = 0;
  // loop over the values
  for (int i=this->begin(); i<this->end(); i++)
  { if (Arithmetic<Type_>::isNA(this->elt(i))) nbMiss++;}
  return nbMiss;
}
template<>
inline void Variable<String>::pushBackNAValues(int n)
{ int first = this->end(), end = first+n;
  this->insertElt(this->end(), n);
  for (int i=first; i<end; i++)
  this->elt(i) = stringNa;
}
template<class Type_>
inline void Variable<Type_>::pushBackNAValues(int n)
{
    int first = this->end(), end = first+n;
    this->insertElt(this->end(), n);
    for (int i=first; i<end; i++)
    this->elt(i) =  Arithmetic<Type_>::NA();
}
template<>
inline int Variable<String>::importFromString( Variable< String > const& V
                                             , std::ios_base& (*f)(std::ios_base&)
                                             )
{ *this = V; return V.size();}
template<class Type_>
inline int Variable<Type_>::importFromString( Variable< String > const& V
                                , std::ios_base& (*f)(std::ios_base&)
                                )
{
  this->resize(V.range());
  this->setName(V.name());
  int nSuccess = V.size();
  for (int i=V.begin(); i<V.end(); i++)
    if ( (Arithmetic<String>::isNA(V[i])) || (V[i]==stringNa) ) // not Available
      this->elt(i) = Arithmetic<Type_>::NA();
    else
    if (!stringToType<Type_>(this->elt(i), V[i], f)) nSuccess--;
  return nSuccess;
}
template<>
inline void Variable<String>::exportAsString( Variable< String >& V) const
{ V = *this;}
template<class Type_>
inline void Variable<Type_>::exportAsString( Variable< String >& V) const
{
  V.resize(this->range());
  V.setName(this->name());
  for (int i=this->begin(); i<=this->lastIdx(); i++)
  { V[i] = this->template eltAsString<Type_>(i);}
}
template<>
inline Variable<String>& Variable<String>::operator<<( Variable< String > const& V)
{
  this->resize(V.range());
  this->setName(V.name());
  for (int i=V.begin(); i<V.end(); i++) this->elt(i) = V[i];
  return *this;
}
template<class Type_>
inline Variable<Type_>& Variable<Type_>::operator<<( Variable< String > const& V)
{
  this->resize(V.range());
  this->setName(V.name());
  for (int i=V.begin(); i<V.end(); i++) this->elt(i) = stringToType<Type_>(V[i]);
  return *this;
}
template<>
inline Variable<String> const& Variable<String>::operator>>(Variable< String >& V) const
{
  V.resize(this->range());
  V.setName(this->name());
  for (int i=this->begin(); i<this->end(); i++) V[i] = this->elt(i);
  return *this;
}
template<class Type_>
inline Variable<Type_> const& Variable<Type_>::operator>>(Variable< String >& V) const
{
  V.resize(this->range());
  V.setName(this->name());
  for (int i=this->begin(); i<this->end(); i++) V[i] = typeToString<Type_>(this->elt(i));
  return *this;
}
template<typename Type_>
inline ostream& operator<<(ostream& s, Variable<Type_> const& V)
{
  s << V.name() << _T("\n");
  return out1D(s, V);
}
 
} // namespace STK
 
#endif //STK_VARIABLE_H