Empirical
Classes | Public Types | Public Member Functions | Public Attributes | Static Public Attributes | List of all members
emp::AvidaCPU_Base< HARDWARE > Class Template Reference

#include <AvidaGP.h>

Classes

struct  Genome
 
struct  Instruction
 
struct  RegBackup
 
struct  ScopeInfo
 

Public Types

using this_t = AvidaCPU_Base< HARDWARE >
 
using hardware_t = HARDWARE
 
using inst_t = Instruction
 
using genome_t = Genome
 
using arg_t = size_t
 
using inst_lib_t = AvidaCPU_InstLib< hardware_t, arg_t, INST_ARGS >
 
using stack_t = emp::vector< double >
 
using arg_set_t = emp::array< arg_t, INST_ARGS >
 

Public Member Functions

void ExitScope ()
 
bool UpdateScope (size_t new_scope, ScopeType type=ScopeType::BASIC)
 
void BypassScope (size_t scope)
 
 AvidaCPU_Base (const genome_t &in_genome)
 Create a new AvidaCPU seeding it with a genome. More...
 
 AvidaCPU_Base ()
 Create a default AvidaCPU (no genome sequence, default instruction set) More...
 
 AvidaCPU_Base (Ptr< const inst_lib_t > inst_lib)
 Create an AvidaCPU with a specified instruction set (but no genome sequence) More...
 
 AvidaCPU_Base (const inst_lib_t &inst_lib)
 
 AvidaCPU_Base (const AvidaCPU_Base &)=default
 Copy constructor. More...
 
 AvidaCPU_Base (AvidaCPU_Base &&)=default
 Move constructor. More...
 
virtual ~AvidaCPU_Base ()
 Destructor. More...
 
bool operator< (const this_t &other) const
 
void Reset ()
 Reset the entire CPU to a starting state, without a genome. More...
 
virtual void ResetHardware ()
 Reset just the CPU hardware, but keep the genome and traits. More...
 
void ResetIP ()
 Reset the instruction pointer to the beginning of the genome AND reset scope. More...
 
Ptr< const inst_lib_tGetInstLib () const
 
inst_t GetInst (size_t pos) const
 
const genome_tGetGenome () const
 
const size_t GetSize () const
 
double GetReg (size_t id) const
 
double GetInput (int id) const
 
const std::unordered_map< int, double > & GetInputs () const
 
size_t GetNumInputs () const
 
double GetOutput (int id) const
 
const std::unordered_map< int, double > & GetOutputs () const
 
size_t GetNumOutputs () const
 
const stack_tGetStack (size_t id) const
 
int GetFunStart (size_t id) const
 
size_t GetIP () const
 
emp::vector< ScopeInfoGetScopeStack () const
 
size_t CurScope () const
 
ScopeType CurScopeType () const
 
ScopeType GetScopeType (size_t id)
 
emp::vector< RegBackupGetRegStack () const
 
emp::vector< size_t > GetCallStack () const
 
size_t GetNumErrors () const
 
double GetTrait (size_t id) const
 
const emp::vector< double > & GetTraits ()
 
size_t GetNumTraits () const
 
void SetInst (size_t pos, const inst_t &inst)
 
void SetInst (size_t pos, size_t id, size_t a0=0, size_t a1=0, size_t a2=0)
 
void SetGenome (const genome_t &g)
 
void SetReg (size_t id, double val)
 
void SetInput (int input_id, double value)
 
void SetInputs (const std::unordered_map< int, double > &vals)
 
void SetInputs (std::unordered_map< int, double > &&vals)
 
void SetOutput (int output_id, double value)
 
void SetOutputs (const std::unordered_map< int, double > &vals)
 
void SetOutputs (std::unordered_map< int, double > &&vals)
 
double PopStack (size_t id)
 
void PushStack (size_t id, double value)
 
void SetFunStart (size_t id, int value)
 
void SetIP (size_t pos)
 
void PushRegInfo (size_t scope_id, size_t reg_id)
 
void PushCallInfo (size_t pos)
 
void IncErrors ()
 
void SetTrait (size_t id, double val)
 
void PushTrait (double val)
 
inst_t GetRandomInst (Random &rand)
 
void RandomizeInst (size_t pos, Random &rand)
 
void PushInst (size_t id, size_t a0=0, size_t a1=0, size_t a2=0)
 
void PushInst (const std::string &name, size_t a0=0, size_t a1=0, size_t a2=0)
 
void PushInst (const Instruction &inst)
 
void PushInst (Instruction &&inst)
 
void PushInstString (std::string info)
 
void PushRandom (Random &rand, const size_t count=1)
 
bool Load (std::istream &input)
 
bool Load (const std::string &filename)
 
void ProcessInst (const inst_t &inst)
 Process a specified instruction, provided by the caller. More...
 
size_t InstScope (const inst_t &inst) const
 Determine the scope associated with a particular instruction. More...
 
void SingleProcess ()
 Process the NEXT instruction pointed to be the instruction pointer. More...
 
void Process (size_t num_inst)
 Process the next SERIES of instructions, directed by the instruction pointer. More...
 
void PrintInst (const inst_t &inst, std::ostream &os=std::cout) const
 Print out a single instruction, with its arguments. More...
 
void PrintGenome (std::ostream &os=std::cout) const
 Print out this program. More...
 
void PrintGenome (const std::string &filename) const
 
size_t PredictNextInst () const
 Figure out which instruction is going to actually be run next SingleProcess() More...
 
void PrintState (std::ostream &os=std::cout) const
 Print out the state of the virtual CPU. More...
 
void Trace (size_t num_inst, std::ostream &os=std::cout)
 Trace the instructions being exectured, with full CPU details. More...
 
void Trace (size_t num_inst, const std::string &filename)
 

Public Attributes

genome_t genome
 
emp::array< double, CPU_SIZEregs
 
std::unordered_map< int, double > inputs
 
std::unordered_map< int, double > outputs
 
emp::array< stack_t, CPU_SIZEstacks
 
emp::array< int, CPU_SIZEfun_starts
 
size_t inst_ptr
 
emp::vector< ScopeInfoscope_stack
 
emp::vector< RegBackupreg_stack
 
emp::vector< size_t > call_stack
 
size_t errors
 
emp::vector< double > traits
 

Static Public Attributes

static constexpr size_t CPU_SIZE = 16
 
static constexpr size_t INST_ARGS = 3
 
static constexpr size_t STACK_CAP = 16
 

Member Typedef Documentation

template<typename HARDWARE>
using emp::AvidaCPU_Base< HARDWARE >::arg_set_t = emp::array<arg_t, INST_ARGS>
template<typename HARDWARE>
using emp::AvidaCPU_Base< HARDWARE >::arg_t = size_t
template<typename HARDWARE>
using emp::AvidaCPU_Base< HARDWARE >::genome_t = Genome
template<typename HARDWARE>
using emp::AvidaCPU_Base< HARDWARE >::hardware_t = HARDWARE
template<typename HARDWARE>
using emp::AvidaCPU_Base< HARDWARE >::inst_lib_t = AvidaCPU_InstLib<hardware_t, arg_t, INST_ARGS>
template<typename HARDWARE>
using emp::AvidaCPU_Base< HARDWARE >::inst_t = Instruction
template<typename HARDWARE>
using emp::AvidaCPU_Base< HARDWARE >::stack_t = emp::vector<double>
template<typename HARDWARE>
using emp::AvidaCPU_Base< HARDWARE >::this_t = AvidaCPU_Base<HARDWARE>

Constructor & Destructor Documentation

template<typename HARDWARE>
emp::AvidaCPU_Base< HARDWARE >::AvidaCPU_Base ( const genome_t in_genome)
inline

Create a new AvidaCPU seeding it with a genome.

template<typename HARDWARE>
emp::AvidaCPU_Base< HARDWARE >::AvidaCPU_Base ( )
inline

Create a default AvidaCPU (no genome sequence, default instruction set)

template<typename HARDWARE>
emp::AvidaCPU_Base< HARDWARE >::AvidaCPU_Base ( Ptr< const inst_lib_t inst_lib)
inline

Create an AvidaCPU with a specified instruction set (but no genome sequence)

template<typename HARDWARE>
emp::AvidaCPU_Base< HARDWARE >::AvidaCPU_Base ( const inst_lib_t inst_lib)
inline
template<typename HARDWARE>
emp::AvidaCPU_Base< HARDWARE >::AvidaCPU_Base ( const AvidaCPU_Base< HARDWARE > &  )
default

Copy constructor.

template<typename HARDWARE>
emp::AvidaCPU_Base< HARDWARE >::AvidaCPU_Base ( AvidaCPU_Base< HARDWARE > &&  )
default

Move constructor.

template<typename HARDWARE>
virtual emp::AvidaCPU_Base< HARDWARE >::~AvidaCPU_Base ( )
inlinevirtual

Destructor.

Member Function Documentation

template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::BypassScope ( size_t  scope)
inline
template<typename HARDWARE>
size_t emp::AvidaCPU_Base< HARDWARE >::CurScope ( ) const
inline
template<typename HARDWARE>
ScopeType emp::AvidaCPU_Base< HARDWARE >::CurScopeType ( ) const
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::ExitScope ( )
inline
template<typename HARDWARE>
emp::vector<size_t> emp::AvidaCPU_Base< HARDWARE >::GetCallStack ( ) const
inline
template<typename HARDWARE>
int emp::AvidaCPU_Base< HARDWARE >::GetFunStart ( size_t  id) const
inline
template<typename HARDWARE>
const genome_t& emp::AvidaCPU_Base< HARDWARE >::GetGenome ( ) const
inline
template<typename HARDWARE>
double emp::AvidaCPU_Base< HARDWARE >::GetInput ( int  id) const
inline
template<typename HARDWARE>
const std::unordered_map<int,double>& emp::AvidaCPU_Base< HARDWARE >::GetInputs ( ) const
inline
template<typename HARDWARE>
inst_t emp::AvidaCPU_Base< HARDWARE >::GetInst ( size_t  pos) const
inline
template<typename HARDWARE>
Ptr<const inst_lib_t> emp::AvidaCPU_Base< HARDWARE >::GetInstLib ( ) const
inline
template<typename HARDWARE>
size_t emp::AvidaCPU_Base< HARDWARE >::GetIP ( ) const
inline
template<typename HARDWARE>
size_t emp::AvidaCPU_Base< HARDWARE >::GetNumErrors ( ) const
inline
template<typename HARDWARE>
size_t emp::AvidaCPU_Base< HARDWARE >::GetNumInputs ( ) const
inline
template<typename HARDWARE>
size_t emp::AvidaCPU_Base< HARDWARE >::GetNumOutputs ( ) const
inline
template<typename HARDWARE>
size_t emp::AvidaCPU_Base< HARDWARE >::GetNumTraits ( ) const
inline
template<typename HARDWARE>
double emp::AvidaCPU_Base< HARDWARE >::GetOutput ( int  id) const
inline
template<typename HARDWARE>
const std::unordered_map<int,double>& emp::AvidaCPU_Base< HARDWARE >::GetOutputs ( ) const
inline
template<typename HARDWARE>
inst_t emp::AvidaCPU_Base< HARDWARE >::GetRandomInst ( Random rand)
inline
template<typename HARDWARE>
double emp::AvidaCPU_Base< HARDWARE >::GetReg ( size_t  id) const
inline
template<typename HARDWARE>
emp::vector<RegBackup> emp::AvidaCPU_Base< HARDWARE >::GetRegStack ( ) const
inline
template<typename HARDWARE>
emp::vector<ScopeInfo> emp::AvidaCPU_Base< HARDWARE >::GetScopeStack ( ) const
inline
template<typename HARDWARE>
ScopeType emp::AvidaCPU_Base< HARDWARE >::GetScopeType ( size_t  id)
inline
template<typename HARDWARE>
const size_t emp::AvidaCPU_Base< HARDWARE >::GetSize ( ) const
inline
template<typename HARDWARE>
const stack_t& emp::AvidaCPU_Base< HARDWARE >::GetStack ( size_t  id) const
inline
template<typename HARDWARE>
double emp::AvidaCPU_Base< HARDWARE >::GetTrait ( size_t  id) const
inline
template<typename HARDWARE>
const emp::vector<double>& emp::AvidaCPU_Base< HARDWARE >::GetTraits ( )
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::IncErrors ( )
inline
template<typename HARDWARE>
size_t emp::AvidaCPU_Base< HARDWARE >::InstScope ( const inst_t inst) const

Determine the scope associated with a particular instruction.

template<typename HARDWARE >
bool emp::AvidaCPU_Base< HARDWARE >::Load ( std::istream &  input)
template<typename HARDWARE>
bool emp::AvidaCPU_Base< HARDWARE >::Load ( const std::string &  filename)
inline
template<typename HARDWARE>
bool emp::AvidaCPU_Base< HARDWARE >::operator< ( const this_t other) const
inline
template<typename HARDWARE>
double emp::AvidaCPU_Base< HARDWARE >::PopStack ( size_t  id)
inline
template<typename HARDWARE >
size_t emp::AvidaCPU_Base< HARDWARE >::PredictNextInst ( ) const

Figure out which instruction is going to actually be run next SingleProcess()

template<typename HARDWARE >
void emp::AvidaCPU_Base< HARDWARE >::PrintGenome ( std::ostream &  os = std::cout) const

Print out this program.

template<typename HARDWARE >
void emp::AvidaCPU_Base< HARDWARE >::PrintGenome ( const std::string &  filename) const
template<typename HARDWARE >
void emp::AvidaCPU_Base< HARDWARE >::PrintInst ( const inst_t inst,
std::ostream &  os = std::cout 
) const

Print out a single instruction, with its arguments.

template<typename HARDWARE >
void emp::AvidaCPU_Base< HARDWARE >::PrintState ( std::ostream &  os = std::cout) const

Print out the state of the virtual CPU.

template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::Process ( size_t  num_inst)
inline

Process the next SERIES of instructions, directed by the instruction pointer.

template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::ProcessInst ( const inst_t inst)
inline

Process a specified instruction, provided by the caller.

template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::PushCallInfo ( size_t  pos)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::PushInst ( size_t  id,
size_t  a0 = 0,
size_t  a1 = 0,
size_t  a2 = 0 
)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::PushInst ( const std::string &  name,
size_t  a0 = 0,
size_t  a1 = 0,
size_t  a2 = 0 
)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::PushInst ( const Instruction inst)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::PushInst ( Instruction &&  inst)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::PushInstString ( std::string  info)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::PushRandom ( Random rand,
const size_t  count = 1 
)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::PushRegInfo ( size_t  scope_id,
size_t  reg_id 
)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::PushStack ( size_t  id,
double  value 
)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::PushTrait ( double  val)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::RandomizeInst ( size_t  pos,
Random rand 
)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::Reset ( )
inline

Reset the entire CPU to a starting state, without a genome.

template<typename HARDWARE>
virtual void emp::AvidaCPU_Base< HARDWARE >::ResetHardware ( )
inlinevirtual

Reset just the CPU hardware, but keep the genome and traits.

template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::ResetIP ( )
inline

Reset the instruction pointer to the beginning of the genome AND reset scope.

template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::SetFunStart ( size_t  id,
int  value 
)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::SetGenome ( const genome_t g)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::SetInput ( int  input_id,
double  value 
)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::SetInputs ( const std::unordered_map< int, double > &  vals)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::SetInputs ( std::unordered_map< int, double > &&  vals)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::SetInst ( size_t  pos,
const inst_t inst 
)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::SetInst ( size_t  pos,
size_t  id,
size_t  a0 = 0,
size_t  a1 = 0,
size_t  a2 = 0 
)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::SetIP ( size_t  pos)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::SetOutput ( int  output_id,
double  value 
)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::SetOutputs ( const std::unordered_map< int, double > &  vals)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::SetOutputs ( std::unordered_map< int, double > &&  vals)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::SetReg ( size_t  id,
double  val 
)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::SetTrait ( size_t  id,
double  val 
)
inline
template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::SingleProcess ( )
inline

Process the NEXT instruction pointed to be the instruction pointer.

template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::Trace ( size_t  num_inst,
std::ostream &  os = std::cout 
)
inline

Trace the instructions being exectured, with full CPU details.

template<typename HARDWARE>
void emp::AvidaCPU_Base< HARDWARE >::Trace ( size_t  num_inst,
const std::string &  filename 
)
inline
template<typename HARDWARE>
bool emp::AvidaCPU_Base< HARDWARE >::UpdateScope ( size_t  new_scope,
ScopeType  type = ScopeType::BASIC 
)
inline

Member Data Documentation

template<typename HARDWARE>
emp::vector<size_t> emp::AvidaCPU_Base< HARDWARE >::call_stack
template<typename HARDWARE>
constexpr size_t emp::AvidaCPU_Base< HARDWARE >::CPU_SIZE = 16
static
template<typename HARDWARE>
size_t emp::AvidaCPU_Base< HARDWARE >::errors
template<typename HARDWARE>
emp::array< int, CPU_SIZE > emp::AvidaCPU_Base< HARDWARE >::fun_starts
template<typename HARDWARE>
genome_t emp::AvidaCPU_Base< HARDWARE >::genome
template<typename HARDWARE>
std::unordered_map<int, double> emp::AvidaCPU_Base< HARDWARE >::inputs
template<typename HARDWARE>
constexpr size_t emp::AvidaCPU_Base< HARDWARE >::INST_ARGS = 3
static
template<typename HARDWARE>
size_t emp::AvidaCPU_Base< HARDWARE >::inst_ptr
template<typename HARDWARE>
std::unordered_map<int, double> emp::AvidaCPU_Base< HARDWARE >::outputs
template<typename HARDWARE>
emp::vector<RegBackup> emp::AvidaCPU_Base< HARDWARE >::reg_stack
template<typename HARDWARE>
emp::array<double, CPU_SIZE> emp::AvidaCPU_Base< HARDWARE >::regs
template<typename HARDWARE>
emp::vector<ScopeInfo> emp::AvidaCPU_Base< HARDWARE >::scope_stack
template<typename HARDWARE>
constexpr size_t emp::AvidaCPU_Base< HARDWARE >::STACK_CAP = 16
static
template<typename HARDWARE>
emp::array< stack_t, CPU_SIZE > emp::AvidaCPU_Base< HARDWARE >::stacks
template<typename HARDWARE>
emp::vector<double> emp::AvidaCPU_Base< HARDWARE >::traits

The documentation for this class was generated from the following file: