STK_ILinearReduct.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::AAModels
 * 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_ILINEAREDUCT_H
#define STK_ILINEAREDUCT_H
 
#include "STK_IReducer.h"
#include <Arrays/include/STK_Array2DVector.h>
 
namespace STK
{
template<class Array, class Weights>
class ILinearReduct: public IReducer<Array, Weights>
{
  public:
    typedef IReducer<Array, Weights> Base;
    using Base::p_data_;
    using Base::p_reduced_;
    ILinearReduct();
    ILinearReduct( Array const* p_data);
    ILinearReduct( Array const& data);
    ILinearReduct( ILinearReduct const& reducer);
    virtual ~ILinearReduct();
    inline VectorX const& criteriaValues() const { return idx_values_; }
    inline Array const& axis() const { return axis_; }
    virtual bool run();
    virtual bool run(Weights const& weights);
 
  protected:
    VectorX idx_values_;
    Array axis_;
 
  private:
    virtual void maximizeStep() =0;
    virtual void maximizeStep( Weights const& weights) =0;
    void projectionStep();
};
 
/*
 * Constructor.
 * @param data the input data set
 */
template<class Array, class Weights>
ILinearReduct<Array, Weights>::ILinearReduct(): Base() {}
 
/*
 * Constructor.
 * @param data the input data set
 */
template<class Array, class Weights>
ILinearReduct<Array, Weights>::ILinearReduct( Array const* p_data): Base(p_data) {}
/*
 * Constructor.
 * @param data the input data set
 */
template<class Array, class Weights>
ILinearReduct<Array, Weights>::ILinearReduct( Array const& data): Base(data) {}
/* copy Constructor.
 *  @param reducer the reducer to copy.
 **/
template<class Array, class Weights>
ILinearReduct<Array, Weights>::ILinearReduct( ILinearReduct const& reducer)
                                           : Base(reducer)
                                            , idx_values_(reducer.idx_values_)
                                            , axis_(reducer.axis_)
{}
/* Destructor */
template<class Array, class Weights>
ILinearReduct<Array, Weights>::~ILinearReduct() {}
 
/* Compute the Index.
 *  @param nbAxis number of Axis to compute
 */
template<class Array, class Weights>
bool ILinearReduct<Array, Weights>::run()
{
  if (!this->p_data_)
  { this->msg_error_ = STKERROR_NO_ARG(MultivariateArray::run(),data is not set);
    return false;
  }
  try
  {
    // maximize the Index and compute the axis
    maximizeStep();
    // project data
    projectionStep();
 
  } catch (Exception const& e)
  {
    this->msg_error_ = e.error();
    return false;
  }
  return true;
}
 
/*
 * Compute the weighted index.
 * @param weights the weights to used
 * @param nbAxis number of Axis to compute
 */
template<class Array, class Weights>
bool ILinearReduct<Array, Weights>::run( Weights const& weights)
{
  if (!this->p_data_)
  { this->msg_error_ = STKERROR_NO_ARG(MultivariateArray::run(),data is not set);
    return false;
  }
  try
  {
    // maximize the Index and compute the axis
    maximizeStep(weights);
    // project data
    projectionStep();
 
  } catch (Exception const& e)
  {
    this->msg_error_ = e.error();
    return false;
  }
  return true;
}
 
/* Compute the reduction of the data set on the Axis. */
template<class Array, class Weights>
void ILinearReduct<Array, Weights>::projectionStep()
{
  // check if p_reduced exists
  if (!p_reduced_) p_reduced_ = new Array;
  // compute matrix multiplication
  *p_reduced_ =   (*p_data_) * axis_;
}
 
 
} // namespace STK
 
#endif /* STK_ILINEARREDUCT_H */