[Avida-SVN] r1858 - development/source/analyze
brysonda at myxo.css.msu.edu
brysonda at myxo.css.msu.edu
Fri Jul 27 13:09:59 PDT 2007
Author: brysonda
Date: 2007-07-27 16:09:59 -0400 (Fri, 27 Jul 2007)
New Revision: 1858
Modified:
development/source/analyze/cMutationalNeighborhood.cc
development/source/analyze/cMutationalNeighborhood.h
Log:
MutationalNeighborhood: Encapsulate two step results.
Modified: development/source/analyze/cMutationalNeighborhood.cc
===================================================================
--- development/source/analyze/cMutationalNeighborhood.cc 2007-07-27 19:30:12 UTC (rev 1857)
+++ development/source/analyze/cMutationalNeighborhood.cc 2007-07-27 20:09:59 UTC (rev 1858)
@@ -55,13 +55,23 @@
cCPUTestInfo test_info;
// Setup One Step Data
- 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);
+ sStep& opdata = m_onestep_point[cur_site];
+ opdata.peak_fitness = m_base_fitness;
+ opdata.peak_genome = m_base_genome;
+ opdata.site_count.Resize(m_base_genome.GetSize(), 0);
+ sStep& oidata = m_onestep_insert[cur_site];
+ oidata.peak_fitness = m_base_fitness;
+ oidata.peak_genome = m_base_genome;
+ oidata.site_count.Resize(m_base_genome.GetSize() + 1, 0);
+
+ sStep& oddata = m_onestep_delete[cur_site];
+ oddata.peak_fitness = m_base_fitness;
+ 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[cur_site];
+ 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);
@@ -114,7 +124,7 @@
m_onestep_point.ResizeClear(m_base_genome.GetSize());
m_onestep_insert.ResizeClear(m_base_genome.GetSize() + 1);
m_onestep_delete.ResizeClear(m_base_genome.GetSize());
- m_twostep.ResizeClear(m_base_genome.GetSize());
+ m_twostep_point.ResizeClear(m_base_genome.GetSize());
m_fitness_point.ResizeClear(m_base_genome.GetSize(), m_inst_set.GetSize());
m_fitness_insert.ResizeClear(m_base_genome.GetSize() + 1, m_inst_set.GetSize());
m_fitness_delete.ResizeClear(m_base_genome.GetSize());
@@ -251,7 +261,7 @@
int cur_site, cGenome& mod_genome)
{
const int inst_size = m_inst_set.GetSize();
- sStep& tdata = m_twostep[cur_site];
+ sStep& tdata = m_twostep_point[cur_site];
// Loop through remaining lines of genome, testing trying all combinations.
for (int line_num = cur_site + 1; line_num < m_base_genome.GetSize(); line_num++) {
@@ -375,84 +385,63 @@
// Initialize values
- m_t_total = 0;
- m_t_total_sqr_fitness = 0.0;
- m_t_pos = 0;
- m_t_neg = 0;
- m_t_neut = 0;
- m_t_dead = 0;
- m_t_size_pos = 0.0;
- m_t_size_neg = 0.0;
- m_t_peak_fitness = m_base_fitness;
- m_t_peak_genome = m_base_genome;
- m_t_site_count.Resize(m_base_genome.GetSize(), 0);
- m_t_total_entropy = 0;
- m_t_task_target = 0;
- m_t_task_target_pos = 0;
- m_t_task_target_neg = 0;
- m_t_task_target_neut = 0;
- m_t_task_target_dead = 0;
- m_t_task_total = 0;
- m_t_task_knockout = 0;
- m_t_task_size_target = 0.0;
- m_t_task_size_target_pos = 0.0;
- m_t_task_size_target_neg = 0.0;
- m_t_task_size_total = 0.0;
- m_t_task_size_knockout = 0.0;
+ m_tp.peak_fitness = m_base_fitness;
+ m_tp.peak_genome = m_base_genome;
+ m_tp.site_count.Resize(m_base_genome.GetSize(), 0);
- for (int i = 0; i < m_twostep.GetSize(); i++) {
- sStep& tdata = m_twostep[i];
- m_t_total += tdata.total;
- m_t_total_fitness += tdata.total_fitness;
- m_t_total_sqr_fitness += tdata.total_sqr_fitness;
- m_t_pos += tdata.pos;
- m_t_neg += tdata.neg;
- m_t_neut += tdata.neut;
- m_t_dead += tdata.dead;
- m_t_size_pos += tdata.size_pos;
- m_t_size_neg += tdata.size_neg;
+ for (int i = 0; i < m_twostep_point.GetSize(); i++) {
+ sStep& 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;
- if (tdata.peak_fitness > m_t_peak_fitness) {
- m_t_peak_genome = tdata.peak_genome;
- m_t_peak_fitness = tdata.peak_fitness;
+ if (tdata.peak_fitness > m_tp.peak_fitness) {
+ m_tp.peak_genome = tdata.peak_genome;
+ m_tp.peak_fitness = tdata.peak_fitness;
}
- for (int j = 0; j < m_t_site_count.GetSize(); j++) {
- m_t_site_count[j] += tdata.site_count[j];
+ for (int j = 0; j < m_tp.site_count.GetSize(); j++) {
+ m_tp.site_count[j] += tdata.site_count[j];
}
- m_t_task_target += tdata.task_target;
- m_t_task_total += tdata.task_total;
- m_t_task_knockout += tdata.task_knockout;
+ m_tp.task_target += tdata.task_target;
+ m_tp.task_total += tdata.task_total;
+ m_tp.task_knockout += tdata.task_knockout;
- m_t_task_size_target += tdata.task_size_target;
- m_t_task_size_total += tdata.task_size_total;
- m_t_task_size_knockout += tdata.task_size_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;
}
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_t_total_entropy += log(static_cast<double>(m_t_site_count[i] + 1)) / max_ent;
+ m_tp.total_entropy += log(static_cast<double>(m_tp.site_count[i] + 1)) / max_ent;
}
- m_t_complexity = m_base_genome.GetSize() - m_t_total_entropy;
+ m_tp.complexity = m_base_genome.GetSize() - m_tp.total_entropy;
sPendingTarget* pend = NULL;
while ((pend = m_pending.Pop())) {
double fitness = m_fitness_point[pend->site][pend->inst];
if (fitness == 0.0) {
- m_t_task_target_dead++;
+ m_tp.task_target_dead++;
} else if (fitness < m_neut_min) {
- m_t_task_target_neg++;
- m_t_task_size_target_neg += fitness;
+ m_tp.task_target_neg++;
+ m_tp.task_size_target_neg += fitness;
} else if (fitness <= m_neut_max) {
- m_t_task_target_neut++;
+ m_tp.task_target_neut++;
} else {
- m_t_task_target_pos++;
- m_t_task_size_target_pos += fitness;
+ m_tp.task_target_pos++;
+ m_tp.task_size_target_pos += fitness;
}
delete pend;
Modified: development/source/analyze/cMutationalNeighborhood.h
===================================================================
--- development/source/analyze/cMutationalNeighborhood.h 2007-07-27 19:30:12 UTC (rev 1857)
+++ development/source/analyze/cMutationalNeighborhood.h 2007-07-27 20:09:59 UTC (rev 1858)
@@ -106,7 +106,7 @@
tArray<sStep> m_onestep_point;
tArray<sStep> m_onestep_insert;
tArray<sStep> m_onestep_delete;
- tArray<sStep> m_twostep;
+ tArray<sStep> m_twostep_point;
tMatrix<double> m_fitness_point;
tMatrix<double> m_fitness_insert;
@@ -181,40 +181,51 @@
// Aggregated Two Step Data
// --------------------------------------------------------------------------
- int m_t_total;
+ struct sTwoStepAggregate
+ {
+ int total;
- double m_t_total_fitness;
- double m_t_total_sqr_fitness;
- cGenome m_t_peak_genome;
- double m_t_peak_fitness;
-
- int m_t_pos;
- int m_t_neg;
- int m_t_neut;
- int m_t_dead;
- double m_t_size_pos;
- double m_t_size_neg;
-
- tArray<int> m_t_site_count;
-
- double m_t_total_entropy;
- double m_t_complexity;
+ 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 m_t_task_target;
- int m_t_task_target_pos;
- int m_t_task_target_neg;
- int m_t_task_target_neut;
- int m_t_task_target_dead;
- int m_t_task_total;
- int m_t_task_knockout;
+ 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 m_t_task_size_target;
- double m_t_task_size_target_pos;
- double m_t_task_size_target_neg;
- double m_t_task_size_total;
- double m_t_task_size_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 m_tp;
+
+
void ProcessInitialize(cAvidaContext& ctx);
void ProcessOneStepPoint(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site);
@@ -421,68 +432,68 @@
- inline int GetDoubleTotal() const { return m_t_total; }
+ inline int GetDoubleTotal() const { return m_tp.total; }
- inline double GetDoubleAverageFitness() const { return m_t_total_fitness / m_t_total; }
- inline double GetDoubleAverageSqrFitness() const { return m_t_total_sqr_fitness / m_t_total; }
- inline const cGenome& GetDoublePeakGenome() const { return m_t_peak_genome; }
- inline double GetDoublePeakFitness() const { return m_t_peak_fitness; }
+ inline double GetDoubleAverageFitness() const { return m_tp.total_fitness / m_tp.total; }
+ inline double GetDoubleAverageSqrFitness() const { return m_tp.total_sqr_fitness / m_tp.total; }
+ inline const cGenome& GetDoublePeakGenome() const { return m_tp.peak_genome; }
+ inline double GetDoublePeakFitness() const { return m_tp.peak_fitness; }
- inline double GetDoubleProbBeneficial() const { return double(m_t_pos) / m_t_total; }
- inline double GetDoubleProbDeleterious() const { return double(m_t_neg) / m_t_total; }
- inline double GetDoubleProbNeutral() const { return double(m_t_neut) / m_t_total; }
- inline double GetDoubleProbLethal() const { return double(m_t_dead) / m_t_total; }
- inline double GetDoubleAverageSizeBeneficial() const { if (m_t_pos == 0) return 0.0; else return m_t_size_pos / m_t_pos; }
- inline double GetDoubleAverageSizeDeleterious() const { if (m_t_neg == 0) return 0.0; else return m_t_size_neg / m_t_neg; }
+ inline double GetDoubleProbBeneficial() const { return double(m_tp.pos) / m_tp.total; }
+ inline double GetDoubleProbDeleterious() const { return double(m_tp.neg) / m_tp.total; }
+ inline double GetDoubleProbNeutral() const { return double(m_tp.neut) / m_tp.total; }
+ inline double GetDoubleProbLethal() const { return double(m_tp.dead) / m_tp.total; }
+ inline double GetDoubleAverageSizeBeneficial() const { if (m_tp.pos == 0) return 0.0; else return m_tp.size_pos / m_tp.pos; }
+ inline double GetDoubleAverageSizeDeleterious() const { if (m_tp.neg == 0) return 0.0; else return m_tp.size_neg / m_tp.neg; }
- inline double GetDoubleTotalEntropy() const { return m_t_total_entropy; }
- inline double GetDoubleComplexity() const { return m_t_complexity; }
+ inline double GetDoubleTotalEntropy() const { return m_tp.total_entropy; }
+ inline double GetDoubleComplexity() const { return m_tp.complexity; }
- inline int GetDoubleTargetTask() const { return m_t_task_target; }
- inline double GetDoubleProbTargetTask() const { return double(m_t_task_target) / m_t_total; }
+ inline int GetDoubleTargetTask() const { return m_tp.task_target; }
+ inline double GetDoubleProbTargetTask() const { return double(m_tp.task_target) / m_tp.total; }
inline double GetDoubleAverageSizeTargetTask() const
{
- if (m_t_task_target == 0) return 0.0; else return double(m_t_task_size_target) / m_t_task_target;
+ if (m_tp.task_target == 0) return 0.0; else return double(m_tp.task_size_target) / m_tp.task_target;
}
- inline int GetDoubleTargetTaskBeneficial() const { return m_t_task_target_pos; }
+ inline int GetDoubleTargetTaskBeneficial() const { return m_tp.task_target_pos; }
inline double GetDoubleProbTargetTaskBeneficial() const
{
- if (m_t_task_target == 0) return 0.0; else return double(m_t_task_target_pos) / (2 * m_t_task_target);
+ if (m_tp.task_target == 0) return 0.0; else return double(m_tp.task_target_pos) / (2 * m_tp.task_target);
}
inline double GetDoubleAverageSizeTargetTaskBeneficial() const
{
- if (m_t_task_target == 0) return 0.0; else return double(m_t_task_size_target_pos) / (2 * m_t_task_target);
+ if (m_tp.task_target == 0) return 0.0; else return double(m_tp.task_size_target_pos) / (2 * m_tp.task_target);
}
- inline int GetDoubleTargetTaskDeleterious() const { return m_t_task_target_neg; }
+ inline int GetDoubleTargetTaskDeleterious() const { return m_tp.task_target_neg; }
inline double GetDoubleProbTargetTaskDeleterious() const
{
- if (m_t_task_target == 0) return 0.0; else return double(m_t_task_target_neg) / (2 * m_t_task_target);
+ if (m_tp.task_target == 0) return 0.0; else return double(m_tp.task_target_neg) / (2 * m_tp.task_target);
}
inline double GetDoubleAverageSizeTargetTaskDeleterious() const
{
- if (m_t_task_target == 0) return 0.0; else return double(m_t_task_size_target_neg) / (2 * m_t_task_target);
+ if (m_tp.task_target == 0) return 0.0; else return double(m_tp.task_size_target_neg) / (2 * m_tp.task_target);
}
- inline int GetDoubleTargetTaskNeutral() const { return m_t_task_target_neut; }
+ inline int GetDoubleTargetTaskNeutral() const { return m_tp.task_target_neut; }
inline double GetDoubleProbTargetTaskNeutral() const
{
- if (m_t_task_target == 0) return 0.0; else return double(m_t_task_target_neut) / (2 * m_t_task_target);
+ if (m_tp.task_target == 0) return 0.0; else return double(m_tp.task_target_neut) / (2 * m_tp.task_target);
}
- inline int GetDoubleTargetTaskLethal() const { return m_t_task_target_dead; }
+ inline int GetDoubleTargetTaskLethal() const { return m_tp.task_target_dead; }
inline double GetDoubleProbTargetTaskLethal() const
{
- if (m_t_task_target == 0) return 0.0; else return double(m_t_task_target_dead) / (2 * m_t_task_target);
+ if (m_tp.task_target == 0) return 0.0; else return double(m_tp.task_target_dead) / (2 * m_tp.task_target);
}
- inline int GetDoubleTask() const { return m_t_task_total; }
- inline double GetDoubleProbTask() const { return double(m_t_task_total) / m_t_total; }
+ inline int GetDoubleTask() const { return m_tp.task_total; }
+ inline double GetDoubleProbTask() const { return double(m_tp.task_total) / m_tp.total; }
inline double GetDoubleAverageSizeTask() const
{
- if (m_t_task_total == 0) return 0.0; else return double(m_t_task_size_total) / m_t_task_total;
+ if (m_tp.task_total == 0) return 0.0; else return double(m_tp.task_size_total) / m_tp.task_total;
}
- inline int GetDoubleKnockout() const { return m_t_task_knockout; }
- inline double GetDoubleProbKnockout() const { return double(m_t_task_knockout) / m_t_total; }
+ inline int GetDoubleKnockout() const { return m_tp.task_knockout; }
+ inline double GetDoubleProbKnockout() const { return double(m_tp.task_knockout) / m_tp.total; }
inline double GetDoubleAverageSizeKnockout() const
{
- if (m_t_task_knockout == 0) return 0.0; else return double(m_t_task_size_knockout) / m_t_task_knockout;
+ if (m_tp.task_knockout == 0) return 0.0; else return double(m_tp.task_size_knockout) / m_tp.task_knockout;
}
};
More information about the Avida-cvs
mailing list