SparseExperience.hpp

Go to the documentation of this file.

#ifndef AI_TOOLBOX_MDP_SPARSE_EXPERIENCE_HEADER_FILE
#define AI_TOOLBOX_MDP_SPARSE_EXPERIENCE_HEADER_FILE
 
#include <iosfwd>
 
#include <AIToolbox/Types.hpp>
#include <AIToolbox/TypeTraits.hpp>
#include <AIToolbox/Utils/Core.hpp>
 
namespace AIToolbox::MDP {
    class SparseExperience {
        public:
            SparseExperience(size_t S, size_t A);
 
            template <IsNaive3DTable V>
            void setVisitsTable(const V & v);
 
            void setVisitsTable(const SparseTable3D & v);
 
            template <IsNaive2DMatrix R>
            void setRewardMatrix(const R & r);
 
            void setRewardMatrix(const SparseMatrix2D & r);
 
            template <IsNaive2DMatrix MM>
            void setM2Matrix(const MM & mm);
 
            void setM2Matrix(const SparseMatrix2D & mm);
 
            void record(size_t s, size_t a, size_t s1, double rew);
 
            void reset();
 
            unsigned long getTimesteps() const;
 
            unsigned long getVisits(size_t s, size_t a, size_t s1) const;
 
            unsigned long getVisitsSum(size_t s, size_t a) const;
 
            double getReward(size_t s, size_t a) const;
 
            double getM2(size_t s, size_t a) const;
 
            const SparseTable3D & getVisitsTable() const;
 
            const SparseTable2D & getVisitsTable(size_t a) const;
 
            const SparseTable2D & getVisitsSumTable() const;
 
            const SparseMatrix2D & getRewardMatrix() const;
 
            const SparseMatrix2D & getM2Matrix() const;
 
            size_t getS() const;
 
            size_t getA() const;
 
        private:
            size_t S, A;
 
            SparseTable3D visits_;
            SparseTable2D visitsSum_;
            SparseMatrix2D rewards_;
            SparseMatrix2D M2s_;
            unsigned long timesteps_;
 
            friend std::istream& operator>>(std::istream &is, SparseExperience &);
    };
 
    template <IsNaive3DTable V>
    void SparseExperience::setVisitsTable(const V & v) {
        for ( size_t a = 0; a < A; ++a )
            visits_[a].setZero();
        visitsSum_.setZero();
 
        for ( size_t s = 0; s < S; ++s )
            for ( size_t a = 0; a < A; ++a )
                for ( size_t s1 = 0; s1 < S; ++s1 )
                    if ( v[s][a][s1] > 0 ) {
                        visits_[a].insert(s, s1) = v[s][a][s1];
                        visitsSum_.coeffRef(s, a) += v[s][a][s1];
                    }
 
        for ( size_t a = 0; a < A; ++a )
            visits_[a].makeCompressed();
        visitsSum_.makeCompressed();
    }
 
    template <IsNaive2DMatrix R>
    void SparseExperience::setRewardMatrix(const R & r) {
        rewards_.setZero();
 
        for ( size_t s = 0; s < S; ++s )
            for ( size_t a = 0; a < A; ++a )
                if ( checkDifferentSmall(0.0, r[s][a]) )
                    rewards_.insert(s, a) = r[s][a];
 
        rewards_.makeCompressed();
    }
 
    template <IsNaive2DMatrix MM>
    void SparseExperience::setM2Matrix(const MM & mm) {
        M2s_.setZero();
 
        for ( size_t s = 0; s < S; ++s )
            for ( size_t a = 0; a < A; ++a )
                if ( checkDifferentSmall(0.0, mm[s][a]) )
                    M2s_.insert(s, a) = mm[s][a];
 
        M2s_.makeCompressed();
    }
}
 
#endif