FactorType.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2013 Shell Hu 
 * Copyright (C) 2013 Shell Hu 
 */

#ifndef __FACTOR_TYPE_H__
#define __FACTOR_TYPE_H__

#include <shogun/base/SGObject.h>
#include <shogun/lib/SGVector.h>

namespace shogun
{

class CFactorType : public CSGObject
{
public:
    CFactorType();

    CFactorType(int32_t id, SGVector<int32_t> card, SGVector<float64_t> w);

    virtual ~CFactorType();

    virtual const char* get_name() const { return "FactorType"; }

    virtual int32_t get_type_id() const;

    virtual void set_type_id(int32_t id);

    virtual SGVector<float64_t> get_w();

    virtual const SGVector<float64_t> get_w() const;

    void set_w(SGVector<float64_t> w);

    virtual int32_t get_w_dim() const;

    virtual const SGVector<int32_t> get_cardinalities() const;

    virtual void set_cardinalities(SGVector<int32_t> cards);

    virtual int32_t get_num_vars();

    virtual int32_t get_num_assignments() const;

    virtual bool is_table() const { return false; }

protected:
    void init_card();

private:
    void init();

protected:
    int32_t m_type_id;

    SGVector<int32_t> m_cards;

    SGVector<int32_t> m_cumprod_cards;

    int32_t m_num_assignments;

    int32_t m_data_size;

    SGVector<float64_t> m_w;
};

class CTableFactorType : public CFactorType
{
public:
    CTableFactorType();

    CTableFactorType(int32_t id, SGVector<int32_t> card, SGVector<float64_t> w);

    virtual ~CTableFactorType();

    virtual const char* get_name() const { return "TableFactorType"; }

    virtual bool is_table() const { return true; }

    int32_t state_from_index(int32_t ei, int32_t var_index) const;

    SGVector<int32_t> assignment_from_index(int32_t ei) const;

    int32_t index_from_new_state(int32_t old_ei, int32_t var_index, int32_t var_state) const;

    int32_t index_from_assignment(const SGVector<int32_t> assig) const;

    int32_t index_from_universe_assignment(const SGVector<int32_t> assig,
        const SGVector<int32_t> var_index) const;

    virtual void compute_energies(const SGVector<float64_t> factor_data,
        SGVector<float64_t>& energies) const;

    virtual void compute_energies(const SGSparseVector<float64_t> factor_data_sparse,
        SGVector<float64_t>& energies) const;

    virtual void compute_gradients(const SGVector<float64_t> factor_data,
        const SGVector<float64_t> marginals,
        SGVector<float64_t>& parameter_gradient, double mult) const;

    virtual void compute_gradients(const SGSparseVector<float64_t> factor_data_sparse,
        const SGVector<float64_t> marginals,
        SGVector<float64_t>& parameter_gradient, double mult) const;

};

}

#endif