perkun.h

/***************************************************************************
 *   Copyright (C) 2014 by Pawel Biernacki                                 *
 *   pawel.f.biernacki@gmail.com                                           *
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef PERKUN_H
#define PERKUN_H

#include <list>
#include <map>
#include <vector>
#include <string>
#include <iostream>
#include <stdexcept>


namespace perkun
{
    
class value
{
private:
    const std::string name;
public:
    value(const std::string & n): name(n) {}

    const std::string & get_name() const { return name; }
};


class variable
{
private:
    const std::string name;
    
protected:
    std::list<const value*> list_of_possible_values;
    
public:
    variable(const std::string & n): name(n) {}
    virtual bool get_is_input_variable() const { return false; }
    virtual bool get_is_hidden_variable() const { return false; }
    virtual bool get_is_output_variable() const { return false; }
    virtual const std::string get_type_name() const = 0;
    
    const std::string & get_name() const { return name; }
    
    void add_possible_value(const value * v) 
    { 
        list_of_possible_values.push_back(v); 
    }
    const std::list<const value*> & get_list_of_possible_values() const { return list_of_possible_values; }
    
    bool get_can_have_value(const value * v) const;
    
    virtual void report_xml(std::ostream & s) const = 0;
};


class collection_of_values
{
private:
    std::vector<value*> vector_of_values;
public:
    collection_of_values& operator<<(value * v) { vector_of_values.push_back(v); return *this; }
    ~collection_of_values();
    
    std::vector<value*>& get_vector_of_values() { return vector_of_values; }
    
    value* get_value(const char * v);
};

class input_variable: public variable
{
public:
    input_variable(const std::string & n): variable(n) {}
    virtual bool get_is_input_variable() const { return true; }
    virtual const std::string get_type_name() const { return "input"; }
    virtual void report_xml(std::ostream & s) const
    {
        s << "<perkun:input_variable name=\"" << get_name() << "\">\n";
        s << "<perkun:possible_values>\n";
        for (std::list<const value*>::const_iterator i(list_of_possible_values.begin());
             i != list_of_possible_values.end(); i++)
             {
                 s << "<perkun:value name=\"" << (*i)->get_name() << "\" />\n";
             }
        s << "</perkun:possible_values>\n";
        s << "</perkun:input_variable>\n";
    }
};

class output_variable: public variable
{
public:
    output_variable(const std::string & n): variable(n) {}  
    virtual bool get_is_output_variable() const { return true; }
    virtual const std::string get_type_name() const { return "output"; }
    virtual void report_xml(std::ostream & s) const
    {
        s << "<perkun:output_variable name=\"" << get_name() << "\">\n";
        s << "<perkun:possible_values>\n";
        for (std::list<const value*>::const_iterator i(list_of_possible_values.begin());
             i != list_of_possible_values.end(); i++)
             {
                 s << "<perkun:value name=\"" << (*i)->get_name() << "\" />\n";
             }
        s << "</perkun:possible_values>\n";
        s << "</perkun:output_variable>\n";
    }
};

class hidden_variable: public variable
{
public:
    hidden_variable(const std::string & n): variable(n) {}
    virtual bool get_is_hidden_variable() const { return true; }
    virtual const std::string get_type_name() const { return "hidden"; }
    virtual void report_xml(std::ostream & s) const
    {
        s << "<perkun:hidden_variable name=\"" << get_name() << "\">\n";
        s << "<perkun:possible_values>\n";
        for (std::list<const value*>::const_iterator i(list_of_possible_values.begin());
             i != list_of_possible_values.end(); i++)
             {
                 s << "<perkun:value name=\"" << (*i)->get_name() << "\" />\n";
             }
        s << "</perkun:possible_values>\n";
        s << "</perkun:hidden_variable>\n";
    }
};

class collection_of_variables
{
private:
    std::vector<variable*> vector_of_variables;
public:
    ~collection_of_variables();
    collection_of_variables& operator<<(variable* v) { vector_of_variables.push_back(v); return *this; }
    std::vector<variable*> & get_vector_of_variables() { return vector_of_variables; }
    
    variable * get_variable(const char * v);
};

class action
{
private:
    collection_of_variables & my_variables;
    collection_of_values & my_values;
    
    std::map<variable*, value*> map_output_variable_to_value;
    
public:
    action(collection_of_variables & v, collection_of_values & w):
        my_variables(v),
        my_values(w)
        {
        }
        
    const value * get_output_variable_value(variable * v) const { return map_output_variable_to_value.at(v); }
        
    void insert(variable * v, value * w) { map_output_variable_to_value.insert(std::pair<variable*,value*>(v, w)); }

    void report(std::ostream & s) const;
    
    void report_xml(std::ostream & s) const;
    
    bool get_match(const std::map<variable*, value*> & m) const;
    
    const std::map<variable*, value*>& get_map_output_variable_to_value() const
        { return map_output_variable_to_value; }
};

class visible_state;

class collection_of_actions
{
private:
    collection_of_variables & my_variables;
    collection_of_values & my_values;
    
    std::list<action*> list_of_actions;
    
    bool get_allowed(const std::map<variable*, std::vector<value*>::const_iterator> & m) const;

public:
    collection_of_actions(collection_of_variables & v, collection_of_values & w):
        my_variables(v), my_values(w) {}
        
    ~collection_of_actions();
        
    void populate();
    
    const std::list<action*> & get_list_of_actions() const { return list_of_actions; }
    
    std::list<action*> & get_list_of_actions() { return list_of_actions; }
    
    action * get(const std::map<variable*, value*> & m);

};

class state
{
private:
    collection_of_variables & my_variables;
    collection_of_values & my_values;
    visible_state & my_visible_state;
    collection_of_actions & my_actions;

    std::map<variable*, value*> map_hidden_variable_to_value;
    
    std::map<const action*, std::map<state*,float> > map_action_to_probability_distribution;
    
    bool impossible;
    
public:
    state(collection_of_variables & v, collection_of_values & w, visible_state & vs, collection_of_actions & a):
        my_variables(v),
        my_values(w),
        my_visible_state(vs),
        my_actions(a),
        impossible(false)
        {
        }
        
    const value * get_hidden_variable_value(variable * v) const
    {
        return map_hidden_variable_to_value.at(v);
    }
        
    void insert(variable * v, value * w) { map_hidden_variable_to_value.insert(std::pair<variable*,value*>(v, w)); }
    
    void report(std::ostream & s) const;
    
    void report_xml(std::ostream & s, bool with_model = true) const;
    
    bool get_match(const std::map<variable*, value*> & m) const;
    
    void set_model(action * a, std::map<state*,float> & m)
    {
        map_action_to_probability_distribution.insert(std::pair<const action*,std::map<state*,float> >(a, m));
    }
    
    const visible_state & get_visible_state() const { return my_visible_state; }
    
    const std::map<const action*, std::map<state*,float> > & get_map_action_to_probability_distribution() const
    { return map_action_to_probability_distribution; }
    
    std::map<const action*, std::map<state*,float> > & get_map_action_to_probability_distribution()
    { return map_action_to_probability_distribution; }
    
    void make_random_model();
    
    int get_model_size() const;
    
    void test_model() const;
    
    void set_impossible()
    {
        impossible = true;
    }
    
    bool get_possible() const { return !impossible; }
};

class collection_of_visible_states;

class visible_state
{
private:
    collection_of_variables & my_variables;
    collection_of_values & my_values;
    collection_of_actions & my_actions;
    collection_of_visible_states & my_visible_states;
    
    std::list<state*> list_of_states; // owned
    std::map<variable*,value*> map_input_variable_to_value;
    
    std::list<action*> list_of_illegal_actions; // not owned
    
    bool get_allowed(const std::map<variable*, std::vector<value*>::const_iterator> & m) const;
    
public:
    visible_state(collection_of_variables & v, collection_of_values & w, collection_of_actions & a, collection_of_visible_states & q): 
        my_variables(v),
        my_values(w),
        my_actions(a),
        my_visible_states(q)
        {
        }
        
    void insert(variable * v, value * w) { map_input_variable_to_value.insert(std::pair<variable*,value*>(v, w)); } 
        
    void populate();
    
    void report(std::ostream & s) const;
    
    void report_xml(std::ostream & s, bool with_states = true) const;
    
    bool get_match(const std::map<variable*, value*> & m) const;
    
    state * get(const std::map<variable*, value*> & m);

    const state * get(const std::map<variable*, value*> & m) const;
    
    const value* get_input_variable_value(variable* v) const { return map_input_variable_to_value.at(v); }
    
    const std::list<state*> & get_list_of_states() const { return list_of_states; }
    
    std::list<state*> & get_list_of_states() { return list_of_states; }
    
    float get_payoff() const;
    
    const collection_of_visible_states & get_visible_states() const { return my_visible_states; }

    collection_of_visible_states & get_visible_states() { return my_visible_states; }
    
    void make_random_model();
    
    int get_amount_of_states() const { return list_of_states.size(); }
    
    int get_model_size() const;
    
    void test_model() const;
    
    int get_amount_of_possible_states() const;
    
    void set_illegal(action * a) { list_of_illegal_actions.push_back(a); }
    
    bool get_is_illegal(action * a) const;
};

class query: public std::map<variable*, value*>
{
private:
    collection_of_variables & my_variables;
public:
    query(collection_of_variables & v, const std::map<variable*,value*> & m): 
        my_variables(v), std::map<variable*, value*>(m) {}
    void report(std::ostream & s) const;
    
    // take only the input variables and ignore the others
    void make_input_query();
    
    // take only the hidden variables and ignore the others
    void make_hidden_query();
    
    void check_contains_all_input_variables() const;
    
    void check_contains_only_input_variables() const;
    
    void check_contains_all_hidden_variables() const;
    
    void check_contains_only_input_or_hidden_variables() const;
    
    void check_contains_all_output_variables() const;
    
    void check_contains_only_output_variables() const;
};

class collection_of_visible_states
{
private:
    collection_of_variables & my_variables;
    collection_of_values & my_values;
    collection_of_actions & my_actions;
    
    std::list<visible_state*> list_of_visible_states;
    
    std::map<const visible_state*,float> map_visible_state_to_payoff_value;
    
    bool get_allowed(const std::map<variable*, std::vector<value*>::const_iterator> & m) const;
    
public:
    collection_of_visible_states(collection_of_variables & v, collection_of_values & w, collection_of_actions & a);
    ~collection_of_visible_states();
    
    void populate();
    
    const visible_state * get(const std::map<variable*, value*> & m) const;

    visible_state * get(const std::map<variable*, value*> & m); 
    
    float get_payoff(const visible_state * s)
    {
        return map_visible_state_to_payoff_value.at(s);
    }
    
    void set_payoff(const visible_state *s, float p) 
    { 
        if (map_visible_state_to_payoff_value.find(s) == map_visible_state_to_payoff_value.end())
            map_visible_state_to_payoff_value.insert(std::pair<const visible_state *,float>(s, p)); 
        else
            map_visible_state_to_payoff_value[s] = p;
    }
    
    void set_payoff(const std::map<variable*, value*> & m, float p)
    {
        const visible_state * s = get(m);
        if (s == NULL)
        {
            throw std::runtime_error("query failed");
        }
        set_payoff(s, p);
        //std::cout << "SET PAYOFF " << p << "\n";
    }
    
    void report(std::ostream & s) const;
    
    void report_xml(std::ostream & s) const;
    
    const std::list<visible_state*> & get_list_of_visible_states() const { return list_of_visible_states; }
    
    std::list<visible_state*> & get_list_of_visible_states() { return list_of_visible_states; }
    
    void make_random_model();
    
    void make_random_payoff();
    
    int get_amount_of_states() const;
    
    void test_model() const;
};

class belief
{
private:
    visible_state & my_visible_state;
    std::map<state *, float> map_state_to_probability;
public:
    belief(visible_state & v): my_visible_state(v) {}
    float get_probability(state * s) const;
    
    void set_probability(state * s, float p) { map_state_to_probability.insert(std::pair<state*,float>(s, p)); }
    
    void set_probability(const std::map<variable*, value*> & query, float p) 
    {
        state * s = my_visible_state.get(query);
        if (s == NULL)
        {
            throw std::runtime_error("query failed");
        }
        set_probability(s, p);
    }
    
    void report(std::ostream & s) const;
    
    void report_xml(std::ostream & s) const;
    
    void make_uniform();
    
    const visible_state & get_visible_state() const { return my_visible_state; }
};

class tracker
{
private:
    std::list<tracker*> & my_stack;
protected:
    const std::string my_function_name;
    
    int my_line_number;
public:
    tracker(std::list<tracker*> & stack, std::string f, int line);
    
    ~tracker();
    
    const std::string & get_function_name() const;
    
    int get_line_number() const;
    
    virtual void report(std::ostream & s) const;
    
    virtual void report_xml(std::ostream & s) const;
};

class dump_controller
{
protected:
    enum target_type { COUT = 0x1, CERR = 0x2, SINGLE_FILE = 0x4, ITERATED_FILES = 0x8 };
    
    enum dump_stack_mode_type { dump_stack_as_XML, dump_stack_as_text };
    
    enum dump_belief_mode_type { dump_belief_as_XML, dump_belief_as_text };
    
    enum dump_iteration_report_mode_type { dump_iteration_report_as_XML, dump_iteration_report_as_text };
    
    dump_stack_mode_type dump_stack_mode;
    
    dump_belief_mode_type dump_belief_mode;
    
    dump_iteration_report_mode_type dump_iteration_report_mode;
    
    target_type dump_stack_target, dump_belief_target, dump_iteration_report_target;
    
protected:
    int min_report_depth, max_report_depth;
    
    int stack_file_counter, belief_file_counter, iteration_report_file_counter;
    
    virtual void dump_stack(std::ostream & s) const = 0;
    virtual void dump_stack_XML(std::ostream & s) const = 0;
    
    virtual void dump_iteration_report(std::ostream & s) const = 0;
    virtual void dump_iteration_report_XML(std::ostream & s) const = 0;
    
    virtual void dump_belief(std::ostream & s) const = 0;
    virtual void dump_belief_XML(std::ostream & s) const = 0;
    
    virtual std::string get_stack_file_prefix() const;
    virtual std::string get_iteration_report_file_prefix() const;
    virtual std::string get_belief_file_prefix() const;
    
protected:
    void dump_stack_to_target_stream();
    void dump_belief_to_target_stream();
    void dump_iteration_report_to_target_stream();
    
public:
    void set_min_report_depth(int d) { min_report_depth = d; }
    void set_max_report_depth(int d) { max_report_depth = d; }
    
    dump_controller();
};



class class_with_tracking: public dump_controller
{
protected:
    std::list<tracker*> stack_of_trackers;
    
    enum decision { BREAK, CONTINUE, NONE };
    
    virtual decision make_decision(const std::list<tracker*> & s);
    
public:
    virtual void dump_stack(std::ostream & s) const;
    virtual void dump_stack_XML(std::ostream & s) const;
    
    virtual void dump_iteration_report(std::ostream & s) const;
    virtual void dump_iteration_report_XML(std::ostream & s) const;
};

class tracker_for_optimizer: public tracker
{
protected:
    float & my_max;
    action *& my_argmax;
    std::list<action*>::const_iterator & my_iterator;
    int my_level;
    const belief & my_belief;
public:
    tracker_for_optimizer(std::list<tracker*> & stack, std::string f, int line, 
                             float & max, action *& argmax, std::list<action*>::const_iterator & i, int l,
                             const belief & b
                        );

    float get_max() const;
    action * get_argmax() const; // can be NULL !
    action * get_current_action() const;
    int get_level() const;
    const belief & get_belief() const;
    
    virtual void report(std::ostream & s) const;
    virtual void report_xml(std::ostream & s) const;
};

class action_iteration_controller: public class_with_tracking
{
protected:
    collection_of_actions & my_actions;
protected:
    
    virtual std::list<action*>::const_iterator get_action_iteration_begin();
    
    virtual void action_iteration_increment(std::list<action*>::const_iterator & target);
    
    virtual bool get_action_iteration_terminated(const std::list<action*>::const_iterator & i);
    
    
    action_iteration_controller(collection_of_actions & a): my_actions(a) {}
};


class optimizer: public action_iteration_controller
{
private:
    collection_of_variables & my_variables;
    collection_of_values & my_values;
    collection_of_visible_states & my_visible_states;
    
    float get_payoff_expected_value_for_consequences(const belief & b1, int n, const action & a);
    
protected:
    bool verbose_flag;
    
    virtual void on_error_in_populate_belief_for_consequence(
        const belief & b1, const action & a, const visible_state & vs, belief & target) const;
    
public:
    optimizer(collection_of_variables & v, collection_of_values & w, collection_of_visible_states & vs,
        collection_of_actions & a):
        action_iteration_controller(a),
        my_variables(v),
        my_values(w),
        my_visible_states(vs),
        verbose_flag(false)
        {
        }

    float get_consequence_probability(const belief & b1, const action & a, const visible_state & vs) const;
    

    void populate_belief_for_consequence(const belief & b1, const action & a, const visible_state & vs, belief & target) const;
    

    const action * get_optimal_action(const belief & b, int n);
    
};


class optimizer_with_all_data: public optimizer
{
private:
    enum mode_type { NONE, DECLARING_VALUES, DECLARING_VARIABLES_VALUES } mode;
public:
    collection_of_values w;
    collection_of_variables v;
    collection_of_actions a;
    collection_of_visible_states vs;
    
    variable * e; // recently created variable (not owned), parsing time
    
    std::map<variable*, value*> q, initial_state_query, action_query; // queries, parsing time
            
    belief *current_belief, *former_belief; // beliefs (owned)
    
    const action * former_action; // former action (not owned)
    
    std::list<variable*> list_of_input_variables; // auxilliary, just for loop
    
private:

    variable * get_variable(const char * v);
    
    value * get_value(const char * v);
    
    bool get_special_command(const char * buffer) const;
    
    void execute_special_command(const char * buffer);
    
    void explain() const;
    
    void verbose();
    
public:
    optimizer_with_all_data();
        
    void declare_values();
    void declare_variables_values();
    void add_value(const char * s);
    
    void create_input_variable(const char * s);
    void create_hidden_variable(const char * s);
    void create_output_variable(const char * s);
    
    void make_model();
    
    void test_model() const;
    
    void clear_query();
    
    void assert_query_fact(const char * v, const char * val);
    
    int parse(const char * filename);
    
    
    virtual void set_apriori_belief(belief * b) const;
    
    virtual void print_initial_loop_message() const;
    
    virtual void print_current_belief();
    
    virtual void get_input(std::map<variable*, value*> & m, bool & eof);
    
    virtual void execute(const action * a);
    
protected:
    virtual void dump_belief(std::ostream & s) const;
    virtual void dump_belief_XML(std::ostream & s) const;
};

}

std::ostream& operator<<(std::ostream & s, const perkun::query & q);


#endif