predicates.h

Go to the documentation of this file.

#ifndef IRI_RULE_LEARNER_PREDICATESS_H
#define IRI_RULE_LEARNER_PREDICATESS_H 1

#include <iri_rule_learner/RuleLearnerConfig.h>
#include <fstream>
#include <symbols.h>

class Predicate : public Symbol
{
    public:
        bool positive_;
        
        Predicate(std::string name, std::vector<std::string> param_names, bool positive) :
            Symbol(name, param_names),
            positive_(positive)
        { }
        
        Predicate(Symbol symbol, bool positive) :
            Symbol(symbol),
            positive_(positive)
        { }
        
        bool satisfies(Predicate predicate)
        {
                // TODO param names?
            if ( (this->name_.compare(predicate.name_) == 0) && (this->positive_ == predicate.positive_))
                return true;
            else
                return false;
        }
        
        Predicate get_negated()
        {
            return Predicate(*this, !positive_);
        }
        
        friend bool operator==(Predicate &p1, Predicate &p2);
        friend std::ostream& operator<<(std::ostream &out, const Predicate& p);
};



typedef std::vector<Predicate> PredicateList;

class PredicateGroup
{
    public:
        PredicateList predicates_;
        
        PredicateGroup( ){ }
        PredicateGroup(PredicateList predicates);
        PredicateGroup(std::string predicates);
        
        bool is_satisfied(PredicateList predicates);
        
        int count_satisfied(PredicateList predicates);
        
        int number_parameters();
        
        void change_variable(std::string orig_var, std::string new_var);
        
        PredicateGroup get_predicates_with_vars(std::vector< std::string > variables) ;
        
        void add_positive_differences(PredicateGroup compared_group);
        PredicateGroup get_differences(const PredicateGroup compared_group);
        
        void remove_duplicated();
        void remove_variables_not_present(std::vector<std::string> variables);
        
        friend std::ostream& operator<<(std::ostream &out, const PredicateGroup& p);
};


class Outcome : public PredicateGroup
{
    public:
        float init_probability_;
        float current_probability_;
        uint num_executions_;
        bool noisy_;
        
        Outcome(float init_probability, bool noisy = false) :
            PredicateGroup(),
            init_probability_(init_probability),
            current_probability_(init_probability),
            num_executions_(0),
            noisy_(noisy)
        { }
        
        Outcome(PredicateList predicates, float init_probability) :
            PredicateGroup(predicates),
            init_probability_(init_probability),
            current_probability_(init_probability),
            num_executions_(0),
            noisy_(false)
        { }
        
        void add_execution() { num_executions_++; }
        
        // m-estimate formula
        void update_probability(uint total_executions, uint m) 
        {
            current_probability_ =  ((init_probability_ * m) + num_executions_)/(m + total_executions);
        }
        
        friend std::ostream& operator<<(std::ostream &out, const Outcome& o);
};

typedef std::vector<Outcome> OutcomeList; 



// get data from string
PredicateList get_predicates_from_string(std::string line);
Outcome get_outcome_from_string(std::string line);

#endif