Action.hpp

#pragma once

#include "definitions.hpp"
#include "Transition.hpp"

#include "cpp11-range-master/range.hpp"
#include <utility>
#include <vector>
#include <limits>
#include <cassert>
#include <string>
#include <numeric>
#include <limits>
#include <algorithm>
#include <stdexcept>
#include <cmath>

namespace craam {

using namespace std;
using namespace util::lang;

// **************************************************************************************
// *** Regular action
// **************************************************************************************

class RegularAction{
protected:
    Transition outcome;

public:

    RegularAction() : outcome() {};

    RegularAction(const Transition& outcome) : outcome(outcome) {};

    vector<Transition> get_outcomes() const {return vector<Transition>{outcome};};

    const Transition& get_outcome(long outcomeid) const {assert(outcomeid == 0); return outcome;};

    Transition& get_outcome(long outcomeid) {assert(outcomeid == 0);return outcome;};

    const Transition& operator[](long outcomeid) const {return get_outcome(outcomeid);}

    Transition& operator[](long outcomeid) {return get_outcome(outcomeid);}

    const Transition& get_outcome() const {return outcome;};

    Transition& get_outcome() {return outcome;};

    Transition& create_outcome(long outcomeid){assert(outcomeid == 0);return outcome;}

    void normalize() {outcome.normalize();};

    size_t outcome_count() const {return 1;};


    void to_string(string& result) const{
        result.append("1(reg)");
    };

    bool is_nature_correct(numvec oid) const {return oid.size() == outcome.size();};

    prec_t mean_reward() const { return outcome.mean_reward();};

    prec_t mean_reward(numvec natpolicy) const { return outcome.mean_reward(natpolicy);};

    Transition mean_transition() const {return outcome;};


    Transition mean_transition(numvec natpolicy) const {
        return Transition(outcome.get_indices(),natpolicy,numvec(outcome.size(),0.0));
    };

    string to_json(long actionid = -1) const{
        string result{"{"};
        result += "\"actionid\" : ";
        result += std::to_string(actionid);
        result += ",\"transition\" : ";
        result += outcome.to_json(-1);
        result += "}";
        return result;
    }
};


// **************************************************************************************
//  Outcome Management (a helper class)
// **************************************************************************************

class OutcomeManagement{

protected:
    vector<Transition> outcomes;

public:
    OutcomeManagement() : outcomes() {};

    OutcomeManagement(const vector<Transition>& outcomes) : outcomes(outcomes) {};

    virtual ~OutcomeManagement() {};

    virtual Transition& create_outcome(long outcomeid){
        if(outcomeid < 0)
            throw invalid_argument("Outcomeid must be non-negative.");

        if(outcomeid >= (long) outcomes.size())
            outcomes.resize(outcomeid + 1);

        return outcomes[outcomeid];
    }

    virtual Transition& create_outcome(){return create_outcome(outcomes.size());};

    const Transition& get_outcome(long outcomeid) const {
        assert((outcomeid >= 0l && outcomeid < (long) outcomes.size()));
        return outcomes[outcomeid];};

    Transition& get_outcome(long outcomeid) {
        assert((outcomeid >= 0l && outcomeid < (long) outcomes.size()));
        return outcomes[outcomeid];};

    const Transition& operator[](long outcomeid) const {return get_outcome(outcomeid);}

    Transition& operator[](long outcomeid) {return get_outcome(outcomeid);}

    size_t outcome_count() const {return outcomes.size();};

    size_t size() const {return outcome_count();};

    void add_outcome(long outcomeid, const Transition& t){ create_outcome(outcomeid) = t; }

    void add_outcome(const Transition& t){add_outcome(outcomes.size(), t);};

    const vector<Transition>& get_outcomes() const {return outcomes;};

    void normalize(){
        for(Transition& t : outcomes)
            t.normalize();
    }

    bool is_nature_correct(numvec oid) const
        {return (oid.size() == outcomes.size());};

    void to_string(string& result) const{
        result.append(std::to_string(get_outcomes().size()));
    }
};


// **************************************************************************************
//  Weighted Outcome Action
// **************************************************************************************


class WeightedOutcomeAction : public OutcomeManagement{

protected:
    numvec distribution;

public:

    WeightedOutcomeAction()
        : OutcomeManagement(), distribution(0) {};

    WeightedOutcomeAction(const vector<Transition>& outcomes)
        : OutcomeManagement(outcomes), distribution(outcomes.size(), 
            1.0 / prec_t(outcomes.size())) {};

    using OutcomeManagement::create_outcome;

    Transition& create_outcome(long outcomeid) override{
        if(outcomeid < 0)
            throw invalid_argument("Outcomeid must be non-negative.");
        // 1: compute the weight for the new outcome and old ones

        size_t newsize = outcomeid + 1; // new size of the list of outcomes
        size_t oldsize = outcomes.size(); // current size of the set
        if(newsize <= oldsize){// no need to add anything
            return outcomes[outcomeid];
        }
        // new uniform weight for each element
        prec_t newweight = 1.0/prec_t(outcomeid+1);
        // check if need to scale the existing weights
        if(oldsize > 0){
            auto weightsum = accumulate(distribution.begin(), distribution.end(), 0.0);
            // only scale when the sum is not zero
            if(weightsum > 0){
                prec_t normal = (oldsize * newweight) / weightsum;
                transform(distribution.begin(), distribution.end(),distribution.begin(),
                          [normal](prec_t x){return x * normal;});
            }
        }
        outcomes.resize(newsize);
        // got to resize the distribution too and assign weights that are uniform
        distribution.resize(newsize, newweight);
        return outcomes[outcomeid];
    }

    Transition& create_outcome(long outcomeid, prec_t weight){
        if(outcomeid < 0)
            throw invalid_argument("Outcomeid must be non-negative.");
        assert(weight >= 0 && weight <= 1);

        if(outcomeid >= static_cast<long>(outcomes.size())){ // needs to resize arrays
            outcomes.resize(outcomeid+1);
            distribution.resize(outcomeid+1);
        }
        set_distribution(outcomeid, weight);
        return outcomes[outcomeid];
    }

    void set_distribution(const numvec& distribution){
        if(distribution.size() != outcomes.size())
            throw invalid_argument("Invalid distribution size.");
        prec_t sum = accumulate(distribution.begin(),distribution.end(), 0.0);
        if(sum < 0.99 || sum > 1.001)
            throw invalid_argument("Distribution does not sum to 1.");
        if((*min_element(distribution.begin(),distribution.end())) < 0)
            throw invalid_argument("Distribution must be non-negative.");

        this->distribution = distribution;
    }

    void set_distribution(long outcomeid, prec_t weight){
        assert(outcomeid >= 0 && (size_t) outcomeid < outcomes.size());
        distribution[outcomeid] = weight;
    }

    const numvec& get_distribution() const {return distribution;};

    void normalize_distribution(){
        auto weightsum = accumulate(distribution.begin(), distribution.end(), 0.0);

        if(weightsum > 0.0){
            for(auto& p : distribution)
                p /= weightsum;
        }else{
            throw invalid_argument("Distribution sums to 0 and cannot be normalized.");
        }
    }

    bool is_distribution_normalized() const{
        return abs(1.0-accumulate(distribution.begin(), distribution.end(), 0.0)) < SOLPREC;
    }

    void uniform_distribution(){
        distribution.clear();
        if(outcomes.size() > 0)
            distribution.resize(outcomes.size(), 1.0/ (prec_t) outcomes.size());
    }

    void to_string(string& result) const {
        result.append(std::to_string(get_outcomes().size()));
        result.append(" / ");
        result.append(std::to_string(get_distribution().size()));
    }

    prec_t mean_reward(const numvec& outcomedist) const{
        assert(outcomedist.size() == outcomes.size());
        prec_t result = 0;
        for(size_t i = 0; i < outcomes.size(); i++){
            result += outcomedist[i] * outcomes[i].mean_reward();
        }
        return result;
    }

    prec_t mean_reward() const {
        return mean_reward(distribution);
    }

    Transition mean_transition(const numvec& outcomedist) const{
        assert(outcomedist.size() == outcomes.size());
        Transition result;
        for(size_t i = 0; i < outcomes.size(); i++)
            outcomes[i].probabilities_addto(outcomedist[i], result);
        return result;
    }

    Transition mean_transition() const{
        return mean_transition(distribution);
    }
    string to_json(long actionid = -1) const{
        string result{"{"};
        result += "\"actionid\" : ";
        result += std::to_string(actionid);
        result += ",\"outcomes\" : [";
        for(auto oi : indices(outcomes)){
            const auto& o = outcomes[oi];
            result +=o.to_json(oi);
            result +=",";
        }
        if(!outcomes.empty()) result.pop_back(); // remove last comma
        result += "],\"distribution\" : [";
        for(auto d : distribution){
            result += std::to_string(d);
            result += ",";
        }
        if(!distribution.empty()) result.pop_back(); // remove last comma
        result += "]}";
        return result;
    }
};

}