environment.h

 
#ifndef ENVIRONMENT_H
#define ENVIRONMENT_H
 
#include <cmath>
#include <iostream>
 
#include "data/constantHandler.h"
#include "data/dataHandler.h"
#include "data/primitiveTypeArray.h"
#include "instructions/instruction.h"
#include "instructions/set.h"
#include "learn/learningParameters.h"
 
typedef struct LineSize
{
    size_t nbInstructionBits;
    size_t nbDestinationBits;
    size_t nbOperandsBits;
    size_t nbOperandDataSourceIndexBits;
    size_t nbOperandLocationBits;
    size_t totalNbBits;
 
    operator size_t() const
    {
        return totalNbBits;
    }
} LineSize;
 
class Environment
{
  protected:
    const Instructions::Set instructionSet;
 
    const Learn::LearningParameters params;
 
    const std::vector<std::reference_wrapper<const Data::DataHandler>>
        dataSources;
 
    const size_t nbRegisters;
 
    const size_t nbConstants;
 
    std::vector<std::reference_wrapper<const Data::DataHandler>>
        fakeDataSources;
 
    const Data::PrimitiveTypeArray<double> fakeRegisters;
 
    const Data::ConstantHandler fakeConstants;
 
    const size_t nbContinuousActions;
 
    const size_t nbInstructions;
 
    const size_t maxNbOperands;
 
    const size_t nbDataSources;
 
    const size_t largestAddressSpace;
 
    const LineSize lineSize;
 
    static size_t computeLargestAddressSpace(
        const size_t nbRegisters, const size_t nbConstants,
        const std::vector<std::reference_wrapper<const Data::DataHandler>>&
            dHandlers);
 
    static const LineSize computeLineSize(const Environment& env);
 
    static Instructions::Set filterInstructionSet(
        const Instructions::Set& iSet, const size_t nbRegisters,
        const size_t nbConstants,
        const std::vector<std::reference_wrapper<const Data::DataHandler>>&
            dataSources);
 
  private:
    Environment() = delete;
 
  public:
    Environment(
        const Instructions::Set& iSet, const Learn::LearningParameters& p,
        const std::vector<std::reference_wrapper<const Data::DataHandler>>&
            dHandlers,
        size_t nbContinuousAct = 0)
        : instructionSet{filterInstructionSet(iSet, p.nbRegisters,
                                              p.nbProgramConstant, dHandlers)},
          params{p}, dataSources{dHandlers}, nbRegisters{p.nbRegisters},
          nbConstants{p.nbProgramConstant}, fakeRegisters(p.nbRegisters),
          fakeConstants(p.nbProgramConstant),
          nbInstructions{instructionSet.getNbInstructions()},
          maxNbOperands{instructionSet.getMaxNbOperands()},
          nbContinuousActions{nbContinuousAct},
          nbDataSources{
              dHandlers.size() +
              (p.nbProgramConstant > 0
                   ? 2
                   : 1)}, // if Constants are used, we need an extra
                          // datasource to store them in the environment
          largestAddressSpace{computeLargestAddressSpace(
              p.nbRegisters, p.nbProgramConstant, dHandlers)},
          lineSize{computeLineSize(*this)}
    {
        this->fakeDataSources.push_back(
            (std::reference_wrapper<const Data::DataHandler>)this
                ->fakeRegisters);
 
        if (p.nbProgramConstant > 0) {
            this->fakeDataSources.push_back(this->fakeConstants);
        }
 
        for (auto& elem : this->dataSources)
            this->fakeDataSources.push_back(elem);
    };
 
    const Learn::LearningParameters& getParams() const;
 
    size_t getNbContinuousActions() const;
 
    size_t getNbInstructions() const;
 
    size_t getMaxNbOperands() const;
 
    size_t getNbDataSources() const;
 
    size_t getLargestAddressSpace() const;
 
    const LineSize& getLineSize() const;
 
    const std::vector<std::reference_wrapper<const Data::DataHandler>>&
    getDataSources() const;
 
    const std::vector<std::reference_wrapper<const Data::DataHandler>>&
    getFakeDataSources() const;
 
    const Instructions::Set& getInstructionSet() const;
};
 
#endif