plLearn1dNormal.h

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

#ifndef __plLear1dNormal_h_
#define __plLear1dNormal_h_

#include <plLearn.h>
#include <plNormal.h>
#include <plBellShape.h>

#define PL_NORMAL_RANGE_PROPORTION 3.0

class plLearn1dNormal :public plNonCndLearnObject
{
public:
  
  plLearn1dNormal(const plVariablesConjunction &vars) 
    :plNonCndLearnObject(vars),
     _s(0.0), _s2(0.0),
     _init_mean(0.0), _init_std_dev(0.0), _init_weight(0.0)
  {};
    
  plLearn1dNormal(const plVariablesConjunction &vars, double init_mean,
                  double init_std_dev, double init_weight = 1.0)
    :plNonCndLearnObject(vars),_init_mean(init_mean), _init_std_dev(init_std_dev), _init_weight(init_weight)
  {
    _total_weight = _init_weight;
    _s = _init_weight*_init_mean;
    _s2 = _init_weight*(_init_mean*_init_mean + _init_std_dev*_init_std_dev);
  };
  
  plLearn1dNormal()
    :plNonCndLearnObject(),_s(0.0), _s2(0.0),
     _init_mean(0.0), _init_std_dev(0.0), _init_weight(0.0)
  {};
    
  virtual ~plLearn1dNormal(){};
    
  void reset()
  {
    _nsamples = 0;
    _total_weight = _init_weight;
    _s = _init_weight*_init_mean;
    _s2 = _init_weight*(_init_mean*_init_mean + _init_std_dev*_init_std_dev);
  }

  void internal_addPoint(const plDataValues &point, double weight)
  { 
    _nsamples++;
    _total_weight += weight;
    double x = double(point[0]);
    _s += weight*x;
    _s2 += (weight*x*x);
  }
  
  double get_mu()const 
  { 
    if( 0.0 != _total_weight ) return _s/_total_weight;
    return 0.0;
  }
  
  double get_var() const
  {
    if( 0.0 != _total_weight ) return _s2/_total_weight;
    return 0.0;
  }

  
  double get_sigma()const 
  { 
    if(0.0 == _total_weight) return 0.0;
         
    double mu = get_mu();
    double v = _s2/_total_weight - mu*mu;
        
    if(v <= 0.0) return 0.0;
        
    return sqrt(v);
  }
  
  void get_params(plValues &params) const
  {
    params[0] = get_mu();
    params[1] = get_sigma();
  }
  
  void get_actual_min_max(double &min, double &max) const
  {
    double mu = get_mu();
    double sigma = get_sigma();
    
    min = mu - PL_NORMAL_RANGE_PROPORTION*sigma;
    max = mu + PL_NORMAL_RANGE_PROPORTION*sigma;
  }
  
  plKernel get_distribution( const void *parameters = NULL ) const
  {
    return plNormal(_left_vars, get_mu(), get_sigma());
  }
  
    
protected:
  double _s;
  double _s2;
  
  
  double _init_mean;
  double _init_std_dev;
  double _init_weight;
};

class plLearnBellShape :public plLearn1dNormal
{
public:
  plLearnBellShape(const plVariablesConjunction &vars) 
    :plLearn1dNormal(vars)
  {}
        
  plLearnBellShape(const plVariablesConjunction &vars, double init_mean,
                   double init_std_dev, double init_weight = 1.0)
    :plLearn1dNormal(vars, init_mean, init_std_dev, init_weight)
  {}

  
  plLearnBellShape()
    :plLearn1dNormal()
  {}
  
  plKernel get_distribution( const void *parameters = NULL ) const
  {
    return plBellShape(_left_vars, get_mu(), get_sigma());
   }

};


#endif

---