[Avida-SVN] r1863 - development/source/analyze
brysonda at myxo.css.msu.edu
brysonda at myxo.css.msu.edu
Sun Jul 29 19:08:14 PDT 2007
Author: brysonda
Date: 2007-07-29 22:08:14 -0400 (Sun, 29 Jul 2007)
New Revision: 1863
Modified:
development/source/analyze/cMutationalNeighborhood.cc
development/source/analyze/cMutationalNeighborhood.h
Log:
MutationalNeighborhood: Aggregate Two Step Data.
Modified: development/source/analyze/cMutationalNeighborhood.cc
===================================================================
--- development/source/analyze/cMutationalNeighborhood.cc 2007-07-30 01:32:27 UTC (rev 1862)
+++ development/source/analyze/cMutationalNeighborhood.cc 2007-07-30 02:08:14 UTC (rev 1863)
@@ -70,12 +70,24 @@
oddata.peak_genome = m_base_genome;
oddata.site_count.Resize(m_base_genome.GetSize(), 0);
+
// Setup Data Used in Two Step
- sStep& tdata = m_twostep_point[cur_site];
- tdata.peak_fitness = m_base_fitness;
- tdata.peak_genome = m_base_genome;
- tdata.site_count.Resize(m_base_genome.GetSize(), 0);
+ sStep& tpdata = m_twostep_point[cur_site];
+ tpdata.peak_fitness = m_base_fitness;
+ tpdata.peak_genome = m_base_genome;
+ tpdata.site_count.Resize(m_base_genome.GetSize(), 0);
+ sStep& tidata = m_twostep_insert[cur_site];
+ tidata.peak_fitness = m_base_fitness;
+ tidata.peak_genome = m_base_genome;
+ tidata.site_count.Resize(m_base_genome.GetSize() + 2, 0);
+
+ sStep& tddata = m_twostep_delete[cur_site];
+ tddata.peak_fitness = m_base_fitness;
+ tddata.peak_genome = m_base_genome;
+ tddata.site_count.Resize(m_base_genome.GetSize(), 0);
+
+
// Do the processing, starting with One Step
ProcessOneStepPoint(ctx, testcpu, test_info, cur_site);
ProcessOneStepInsert(ctx, testcpu, test_info, cur_site);
@@ -429,70 +441,63 @@
- // Initialize values
- sPendingTarget* pend = NULL;
-
m_tp.peak_fitness = m_base_fitness;
m_tp.peak_genome = m_base_genome;
m_tp.site_count.Resize(m_base_genome.GetSize(), 0);
+ AggregateTwoStep(m_twostep_point, m_tp);
- for (int i = 0; i < m_twostep_point.GetSize(); i++) {
- sTwoStep& tdata = m_twostep_point[i];
- m_tp.total += tdata.total;
- m_tp.total_fitness += tdata.total_fitness;
- m_tp.total_sqr_fitness += tdata.total_sqr_fitness;
- m_tp.pos += tdata.pos;
- m_tp.neg += tdata.neg;
- m_tp.neut += tdata.neut;
- m_tp.dead += tdata.dead;
- m_tp.size_pos += tdata.size_pos;
- m_tp.size_neg += tdata.size_neg;
+ m_ti.peak_fitness = m_base_fitness;
+ m_ti.peak_genome = m_base_genome;
+ m_ti.site_count.Resize(m_base_genome.GetSize() + 2, 0);
+ AggregateTwoStep(m_twostep_insert, m_ti);
- if (tdata.peak_fitness > m_tp.peak_fitness) {
- m_tp.peak_genome = tdata.peak_genome;
- m_tp.peak_fitness = tdata.peak_fitness;
- }
+ m_td.peak_fitness = m_base_fitness;
+ m_td.peak_genome = m_base_genome;
+ m_td.site_count.Resize(m_base_genome.GetSize(), 0);
+ AggregateTwoStep(m_twostep_delete, m_td);
+
+ // Collect totals across all two step mutants
+ m_tt.total = m_tp.total + m_ti.total + m_td.total;
+ m_tt.total_fitness = m_tp.total_fitness + m_ti.total_fitness + m_td.total_fitness;
+ m_tt.total_sqr_fitness = m_tp.total_sqr_fitness + m_ti.total_sqr_fitness + m_td.total_sqr_fitness;
- for (int j = 0; j < m_tp.site_count.GetSize(); j++) {
- m_tp.site_count[j] += tdata.site_count[j];
- }
-
- m_tp.task_target += tdata.task_target;
- m_tp.task_total += tdata.task_total;
- m_tp.task_knockout += tdata.task_knockout;
-
- m_tp.task_size_target += tdata.task_size_target;
- m_tp.task_size_total += tdata.task_size_total;
- m_tp.task_size_knockout += tdata.task_size_knockout;
-
- while ((pend = tdata.pending.Pop())) {
- double fitness = m_fitness_point[pend->site][pend->inst];
-
- if (fitness == 0.0) {
- m_tp.task_target_dead++;
- } else if (fitness < m_neut_min) {
- m_tp.task_target_neg++;
- m_tp.task_size_target_neg += fitness;
- } else if (fitness <= m_neut_max) {
- m_tp.task_target_neut++;
- } else {
- m_tp.task_target_pos++;
- m_tp.task_size_target_pos += fitness;
- }
-
- delete pend;
- }
+ if (m_tp.peak_fitness >= m_ti.peak_fitness && m_tp.peak_fitness >= m_td.peak_fitness) {
+ m_tt.peak_fitness = m_tp.peak_fitness;
+ m_tt.peak_genome = m_tp.peak_genome;
+ } else if (m_ti.peak_fitness >= m_td.peak_fitness) {
+ m_tt.peak_fitness = m_ti.peak_fitness;
+ m_tt.peak_genome = m_ti.peak_genome;
+ } else {
+ m_tt.peak_fitness = m_td.peak_fitness;
+ m_tt.peak_genome = m_td.peak_genome;
}
+
+ m_tt.pos = m_tp.pos + m_ti.pos + m_td.pos;
+ m_tt.neg = m_tp.neg + m_ti.neg + m_td.neg;
+ m_tt.neut = m_tp.neut + m_ti.neut + m_td.neut;
+ m_tt.dead = m_tp.dead + m_ti.dead + m_td.dead;
+ m_tt.size_pos = m_tp.size_pos + m_ti.size_pos + m_td.size_pos;
+ m_tt.size_neg = m_tp.size_neg + m_ti.size_neg + m_td.size_neg;
+
+ // @TODO - total_entropy/complexity across all mutation classes?
+
+ m_tt.task_target = m_tp.task_target + m_ti.task_target + m_td.task_target;
+ m_tt.task_target_pos = m_tp.task_target_pos + m_ti.task_target_pos + m_td.task_target_pos;
+ m_tt.task_target_neg = m_tp.task_target_neg + m_ti.task_target_neg + m_td.task_target_neg;
+ m_tt.task_target_neut = m_tp.task_target_neut + m_ti.task_target_neut + m_td.task_target_neut;
+ m_tt.task_target_dead = m_tp.task_target_dead + m_ti.task_target_dead + m_td.task_target_dead;
+ m_tt.task_total = m_tp.task_total + m_ti.task_total + m_td.task_total;
+ m_tt.task_knockout = m_tp.task_knockout + m_ti.task_knockout + m_td.task_knockout;
+
+ m_tt.task_size_target = m_tp.task_size_target + m_ti.task_size_target + m_td.task_size_target;
+ m_tt.task_size_target_pos = m_tp.task_size_target_pos + m_ti.task_size_target_pos + m_td.task_size_target_pos;
+ m_tt.task_size_target_neg = m_tp.task_size_target_neg + m_ti.task_size_target_neg + m_td.task_size_target_neg;
+ m_tt.task_size_total = m_tp.task_size_total + m_ti.task_size_total + m_td.task_size_total;
+ m_tt.task_size_knockout = m_tp.task_size_knockout + m_ti.task_size_knockout + m_td.task_size_knockout;
+
+
- const double max_ent = log(static_cast<double>(m_inst_set.GetSize()));
- for (int i = 0; i < m_base_genome.GetSize(); i++) {
- // Per-site entropy is the log of the number of legal states for that
- // site. Add one to account for the unmutated state.
- m_tp.total_entropy += log(static_cast<double>(m_tp.site_count[i] + 1)) / max_ent;
- }
- m_tp.complexity = m_base_genome.GetSize() - m_tp.total_entropy;
-
m_rwlock.WriteUnlock();
}
@@ -539,6 +544,70 @@
}
+void cMutationalNeighborhood::AggregateTwoStep(tArray<sTwoStep>& steps, sTwoStepAggregate tsa)
+{
+ sPendingTarget* pend = NULL;
+
+ for (int i = 0; i < steps.GetSize(); i++) {
+ sTwoStep& tdata = steps[i];
+ tsa.total += tdata.total;
+ tsa.total_fitness += tdata.total_fitness;
+ tsa.total_sqr_fitness += tdata.total_sqr_fitness;
+ tsa.pos += tdata.pos;
+ tsa.neg += tdata.neg;
+ tsa.neut += tdata.neut;
+ tsa.dead += tdata.dead;
+ tsa.size_pos += tdata.size_pos;
+ tsa.size_neg += tdata.size_neg;
+
+ if (tdata.peak_fitness > tsa.peak_fitness) {
+ tsa.peak_genome = tdata.peak_genome;
+ tsa.peak_fitness = tdata.peak_fitness;
+ }
+
+
+ for (int j = 0; j < tsa.site_count.GetSize(); j++) {
+ tsa.site_count[j] += tdata.site_count[j];
+ }
+
+ tsa.task_target += tdata.task_target;
+ tsa.task_total += tdata.task_total;
+ tsa.task_knockout += tdata.task_knockout;
+
+ tsa.task_size_target += tdata.task_size_target;
+ tsa.task_size_total += tdata.task_size_total;
+ tsa.task_size_knockout += tdata.task_size_knockout;
+
+ while ((pend = tdata.pending.Pop())) {
+ double fitness = m_fitness_point[pend->site][pend->inst];
+
+ if (fitness == 0.0) {
+ tsa.task_target_dead++;
+ } else if (fitness < m_neut_min) {
+ tsa.task_target_neg++;
+ tsa.task_size_target_neg += fitness;
+ } else if (fitness <= m_neut_max) {
+ tsa.task_target_neut++;
+ } else {
+ tsa.task_target_pos++;
+ tsa.task_size_target_pos += fitness;
+ }
+
+ delete pend;
+ }
+ }
+
+ const double max_ent = log(static_cast<double>(m_inst_set.GetSize()));
+ for (int i = 0; i < m_base_genome.GetSize(); i++) {
+ // Per-site entropy is the log of the number of legal states for that
+ // site. Add one to account for the unmutated state.
+ tsa.total_entropy += log(static_cast<double>(tsa.site_count[i] + 1)) / max_ent;
+ }
+ tsa.complexity = m_base_genome.GetSize() - tsa.total_entropy;
+
+}
+
+
void cMutationalNeighborhood::PrintStats(cDataFile& df, int update) const
{
df.Write(update, "Update/Tree Depth");
Modified: development/source/analyze/cMutationalNeighborhood.h
===================================================================
--- development/source/analyze/cMutationalNeighborhood.h 2007-07-30 01:32:27 UTC (rev 1862)
+++ development/source/analyze/cMutationalNeighborhood.h 2007-07-30 02:08:14 UTC (rev 1863)
@@ -144,6 +144,8 @@
struct sTwoStep : public sStep
{
tList<sPendingTarget> pending;
+
+ sTwoStep() : sStep() { ; }
};
tArray<sTwoStep> m_twostep_point;
tArray<sTwoStep> m_twostep_insert;
@@ -204,50 +206,25 @@
// Aggregated Two Step Data
// -----------------------------------------------------------------------------------------------------------------------
- struct sTwoStepAggregate
+ struct sTwoStepAggregate : public sOneStepAggregate
{
- int total;
-
- double total_fitness;
- double total_sqr_fitness;
- cGenome peak_genome;
- double peak_fitness;
-
- int pos;
- int neg;
- int neut;
- int dead;
- double size_pos;
- double size_neg;
-
- tArray<int> site_count;
-
- double total_entropy;
- double complexity;
-
- int task_target;
int task_target_pos;
int task_target_neg;
int task_target_neut;
int task_target_dead;
- int task_total;
- int task_knockout;
- double task_size_target;
double task_size_target_pos;
double task_size_target_neg;
- double task_size_total;
- double task_size_knockout;
- sTwoStepAggregate() : total(0), total_fitness(0.0), total_sqr_fitness(0.0), peak_fitness(0.0), pos(0), neg(0), neut(0),
- dead(0), size_pos(0.0), size_neg(0.0), total_entropy(0.0), complexity(0.0), task_target(0), task_total(0),
- task_knockout(0), task_size_target(0.0), task_size_target_pos(0.0), task_size_target_neg(0.0), task_size_total(0.0),
- task_size_knockout(0.0) { ; }
+ sTwoStepAggregate() : sOneStepAggregate(), task_target_pos(0), task_target_neg(0), task_target_neut(0),
+ task_target_dead(0), task_size_target_pos(0.0), task_size_target_neg(0.0) { ; }
};
sTwoStepAggregate m_tp;
sTwoStepAggregate m_ti;
sTwoStepAggregate m_td;
+
+ sTwoStepAggregate m_tt;
@@ -279,20 +256,20 @@
void ProcessOneStepDelete(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site);
double ProcessOneStepGenome(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, const cGenome& mod_genome,
sStep& odata, int cur_site);
-
+ void AggregateOneStep(tArray<sStep>& steps, sOneStepAggregate osa);
+
void ProcessTwoStepPoint(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site, cGenome& mod_genome);
void ProcessTwoStepInsert(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site, cCPUMemory& mod_genome);
void ProcessTwoStepDelete(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site, cCPUMemory& mod_genome);
// void ProcessInDelPointCombo(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site, cGenome& mod_genome);
double ProcessTwoStepGenome(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, const cGenome& mod_genome,
sTwoStep& tdata, int cur_site, int oth_site);
+ void AggregateTwoStep(tArray<sTwoStep>& steps, sTwoStepAggregate osa);
void ProcessComplete(cAvidaContext& ctx);
- void AggregateOneStep(tArray<sStep>& steps, sOneStepAggregate osa);
-
// cMutationalNeighborhoodResults Backing Methods
// -----------------------------------------------------------------------------------------------------------------------
void PrintStats(cDataFile& df, int update = -1) const;
More information about the Avida-cvs
mailing list