• Main Page
  • Modules
  • Classes
  • Files
  • File List

D:/Projekt/ECF_trunk/ECF/tree/Terminal.h

00001 #ifndef Terminal_h
00002 #define Terminal_h
00003 #include "Primitive.h"
00004 
00005 namespace Tree {
00006 namespace Primitives {
00007 
00014 template <class T>
00015 class TerminalT : public Primitive
00016 {
00017 public:
00018     TerminalT();
00019     T value_;
00020     void execute(void* result, Tree& tree);
00021     void setValue(void* value);
00022     void getValue(void* value);
00023     ~TerminalT();
00024 };
00025 // default type is double:
00026 typedef TerminalT<double> Terminal;
00027 
00028 
00029 template <class T>
00030 TerminalT<T>::TerminalT()
00031 {
00032     nArguments_ = 0;
00033 }
00034 
00035 
00036 template <class T>
00037 TerminalT<T>::~TerminalT(void)
00038 {   }
00039 
00040 
00045 template <class T>
00046 void TerminalT<T>::setValue(void* value)
00047 {
00048     value_ = *(T*)value;
00049 }
00050 
00051 
00056 template <class T>
00057 void TerminalT<T>::getValue(void* value)
00058 {
00059     *(T*)value = value_;
00060 }
00061 
00062 
00063 template <class T>
00064 void TerminalT<T>::execute(void* result, Tree& tree)
00065 {
00066     T& res = *(T*)result;
00067     res = value_;
00068 }
00069 
00070 
00071 
00084 template <class T>
00085 class ERC : public Primitive
00086 {
00087 public:
00088     std::string baseName_;
00089     T value_;
00090 
00091     ERC()
00092     {
00093         nArguments_ = 0;
00094         name_ = "ERC";
00095         // ime se treba postaviti u Tree::initialize zbog prefiksa po tipu
00096     }
00097 
00098 
00104     bool initialize(StateP state)
00105     {
00106         state_ = state;
00107         values_ = new std::vector<T>;
00108 
00109         name_.erase(name_.end() - 1);
00110         std::stringstream ss;
00111         ss << name_;
00112         ss >> name_;
00113         char bracket;
00114         ss >> bracket;
00115 
00116         T datum;
00117         while(ss >> datum) {
00118             values_->push_back(datum);
00119         }
00120 
00121         return true;
00122     }
00123 
00124 
00125     void execute(void *result, Tree& tree)
00126     {
00127         T& res = *(T*)result;
00128         res = value_;
00129     }
00130 
00131 
00136     void setValue(void* value)
00137     {
00138         value_ = *(T*)value;
00139     }
00140 
00141 
00146     void getValue(void* value)
00147     {
00148         *(T*)value = value_;
00149     }
00150 
00151 
00152     PrimitiveP copyWithNode(PrimitiveP primitive)
00153     {
00154         return (PrimitiveP) new ERC<T>(*this);
00155     }
00156 
00161     PrimitiveP assignToNode(PrimitiveP primitive)
00162     {
00163         // shallow copy - the values_ vector is not copied
00164         ERC<T> *erc = new ERC<T>(*this);
00165 
00166         uint iData = state_->getRandomizer()->getRandomInteger((int)values_->size());
00167         erc->value_ = values_->at(iData);
00168         std::ostringstream ss;
00169         ss << values_->at(iData);
00170         erc->setName(name_ + ss.str());
00171         return (PrimitiveP) erc;
00172     }
00173 
00174 protected:
00177     std::vector<T> *values_;
00178 };
00179 
00180 
00181 
00188 class ERCD : public ERC<double>
00189 {
00190 public:
00191     bool initialize(StateP state)
00192     {
00193         useInterval_ = true;
00194         state_ = state;
00195         values_ = new std::vector<double>;
00196 
00197         if(name_[name_.size() - 1] == '}')
00198             useInterval_ = false;
00199         name_.erase(name_.end() - 1);
00200         std::stringstream ss;
00201         ss << name_;
00202         ss >> name_;
00203         char bracket;
00204         ss >> bracket;
00205 
00206         double datum;
00207         while(ss >> datum) {
00208             values_->push_back(datum);
00209         }
00210 
00211         return true;
00212     }
00213 
00214     PrimitiveP assignToNode(PrimitiveP primitive)
00215     {
00216         // shallow copy - the values_ are not copied
00217         ERCD *erc = new ERCD(*this);
00218 
00219         // generate a random value in the interval
00220         if(useInterval_) {
00221             double r = state_->getRandomizer()->getRandomDouble();
00222             erc->value_ = (*values_)[0] + r * ((*values_)[1] - (*values_)[0]);
00223         }
00224         // or choose a random predefined value
00225         else {
00226             uint iData = state_->getRandomizer()->getRandomInteger((int)values_->size());
00227             erc->value_ = values_->at(iData);
00228         }
00229         std::ostringstream ss;
00230         ss << erc->value_;
00231         erc->setName(name_ + ss.str());
00232         return (PrimitiveP) erc;
00233     }
00234 
00235 protected:
00236         bool useInterval_;    
00237 };
00238 
00239 }
00240 }
00241 
00242 #endif

Generated on Tue Nov 4 2014 13:04:31 for ECF by  doxygen 1.7.1