Semantic_step_proposal.h

Go to the documentation of this file.

#ifndef SEMANTIC_STEP_PROPOSAL_H_
#define SEMANTIC_STEP_PROPOSAL_H_

#include "prob_cpp/prob_weight_array.h"
#include "semantics/Elaboration_tree.h"
#include "semantics/Syntactic_event.h"
#include "semantics/Semantic_step_event.h"
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/discrete_distribution.hpp>

namespace
{
    const double minimum = 0.001;
    const double mutability = 0.3;
}

namespace semantics
{
    class Semantic_step_proposal
    {
    public:
        typedef boost::shared_ptr<Semantic_step_proposal> Self_ptr;
        typedef Elaboration_tree::Elab_ptr                Elab_ptr;
        typedef Elaboration_tree::Elab_ptr_const          Elab_ptr_const;
        typedef Syntactic_event::Event_ptr                Syn_event_ptr;
        typedef Semantic_step_event::Event_ptr            Sem_event_ptr;
        typedef boost::tuple<Step_code_t, Elab_ptr_const, Sem_event_ptr, Syn_event_ptr>
        Proposal;
        typedef boost::array<Proposal, Step_code::NUM_STEPS> Proposal_array;
        typedef Elaboration_tree::Step_result             Step_result;
        typedef boost::random::discrete_distribution<>    Proposal_dist;
        static boost::mt19937 urng;
        static bool VERBOSE;
    public:
        Semantic_step_proposal();

        bool propose(
            const Elab_ptr_const semantic_parent,
            const Sem_event_ptr  sem_event,
            const Syn_event_ptr  syn_event,
            const Step_code_t&   curr_step,
            const bool&          tree_is_altered,
            const bool&          collins = false
            );

        static double evaluate_a_proposal(
            const Elab_ptr_const semantic_parent,
            const Sem_event_ptr  sem_event,
            const Syn_event_ptr  syn_event,
            const Step_code_t    step,
            const bool&          tree_is_altered,
            const bool&          collins = false
            );

        static const double& min_prob()
        {
            static double mp = minimum;
            return mp;
        }

        static const double& mutability_prob()
        {
            static double mp = mutability;
            return mp;
        }
        
        Proposal state(){return state_;}
        double prob(){return prob_;}
    private:
        void sample_a_proposal(
            const Proposal_array&  proposals,
            const Proposal_dist&   dist
            );
        
        Proposal state_; 
        double prob_;
    };
}

#endif