bayesnet.h

gibbs

#ifndef BAYESNET_H
#define BAYESNET_H

#include <expat.h>
#include <list>
#include <vector>
#include "VarSchema.h"
#include "DecisionTree.h"
#include "Range.h"

class BayesNet
{
    vector<list<int> > parents;
    vector<list<int> > children;
    vector<DecisionTree*> decisionTrees;
    int numVars;

public:
    BayesNet() : numVars(0) { /* NOP */ }

    ~BayesNet() {
        for (int i = 0; i < numVars; i++) {
            delete decisionTrees[i];
        }
    }

    // Construct a schema for caller
    VarSchema getSchema() const {
        VarSchema s(-1, numVars);
        for (int i = 0; i < numVars; i++) {
            s[i] = getRange(i);
        }
        return s;
    }

    int getNumVars() const { return numVars; }
    int getRange(int var) const { return decisionTrees[var]->getRange(); }

    void addVar(int numStates) {
        children.push_back(list<int>());
        parents.push_back(list<int>());
        decisionTrees.push_back(new DecisionTree(numVars, numStates));
        numVars++;
    }

    void addChild(int parent, int child) {

        // DEBUG
        if (parent >= numVars) {
            cout << "ERROR: parent index out of range (" << parent 
                << " >= " << numVars << ")\n";
            return;
        }

        // DEBUG
        if (child >= numVars) {
            cout << "ERROR: child index out of range (" << child 
                << " >= " << numVars << ")\n";
            return;
        }

        children[parent].push_back(child);
        parents[child].push_back(parent);
        decisionTrees[child]->addInput(parent);
    }

    DecisionTree* getDecisionTree(int var) {
        return decisionTrees[var];
    }

    const DecisionTree* getDecisionTree(int var) const {
        return decisionTrees[var];
    }

    void setDecisionTree(int var, DecisionTree* dtree) {
        // DEBUG
        //cout << "Setting decision tree for " << var << endl;
        delete decisionTrees[var];
        decisionTrees[var] = dtree;
    }

    double getProb(int var, double* allVars) const {
        // DEBUG
        double p = decisionTrees[var]->getProb(allVars[var], allVars);
        if (p == 0.0) {
            cout << "ERROR: getProb returning 0.0!\n";
        }
        return p;
    }

    double getLogProb(int var, double* allVars) const {
        double lp = decisionTrees[var]->getLogProb(allVars[var], allVars);
        return lp;
    }

    // Get standard deviation of continuous variable, given
    // values of its parents.
    double getSD(int var, double* allVars) const {
        const Leaf* l = decisionTrees[var]->getLeaf(allVars);
        const BinGaussian* bg = (const BinGaussian*)l;
        return bg->SD;
    }

    // Sample from the variable's parent
    double sample(int var, double* allVars) const {
        return decisionTrees[var]->sample(allVars);
    }

    // Sample from the variable's Markov blanket
    vector<double> MBdist(int var, VarSet& allVars) const;

    // Sample from the variable's Markov blanket
    double MBsample(int var, VarSet& allVars) const;

    // Generate a complete sample
    void wholeSample(VarSet& allvars) const; 

private:
    // Disable copy-constructor
    BayesNet(const BayesNet& other);

    friend class MarkovNet;
};


// Load a model from a file using C-style I/O.
#include <stdio.h>
void loadModel(FILE* in, BayesNet& model);

istream& operator>>(istream& in, BayesNet& model);
#endif // ndef BAYESNET_H