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
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
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
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
00217 ERCD *erc = new ERCD(*this);
00218
00219
00220 if(useInterval_) {
00221 double r = state_->getRandomizer()->getRandomDouble();
00222 erc->value_ = (*values_)[0] + r * ((*values_)[1] - (*values_)[0]);
00223 }
00224
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