STK_Visitors.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::Arrays
 * created on: 27 sept. 2012
 * Author:   iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 **/
 
#ifndef STK_VISITORS_H
#define STK_VISITORS_H
 
 
namespace STK
{
 
namespace hidden
{
 
template <class Visitor, int Structure_> struct GetIdx;
template <class Visitor> struct GetIdx<Visitor, Arrays::vector_>
{ inline static int idx(Visitor const& visitor) { return visitor.row_;};};
 
template <class Visitor> struct GetIdx<Visitor, Arrays::point_>
{ inline static int idx(Visitor const& visitor) { return visitor.col_;};};
 
template <class Visitor> struct GetIdx<Visitor, Arrays::diagonal_>
{ inline static int idx(Visitor const& visitor) { return visitor.col_;};};
 
 
template <typename Type_>
struct EltVisitor2DBase
{
  typedef Type_ Type;
  typedef typename RemoveConst<Type>::Type const& TypeConst;
  inline EltVisitor2DBase() : row_(baseIdx), col_(baseIdx), res_(Arithmetic<Type>::NA()) {};
  int row_, col_;
  Type res_;
  inline TypeConst result() const { return res_;}
};
 
template <typename Type>
struct MinEltVisitor : EltVisitor2DBase<Type>
{
  inline MinEltVisitor() : EltVisitor2DBase<Type>()
  { this->res_ = Arithmetic<Type>::max(); }
  inline void operator()( Type const& value, int i, int j)
  {
    if (value < this->res_)
    { this->res_ = value; this->row_ = i; this->col_ = j;}
  }
};
 
template <typename Type>
struct MinEltSafeVisitor : EltVisitor2DBase<Type>
{
  inline MinEltSafeVisitor() : EltVisitor2DBase<Type>()
  { this->res_ = Arithmetic<Type>::max(); }
  inline void operator()( Type const& value, int i, int j)
  {
    if (Arithmetic<Type>::isFinite(value) && (value < this->res_))
    { this->res_ = value; this->row_ = i; this->col_ = j;}
  }
};
template <typename Type>
struct MaxEltVisitor : EltVisitor2DBase<Type>
{
  inline MaxEltVisitor(): EltVisitor2DBase<Type>()
  { this->res_ = -Arithmetic<Type>::max(); }
  inline void operator()( Type const& value, int i, int j)
  {
    if (value > this->res_)
    { this->res_ = value; this->row_ = i; this->col_ = j;}
  }
};
template <typename Type>
struct MaxEltSafeVisitor : EltVisitor2DBase<Type>
{
  inline MaxEltSafeVisitor(): EltVisitor2DBase<Type>()
  { this->res_ = -Arithmetic<Type>::max(); }
  inline void operator()( Type const& value, int i, int j)
  {
    if (Arithmetic<Type>::isFinite(value))
      if(value > this->res_)
      { this->res_ = value; this->row_ = i; this->col_ = j;}
  }
};
template <typename Type_>
struct MinVisitor
{
  typedef Type_ Type;
  typedef typename RemoveConst<Type>::Type const& TypeConst;
 
  Type res_;
  inline MinVisitor(): res_(Arithmetic<Type>::max()) {}
  inline void operator() ( Type const& value, int i, int j)
  { res_ = std::min(res_,value);}
  inline void operator() ( Type const& value, int i)
  { res_ = std::min(res_,value);}
  inline TypeConst result() const { return res_;}
};
template <typename Type_>
struct MinSafeVisitor
{
  typedef Type_ Type;
  typedef typename RemoveConst<Type>::Type const& TypeConst;
 
  Type res_;
  inline MinSafeVisitor(): res_(Arithmetic<Type>::max()) {}
  inline void operator() ( Type const& value, int i, int j)
  {  if (Arithmetic<Type>::isFinite(value)) { res_ = std::min(res_,value);} }
  inline void operator() ( Type const& value, int i)
  { if (Arithmetic<Type>::isFinite(value)) { res_ = std::min(res_,value);}}
  inline TypeConst result() const { return res_;}
};
template <typename Type_>
struct MaxVisitor
{
  typedef Type_ Type;
  typedef typename RemoveConst<Type>::Type const& TypeConst;
 
  Type res_;
  inline MaxVisitor(): res_(-Arithmetic<Type>::max()) {}
  inline void operator() ( Type const& value, int i, int j)
  { res_ = std::max(res_,value);}
  inline void operator() ( Type const& value, int i)
  { res_ = std::max(res_,value);}
  inline TypeConst result() const { return res_;}
};
template <typename Type_>
struct MaxSafeVisitor
{
  typedef Type_ Type;
  typedef typename RemoveConst<Type>::Type const& TypeConst;
 
  Type res_;
  inline MaxSafeVisitor(): res_(-Arithmetic<Type>::max()) {}
  inline void operator() ( Type const& value, int i, int j)
  { if (Arithmetic<Type>::isFinite(value)) { res_ = std::max(res_,value);}}
  inline void operator() ( Type const& value, int i)
  { if (Arithmetic<Type>::isFinite(value)) { res_ = std::max(res_,value);}}
  inline TypeConst result() const { return res_;}
};
template <typename Type_>
struct SumVisitor
{
  typedef Type_ Type;
  typedef typename RemoveConst<Type>::Type const& TypeConst;
 
  Type res_;
  inline SumVisitor(): res_(Type(0)) {}
  inline void operator() ( Type const& value, int i, int j)
  { res_ += value;}
  inline void operator() ( Type const& value, int i)
  { res_ += value;}
  inline TypeConst result() const { return res_;}
};
template <typename Type_>
struct MeanVisitor
{
  typedef Type_ Type;
  typedef typename RemoveConst<Type>::Type TypeConst;
  Type res_;
  int nb_;
  inline MeanVisitor(): res_(Type(0)), nb_(0) {}
  inline void operator() ( Type const& value, int i, int j)
  { res_ += value; nb_++;}
  inline void operator() ( Type const& value, int i)
  { res_ += value; nb_++;}
  inline TypeConst result() const { return nb_ == 0  ? Arithmetic<Type>::NA() : res_/nb_;}
};
template <typename Type_>
struct MeanSafeVisitor
{
  typedef Type_ Type;
  typedef typename RemoveConst<Type>::Type TypeConst;
  Type res_;
  int nb_;
  inline MeanSafeVisitor(): res_(Type(0)), nb_(0) {}
  inline void operator() ( Type const& value, int i, int j)
  {
    if (Arithmetic<Type>::isFinite(value))
    {  res_ += value; nb_++;}
  }
  inline void operator() ( Type const& value, int i)
  {
    if (Arithmetic<Type>::isFinite(value))
    {  res_ += value; nb_++;}
  }
  inline TypeConst result() const { return nb_ == 0  ? Arithmetic<Type>::NA() : res_/nb_;}
};
template <typename Type_>
struct CountVisitor
{
  int res_;
  typedef int Type;
  typedef int const& TypeConst;
  CountVisitor(): res_(0) {}
  inline void operator() ( Type_ const& value, int i, int j)
  { if (value) ++res_;}
  inline void operator() ( Type_ const& value, int i)
  { if (value) ++res_;}
  inline TypeConst result() const { return res_;}
};
 
template <typename Type_>
struct AllVisitor
{
  bool res_;
  typedef bool Type;
  typedef bool const& TypeConst;
  inline AllVisitor(): res_(true) {}
  inline void operator() ( Type_ const& value, int i, int j)
  { res_ &= (value);}
  inline void operator() ( Type_ const& value, int i)
  { res_ &= (value);}
  inline TypeConst result() const { return res_;}
};
template <typename Type_>
struct AnyVisitor
{
  bool res_;
  typedef bool Type;
  typedef bool const& TypeConst;
  inline AnyVisitor(): res_(false) {}
  inline void operator() ( Type_ const& value, int i, int j) { res_ |= (value);}
  inline void operator() ( Type_ const& value, int i) { res_ |= (value);}
  inline TypeConst result() const { return res_;}
};
 
} //namespace hidden
 
} // namespace STK
 
#endif /* STK_VISITORS_H */