drwnSuffStats.h

/******************************************************************************
** DARWIN: A FRAMEWORK FOR MACHINE LEARNING RESEARCH AND DEVELOPMENT
** Distributed under the terms of the BSD license (see the LICENSE file)
** Copyright (c) 2007-2015, Stephen Gould
** All rights reserved.
**
******************************************************************************
** FILENAME:    drwnFeatureWhitener.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
**
*****************************************************************************/

#pragma once

#include <vector>
#include <limits>

#include "Eigen/Core"

#include "drwnBase.h"

using namespace std;
using namespace Eigen;

// drwnPairSuffStatsType -----------------------------------------------------

typedef enum _drwnPairSuffStatsType {
    DRWN_PSS_FULL,             
    DRWN_PSS_DIAG,             
    DRWN_PSS_NONE,             
} drwnPairSuffStatsType;

// drwnSuffStats class -------------------------------------------------------

class drwnSuffStats : public drwnStdObjIface {
 private:
    int _n;                   
    drwnPairSuffStatsType _pairStats; 

    double _count;            
    VectorXd _sum;            
    MatrixXd _sum2;           

 public:
    drwnSuffStats(int n = 1, drwnPairSuffStatsType pairStats = DRWN_PSS_FULL);
    drwnSuffStats(double count, VectorXd& sum, MatrixXd& sum2);
    drwnSuffStats(const drwnSuffStats& stats);
    ~drwnSuffStats();

    void clear();
    void clear(int n, drwnPairSuffStatsType pairStats = DRWN_PSS_FULL);
    void diagonalize();

    inline int size() const { return _n; }
    inline bool isDiagonal() const { return (_pairStats == DRWN_PSS_DIAG); }
    inline bool hasPairs() const { return (_pairStats != DRWN_PSS_NONE); }
    inline double count() const { return _count; }
    inline double sum(int i = 0) const { return _sum(i); }
    inline double sum2(int i = 0, int j = 0) const {
        switch (_pairStats) {
        case DRWN_PSS_FULL: return _sum2(i, j);
        case DRWN_PSS_DIAG: return (i == j) ? _sum2(i, 0) : 0.0;
        case DRWN_PSS_NONE: return 0.0;
        }
        return 0.0;
    }

    inline const VectorXd& firstMoments() const { return _sum; }
    inline MatrixXd secondMoments() const {
        switch (_pairStats) {
        case DRWN_PSS_FULL: return _sum2;
        case DRWN_PSS_DIAG: return _sum2.col(0).asDiagonal();
        case DRWN_PSS_NONE: return MatrixXd::Zero(_n, _n);
        }
        return _sum2;
    }

    // i/o
    const char *type() const { return "drwnSuffStats"; }
    drwnSuffStats *clone() const { return new drwnSuffStats(*this); }
    bool save(drwnXMLNode& xml) const;
    bool load(drwnXMLNode& xml);

    // modification
    void accumulate(const vector<double>& x);
    void accumulate(const vector<double>& x, double w);
    void accumulate(const vector<vector<double> >& x, double w = 1.0);
    void accumulate(const drwnSuffStats& stats, double w = 1.0);
    void subtract(const vector<double>& x);
    void subtract(const vector<double>& x, double w);
    void subtract(const vector<vector<double> >& x, double w = 1.0);
    void subtract(const drwnSuffStats& stats, double w = 1.0);

    // standard operators
    drwnSuffStats& operator=(const drwnSuffStats& stats);
};

// drwnCondSuffStats class --------------------------------------------------

class drwnCondSuffStats : public drwnStdObjIface {
 private:
    int _n;                 
    int _k;                 

    vector<drwnSuffStats> _stats;

 public:
    drwnCondSuffStats(int n = 1, int k = 2, drwnPairSuffStatsType pairStats = DRWN_PSS_FULL);
    drwnCondSuffStats(const drwnCondSuffStats& condStats);
    ~drwnCondSuffStats();

    void clear();
    void clear(int n, int k, drwnPairSuffStatsType pairStats = DRWN_PSS_FULL);

    inline int size() const { return _n; }
    inline int states() const { return _k; }
    inline double count() const;
    inline double count(int k) const { return _stats[k].count(); }

    inline drwnSuffStats const& suffStats(int k) const {
        return _stats[k];
    }

    // i/o
    const char *type() const { return "drwnCondSuffStats"; }
    drwnCondSuffStats *clone() const { return new drwnCondSuffStats(*this); }
    bool save(drwnXMLNode& xml) const;
    bool load(drwnXMLNode& xml);

    // modification
    inline void accumulate(const vector<double>& x, int y);
    inline void accumulate(const vector<double>& x, int y, double w);
    void accumulate(const vector<vector<double> >& x, int y, double w = 1.0);
    void accumulate(const vector<vector<double> >& x, const vector<int>& y);
    void accumulate(const vector<vector<double> >& x, const vector<int>& y, const vector<double>& w);
    void accumulate(const drwnSuffStats& stats, int y, double w = 1.0);
    inline void subtract(const vector<double>& x, int y);
    inline void subtract(const vector<double>& x, int y, double w);
    void subtract(const vector<vector<double> >& x, int y, double w = 1.0);
    void subtract(const vector<vector<double> >& x, const vector<int>& y);
    void subtract(const vector<vector<double> >& x, const vector<int>& y, const vector<double>& w);
    void subtract(const drwnSuffStats& stats, int y, double w = 1.0);
    void redistribute(int y, int k);

    // operators
    inline const drwnSuffStats& operator[](unsigned k) const { return _stats[k]; }
};

// inline functions ---------------------------------------------------------

inline double drwnCondSuffStats::count() const {
    double c = 0;
    for (int y = 0; y < _k; y++) {
        c += _stats[y].count();
    }

    return c;
}

inline void drwnCondSuffStats::accumulate(const vector<double>& x, int y) {
    DRWN_ASSERT_MSG((y >= 0) && (y < _k), y);
    _stats[y].accumulate(x);
}

inline void drwnCondSuffStats::accumulate(const vector<double>& x, int y, double w) {
    DRWN_ASSERT_MSG((y >= 0) && (y < _k), y);
    _stats[y].accumulate(x, w);
}

inline void drwnCondSuffStats::subtract(const vector<double>& x, int y) {
    DRWN_ASSERT_MSG((y >= 0) && (y < _k), y);
    _stats[y].subtract(x);
}

inline void drwnCondSuffStats::subtract(const vector<double>& x, int y, double w) {
    DRWN_ASSERT_MSG((y >= 0) && (y < _k), y);
    _stats[y].subtract(x, w);
}