StatsCollector.h

Go to the documentation of this file.

// -*- C++ -*-

// PLearn (A C++ Machine Learning Library)
// Copyright (C) 2001,2002 Pascal Vincent
//

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 
//  1. Redistributions of source code must retain the above copyright
//     notice, this list of conditions and the following disclaimer.
// 
//  2. Redistributions in binary form must reproduce the above copyright
//     notice, this list of conditions and the following disclaimer in the
//     documentation and/or other materials provided with the distribution.
// 
//  3. The name of the authors may not be used to endorse or promote
//     products derived from this software without specific prior written
//     permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
// NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// This file is part of the PLearn library. For more information on the PLearn
// library, go to the PLearn Web site at www.plearn.org
 
/* *******************************************************      
   * $Id: StatsCollector.h,v 1.29 2004/07/21 16:30:53 chrish42 Exp $
   * This file is part of the PLearn library.
   ******************************************************* */

#ifndef StatsCollector_INC
#define StatsCollector_INC

#include <plearn/base/general.h>
#include <plearn/base/Object.h>
#include "TMat.h"
#include <plearn/base/RealMapping.h>

namespace PLearn {
using namespace std;

class StatsCollectorCounts
{
public:
  double n; 
  double nbelow; 
  double sum; 
  double sumsquare; 
  int id; 
  
  StatsCollectorCounts(): 
    n(0), nbelow(0),
    sum(0.), sumsquare(0.),id(0) {}          
};

typedef pair<real,StatsCollectorCounts*> PairRealSCCType;


inline PStream& operator>>(PStream& in, StatsCollectorCounts& c)
{ in >> c.n >> c.nbelow >> c.sum >> c.sumsquare >> c.id; return in; }

inline PStream& operator<<(PStream& out, const StatsCollectorCounts& c)
{ out << c.n << c.nbelow << c.sum << c.sumsquare << c.id; return out; }

  class StatsCollector: public Object
  {
  public:
    typedef Object inherited;
    PLEARN_DECLARE_OBJECT(StatsCollector);
      
  public:

    typedef Object inherited;

    // ** Build options **

    int maxnvalues; 


    // ** Learnt options **

    double nmissing_;      
    double nnonmissing_;   
    double sum_;           
    double sumsquare_;     
    double sumweights_;    
    real min_;             
    real max_;             
    real first_;           
    real last_;            

    map<real,StatsCollectorCounts> counts; 
      
  private:
  // (Please implement in .cc)
  void build_();

  protected: 
    static void declareOptions(OptionList& ol);

  public:


    StatsCollector(int the_maxnvalues=0);
      
    real n() const { return nmissing_ + nnonmissing_; } 
    real nmissing() const { return nmissing_; }
    real nnonmissing() const { return nnonmissing_; }
    real sum() const { return real(sum_+nnonmissing_*first_); }
    //real sumsquare() const { return real(sumsquare_); }
    real sumsquare() const { return real(sumsquare_+2*first_*sum()-first_*first_*nnonmissing_); }
    real min() const { return min_; }
    real max() const { return max_; }
    real mean() const { return real(sum()/nnonmissing_); }
    //real variance() const { return real((sumsquare_ - square(sum_)/nnonmissing_)/(nnonmissing_-1)); }
    real variance() const { return real((sumsquare_ - square(sum_)/nnonmissing_)/(nnonmissing_-1)); }
    real stddev() const { return sqrt(variance()); }
    real stderror() const { return sqrt(variance()/nnonmissing()); }
    real first_obs() const { return first_; }
    real last_obs() const { return last_; }
    real sharperatio() const { return mean()/stddev(); }

    real getStat(const string& statname) const;

    virtual void build();

    void forget();

    void update(real val, real weight = 1.0);

    void finalize() {}

    map<real,StatsCollectorCounts> * getCounts(){return &counts;}
    int getMaxNValues(){return maxnvalues;}

    Mat cdf(bool normalized=true) const;

    void sortIds();

    RealMapping getBinMapping(double discrete_mincount,
                              double continuous_mincount,
                              real tolerance=.1,
                              TVec<double>* fcount=0) const;

    RealMapping getAllValuesMapping(TVec<double>* fcount=0) const;
    RealMapping getAllValuesMapping(TVec<bool>* to_be_included, TVec<double>* fcount=0, bool ignore_other = false, real tolerance = 0) const;

    virtual void oldwrite(ostream& out) const;
    virtual void oldread(istream& in);
    virtual void print(ostream& out) const;

  };

  DECLARE_OBJECT_PTR(StatsCollector);

  template <>
  inline void deepCopyField(StatsCollector& field, CopiesMap& copies)
  {
    field.makeDeepCopyFromShallowCopy(copies);
  }

TVec<RealMapping> computeRanges(TVec<StatsCollector> stats, int discrete_mincount, int continuous_mincount);

} // end of namespace PLearn

#endif

---