Experience.hpp

Go to the documentation of this file.

#ifndef AI_TOOLBOX_MDP_EXPERIENCE_HEADER_FILE
#define AI_TOOLBOX_MDP_EXPERIENCE_HEADER_FILE
 
#include <iosfwd>
 
#include <AIToolbox/Types.hpp>
#include <AIToolbox/TypeTraits.hpp>
#include <AIToolbox/Utils/Core.hpp>
#include <AIToolbox/MDP/Types.hpp>
 
namespace AIToolbox::MDP {
    class Experience {
        public:
            Experience(size_t S, size_t A);
 
            template <IsNaive3DTable V>
            void setVisitsTable(const V & v);
 
            void setVisitsTable(const Table3D & v);
 
            template <IsNaive2DMatrix R>
            void setRewardMatrix(const R & r);
 
            void setRewardMatrix(const Matrix2D & r);
 
            template <IsNaive2DMatrix MM>
            void setM2Matrix(const MM & mm);
 
            void setM2Matrix(const Matrix2D & 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 Table3D & getVisitsTable() const;
 
            const Table2D & getVisitsTable(size_t a) const;
 
            const Table2D & getVisitsSumTable() const;
 
            const QFunction & getRewardMatrix() const;
 
            const Matrix2D & getM2Matrix() const;
 
            size_t getS() const;
 
            size_t getA() const;
 
        private:
            size_t S, A;
 
            Table3D visits_;
            Table2D visitsSum_;
            Matrix2D rewards_;
            Matrix2D M2s_;
            unsigned long timesteps_;
 
            friend std::istream& operator>>(std::istream &is, Experience &);
    };
 
    template <IsNaive3DTable V>
    void Experience::setVisitsTable(const V & v) {
        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 ) {
                    visits_[a](s, s1) = v[s][a][s1];
                    visitsSum_(s, a) += v[s][a][s1];
                }
            }
        }
    }
 
    template <IsNaive2DMatrix R>
    void Experience::setRewardMatrix(const R & r) {
        for ( size_t s = 0; s < S; ++s )
            for ( size_t a = 0; a < A; ++a )
                rewards_(s, a) = r[s][a];
    }
 
    template <IsNaive2DMatrix MM>
    void Experience::setM2Matrix(const MM & m) {
        for ( size_t s = 0; s < S; ++s )
            for ( size_t a = 0; a < A; ++a )
                M2s_(s, a) = m[s][a];
    }
}
 
#endif