[Avida-SVN] r1854 - development/source/analyze
brysonda at myxo.css.msu.edu
brysonda at myxo.css.msu.edu
Fri Jul 27 10:07:05 PDT 2007
Author: brysonda
Date: 2007-07-27 13:07:05 -0400 (Fri, 27 Jul 2007)
New Revision: 1854
Modified:
development/source/analyze/cMutationalNeighborhood.cc
development/source/analyze/cMutationalNeighborhood.h
Log:
MutationalNeighborhood: Encapsulate one step aggregate date in a reusable structure and aggregation function.
Modified: development/source/analyze/cMutationalNeighborhood.cc
===================================================================
--- development/source/analyze/cMutationalNeighborhood.cc 2007-07-27 16:25:10 UTC (rev 1853)
+++ development/source/analyze/cMutationalNeighborhood.cc 2007-07-27 17:07:05 UTC (rev 1854)
@@ -55,7 +55,7 @@
cCPUTestInfo test_info;
// Setup One Step Data
- sStep& odata = m_onestep[cur_site];
+ sStep& odata = m_onestep_point[cur_site];
odata.peak_fitness = m_base_fitness;
odata.peak_genome = m_base_genome;
odata.site_count.Resize(m_base_genome.GetSize(), 0);
@@ -105,7 +105,7 @@
delete testcpu;
// Setup state to begin processing
- m_onestep.ResizeClear(m_base_genome.GetSize());
+ m_onestep_point.ResizeClear(m_base_genome.GetSize());
m_twostep.ResizeClear(m_base_genome.GetSize());
m_fitness.ResizeClear(m_base_genome.GetSize(), m_inst_set.GetSize());
@@ -129,7 +129,7 @@
void cMutationalNeighborhood::ProcessOneStepPoint(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site)
{
const int inst_size = m_inst_set.GetSize();
- sStep& odata = m_onestep[cur_site];
+ sStep& odata = m_onestep_point[cur_site];
cGenome mod_genome(m_base_genome);
@@ -272,66 +272,8 @@
void cMutationalNeighborhood::ProcessComplete(cAvidaContext& ctx)
{
- // Initialize values
- m_o_total = 0;
- m_o_total_sqr_fitness = 0.0;
- m_o_pos = 0;
- m_o_neg = 0;
- m_o_neut = 0;
- m_o_dead = 0;
- m_o_size_pos = 0.0;
- m_o_size_neg = 0.0;
- m_o_peak_fitness = m_base_fitness;
- m_o_peak_genome = m_base_genome;
- m_o_site_count.Resize(m_base_genome.GetSize(), 0);
- m_o_total_entropy = 0;
- m_o_task_target = 0;
- m_o_task_total = 0;
- m_o_task_knockout = 0;
- m_o_task_size_target = 0.0;
- m_o_task_size_total = 0.0;
- m_o_task_size_knockout = 0.0;
-
- for (int i = 0; i < m_onestep.GetSize(); i++) {
- sStep& odata = m_onestep[i];
- m_o_total += odata.total;
- m_o_total_fitness += odata.total_fitness;
- m_o_total_sqr_fitness += odata.total_sqr_fitness;
- m_o_pos += odata.pos;
- m_o_neg += odata.neg;
- m_o_neut += odata.neut;
- m_o_dead += odata.dead;
- m_o_size_pos += odata.size_pos;
- m_o_size_neg += odata.size_neg;
+ AggregateOneStep(m_onestep_point, m_op);
- if (odata.peak_fitness > m_o_peak_fitness) {
- m_o_peak_genome = odata.peak_genome;
- m_o_peak_fitness = odata.peak_fitness;
- }
-
-
- for (int j = 0; j < m_o_site_count.GetSize(); j++) {
- m_o_site_count[j] += odata.site_count[j];
- }
-
- m_o_task_target += odata.task_target;
- m_o_task_total += odata.task_total;
- m_o_task_knockout += odata.task_knockout;
-
- m_o_task_size_target += odata.task_size_target;
- m_o_task_size_total += odata.task_size_total;
- m_o_task_size_knockout += odata.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_o_total_entropy += log(static_cast<double>(m_o_site_count[i] + 1)) / max_ent;
- }
- m_o_complexity = m_base_genome.GetSize() - m_o_total_entropy;
-
-
// Initialize values
m_t_total = 0;
m_t_total_sqr_fitness = 0.0;
@@ -389,6 +331,7 @@
m_t_task_size_knockout += tdata.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.
@@ -418,7 +361,54 @@
m_rwlock.WriteUnlock();
}
+void cMutationalNeighborhood::AggregateOneStep(tArray<sStep>& steps, sOneStepAggregate osa)
+{
+ // Initialize values
+ osa.peak_fitness = m_base_fitness;
+ osa.peak_genome = m_base_genome;
+ osa.site_count.Resize(m_base_genome.GetSize(), 0);
+
+ for (int i = 0; i < steps.GetSize(); i++) {
+ sStep& odata = steps[i];
+ osa.total += odata.total;
+ osa.total_fitness += odata.total_fitness;
+ osa.total_sqr_fitness += odata.total_sqr_fitness;
+ osa.pos += odata.pos;
+ osa.neg += odata.neg;
+ osa.neut += odata.neut;
+ osa.dead += odata.dead;
+ osa.size_pos += odata.size_pos;
+ osa.size_neg += odata.size_neg;
+
+ if (odata.peak_fitness > osa.peak_fitness) {
+ osa.peak_genome = odata.peak_genome;
+ osa.peak_fitness = odata.peak_fitness;
+ }
+
+
+ for (int j = 0; j < osa.site_count.GetSize(); j++) {
+ osa.site_count[j] += odata.site_count[j];
+ }
+
+ osa.task_target += odata.task_target;
+ osa.task_total += odata.task_total;
+ osa.task_knockout += odata.task_knockout;
+
+ osa.task_size_target += odata.task_size_target;
+ osa.task_size_total += odata.task_size_total;
+ osa.task_size_knockout += odata.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.
+ osa.total_entropy += log(static_cast<double>(osa.site_count[i] + 1)) / max_ent;
+ }
+ osa.complexity = m_base_genome.GetSize() - osa.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-27 16:25:10 UTC (rev 1853)
+++ development/source/analyze/cMutationalNeighborhood.h 2007-07-27 17:07:05 UTC (rev 1854)
@@ -103,7 +103,9 @@
size_pos(0.0), size_neg(0.0), task_target(0), task_total(0), task_knockout(0), task_size_target(0.0),
task_size_total(0.0), task_size_knockout(0.0) { ; }
};
- tArray<sStep> m_onestep;
+ tArray<sStep> m_onestep_point;
+ tArray<sStep> m_onestep_insert;
+ tArray<sStep> m_onestep_delete;
tArray<sStep> m_twostep;
tMatrix<double> m_fitness;
@@ -119,6 +121,7 @@
const cInstSet& m_inst_set;
int m_target;
+
// Base data
// --------------------------------------------------------------------------
cGenome m_base_genome;
@@ -129,35 +132,46 @@
double m_neut_min; // These two variables are a range around the base
double m_neut_max; // fitness to be counted as neutral mutations.
+
// Aggregated One Step Data
// --------------------------------------------------------------------------
- int m_o_total;
-
- double m_o_total_fitness;
- double m_o_total_sqr_fitness;
- cGenome m_o_peak_genome;
- double m_o_peak_fitness;
+ struct 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_total;
+ int task_knockout;
+
+ double task_size_target;
+ double task_size_total;
+ double task_size_knockout;
+
+ sOneStepAggregate() : 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_total(0.0), task_size_knockout(0.0) { ; }
+ };
- int m_o_pos;
- int m_o_neg;
- int m_o_neut;
- int m_o_dead;
- double m_o_size_pos;
- double m_o_size_neg;
+ sOneStepAggregate m_op;
- tArray<int> m_o_site_count;
- double m_o_total_entropy;
- double m_o_complexity;
-
- int m_o_task_target;
- int m_o_task_total;
- int m_o_task_knockout;
-
- double m_o_task_size_target;
- double m_o_task_size_total;
- double m_o_task_size_knockout;
-
// Aggregated Two Step Data
// --------------------------------------------------------------------------
int m_t_total;
@@ -204,6 +218,8 @@
// void ProcessInDelPointCombo(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site, cGenome& mod_genome);
void ProcessComplete(cAvidaContext& ctx);
+ void AggregateOneStep(tArray<sStep>& steps, sOneStepAggregate osa);
+
cMutationalNeighborhood(); // @not_implemented
cMutationalNeighborhood(const cMutationalNeighborhood&); // @not_implemented
cMutationalNeighborhood& operator=(const cMutationalNeighborhood&); // @not_implemented
@@ -235,40 +251,40 @@
if (m_base_tasks.GetSize()) return m_base_tasks[m_target]; else return false;
}
- inline int GetSingleTotal() const { return m_o_total; }
+ inline int GetSingleTotal() const { return m_op.total; }
- inline double GetSingleAverageFitness() const { return m_o_total_fitness / m_o_total; }
- inline double GetSingleAverageSqrFitness() const { return m_o_total_sqr_fitness / m_o_total; }
- inline const cGenome& GetSinglePeakGenome() const { return m_o_peak_genome; }
- inline double GetSinglePeakFitness() const { return m_o_peak_fitness; }
+ inline double GetSingleAverageFitness() const { return m_op.total_fitness / m_op.total; }
+ inline double GetSingleAverageSqrFitness() const { return m_op.total_sqr_fitness / m_op.total; }
+ inline const cGenome& GetSinglePeakGenome() const { return m_op.peak_genome; }
+ inline double GetSinglePeakFitness() const { return m_op.peak_fitness; }
- inline double GetSingleProbBeneficial() const { return double(m_o_pos) / m_o_total; }
- inline double GetSingleProbDeleterious() const { return double(m_o_neg) / m_o_total; }
- inline double GetSingleProbNeutral() const { return double(m_o_neut) / m_o_total; }
- inline double GetSingleProbLethal() const { return double(m_o_dead) / m_o_total; }
- inline double GetSingleAverageSizeBeneficial() const { if (m_o_pos == 0) return 0.0; else return m_o_size_pos / m_o_pos; }
- inline double GetSingleAverageSizeDeleterious() const { if (m_o_neg == 0) return 0.0; else return m_o_size_neg / m_o_neg; }
+ inline double GetSingleProbBeneficial() const { return double(m_op.pos) / m_op.total; }
+ inline double GetSingleProbDeleterious() const { return double(m_op.neg) / m_op.total; }
+ inline double GetSingleProbNeutral() const { return double(m_op.neut) / m_op.total; }
+ inline double GetSingleProbLethal() const { return double(m_op.dead) / m_op.total; }
+ inline double GetSingleAverageSizeBeneficial() const { if (m_op.pos == 0) return 0.0; else return m_op.size_pos / m_op.pos; }
+ inline double GetSingleAverageSizeDeleterious() const { if (m_op.neg == 0) return 0.0; else return m_op.size_neg / m_op.neg; }
- inline double GetSingleTotalEntropy() const { return m_o_total_entropy; }
- inline double GetSingleComplexity() const { return m_o_complexity; }
+ inline double GetSingleTotalEntropy() const { return m_op.total_entropy; }
+ inline double GetSingleComplexity() const { return m_op.complexity; }
- inline int GetSingleTargetTask() const { return m_o_task_target; }
- inline double GetSingleProbTargetTask() const { return double(m_o_task_target) / m_o_total; }
+ inline int GetSingleTargetTask() const { return m_op.task_target; }
+ inline double GetSingleProbTargetTask() const { return double(m_op.task_target) / m_op.total; }
inline double GetSingleAverageSizeTargetTask() const
{
- if (m_o_task_target == 0) return 0.0; else return double(m_o_task_size_target) / m_o_task_target;
+ if (m_op.task_target == 0) return 0.0; else return double(m_op.task_size_target) / m_op.task_target;
}
- inline int GetSingleTask() const { return m_o_task_total; }
- inline double GetSingleProbTask() const { return double(m_o_task_total) / m_o_total; }
+ inline int GetSingleTask() const { return m_op.task_total; }
+ inline double GetSingleProbTask() const { return double(m_op.task_total) / m_op.total; }
inline double GetSingleAverageSizeTask() const
{
- if (m_o_task_total == 0) return 0.0; else return double(m_o_task_size_total) / m_o_task_total;
+ if (m_op.task_total == 0) return 0.0; else return double(m_op.task_size_total) / m_op.task_total;
}
- inline int GetSingleKnockout() const { return m_o_task_knockout; }
- inline double GetSingleProbKnockout() const { return double(m_o_task_knockout) / m_o_total; }
+ inline int GetSingleKnockout() const { return m_op.task_knockout; }
+ inline double GetSingleProbKnockout() const { return double(m_op.task_knockout) / m_op.total; }
inline double GetSingleAverageSizeKnockout() const
{
- if (m_o_task_knockout == 0) return 0.0; else return double(m_o_task_size_knockout) / m_o_task_knockout;
+ if (m_op.task_knockout == 0) return 0.0; else return double(m_op.task_size_knockout) / m_op.task_knockout;
}
More information about the Avida-cvs
mailing list