STK_IReducer.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::Reduct
 * created on: 17 avr. 2010
 * Purpose:  Abstract class for the computation of the Index in the SLAAM.
 * Author:   iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 *
 **/
 
#ifndef STK_IREDUCER_H
#define STK_IREDUCER_H
 
#include <Sdk.h>
 
namespace STK
{
 
template<class Array, class Weights>
class IReducer: public IRunnerUnsupervised<Array, Weights>
{
  protected:
    typedef IRunnerUnsupervised<Array, Weights> Runner;
    IReducer();
    IReducer( Array const* p_data);
    IReducer( Array const& data);
    IReducer( IReducer const& reducer);
 
  public:
    virtual ~IReducer();
    inline int dim() const { return dim_;}
    inline Array* p_reduced() const { return p_reduced_; }
    inline void setDimension( const int& dim) { dim_ = dim;}
    inline void clear()
    { if (p_reduced_) { delete p_reduced_; p_reduced_ = 0;} }
 
  protected:
    int dim_;
    Array* p_reduced_;
};
 
/* Default constructor. */
template<class Array, class Weights>
IReducer<Array, Weights>::IReducer(): Runner(), dim_(0), p_reduced_(0) {}
 
/* Constructor with a pointer on the constant data set.
 *  @param p_data the data set to reduce.
 **/
template<class Array, class Weights>
IReducer<Array, Weights>::IReducer( Array const* p_data)
                                  : Runner(p_data), dim_(0), p_reduced_(0)
{}
/* Constructor with a constant reference on the data set.
 *  @param data the data set to reduce.
 * */
template<class Array, class Weights>
IReducer<Array, Weights>::IReducer( Array const& data)
                                  : Runner(data), dim_(0), p_reduced_(0)
{}
/* Copy constructor.
 *  @param data The data set to reduce.
 * */
template<class Array, class Weights>
IReducer<Array, Weights>::IReducer( IReducer const& reducer)
                                  : Runner(reducer), dim_(reducer.dim_), p_reduced_(0)
{
  if (reducer.p_reduced_)
  { p_reduced_ = reducer.p_reduced_->clone();}
}
 
/*
 * Destructor
 */
template<class Array, class Weights>
IReducer<Array, Weights>::~IReducer()
{ if (p_reduced_) delete p_reduced_;}
 
 
} // namespace STK
 
#endif /* STK_IREDUCER_H */