[Avida-SVN] r1454 - branches/collect/source/main
blwalker at myxo.css.msu.edu
blwalker at myxo.css.msu.edu
Tue Apr 3 17:42:33 PDT 2007
Author: blwalker
Date: 2007-04-03 20:42:33 -0400 (Tue, 03 Apr 2007)
New Revision: 1454
Modified:
branches/collect/source/main/cOrganism.cc
branches/collect/source/main/cOrganism.h
branches/collect/source/main/cPhenotype.cc
branches/collect/source/main/cPhenotype.h
branches/collect/source/main/cPopulation.cc
branches/collect/source/main/cStats.cc
branches/collect/source/main/cStats.h
Log:
Completed statistics implementation: stats are now updated when they ought to be.
At the individual level, the following are available in both cur and last flavors:
- "internal" task count (tasks done using internal resources)
- internal task quality
- rbins_total (total resources absorbed over lifetime)
- rbins_avail (internal resources currently available)
At the population level, internal task data is available. rbin data is not as it did not seem likely to be very informative.
Modified: branches/collect/source/main/cOrganism.cc
===================================================================
--- branches/collect/source/main/cOrganism.cc 2007-04-03 17:28:54 UTC (rev 1453)
+++ branches/collect/source/main/cOrganism.cc 2007-04-04 00:42:33 UTC (rev 1454)
@@ -114,7 +114,29 @@
m_interface = interface;
}
+void cOrganism::SetRBins(const tArray<double>& rbins_in)
+{
+ m_rbins = rbins_in;
+ m_phenotype.SetCurRBinsAvail(rbins_in);
+ //@blw does not change cur_rbins_total
+}
+void cOrganism::SetRBin(const int index, const double value)
+{
+ m_rbins[index] = value;
+ m_phenotype.SetCurRBinAvail(index, value);
+ //@blw does not change cur_rbins_total
+}
+
+void cOrganism::AddToRBin(const int index, const double value)
+{
+ m_rbins[index] += value;
+ m_phenotype.AddToCurRBinAvail(index, value);
+
+ if(value > 0)
+ { m_phenotype.AddToCurRBinTotal(index, value); }
+}
+
double cOrganism::GetTestFitness(cAvidaContext& ctx)
{
assert(m_interface);
Modified: branches/collect/source/main/cOrganism.h
===================================================================
--- branches/collect/source/main/cOrganism.h 2007-04-03 17:28:54 UTC (rev 1453)
+++ branches/collect/source/main/cOrganism.h 2007-04-04 00:42:33 UTC (rev 1454)
@@ -163,9 +163,9 @@
const tArray<double>& GetRBins() const { return m_rbins; }
tArray<double>& GetRBins() { return m_rbins; }
- void SetRBins(const tArray<double>& rbins_in) { m_rbins = rbins_in; }
- void SetRBin(const int index, const double value) { m_rbins[index] = value; }
- void AddToRBin(const int index, const double value) { m_rbins[index] += value; }
+ void SetRBins(const tArray<double>& rbins_in);
+ void SetRBin(const int index, const double value);
+ void AddToRBin(const int index, const double value);
int GetMaxExecuted() const { return m_max_executed; }
Modified: branches/collect/source/main/cPhenotype.cc
===================================================================
--- branches/collect/source/main/cPhenotype.cc 2007-04-03 17:28:54 UTC (rev 1453)
+++ branches/collect/source/main/cPhenotype.cc 2007-04-04 00:42:33 UTC (rev 1454)
@@ -46,16 +46,20 @@
, eff_task_count(m_world->GetEnvironment().GetNumTasks())
, cur_task_quality(m_world->GetEnvironment().GetNumTasks())
, cur_internal_task_quality(m_world->GetEnvironment().GetNumTasks())
- , cur_rbin_total(m_world->GetNumResources())
- , cur_rbin_avail(m_world->GetNumResources())
+ , cur_rbins_total(m_world->GetNumResources())
+ , cur_rbins_avail(m_world->GetNumResources())
, cur_reaction_count(m_world->GetEnvironment().GetReactionLib().GetSize())
, cur_reaction_add_reward(m_world->GetEnvironment().GetReactionLib().GetSize())
, cur_inst_count(world->GetHardwareManager().GetInstSet().GetSize())
, cur_sense_count(m_world->GetStats().GetSenseSize())
, sensed_resources(m_world->GetEnvironment().GetResourceLib().GetSize())
, last_task_count(m_world->GetEnvironment().GetNumTasks())
+ , last_internal_task_count(m_world->GetEnvironment().GetNumTasks())
, last_reaction_add_reward(m_world->GetEnvironment().GetReactionLib().GetSize())
, last_task_quality(m_world->GetEnvironment().GetNumTasks())
+ , last_internal_task_quality(m_world->GetEnvironment().GetNumTasks())
+ , last_rbins_total(m_world->GetNumResources())
+ , last_rbins_avail(m_world->GetNumResources())
, last_reaction_count(m_world->GetEnvironment().GetReactionLib().GetSize())
, last_inst_count(world->GetHardwareManager().GetInstSet().GetSize())
, last_sense_count(m_world->GetStats().GetSenseSize())
@@ -137,8 +141,8 @@
eff_task_count.SetAll(0);
cur_task_quality.SetAll(0);
cur_internal_task_quality.SetAll(0);
- cur_rbin_total.SetAll(0);
- cur_rbin_avail.SetAll(0);
+ cur_rbins_total.SetAll(0);
+ cur_rbins_avail.SetAll(0);
cur_reaction_count.SetAll(0);
cur_reaction_add_reward.SetAll(0);
cur_inst_count.SetAll(0);
@@ -156,8 +160,8 @@
last_internal_task_count = parent_phenotype.last_internal_task_count;
last_task_quality = parent_phenotype.last_task_quality;
last_internal_task_quality= parent_phenotype.last_internal_task_quality;
- last_rbin_total = parent_phenotype.last_rbin_total;
- last_rbin_avail = parent_phenotype.last_rbin_avail;
+ last_rbins_total = parent_phenotype.last_rbins_total;
+ last_rbins_avail = parent_phenotype.last_rbins_avail;
last_reaction_count = parent_phenotype.last_reaction_count;
last_reaction_add_reward = parent_phenotype.last_reaction_add_reward;
last_inst_count = parent_phenotype.last_inst_count;
@@ -235,8 +239,8 @@
eff_task_count.SetAll(0);
cur_task_quality.SetAll(0);
cur_internal_task_quality.SetAll(0);
- cur_rbin_total.SetAll(0);
- cur_rbin_avail.SetAll(0);
+ cur_rbins_total.SetAll(0);
+ cur_rbins_avail.SetAll(0);
cur_reaction_count.SetAll(0);
cur_reaction_add_reward.SetAll(0);
cur_inst_count.SetAll(0);
@@ -253,8 +257,8 @@
last_internal_task_count.SetAll(0);
last_task_quality.SetAll(0);
last_internal_task_quality.SetAll(0);
- last_rbin_total.SetAll(0);
- last_rbin_avail.SetAll(0);
+ last_rbins_total.SetAll(0);
+ last_rbins_avail.SetAll(0);
last_reaction_count.SetAll(0);
last_reaction_add_reward.SetAll(0);
last_sense_count.SetAll(0);
@@ -337,8 +341,8 @@
last_internal_task_count = cur_internal_task_count;
last_task_quality = cur_task_quality;
last_internal_task_quality= cur_internal_task_quality;
- last_rbin_total = cur_rbin_total;
- last_rbin_avail = cur_rbin_avail;
+ last_rbins_total = cur_rbins_total;
+ last_rbins_avail = cur_rbins_avail;
last_reaction_count = cur_reaction_count;
last_reaction_add_reward = cur_reaction_add_reward;
last_inst_count = cur_inst_count;
@@ -353,8 +357,8 @@
eff_task_count.SetAll(0);
cur_task_quality.SetAll(0);
cur_internal_task_quality.SetAll(0);
- cur_rbin_total.SetAll(0);
- cur_rbin_avail.SetAll(0);
+ cur_rbins_total.SetAll(0);
+ cur_rbins_avail.SetAll(0);
cur_reaction_count.SetAll(0);
cur_reaction_add_reward.SetAll(0);
cur_inst_count.SetAll(0);
@@ -445,8 +449,8 @@
last_internal_task_count = cur_internal_task_count;
last_task_quality = cur_task_quality;
last_internal_task_quality= cur_internal_task_quality;
- last_rbin_total = cur_rbin_total;
- last_rbin_avail = cur_rbin_avail;
+ last_rbins_total = cur_rbins_total;
+ last_rbins_avail = cur_rbins_avail;
last_reaction_count = cur_reaction_count;
last_reaction_add_reward = cur_reaction_add_reward;
last_inst_count = cur_inst_count;
@@ -461,8 +465,8 @@
eff_task_count.SetAll(0);
cur_task_quality.SetAll(0);
cur_internal_task_quality.SetAll(0);
- cur_rbin_total.SetAll(0);
- cur_rbin_avail.SetAll(0);
+ cur_rbins_total.SetAll(0);
+ cur_rbins_avail.SetAll(0);
cur_reaction_count.SetAll(0);
cur_reaction_add_reward.SetAll(0);
cur_inst_count.SetAll(0);
@@ -673,9 +677,9 @@
double rbin_diff;
for(int i = 0; i < num_resources; i++)
{
- rbin_diff = cur_rbin_avail[i] - rbins_in[i];
- cur_rbin_avail[i] = rbins_in[i];
- if(rbin_diff > 0) { cur_rbin_total[i] += rbin_diff; }
+ rbin_diff = cur_rbins_avail[i] - rbins_in[i];
+ cur_rbins_avail[i] = rbins_in[i];
+ if(rbin_diff > 0) { cur_rbins_total[i] += rbin_diff; }
}
}
@@ -717,6 +721,15 @@
for (int i = 0; i < cur_task_count.GetSize(); i++) {
fp << cur_task_count[i] << " ";
}
+ for (int i = 0; i < cur_internal_task_count.GetSize(); i++) {
+ fp << cur_internal_task_count[i] << " ";
+ }
+ for (int i = 0; i < cur_rbins_total.GetSize(); i++) {
+ fp << cur_rbins_total[i] << " ";
+ }
+ for ( int i = 0; i < cur_rbins_avail.GetSize(); i++) {
+ fp << cur_rbins_avail[i] << " ";
+ }
for (int i = 0; i < cur_reaction_count.GetSize(); i++) {
fp << cur_reaction_count[i] << " ";
}
@@ -731,6 +744,15 @@
for (int i = 0; i < last_task_count.GetSize(); i++) {
fp << last_task_count[i] << " ";
}
+ for (int i = 0; i < last_internal_task_count.GetSize(); i++) {
+ fp << last_internal_task_count[i] << " ";
+ }
+ for (int i = 0; i < last_rbins_total.GetSize(); i++) {
+ fp << last_rbins_total[i] << " ";
+ }
+ for ( int i = 0; i < last_rbins_avail.GetSize(); i++) {
+ fp << last_rbins_avail[i] << " ";
+ }
for (int i = 0; i < last_reaction_count.GetSize(); i++) {
fp << last_reaction_count[i] << " ";
}
@@ -794,6 +816,15 @@
for (int i = 0; i < cur_task_count.GetSize(); i++) {
fp >> cur_task_count[i];
}
+ for (int i = 0; i < cur_internal_task_count.GetSize(); i++) {
+ fp >> cur_internal_task_count[i];
+ }
+ for (int i = 0; i < cur_rbins_total.GetSize(); i++) {
+ fp >> cur_rbins_total[i];
+ }
+ for (int i = 0; i < cur_rbins_avail.GetSize(); i++) {
+ fp >> cur_rbins_avail[i];
+ }
for (int i = 0; i < cur_reaction_count.GetSize(); i++) {
fp >> cur_reaction_count[i];
}
@@ -808,6 +839,15 @@
for (int i = 0; i < last_task_count.GetSize(); i++) {
fp >> last_task_count[i];
}
+ for (int i = 0; i < last_internal_task_count.GetSize(); i++) {
+ fp >> last_internal_task_count[i];
+ }
+ for (int i = 0; i < last_rbins_total.GetSize(); i++) {
+ fp >> last_rbins_total[i];
+ }
+ for (int i = 0; i < last_rbins_avail.GetSize(); i++) {
+ fp >> last_rbins_avail[i];
+ }
for (int i = 0; i < last_reaction_count.GetSize(); i++) {
fp >> last_reaction_count[i];
}
Modified: branches/collect/source/main/cPhenotype.h
===================================================================
--- branches/collect/source/main/cPhenotype.h 2007-04-03 17:28:54 UTC (rev 1453)
+++ branches/collect/source/main/cPhenotype.h 2007-04-04 00:42:33 UTC (rev 1454)
@@ -108,8 +108,8 @@
tArray<int> eff_task_count; // Total times each task was performed (resetable during the life of the organism)
tArray<double> cur_task_quality; // Average (total?) quality with which each task was performed
tArray<double> cur_internal_task_quality; // Average (total?) quaility with which each task using internal resources was performed
- tArray<double> cur_rbin_total; // Total amount of resources collected
- tArray<double> cur_rbin_avail; // Total amount of internal resources available
+ tArray<double> cur_rbins_total; // Total amount of resources collected
+ tArray<double> cur_rbins_avail; // Total amount of internal resources available
tArray<int> cur_reaction_count; // Total times each reaction was triggered.
tArray<double> cur_reaction_add_reward; // Bonus change from triggering each reaction.
tArray<int> cur_inst_count; // Instruction exection counter
@@ -133,8 +133,8 @@
tArray<int> last_internal_task_count;
tArray<double> last_task_quality;
tArray<double> last_internal_task_quality;
- tArray<double> last_rbin_total;
- tArray<double> last_rbin_avail;
+ tArray<double> last_rbins_total;
+ tArray<double> last_rbins_avail;
tArray<int> last_reaction_count;
tArray<double> last_reaction_add_reward;
tArray<int> last_inst_count; // Instruction exection counter
@@ -245,8 +245,8 @@
void ClearEffTaskCount() { assert(initialized == true); eff_task_count.SetAll(0); }
const tArray<double> & GetCurTaskQuality() const { assert(initialized == true); return cur_task_quality; }
const tArray<double> & GetCurInternalTaskQuality() const { assert(initialized == true); return cur_internal_task_quality; }
- const tArray<double>& GetCurRBinTotal() const { assert(initialized == true); return cur_rbin_total; }
- const tArray<double>& GetCurRBinAvail() const { assert(initialized == true); return cur_rbin_avail; }
+ const tArray<double>& GetCurRBinsTotal() const { assert(initialized == true); return cur_rbins_total; }
+ const tArray<double>& GetCurRBinsAvail() const { assert(initialized == true); return cur_rbins_avail; }
const tArray<int>& GetCurReactionCount() const { assert(initialized == true); return cur_reaction_count;}
const tArray<int>& GetCurInstCount() const { assert(initialized == true); return cur_inst_count; }
const tArray<int>& GetCurSenseCount() const { assert(initialized == true); return cur_sense_count; }
@@ -263,8 +263,8 @@
const tArray<int>& GetLastInternalTaskCount() const { assert(initialized == true); return last_internal_task_count; }
const tArray<double>& GetLastTaskQuality() const { assert(initialized == true); return last_task_quality; }
const tArray<double>& GetLastInternalTaskQuality() const { assert(initialized == true); return last_internal_task_quality; }
- const tArray<double>& GetLastRBinTotal() const { assert(initialized == true); return last_rbin_total; }
- const tArray<double>& GetLastRBinAvail() const { assert(initialized == true); return last_rbin_avail; }
+ const tArray<double>& GetLastRBinsTotal() const { assert(initialized == true); return last_rbins_total; }
+ const tArray<double>& GetLastRBinsAvail() const { assert(initialized == true); return last_rbins_avail; }
const tArray<int>& GetLastReactionCount() const { assert(initialized == true); return last_reaction_count; }
const tArray<double>& GetLastReactionAddReward() const { assert(initialized == true); return last_reaction_add_reward; }
const tArray<int>& GetLastInstCount() const { assert(initialized == true); return last_inst_count; }
@@ -317,6 +317,13 @@
void SetCrossNum(int _cross_num) { cross_num = _cross_num; }
void SetToDie() { to_die = true; }
void SetToDelete() { to_delete = true; }
+
+ void SetCurRBinsAvail(const tArray<double>& in_avail) { cur_rbins_avail = in_avail; }
+ void SetCurRbinsTotal(const tArray<double>& in_total) { cur_rbins_total = in_total; }
+ void SetCurRBinAvail(int index, double val) { cur_rbins_avail[index] = val; }
+ void SetCurRBinTotal(int index, double val) { cur_rbins_total[index] = val; }
+ void AddToCurRBinAvail(int index, double val) { cur_rbins_avail[index] += val; }
+ void AddToCurRBinTotal(int index, double val) { cur_rbins_total[index] += val; }
void SetIsDonorCur() { is_donor_cur = true; }
void SetIsReceiver() { is_receiver = true; }
Modified: branches/collect/source/main/cPopulation.cc
===================================================================
--- branches/collect/source/main/cPopulation.cc 2007-04-03 17:28:54 UTC (rev 1453)
+++ branches/collect/source/main/cPopulation.cc 2007-04-04 00:42:33 UTC (rev 1454)
@@ -1517,6 +1517,19 @@
}
}
+ // Test what tasks this organism has completed using internal resources.
+ for (int j = 0; j < m_world->GetEnvironment().GetNumTasks(); j++) {
+ if (phenotype.GetCurInternalTaskCount()[j] > 0) {
+ stats.AddCurInternalTask(j);
+ stats.AddCurInternalTaskQuality(j, phenotype.GetCurInternalTaskQuality()[j]);
+ }
+
+ if (phenotype.GetLastInternalTaskCount()[j] > 0) {
+ stats.AddLastInternalTask(j);
+ stats.AddLastInternalTaskQuality(j, phenotype.GetLastInternalTaskQuality()[j]);
+ }
+ }
+
// Record what add bonuses this organism garnered for different reactions
for (int j = 0; j < m_world->GetNumReactions(); j++) {
stats.AddLastReactionAddReward(j, phenotype.GetLastReactionAddReward()[j]);
Modified: branches/collect/source/main/cStats.cc
===================================================================
--- branches/collect/source/main/cStats.cc 2007-04-03 17:28:54 UTC (rev 1453)
+++ branches/collect/source/main/cStats.cc 2007-04-04 00:42:33 UTC (rev 1454)
@@ -159,10 +159,6 @@
task_internal_last_quality.Resize(num_tasks, 0);
task_internal_cur_max_quality.Resize(num_tasks, 0);
task_internal_last_max_quality.Resize(num_tasks, 0);
- rbin_avail_cur_count.Resize(m_world->GetNumResources(), 0);
- rbin_avail_last_count.Resize(m_world->GetNumResources(), 0);
- rbin_total_cur_count.Resize(m_world->GetNumResources(), 0);
- rbin_total_last_count.Resize(m_world->GetNumResources(), 0);
// This block calculates how many slots we need to
// make for paying attention to different label combinations
@@ -463,11 +459,6 @@
task_internal_cur_max_quality.SetAll(0);
task_internal_last_max_quality.SetAll(0);
- rbin_avail_cur_count.SetAll(0);
- rbin_avail_last_count.SetAll(0);
- rbin_total_cur_count.SetAll(0);
- rbin_total_last_count.SetAll(0);
-
sense_last_count.SetAll(0);
sense_last_exe_count.SetAll(0);
Modified: branches/collect/source/main/cStats.h
===================================================================
--- branches/collect/source/main/cStats.h 2007-04-03 17:28:54 UTC (rev 1453)
+++ branches/collect/source/main/cStats.h 2007-04-04 00:42:33 UTC (rev 1454)
@@ -224,10 +224,6 @@
tArray<double> task_internal_last_quality;
tArray<double> task_internal_cur_max_quality;
tArray<double> task_internal_last_max_quality;
- tArray<double> rbin_avail_cur_count;
- tArray<double> rbin_avail_last_count;
- tArray<double> rbin_total_cur_count;
- tArray<double> rbin_total_last_count;
tArray<double> reaction_count;
tArray<double> reaction_add_reward;
@@ -469,24 +465,20 @@
{ sense_last_exe_count[res_comb_index]+= count; }
// internal resource bins and use of internal resources
- void AddInternalCurTask(int task_num) { task_internal_cur_count[task_num]++; }
- void AddInternalCurTaskQuality(int task_num, double quality)
+ void AddCurInternalTask(int task_num) { task_internal_cur_count[task_num]++; }
+ void AddCurInternalTaskQuality(int task_num, double quality)
{
task_internal_cur_quality[task_num] += quality;
if(quality > task_internal_cur_max_quality[task_num])
task_internal_cur_max_quality[task_num] = quality;
}
- void AddInternalLastTask(int task_num) { task_internal_last_count[task_num]++; }
- void AddInternalLastTaskQuality(int task_num, double quality)
+ void AddLastInternalTask(int task_num) { task_internal_last_count[task_num]++; }
+ void AddLastInternalTaskQuality(int task_num, double quality)
{
task_internal_last_quality[task_num] += quality;
if(quality > task_internal_last_max_quality[task_num])
task_internal_last_max_quality[task_num] = quality;
}
- void SetCurAvailRBins(const tArray<double> &_in) { rbin_avail_cur_count = _in; }
- void SetLastAvailRBins(const tArray<double> &_in) { rbin_avail_last_count = _in; }
- void SetCurTotalRBins(const tArray<double> &_in) { rbin_total_cur_count = _in; }
- void SetLastTotalRBins(const tArray<double> &_in) { rbin_total_last_count = _in; }
void SetReactions(const tArray<double> &_in) { reaction_count = _in; }
void AddLastReactionAddReward(int _id, double _reward) { reaction_add_reward[_id] += _reward; }
@@ -546,16 +538,12 @@
int GetTaskExeCount(int task_num) const { return task_exe_count[task_num]; }
// internal resource bins and use of internal resources
- int GetTaskInternalCurCount(int task_num) const { return task_internal_cur_count[task_num]; }
- double GetTaskInternalCurQuality(int task_num) const { return task_internal_cur_quality[task_num]/(double)task_internal_cur_count[task_num]; }
- double GetTaskMaxInternalCurQuality(int task_num) const { return task_internal_cur_max_quality[task_num]; }
- int GetTaskInternalLastCount(int task_num) const { return task_internal_last_count[task_num]; }
- double GetTaskInternalLastQuality(int task_num) const { return task_internal_last_quality[task_num]/(double)task_internal_last_count[task_num]; }
- double GetTaskMaxInternalLastQuality(int task_num) const { return task_internal_last_max_quality[task_num]; }
- const tArray<double> & GetCurAvailRBins() const { return rbin_avail_cur_count; }
- const tArray<double> & GetLastAvailRBins() const { return rbin_avail_last_count; }
- const tArray<double> & GetCurTotalRBins() const { return rbin_total_cur_count; }
- const tArray<double> & GetLastTotalRBins() const { return rbin_total_last_count; }
+ int GetInternalTaskCurCount(int task_num) const { return task_internal_cur_count[task_num]; }
+ double GetInternalTaskCurQuality(int task_num) const { return task_internal_cur_quality[task_num]/(double)task_internal_cur_count[task_num]; }
+ double GetInternalTaskMaxCurQuality(int task_num) const { return task_internal_cur_max_quality[task_num]; }
+ int GetInternalTaskLastCount(int task_num) const { return task_internal_last_count[task_num]; }
+ double GetInternalTaskLastQuality(int task_num) const { return task_internal_last_quality[task_num]/(double)task_internal_last_count[task_num]; }
+ double GetInternalTaskMaxLastQuality(int task_num) const { return task_internal_last_max_quality[task_num]; }
const tArray<double> & GetReactions() const { return reaction_count; }
const tArray<double> & GetResources() const { return resource_count; }
More information about the Avida-cvs
mailing list