context.hpp

非常好的进化算法EC 实现平台 可以实现多种算法 GA GP

    Beagle_StackTraceBeginM();
    return mProcessedDeme;
    Beagle_StackTraceEndM("unsigned int Context::getProcessedDeme() const");
  }

  /*!
   *  \return Total number of individuals processed by the actual deme in the evolution.
   */
  inline unsigned int getTotalProcessedDeme() const
  {
    Beagle_StackTraceBeginM();
    return mTotalProcDeme;
    Beagle_StackTraceEndM("unsigned int Context::getTotalProcessedDeme() const");
  }

  /*!
   *  \return Number of individuals processed by the actual vivarium in this generation.
   */
  inline unsigned int getProcessedVivarium() const
  {
    Beagle_StackTraceBeginM();
    return mProcessedViva;
    Beagle_StackTraceEndM("unsigned int Context::getProcessedVivarium() const");
  }

  /*!
   *  \return Total number of individuals processed by the actual vivarium in the evolution.
   */
  inline unsigned int getTotalProcessedVivarium() const
  {
    Beagle_StackTraceBeginM();
    return mTotalProcViva;
    Beagle_StackTraceEndM("unsigned int Context::getTotalProcessedVivarium() const");
  }

  /*!
   *  \brief Return a constant reference to the system.
   *  \return Evolution system constant reference.
   */
  inline const System& getSystem() const
  {
    Beagle_StackTraceBeginM();
#ifndef BEAGLE_NDEBUG
    if(mSystemHandle == NULL) throw Beagle_RunTimeExceptionM(
      string("The context does not have a handle to a system. ")+
      string("Consider Beagle::Context::setSystemHandle()."));
#endif // BEAGLE_NDEBUG
    return *mSystemHandle;
    Beagle_StackTraceEndM("const System& Context::getSystem() const");
  }

  /*!
   *  \brief Return a reference to the system.
   *  \return Evolution system reference.
   */
  inline System& getSystem()
  {
    Beagle_StackTraceBeginM();
#ifndef BEAGLE_NDEBUG
    if(mSystemHandle == NULL) throw Beagle_RunTimeExceptionM(
      string("The context does not have a handle to a system. ")+
      string("Consider Beagle::Context::setSystemHandle()."));
#endif // BEAGLE_NDEBUG
    return *mSystemHandle;
    Beagle_StackTraceEndM("System& Context::getSystem()");
  }

  /*!
   *  \brief Return a handle to the system.
   *  \return Evolution system handle.
   */
  inline System::Handle getSystemHandle()
  {
    Beagle_StackTraceBeginM();
    return mSystemHandle;
    Beagle_StackTraceEndM("System::Handle Context::getSystemHandle()");
  }

  /*!
   *  \brief Return a constant reference to the vivarium.
   *  \return Evolution vivarium constant reference.
   */
  inline const Vivarium& getVivarium() const
  {
    Beagle_StackTraceBeginM();
#ifndef BEAGLE_NDEBUG
    if(mVivariumHandle == NULL) throw Beagle_RunTimeExceptionM(
      string("The context does not have a handle to a vivarium. ")+
      string("Consider Beagle::Context::setVivariumHandle()."));
#endif // BEAGLE_NDEBUG
    return *mVivariumHandle;
    Beagle_StackTraceEndM("const Vivarium& Context::getVivarium() const");
  }

  /*!
   *  \brief Return a reference to the vivarium.
   *  \return Evolution vivarium reference.
   */
  inline Vivarium& getVivarium()
  {
    Beagle_StackTraceBeginM();
#ifndef BEAGLE_NDEBUG
    if(mVivariumHandle == NULL) throw Beagle_RunTimeExceptionM(
      string("The context does not have a handle to a vivarium. ")+
      string("Consider Beagle::Context::setVivariumHandle()."));
#endif // BEAGLE_NDEBUG
    return *mVivariumHandle;
    Beagle_StackTraceEndM("Vivarium& Context::getVivarium()");
  }

  /*!
   *  \brief Return a handle to the vivarium.
   *  \return Evolution vivarium handle.
   */
  inline Vivarium::Handle getVivariumHandle()
  {
    Beagle_StackTraceBeginM();
    return mVivariumHandle;
    Beagle_StackTraceEndM("Vivarium::Handle Context::getVivariumHandle()");
  }

  /*!
   *  \brief Set the evolution continuing flag.
   *  \param inContinueFlag Continuing flag value.
   */
  inline void setContinueFlag(bool inContinueFlag)
  {
    Beagle_StackTraceBeginM();
    mContinueFlag = inContinueFlag;
    Beagle_StackTraceEndM("void Context::setContinueFlag(bool inContinueFlag)");
  }

  /*!
   *  \brief Set an handle to the actual deme.
   *  \param inDemeHandle Actual deme handle.
   */
  inline void setDemeHandle(Deme::Handle inDemeHandle)
  {
    Beagle_StackTraceBeginM();
    mDemeHandle = inDemeHandle;
    Beagle_StackTraceEndM("void Context::setDemeHandle(Deme::Handle inDemeHandle)");
  }

  /*!
   *  \brief Set the actual deme index.
   *  \param inDemeIndex Actual deme index.
   */
  inline void setDemeIndex(unsigned int inDemeIndex)
  {
    Beagle_StackTraceBeginM();
    mDemeIndex = inDemeIndex;
    Beagle_StackTraceEndM("void Context::setDemeIndex(unsigned int inDemeIndex)");
  }

  /*!
   *  \brief Set an handle to the evolver.
   *  \param inEvolverHandle Evolver handle.
   */
  inline void setEvolverHandle(Evolver::Handle inEvolverHandle)
  {
    Beagle_StackTraceBeginM();
    mEvolverHandle = inEvolverHandle;
    Beagle_StackTraceEndM("void Context::setEvolverHandle(Evolver::Handle inEvolverHandle)");
  }

  /*!
   *  \brief Set an handle to the actual individual.
   *  \param inIndividualHandle Actual individual handle.
   */
  inline void setIndividualHandle(Individual::Handle inIndividualHandle)
  {
    Beagle_StackTraceBeginM();
    mIndividualHandle = inIndividualHandle;
    Beagle_StackTraceEndM("void Context::setIndividualHandle(Individual::Handle inIndividualHandle)");
  }

  /*!
   *  \brief Set the actual individual index.
   *  \param inIndividualIndex Actual individual index.
   */
  inline void setIndividualIndex(unsigned int inIndividualIndex)
  {
    Beagle_StackTraceBeginM();
    mIndividualIndex = inIndividualIndex;
    Beagle_StackTraceEndM("void Context::setIndividualIndex(unsigned int inIndividualIndex)");
  }

  /*!
   *  \brief Set an handle to the actual genotype.
   *  \param inGenotypeHandle Actual genotype handle.
   */
  inline void setGenotypeHandle(Genotype::Handle inGenotypeHandle)
  {
    Beagle_StackTraceBeginM();
    mGenotypeHandle = inGenotypeHandle;
    Beagle_StackTraceEndM("void Context::setGenotypeHandle(Genotype::Handle inGenotypeHandle)");
  }

  /*!
   *  \brief Set the actual genotype index.
   *  \param inGenotypeIndex Actual genotype index.
   */
  inline void setGenotypeIndex(unsigned int inGenotypeIndex)
  {
    Beagle_StackTraceBeginM();
    mGenotypeIndex = inGenotypeIndex;
    Beagle_StackTraceEndM("void Context::setGenotypeIndex(unsigned int inGenotypeIndex)");
  }

  /*!
   *  \brief Set the actual generation number.
   *  \param inGeneration Actual generation number.
   */
  inline void setGeneration(unsigned int inGeneration)
  {
    Beagle_StackTraceBeginM();
    mGeneration = inGeneration;
    Beagle_StackTraceEndM("void Context::setGeneration(unsigned int inGeneration)");
  }

  /*!
   *  \brief Set the number of individuals processed by the deme for the actual generation.
   *  \param inProcessedDeme Number of individuals processed by the deme.
   */
  inline void setProcessedDeme(unsigned int inProcessedDeme)
  {
    Beagle_StackTraceBeginM();
    mProcessedDeme = inProcessedDeme;
    Beagle_StackTraceEndM("void Context::setProcessedDeme(unsigned int inProcessedDeme)");
  }

  /*!
   *  \brief Set the total number of individuals processed by the deme for the evolution.
   *  \param inTotalProcDeme Total number of individuals processed by the deme.
   */
  inline void setTotalProcessedDeme(unsigned int inTotalProcDeme)
  {
    Beagle_StackTraceBeginM();
    mTotalProcDeme = inTotalProcDeme;
    Beagle_StackTraceEndM("void Context::setTotalProcessedDeme(unsigned int inTotalProcDeme)");
  }


  /*!
   *  \brief Set the number of individuals processed by the vivarium for the actual generation.
   *  \param inProcessedViva Number of individuals processed by the vivarium.
   */
  inline void setProcessedVivarium(unsigned int inProcessedViva)
  {
    Beagle_StackTraceBeginM();
    mProcessedViva = inProcessedViva;
    Beagle_StackTraceEndM("void Context::setProcessedVivarium(unsigned int inProcessedViva)");
  }

  /*!
   *  \brief Set the total number of individuals processed by the vivarium for the evolution.
   *  \param inTotalProcViva Total number of individuals processed by the vivarium.
   */
  inline void setTotalProcessedVivarium(unsigned int inTotalProcViva)
  {
    Beagle_StackTraceBeginM();
    mTotalProcViva = inTotalProcViva;
    Beagle_StackTraceEndM("void Context::setTotalProcessedVivarium(unsigned int inTotalProcViva)");
  }

  /*!
   *  \brief Set the system handle.
   *  \param inSystemHandle Handle to the system.
   */
  inline void setSystemHandle(System::Handle inSystemHandle)
  {
    Beagle_StackTraceBeginM();
    mSystemHandle = inSystemHandle;
    Beagle_StackTraceEndM("void Context::setSystemHandle(System::Handle inSystemHandle)");
  }

  /*!
   *  \brief Set the vivarium handle.
   *  \param inVivariumHandle Handle to the vivarium.
   */
  inline void setVivariumHandle(Vivarium::Handle inVivariumHandle)
  {
    Beagle_StackTraceBeginM();
    mVivariumHandle = inVivariumHandle;
    Beagle_StackTraceEndM("void Context::setVivariumHandle(Vivarium::Handle inVivariumHandle)");
  }

protected:
  System::Handle     mSystemHandle;       //!< Handle to the system of the evolution.
  Evolver::Handle    mEvolverHandle;      //!< Handle to the evolver of the evolution.
  Vivarium::Handle   mVivariumHandle;     //!< Handle to the vivarium of the evolution.
  Deme::Handle       mDemeHandle;         //!< Handle to the actual deme of the evolution.
  unsigned int       mDemeIndex;          //!< Index of the actual deme of the evolution.
  Individual::Handle mIndividualHandle;   //!< Handle to the actual individual of the evolution.
  unsigned int       mIndividualIndex;    //!< Index of the actual individual of the evolution.
  Genotype::Handle   mGenotypeHandle;     //!< Handle to the actual genotype of the evolution.
  unsigned int       mGenotypeIndex;      //!< Index of the actual genotype of the evolution.
  unsigned int       mGeneration;         //!< Actual generation number of the evolution.
  unsigned int       mProcessedDeme;      //!< # of indiv. processed by deme during actual gen.
  unsigned int       mTotalProcDeme;      //!< Total # of indiv. processed by the deme.
  unsigned int       mProcessedViva;      //!< # of indiv. processed by vivarium during actual gen.
  unsigned int       mTotalProcViva;      //!< Total # of indiv. processed by the vivarium.
  bool               mContinueFlag;       //!< Flag set if the evolution must continue.

};

}

#endif // Beagle_Context_hpp