Cell_base_classes.h

Go to the documentation of this file.

/* $Id: Cell_base_classes.h 17119 2014-07-17 00:46:17Z cdawson $ */

#ifndef CELL_BASE_CLASSES_H_
#define CELL_BASE_CLASSES_H_

#include <semantics/Categorical_event.h>
#include <boost/shared_ptr.hpp>
#include <vector>

/* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */ 

namespace semantics
{
    class Cell;
    class Marginal_cell_base;
    class Context_cell_base;

class Cell
{
public:
    typedef boost::shared_ptr<Cell> Self_ptr;
    typedef std::vector<size_t> Step_sizes;
    static bool VERBOSE;
public:
    const size_t& count() const {return count_;}
    
    const size_t& table_count() const {return table_count_;}
    
    virtual const Categorical_event_base& key() const = 0;
    
    virtual void increment() {++count_;}

    virtual void decrement()
    {
        assert(count_ > 0);
        --count_;
    }

    virtual void increment_table_count() {++table_count_;}

    virtual void decrement_table_count()
    {
        assert(table_count_ > 0);
        --table_count_;
    }

protected:
    size_t count_;
    size_t table_count_;
    
    Cell() : count_(0), table_count_(0) {}

    virtual ~Cell() {}
};

/* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */ 

class Marginal_cell_base : public Cell
{
public:
    typedef boost::shared_ptr<Marginal_cell_base> Self_ptr;
    typedef boost::shared_ptr<Context_cell_base> Context_ptr;
    typedef std::map<size_t, size_t> Table_count_map;
protected:
    /*------------------------------------------------------------
     * CONSTRUCTORS/DESTRUCTOR
     *------------------------------------------------------------*/

    Marginal_cell_base()
        : Cell(),
          per_table_counts_()
    {}

public:

    /*------------------------------------------------------------
     * ACCCESSORS
     *------------------------------------------------------------*/
    
    virtual Self_ptr margin() const = 0;

    virtual Context_ptr context() const = 0;

    /*------------------------------------------------------------
     * MANIPULATORS
     *------------------------------------------------------------*/

    virtual void increment(const size_t& table_code) = 0;
    
    virtual void decrement(const size_t& table_code) = 0;
    
    virtual size_t sample_table_assignment() = 0;

    /*------------------------------------------------------------
     * COMPUTATION
     *------------------------------------------------------------*/

    virtual double smoothed_probability() = 0;

    virtual double backoff_probability() const = 0;

    virtual double predictive_probability() const = 0;
protected:
    Table_count_map per_table_counts_;
};

/* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */ 

class Context_cell_base : public Cell
{
public:
    /*------------------------------------------------------------
     * TYPEDEFS
     *------------------------------------------------------------*/
    typedef boost::shared_ptr<Context_cell_base> Self_ptr;

    /*------------------------------------------------------------
     * STATIC MEMBERS
     *------------------------------------------------------------*/

    static const double& a();
    static const double& b();
    
protected:
    
    /*------------------------------------------------------------
     * CONSTRUCTORS/DESTRUCTOR
     *------------------------------------------------------------*/
    
    Context_cell_base()
        : Cell(),
          alpha_(1.0),
          w_(0.5),
          s_(0.0),
          diversity_(0)
    {}

public:

    /*------------------------------------------------------------
     * ACCESSORS
     *------------------------------------------------------------*/
    
    int diversity() const {return diversity_;}

    double alpha() const {return alpha_;}

    /*------------------------------------------------------------
     * MANIPULATORS
     *------------------------------------------------------------*/

    virtual void increment_diversity() {++diversity_;}

    virtual void decrement_diversity() {--diversity_;}

    void resample_alpha();

    /*------------------------------------------------------------
     * COMPUTATION
     *------------------------------------------------------------*/

    double effective_tables() const {return alpha_ + table_count_;}

    double effective_observations() const {return alpha_ + count_;}
    
    double table_backoff_weight() const {return alpha_ / effective_tables();}

    double observation_backoff_weight() const
    {
        return alpha_ / effective_observations();
    }

private:
    double alpha_;
    double w_;
    double s_;
    size_t diversity_;
};

}; //namespace semantics


#endif