drwnTableFactor.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:    drwnTableFactor.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
**
*****************************************************************************/

#pragma once

#include <cstdlib>
#include <cassert>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <vector>
#include <map>
#include <list>

#include "Eigen/Core"

#include "drwnBase.h"
#include "drwnIO.h"
#include "drwnVarUniverse.h"
#include "drwnVarAssignment.h"

using namespace std;
using namespace Eigen;

// drwnFactor --------------------------------------------------------------

class drwnFactor : public drwnStdObjIface {
 public:
#ifdef DRWN_FACTOR_DEBUG_STATISTICS
    static unsigned _dbStatsRefCount;
    static unsigned _dbStatsProductCount;
    static unsigned _dbStatsDivideCount;
    static unsigned _dbStatsAdditionCount;
    static unsigned _dbStatsSubtractionCount;
    static unsigned _dbStatsMarginalCount;
    static unsigned _dbStatsMaxMinCount;
    static unsigned _dbStatsReductionCount;
    static unsigned _dbStatsNormalizeCount;
    static unsigned _dbStatsNormalizeErrors;
    static unsigned _dbStatsLargestFactorSize;
    static unsigned _dbStatsCurrentMem;
    static unsigned _dbStatsMaxMem;
    static unsigned _dbStatsMaxTable;
    static unsigned _dbStatsTotalMem;
#endif

 protected:
    drwnVarUniversePtr _pUniverse;  
    vector<int> _variables;         
    map<int, int> _varIndex;        

 public:
    drwnFactor(const drwnVarUniversePtr& ptr);
    drwnFactor(const drwnFactor& psi);
    virtual ~drwnFactor();

    // access functions
    virtual drwnFactor *clone() const = 0;

    bool empty() const { return _variables.empty(); }
    size_t size() const { return _variables.size(); }
    virtual size_t memory() const { return 0; }

    const drwnVarUniversePtr& getUniverse() const { return _pUniverse; }
    drwnVarUniverse getSubUniverse() const;
    bool hasVariable(int var) const { return (_varIndex.find(var) != _varIndex.end()); }
    int varId(int indx) const { return _variables[indx]; }
    int varCard(int indx) const { return _pUniverse->varCardinality(_variables[indx]); }

    virtual void addVariable(int var);
    void addVariable(const char *name);
    void addVariables(const char *name, ...);
    void addVariables(const vector<int>& c);
    void addVariables(const drwnClique& c);
    void addVariables(const drwnFactor& psi);

    const vector<int>& getOrderedVars() const { return _variables; }
    drwnClique getClique() const { return drwnClique(_variables.begin(), _variables.end()); }

    // i/o
    bool save(drwnXMLNode& xml) const;
    bool load(drwnXMLNode& xml);

    virtual double getValueOf(const drwnFullAssignment& y) const = 0;
    double getValueOf(const drwnPartialAssignment& y) const {
        return getValueOf((drwnFullAssignment)y);
    }
    virtual void setValueOf(const drwnFullAssignment& y, double val) = 0;
    void setValueOf(const drwnPartialAssignment& y, double val) {
        setValueOf(drwnFullAssignment(y), val);
    }

 protected:
#ifdef DRWN_FACTOR_DEBUG_STATISTICS
    static void updateMemoryStats(int nSize, int previousSize = 0);
#endif
};

// drwnTableFactor --------------------------------------------------------

class drwnTableFactorStorage;


class drwnTableFactor : public drwnFactor {
 protected:
    friend class drwnTableFactorStorage;

    std::vector<int> _stride;           

    int _nSize;                         
    double *_data;                      
    drwnTableFactorStorage *_storage;   

 public:
    drwnTableFactor(const drwnVarUniversePtr& ptr, drwnTableFactorStorage *storage = NULL);
    drwnTableFactor(const drwnTableFactor& psi);
    virtual ~drwnTableFactor();

    // access functions
    const char *type() const { return "drwnTableFactor"; }
    drwnTableFactor *clone() const { return new drwnTableFactor(*this); }

    size_t memory() const { return _nSize * sizeof(double); }
    size_t entries() const { return _nSize; }
    bool isShared() const { return (_storage != NULL); }

    // add variables
    using drwnFactor::addVariable;
    void addVariable(int var);

    int indexOf(int var, int val, int indx = 0) const;
    int indexOf(const drwnFullAssignment& assignment) const;
    int indexOf(const drwnPartialAssignment& assignment) const;
    int valueOf(int var, int indx) const;
    void assignmentOf(int indx, drwnPartialAssignment& assignment) const;
    void assignmentOf(int indx, drwnFullAssignment& assignment) const;

    int indexOfMin() const;
    int indexOfMax() const;
    pair<int, int> indexOfMinAndMax() const;

    // inline modifications
    virtual drwnTableFactor& initialize();
    drwnTableFactor& fill(double alpha);
    drwnTableFactor& copy(const double *data);
    drwnTableFactor& scale(double alpha);
    drwnTableFactor& offset(double alpha);
    virtual drwnTableFactor& normalize();

    // i/o
    bool save(drwnXMLNode& xml) const;
    bool load(drwnXMLNode& xml);

    double getValueOf(const drwnFullAssignment& y) const {
        return _data[indexOf(y)];
    }

    void setValueOf(const drwnFullAssignment& y, double val) {
        _data[indexOf(y)] = val;
    }

    // epsilon-tolerant data comparison
    bool dataCompare(const drwnTableFactor& psi) const;
    bool dataCompareAndCopy(const drwnTableFactor& psi);

    // operators
    inline double& operator[](unsigned index) { return _data[index]; }
    inline const double& operator[](unsigned index) const { return _data[index]; }

    drwnTableFactor& operator=(const drwnTableFactor& psi);
};

// drwnTableFactorStorage class -------------------------------------------

class drwnTableFactorStorage {
    friend class drwnTableFactor;

 protected:
    int _dataSize;                   
    double *_data;                   

    set<drwnTableFactor *> _tables;  

 public:
    drwnTableFactorStorage(int nSize = 0);
    ~drwnTableFactorStorage();

    inline int capacity() const { return _dataSize; }
    void reserve(int nSize);

    inline void zero(int nSize = -1) { fill(0.0, nSize); }
    void fill(double v, int nSize = -1);
    void copy(const double *p, int nSize = -1);
    void copy(const drwnTableFactorStorage *p, int nSize = -1);

    // data access
    inline double& operator[](unsigned index) { return _data[index]; }
    inline const double& operator[](unsigned index) const { return _data[index]; }

 protected:
    void registerFactor(drwnTableFactor *factor);
    void unregisterFactor(drwnTableFactor *factor);
};