00001
00020 #include "running.h"
00021 #include <math.h>
00022 #include <cassert>
00023 #include <cstdio>
00024
00025 using namespace realea;
00026
00027 OptimeCriterion::OptimeCriterion(double optime, double dif) {
00028 m_optime = optime;
00029 m_threshold = dif;
00030 }
00031
00032 void OptimeCriterion::setThreshold(double dif) {
00033 assert(dif > 0);
00034 m_threshold = dif;
00035 }
00036
00037 bool OptimeCriterion::isOptime(double fitness) {
00038 if (fitness < m_optime)
00039 return true;
00040 else
00041 return (fitness-m_optime <= m_threshold);
00042 }
00043
00044 double OptimeCriterion::getThreshold(void) {
00045 return m_threshold;
00046 }
00047
00048 void Running::increm(void) {
00049 if (m_optimized) {
00050 printf("Warning: Optimized value achieved\n");
00051
00052 }
00053 if (m_maxmsecs == 0 && m_neval == m_maxeval) {
00054 printf("Warning: Max eval achieved\n");
00055
00056 }
00057
00058 m_neval += 1;
00059
00060 }
00061
00062 void Running::reset(void) {
00063 m_neval = 0;
00064 m_timeInit = clock();
00065 m_optimized = false;
00066 }
00067
00068 Running::Running(OptimeCriterion *isOptime) : m_checkOptime(isOptime), m_children() {
00069 m_maxeval = m_neval = 0;
00070 m_optimized = false;
00071 m_parent = NULL;
00072 m_maxmsecs = 0;
00073 m_timeInit = 0;
00074 }
00075
00076 void Running::setMaxEval(unsigned int max) {
00077 m_maxeval = max;
00078 m_neval = 0;
00079 }
00080
00081 unsigned int Running::maxEval(void) {
00082 return m_maxeval;
00083 }
00084
00085 bool Running::isOptime(double fitness) {
00086 if (m_checkOptime->isOptime(fitness)) {
00087 m_optimized = true;
00088 return true;
00089 }
00090 else {
00091 return false;
00092 }
00093
00094 }
00095
00096 bool Running::isFinish(void) {
00097 if (m_optimized || (m_maxmsecs == 0 && (m_neval >= m_maxeval)) ) {
00098 return true;
00099 }
00100 else if (m_parent != NULL) {
00101 return m_parent->isFinish();
00102 }
00103 else if (m_maxmsecs > 0) {
00104 clock_t current = clock();
00105 clock_t dif = (10*(current-m_timeInit))/CLOCKS_PER_SEC;
00106 return (dif >= m_maxmsecs);
00107 }
00108 else {
00109 return false;
00110 }
00111 }
00112
00113 double Running::ratio(void) {
00114 if (m_neval == 0) {
00115 return 0;
00116 }
00117 else {
00118 return (( (double)m_neval)/m_maxeval);
00119 }
00120 }
00121
00122 unsigned int Running::numEval(void) {
00123 return m_neval;
00124 }
00125
00126 void Running::setThreshold(double dif) {
00127
00128 if (m_neval > 0) {
00129 throw new RunningException("Threshold can't be changed in running");
00130 }
00131
00132 m_checkOptime->setThreshold(dif);
00133 }
00134
00135 double Running::getThreshold(void) {
00136 if (m_checkOptime == NULL) {
00137 throw new RunningException("Max eval achieved");
00138 }
00139
00140 return m_checkOptime->getThreshold();
00141 }
00142
00143 void Running::notifyEval(double fit) {
00144 assert(fit >= 0);
00145 increm();
00146 if (isOptime(fit))
00147 m_best = fit;
00148 else if (m_neval == 1)
00149 m_best = fit;
00150 else if (m_checkOptime->isBetter(fit, m_best) ) {
00151 m_best = fit;
00152 }
00153
00154 if (m_parent != NULL) {
00155 m_parent->notifyEval(fit);
00156 }
00157
00158 }
00159
00160 RunningPtr Running::getSubRunning(unsigned submaxeval) {
00161 Running *run = new Running(m_checkOptime);
00162 run->setMaxEval(submaxeval);
00163 run->m_parent = this;
00164 m_children.push_back(run);
00165 return run;
00166 }
00167
00168
00169 Running::~Running(void) {
00170 list<Running*>::iterator item;
00171
00172 for (item = m_children.begin(); item != m_children.end(); ++item) {
00173 delete *item;
00174 }
00175 }
00176
00177 void Running::setMaxTime(unsigned ms) {
00178 m_maxmsecs = ms;
00179 m_timeInit = clock();
00180 }