plLearn.h

/*=============================================================================
 * Product        : OpenPL 
 * File           : plLearn.h
 * Author         : Kamel Mekhnacha
 * Creation       : Mon Oct 27 14:56:09 2003
 *
 *=============================================================================
 *     (c) Copyright 2000, Centre National de la Recherche Scientifique,
 *                              all rights reserved
 *=============================================================================
 *
 *------------------------- Description ---------------------------------------
 *   
 *   
 *-----------------------------------------------------------------------------
 */

#ifndef __plLearn_h__
#define __plLearn_h__


#include <plDataValues.h>
#include <plValues.h>
#include <plVariablesConjunction.h>
#include <plKernelTable.h>
#include <plKernelMap.h>

class kplVariable;

class plLearnObject : public plObject
{
public:
  plLearnObject(const plVariablesConjunction &variables)
    :_nsamples(0),
     _total_weight(0.0),
     _all_vars(variables.get_variable_list()),
     _values(_all_vars){};
  
  plLearnObject()
    :_nsamples(0),_total_weight(0.0){};
    
  virtual ~plLearnObject(){};
  
  unsigned int get_nsamples() const {return _nsamples;}

  double get_total_weight() const {return _total_weight;}
  
  virtual void reset() = 0;
 
  virtual void internal_addPoint(const plDataValues &point, double weight = 1.0) = 0;
        
public:
  void addNewPoint(const plValues &point, double weight = 1.0)
  {
    internal_addPoint(point.to_data_values(_all_vars), weight);
  }
    
  template <class arrayT>
  void addNewPoint(arrayT* point, double weight = 1.0)
  {
    for(unsigned int i = 0; i < _values.size(); i++){
      _values[i] = point[i];
    }
    internal_addPoint(_values, weight);
  }
  
  template <class arrayT>
  void addNewPoint(const vector <arrayT> &point, double weight = 1.0)
  {
    for(unsigned int i = 0; i < _values.size(); i++){
      _values[i] = point[i];
    }
    internal_addPoint(_values, weight);
  }
  template <class singleT>
  void addNewPoint(singleT point, double weight = 1.0)
  {
    _values[0] = point;
    internal_addPoint(_values, weight);
  }
    
  const list <kplVariable*> &get_vars()const{return _all_vars;}
   
  void set_known_range(const vector <bool> known_range){ _known_range = known_range;}
  
  virtual plKernelMap get_kernel_map( const void *parameters = NULL )const {return plKernelMap();}
  
  //$$$$$$$$$$$$$$$$$$$$$
  virtual void internal_addPointWithDef(const plDataValues &point, const vector <bool> &left_defined, double weight = 1.0)
  {
    internal_addPointWithDef(point, left_defined, weight);
  }

  void addNewPointWithDef(const plValues &point, const vector <bool> &left_defined, double weight = 1.0)
  {
    internal_addPointWithDef(point.to_data_values(_all_vars), left_defined, weight);
  }
    
  template <class arrayT>
  void addNewPointWithDef(arrayT* point, const vector <bool> &left_defined, double weight = 1.0)
  {
    for(unsigned int i = 0; i < _values.size(); i++){
      _values[i] = point[i];
    }
    internal_addPointWithDef(_values, left_defined, weight);
  }
  
  template <class arrayT>
  void addNewPointWithDef(const vector <arrayT> &point, const vector <bool> &left_defined, double weight = 1.0)
  {
    for(unsigned int i = 0; i < _values.size(); i++){
      _values[i] = point[i];
    }
    internal_addPointWithDef(_values, left_defined, weight);
  }

    
protected:
  unsigned int _nsamples;
  double _total_weight;


  list <kplVariable*> _all_vars;
  vector <bool> _known_range;
  plDataValues _values;
};


class plNonCndLearnObject :public plLearnObject
{
public:
  plNonCndLearnObject()
    :plLearnObject(){}
  
  plNonCndLearnObject(const plVariablesConjunction &variables)
    :plLearnObject(variables),_left_vars(variables){}
                      

  virtual ~plNonCndLearnObject(){}
  
  virtual void get_params(plValues &params) const = 0;
  
  virtual plKernel get_distribution(const void *parameters = NULL ) const = 0;
  
protected:
   plVariablesConjunction _left_vars;
};


template <class T>
class plCndLearnObject :public plLearnObject
{
public:
  plCndLearnObject(const plVariablesConjunction &left_vars, const plVariablesConjunction &right_vars)
    :plLearnObject(left_vars^right_vars), 
     _left_value(left_vars.get_variable_list()), 
     _right_value(right_vars.get_variable_list()), 
     _left_vars(left_vars), _right_vars(right_vars), _initialized(false)
  {
  }
  
  plCndLearnObject(const plVariablesConjunction &left_vars, const plVariablesConjunction &right_vars, const T&init_object)
    :plLearnObject(left_vars^right_vars), 
     _left_value(left_vars.get_variable_list()), 
     _right_value(right_vars.get_variable_list()), 
     _left_vars(left_vars), _right_vars(right_vars), _initialized(true), _init_object(init_object)
  {
  }
  
  virtual ~plCndLearnObject(){}
    
  void reset()
  {
    _nsamples = 0;
    _total_weight = 0.0;
    _NCndLObjects_map.clear();
  }

  void internal_addPoint(const plDataValues &point, double weight = 1.0)
  {
    _nsamples++;
    _total_weight += weight;
    point.extract(_left_value, 0, _left_value.size());
    point.extract(_right_value, _left_value.size(), _right_value.size());
    typename map <plDataValues, T>::iterator mapIt = _NCndLObjects_map.find(_right_value);
    if(mapIt != _NCndLObjects_map.end() )
      (mapIt->second).internal_addPoint(_left_value, weight);
    else{
      if(_initialized){
        T nlo(_init_object);
        nlo.internal_addPoint(_left_value, weight);
        pair<plDataValues,T> p(_right_value, nlo);
        _NCndLObjects_map.insert(p);
      }
      else{
        T nlo(_left_vars);
        nlo.internal_addPoint(_left_value, weight);
        pair<plDataValues,T> p(_right_value, nlo);
        _NCndLObjects_map.insert(p);
      }
      
    }
    
  }
  
    //$$$$$$$$$$$$$$$$$$$$$
  void internal_addPointWithDef(const plDataValues &point, const vector <bool> &left_defined, double weight = 1.0)
  {
    _nsamples++;
    _total_weight += weight;
    point.extract(_left_value, 0, _left_value.size());
    point.extract(_right_value, _left_value.size(), _right_value.size());
    typename map <plDataValues, T>::iterator mapIt = _NCndLObjects_map.find(_right_value);
    if(mapIt != _NCndLObjects_map.end() )
      (mapIt->second).internal_addPointWithDef(_left_value, left_defined, weight);
    else{
      if(_initialized){
        T nlo(_init_object);
        nlo.internal_addPointWithDef(_left_value, left_defined, weight);
        pair<plDataValues,T> p(_right_value, nlo);
        _NCndLObjects_map.insert(p);
      }
      else{
        T nlo(_left_vars);
        nlo.internal_addPointWithDef(_left_value, left_defined, weight);
        pair<plDataValues,T> p(_right_value, nlo);
        _NCndLObjects_map.insert(p);
      }
      
    }
  }
  
  
  //$$$$$$$$$$$$$$$$$$$$$
  

public:
  const map <plDataValues, T> &get_map()const
  {
    return _NCndLObjects_map;
  }
    
  void get_params(plValues &params, const plValues &right_value)
  {
    typename map <plDataValues, T>::iterator mIt = 
      _NCndLObjects_map.find(right_value.to_data_values(_right_vars.get_variable_list()));
    
    if(mIt != _NCndLObjects_map.end())
      mIt->second.get_params(params);
    else
      plWarning(51);
  }

    plKernelMap get_kernel_map( const void *parameters = NULL )const
    {
        plKernelMap kenMap(_left_vars, _right_vars);
        plValues rightVals(_right_vars);
        
        typename map< plDataValues, T >::const_iterator mapIt;
        for(mapIt = _NCndLObjects_map.begin(); mapIt != _NCndLObjects_map.end(); ++mapIt)
        {
            rightVals.set_values_values(mapIt->first);
            kenMap.push(rightVals, mapIt->second.get_distribution( parameters ) );
        }
        return kenMap;
    }
    
    void get_total_weights(vector <double> &w)const
    {
        w.resize(_NCndLObjects_map.size());
        
        typename map< plDataValues, T >::const_iterator mapIt;

        unsigned int index;
        for(index = 0, mapIt = _NCndLObjects_map.begin(); mapIt != _NCndLObjects_map.end(); ++mapIt, ++index){
            w[index] = mapIt->second.get_total_weight();
        }

    }

  
protected:

  map <plDataValues, T> _NCndLObjects_map;
  plDataValues _left_value;
  plDataValues _right_value;
    
  plVariablesConjunction _left_vars;
  plVariablesConjunction _right_vars;
  
  bool _initialized;
  const T _init_object;
    
};


class plLearnDistribVector :public plLearnObject
{
public:
  plLearnDistribVector(const vector <plLearnObject*> &learn_objects,                          
               const plVariablesConjunction &vars,
               const vector <bool> &known_range);

  plLearnDistribVector(const vector <plLearnObject*> &learn_objects,
               const plVariablesConjunction &vars);
                          

  virtual ~plLearnDistribVector(){}
                    
  void reset();

  void internal_addPoint(const plDataValues &point, double weight = 1.0);

  
  template <class filterArrayT>
  void addFilterNewPoint(const plValues &point, filterArrayT filter, double weight = 1.0)
  {
    addFilterPoint(point.to_data_values(_all_vars), filter, weight);
  }
    
  template <class arrayT, class filterArrayT>
  void addFilterNewPoint(arrayT* point, filterArrayT filter, double weight = 1.0)
  {
    for(unsigned int i = 0; i < _values.size(); i++){
      _values[i] = point[i];
    }
    addFilterPoint(_values, filter, weight);
  }
     
  template <class arrayT, class filterArrayT>
  void addFilterNewPoint(const vector <arrayT> &point, filterArrayT filter, double weight = 1.0)
  {
    for(unsigned int i = 0; i < _values.size(); i++){
      _values[i] = point[i];
    }
    addFilterPoint(_values, filter, weight);
  }
    
  template <class singleT, class filterArrayT>
  void addFilterNewPoint(singleT point, filterArrayT filter, double weight = 1.0)
  {
    _values[0] = point;
    addFilterPoint(_values, filter, weight);
  }
  
  template <class filterArrayT>
  void addFilterPoint(const plDataValues &point,  filterArrayT distrib_to_update, double weight = 1.0)
  {
    unsigned int i, j;
    
    for( i = 0; i < _learn_objects.size(); i++){
      
    if(distrib_to_update[i]){
        for(j = 0; j < _point_to_children_points[i].size(); j++){
            _children_points[i][j] = point[  _point_to_children_points[i][j]];
        }
        _learn_objects[i]->internal_addPoint(_children_points[i], weight);
      }
    }
  }
  
     
protected:
  void Init(const vector <plLearnObject*> &learn_objects, const vector <bool> &known_range);
protected:
  vector <plLearnObject*> _learn_objects;
  vector <plDataValues> _children_points;
    
  vector < vector < unsigned int> > _point_to_children_points;
    
};


#endif

---