[Avida-SVN] r1857 - development/source/analyze
brysonda at myxo.css.msu.edu
brysonda at myxo.css.msu.edu
Fri Jul 27 12:30:12 PDT 2007
Author: brysonda
Date: 2007-07-27 15:30:12 -0400 (Fri, 27 Jul 2007)
New Revision: 1857
Modified:
development/source/analyze/cMutationalNeighborhood.cc
development/source/analyze/cMutationalNeighborhood.h
development/source/analyze/cMutationalNeighborhoodResults.h
Log:
MutationalNeighborhood: Add One Step Insertion and Deletion calculations.
Modified: development/source/analyze/cMutationalNeighborhood.cc
===================================================================
--- development/source/analyze/cMutationalNeighborhood.cc 2007-07-27 18:27:53 UTC (rev 1856)
+++ development/source/analyze/cMutationalNeighborhood.cc 2007-07-27 19:30:12 UTC (rev 1857)
@@ -68,6 +68,12 @@
// Do the processing, starting with One Step
ProcessOneStepPoint(ctx, testcpu, test_info, cur_site);
+ ProcessOneStepInsert(ctx, testcpu, test_info, cur_site);
+ if (cur_site == (m_base_genome.GetSize() - 1)) {
+ // Process the hanging insertion on the last cycle through
+ ProcessOneStepInsert(ctx, testcpu, test_info, cur_site + 1);
+ }
+ ProcessOneStepDelete(ctx, testcpu, test_info, cur_site);
// Cleanup
delete testcpu;
@@ -106,8 +112,12 @@
// Setup state to begin processing
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_fitness.ResizeClear(m_base_genome.GetSize(), m_inst_set.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());
m_cur_site = 0;
m_completed = 0;
@@ -137,66 +147,106 @@
int cur_inst = mod_genome[cur_site].GetOp();
// Fill in unmutated entry in fitness table with base fitness
- m_fitness[cur_site][cur_inst] = m_base_fitness;
+ m_fitness_point[cur_site][cur_inst] = m_base_fitness;
// Loop through all instructions...
for (int inst_num = 0; inst_num < inst_size; inst_num++) {
if (cur_inst == inst_num) continue;
mod_genome[cur_site].SetOp(inst_num);
- testcpu->TestGenome(ctx, test_info, mod_genome);
+ m_fitness_point[cur_site][inst_num] = ProcessOneStepGenome(ctx, testcpu, test_info, mod_genome, odata, cur_site);
+
+ ProcessTwoStepPoint(ctx, testcpu, test_info, cur_site, mod_genome);
+ }
+}
+
+void cMutationalNeighborhood::ProcessOneStepInsert(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site)
+{
+ const int inst_size = m_inst_set.GetSize();
+ sStep& odata = m_onestep_insert[cur_site];
+
+ cCPUMemory mod_genome(m_base_genome);
+ mod_genome.Insert(cur_site, cInstruction(0));
+
+ // Loop through all instructions...
+ for (int inst_num = 0; inst_num < inst_size; inst_num++) {
+ mod_genome[cur_site].SetOp(inst_num);
+ m_fitness_insert[cur_site][inst_num] = ProcessOneStepGenome(ctx, testcpu, test_info, mod_genome, odata, cur_site);
- double test_fitness = test_info.GetColonyFitness();
-
- odata.total_fitness += test_fitness;
- odata.total_sqr_fitness += test_fitness * test_fitness;
- odata.total++;
- if (test_fitness == 0.0) {
- odata.dead++;
- } else if (test_fitness < m_neut_min) {
- odata.neg++;
- odata.size_neg += test_fitness;
- } else if (test_fitness <= m_neut_max) {
- odata.neut++;
- } else {
- odata.pos++;
- odata.size_pos += test_fitness;
- if (test_fitness > odata.peak_fitness) {
- odata.peak_fitness = test_fitness;
- odata.peak_genome = mod_genome;
- }
- }
-
- if (test_fitness >= m_neut_min) odata.site_count[cur_site]++;
-
- m_fitness[cur_site][cur_inst] = test_fitness;
+ //ProcessTwoStepPoint(ctx, testcpu, test_info, cur_site, mod_genome);
+ }
+}
- if (test_fitness != 0.0) { // Only count tasks if the organism is alive
- const tArray<int>& cur_tasks = test_info.GetColonyOrganism()->GetPhenotype().GetLastTaskCount();
- bool knockout = false;
- bool anytask = false;
- for (int i = 0; i < m_base_tasks.GetSize(); i++) {
- if (m_base_tasks[i] && !cur_tasks[i]) knockout = true;
- else if (!m_base_tasks[i] && cur_tasks[i]) anytask = true;
- }
- if (knockout) {
- odata.task_knockout++;
- odata.task_size_knockout += test_fitness;
- }
- if (anytask) {
- odata.task_total++;
- odata.task_size_total += test_fitness;
- }
- if (m_base_tasks.GetSize() && !m_base_tasks[m_target] && cur_tasks[m_target]) {
- odata.task_target++;
- odata.task_size_target += test_fitness;
- }
+
+void cMutationalNeighborhood::ProcessOneStepDelete(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site)
+{
+ sStep& odata = m_onestep_delete[cur_site];
+
+ cCPUMemory mod_genome(m_base_genome);
+ mod_genome.Remove(cur_site);
+ m_fitness_delete[cur_site] = ProcessOneStepGenome(ctx, testcpu, test_info, mod_genome, odata, cur_site);
+ //ProcessTwoStepPoint(ctx, testcpu, test_info, cur_site, mod_genome);
+}
+
+
+double cMutationalNeighborhood::ProcessOneStepGenome(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info,
+ const cGenome& mod_genome, sStep& odata, int cur_site)
+{
+ // Run the modified genome through the Test CPU
+ testcpu->TestGenome(ctx, test_info, mod_genome);
+
+ // Collect the calculated fitness
+ double test_fitness = test_info.GetColonyFitness();
+
+
+ odata.total_fitness += test_fitness;
+ odata.total_sqr_fitness += test_fitness * test_fitness;
+ odata.total++;
+ if (test_fitness == 0.0) {
+ odata.dead++;
+ } else if (test_fitness < m_neut_min) {
+ odata.neg++;
+ odata.size_neg += test_fitness;
+ } else if (test_fitness <= m_neut_max) {
+ odata.neut++;
+ } else {
+ odata.pos++;
+ odata.size_pos += test_fitness;
+ if (test_fitness > odata.peak_fitness) {
+ odata.peak_fitness = test_fitness;
+ odata.peak_genome = mod_genome;
}
-
- ProcessTwoStepPoint(ctx, testcpu, test_info, cur_site, mod_genome);
}
+
+ if (test_fitness >= m_neut_min) odata.site_count[cur_site]++;
+
+ if (test_fitness != 0.0) { // Only count tasks if the organism is alive
+ const tArray<int>& cur_tasks = test_info.GetColonyOrganism()->GetPhenotype().GetLastTaskCount();
+ bool knockout = false;
+ bool anytask = false;
+ for (int i = 0; i < m_base_tasks.GetSize(); i++) {
+ if (m_base_tasks[i] && !cur_tasks[i]) knockout = true;
+ else if (!m_base_tasks[i] && cur_tasks[i]) anytask = true;
+ }
+ if (knockout) {
+ odata.task_knockout++;
+ odata.task_size_knockout += test_fitness;
+ }
+ if (anytask) {
+ odata.task_total++;
+ odata.task_size_total += test_fitness;
+ }
+ if (m_base_tasks.GetSize() && !m_base_tasks[m_target] && cur_tasks[m_target]) {
+ odata.task_target++;
+ odata.task_size_target += test_fitness;
+ }
+ }
+
+ return test_fitness;
}
+
+
void cMutationalNeighborhood::ProcessTwoStepPoint(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info,
int cur_site, cGenome& mod_genome)
{
@@ -272,8 +322,58 @@
void cMutationalNeighborhood::ProcessComplete(cAvidaContext& ctx)
{
+ m_op.peak_fitness = m_base_fitness;
+ m_op.peak_genome = m_base_genome;
+ m_op.site_count.Resize(m_base_genome.GetSize(), 0);
AggregateOneStep(m_onestep_point, m_op);
+
+ m_oi.peak_fitness = m_base_fitness;
+ m_oi.peak_genome = m_base_genome;
+ m_oi.site_count.Resize(m_base_genome.GetSize() + 1, 0);
+ AggregateOneStep(m_onestep_insert, m_oi);
+
+ m_od.peak_fitness = m_base_fitness;
+ m_od.peak_genome = m_base_genome;
+ m_od.site_count.Resize(m_base_genome.GetSize(), 0);
+ AggregateOneStep(m_onestep_delete, m_od);
+
+ // Collect totals across all one step mutants
+ m_ot.total = m_op.total + m_oi.total + m_od.total;
+ m_ot.total_fitness = m_op.total_fitness + m_oi.total_fitness + m_od.total_fitness;
+ m_ot.total_sqr_fitness = m_op.total_sqr_fitness + m_oi.total_sqr_fitness + m_od.total_sqr_fitness;
+
+ if (m_op.peak_fitness >= m_oi.peak_fitness && m_op.peak_fitness >= m_od.peak_fitness) {
+ m_ot.peak_fitness = m_op.peak_fitness;
+ m_ot.peak_genome = m_op.peak_genome;
+ } else if (m_oi.peak_fitness >= m_od.peak_fitness) {
+ m_ot.peak_fitness = m_oi.peak_fitness;
+ m_ot.peak_genome = m_oi.peak_genome;
+ } else {
+ m_ot.peak_fitness = m_od.peak_fitness;
+ m_ot.peak_genome = m_od.peak_genome;
+ }
+
+ m_ot.pos = m_op.pos + m_oi.pos + m_od.pos;
+ m_ot.neg = m_op.neg + m_oi.neg + m_od.neg;
+ m_ot.neut = m_op.neut + m_oi.neut + m_od.neut;
+ m_ot.dead = m_op.dead + m_oi.dead + m_od.dead;
+ m_ot.size_pos = m_op.size_pos + m_oi.size_pos + m_od.size_pos;
+ m_ot.size_neg = m_op.size_neg + m_oi.size_neg + m_od.size_neg;
+
+ // @TODO - total_entropy/complexity across all mutation classes?
+
+ m_ot.task_target = m_op.task_target + m_oi.task_target + m_od.task_target;
+ m_ot.task_total = m_op.task_total + m_oi.task_total + m_od.task_total;
+ m_ot.task_knockout = m_op.task_knockout + m_oi.task_knockout + m_od.task_knockout;
+
+ m_ot.task_size_target = m_op.task_size_target + m_oi.task_size_target + m_od.task_size_target;
+ m_ot.task_size_total = m_op.task_size_total + m_oi.task_size_total + m_od.task_size_total;
+ m_ot.task_size_knockout = m_op.task_size_knockout + m_oi.task_size_knockout + m_od.task_size_knockout;
+
+
+
+
// Initialize values
m_t_total = 0;
m_t_total_sqr_fitness = 0.0;
@@ -341,7 +441,7 @@
sPendingTarget* pend = NULL;
while ((pend = m_pending.Pop())) {
- double fitness = m_fitness[pend->site][pend->inst];
+ double fitness = m_fitness_point[pend->site][pend->inst];
if (fitness == 0.0) {
m_t_task_target_dead++;
@@ -363,11 +463,6 @@
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;
@@ -421,28 +516,94 @@
df.Write(GetBaseGenome().GetSize(), "Base Genome Length");
df.Write(GetBaseTargetTask(), "Base Performs Target Task");
- df.Write(GetSingleTotal(), "Total One Step Mutants");
- df.Write(GetSingleProbBeneficial(), "One Step Probability Beneficial");
- df.Write(GetSingleProbDeleterious(), "One Step Probability Deleterious");
- df.Write(GetSingleProbNeutral(), "One Step Probability Neutral");
- df.Write(GetSingleProbLethal(), "One Step Probability Lethal");
- df.Write(GetSingleAverageSizeBeneficial(), "One Step Average Beneficial Size");
- df.Write(GetSingleAverageSizeDeleterious(), "One Step Average Deleterious Size");
- df.Write(GetSinglePeakFitness(), "One Step Peak Fitness");
- df.Write(GetSingleAverageFitness(), "One Step Average Fitness");
- df.Write(GetSingleAverageSqrFitness(), "One Step Average Square Fitness");
- df.Write(GetSingleTotalEntropy(), "One Step Total Entropy");
- df.Write(GetSingleComplexity(), "One Step Total Complexity");
- df.Write(GetSingleTargetTask(), "One Step Confers Target Task");
- df.Write(GetSingleProbTargetTask(), "One Step Probability Confers Target Task");
- df.Write(GetSingleAverageSizeTargetTask(), "One Step Average Size of Target Task Conferral");
- df.Write(GetSingleTask(), "One Step Confers Any Task");
- df.Write(GetSingleProbTask(), "One Step Probability Confers Any Task");
- df.Write(GetSingleAverageSizeTask(), "One Step Average Size of Any Task Conferral");
- df.Write(GetSingleKnockout(), "One Step Knockout Task");
- df.Write(GetSingleProbKnockout(), "One Step Probability Knockout Task");
- df.Write(GetSingleAverageSizeKnockout(), "One Step Average Size of Task Knockout");
+ df.Write(Get1SAggregateTotal(), "Total 1-Step Mutants");
+ df.Write(Get1SAggregateProbBeneficial(), "1-Step Probability Beneficial");
+ df.Write(Get1SAggregateProbDeleterious(), "1-Step Probability Deleterious");
+ df.Write(Get1SAggregateProbNeutral(), "1-Step Probability Neutral");
+ df.Write(Get1SAggregateProbLethal(), "1-Step Probability Lethal");
+ df.Write(Get1SAggregateAverageSizeBeneficial(), "1-Step Average Beneficial Size");
+ df.Write(Get1SAggregateAverageSizeDeleterious(), "1-Step Average Deleterious Size");
+ df.Write(Get1SAggregatePeakFitness(), "1-Step Peak Fitness");
+ df.Write(Get1SAggregateAverageFitness(), "1-Step Average Fitness");
+ df.Write(Get1SAggregateAverageSqrFitness(), "1-Step Average Square Fitness");
+// df.Write(Get1SAggregateTotalEntropy(), "1-Step Total Entropy");
+// df.Write(Get1SAggregateComplexity(), "1-Step Total Complexity");
+ df.Write(Get1SAggregateTargetTask(), "1-Step Confers Target Task");
+ df.Write(Get1SAggregateProbTargetTask(), "1-Step Probability Confers Target Task");
+ df.Write(Get1SAggregateAverageSizeTargetTask(), "1-Step Average Size of Target Task Conferral");
+ df.Write(Get1SAggregateTask(), "1-Step Confers Any Task");
+ df.Write(Get1SAggregateProbTask(), "1-Step Probability Confers Any Task");
+ df.Write(Get1SAggregateAverageSizeTask(), "1-Step Average Size of Any Task Conferral");
+ df.Write(Get1SAggregateKnockout(), "1-Step Knockout Task");
+ df.Write(Get1SAggregateProbKnockout(), "1-Step Probability Knockout Task");
+ df.Write(Get1SAggregateAverageSizeKnockout(), "1-Step Average Size of Task Knockout");
+
+ df.Write(Get1SPointTotal(), "Total 1-Step Point Mutants");
+ df.Write(Get1SPointProbBeneficial(), "1-Step Point Probability Beneficial");
+ df.Write(Get1SPointProbDeleterious(), "1-Step Point Probability Deleterious");
+ df.Write(Get1SPointProbNeutral(), "1-Step Point Probability Neutral");
+ df.Write(Get1SPointProbLethal(), "1-Step Point Probability Lethal");
+ df.Write(Get1SPointAverageSizeBeneficial(), "1-Step Point Average Beneficial Size");
+ df.Write(Get1SPointAverageSizeDeleterious(), "1-Step Point Average Deleterious Size");
+ df.Write(Get1SPointPeakFitness(), "1-Step Point Peak Fitness");
+ df.Write(Get1SPointAverageFitness(), "1-Step Point Average Fitness");
+ df.Write(Get1SPointAverageSqrFitness(), "1-Step Point Average Square Fitness");
+ df.Write(Get1SPointTotalEntropy(), "1-Step Point Total Entropy");
+ df.Write(Get1SPointComplexity(), "1-Step Point Total Complexity");
+ df.Write(Get1SPointTargetTask(), "1-Step Point Confers Target Task");
+ df.Write(Get1SPointProbTargetTask(), "1-Step Point Probability Confers Target Task");
+ df.Write(Get1SPointAverageSizeTargetTask(), "1-Step Point Average Size of Target Task Conferral");
+ df.Write(Get1SPointTask(), "1-Step Point Confers Any Task");
+ df.Write(Get1SPointProbTask(), "1-Step Point Probability Confers Any Task");
+ df.Write(Get1SPointAverageSizeTask(), "1-Step Point Average Size of Any Task Conferral");
+ df.Write(Get1SPointKnockout(), "1-Step Point Knockout Task");
+ df.Write(Get1SPointProbKnockout(), "1-Step Point Probability Knockout Task");
+ df.Write(Get1SPointAverageSizeKnockout(), "1-Step Point Average Size of Task Knockout");
+ df.Write(Get1SInsertTotal(), "Total 1-Step Insert Mutants");
+ df.Write(Get1SInsertProbBeneficial(), "1-Step Insert Probability Beneficial");
+ df.Write(Get1SInsertProbDeleterious(), "1-Step Insert Probability Deleterious");
+ df.Write(Get1SInsertProbNeutral(), "1-Step Insert Probability Neutral");
+ df.Write(Get1SInsertProbLethal(), "1-Step Insert Probability Lethal");
+ df.Write(Get1SInsertAverageSizeBeneficial(), "1-Step Insert Average Beneficial Size");
+ df.Write(Get1SInsertAverageSizeDeleterious(), "1-Step Insert Average Deleterious Size");
+ df.Write(Get1SInsertPeakFitness(), "1-Step Insert Peak Fitness");
+ df.Write(Get1SInsertAverageFitness(), "1-Step Insert Average Fitness");
+ df.Write(Get1SInsertAverageSqrFitness(), "1-Step Insert Average Square Fitness");
+ df.Write(Get1SInsertTotalEntropy(), "1-Step Insert Total Entropy");
+ df.Write(Get1SInsertComplexity(), "1-Step Insert Total Complexity");
+ df.Write(Get1SInsertTargetTask(), "1-Step Insert Confers Target Task");
+ df.Write(Get1SInsertProbTargetTask(), "1-Step Insert Probability Confers Target Task");
+ df.Write(Get1SInsertAverageSizeTargetTask(), "1-Step Insert Average Size of Target Task Conferral");
+ df.Write(Get1SInsertTask(), "1-Step Insert Confers Any Task");
+ df.Write(Get1SInsertProbTask(), "1-Step Insert Probability Confers Any Task");
+ df.Write(Get1SInsertAverageSizeTask(), "1-Step Insert Average Size of Any Task Conferral");
+ df.Write(Get1SInsertKnockout(), "1-Step Insert Knockout Task");
+ df.Write(Get1SInsertProbKnockout(), "1-Step Insert Probability Knockout Task");
+ df.Write(Get1SInsertAverageSizeKnockout(), "1-Step Insert Average Size of Task Knockout");
+
+ df.Write(Get1SDeleteTotal(), "Total 1-Step Delete Mutants");
+ df.Write(Get1SDeleteProbBeneficial(), "1-Step Delete Probability Beneficial");
+ df.Write(Get1SDeleteProbDeleterious(), "1-Step Delete Probability Deleterious");
+ df.Write(Get1SDeleteProbNeutral(), "1-Step Delete Probability Neutral");
+ df.Write(Get1SDeleteProbLethal(), "1-Step Delete Probability Lethal");
+ df.Write(Get1SDeleteAverageSizeBeneficial(), "1-Step Delete Average Beneficial Size");
+ df.Write(Get1SDeleteAverageSizeDeleterious(), "1-Step Delete Average Deleterious Size");
+ df.Write(Get1SDeletePeakFitness(), "1-Step Delete Peak Fitness");
+ df.Write(Get1SDeleteAverageFitness(), "1-Step Delete Average Fitness");
+ df.Write(Get1SDeleteAverageSqrFitness(), "1-Step Delete Average Square Fitness");
+ df.Write(Get1SDeleteTotalEntropy(), "1-Step Delete Total Entropy");
+ df.Write(Get1SDeleteComplexity(), "1-Step Delete Total Complexity");
+ df.Write(Get1SDeleteTargetTask(), "1-Step Delete Confers Target Task");
+ df.Write(Get1SDeleteProbTargetTask(), "1-Step Delete Probability Confers Target Task");
+ df.Write(Get1SDeleteAverageSizeTargetTask(), "1-Step Delete Average Size of Target Task Conferral");
+ df.Write(Get1SDeleteTask(), "1-Step Delete Confers Any Task");
+ df.Write(Get1SDeleteProbTask(), "1-Step Delete Probability Confers Any Task");
+ df.Write(Get1SDeleteAverageSizeTask(), "1-Step Delete Average Size of Any Task Conferral");
+ df.Write(Get1SDeleteKnockout(), "1-Step Delete Knockout Task");
+ df.Write(Get1SDeleteProbKnockout(), "1-Step Delete Probability Knockout Task");
+ df.Write(Get1SDeleteAverageSizeKnockout(), "1-Step Delete Average Size of Task Knockout");
+
df.Write(GetDoubleTotal(), "Total Two Step Mutants");
df.Write(GetDoubleProbBeneficial(), "Two Step Probability Beneficial");
df.Write(GetDoubleProbDeleterious(), "Two Step Probability Deleterious");
Modified: development/source/analyze/cMutationalNeighborhood.h
===================================================================
--- development/source/analyze/cMutationalNeighborhood.h 2007-07-27 18:27:53 UTC (rev 1856)
+++ development/source/analyze/cMutationalNeighborhood.h 2007-07-27 19:30:12 UTC (rev 1857)
@@ -108,7 +108,9 @@
tArray<sStep> m_onestep_delete;
tArray<sStep> m_twostep;
- tMatrix<double> m_fitness;
+ tMatrix<double> m_fitness_point;
+ tMatrix<double> m_fitness_insert;
+ tArray<double> m_fitness_delete;
struct sPendingTarget
{
@@ -168,10 +170,15 @@
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) { ; }
};
+
+ sOneStepAggregate m_op; // One Step Point Mutants
+ sOneStepAggregate m_oi; // One Step Insert Mutants
+ sOneStepAggregate m_od; // One Step Delete Mutants
+
+ sOneStepAggregate m_ot; // One Step Total
+
- sOneStepAggregate m_op;
-
// Aggregated Two Step Data
// --------------------------------------------------------------------------
int m_t_total;
@@ -209,13 +216,18 @@
void ProcessInitialize(cAvidaContext& ctx);
+
void ProcessOneStepPoint(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site);
+ void ProcessOneStepInsert(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site);
+ 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 ProcessTwoStepPoint(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site, cGenome& mod_genome);
-// void ProcessOneStepInsert(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site);
-// void ProcessTwoStepInsert(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site, cGenome& mod_genome);
-// void ProcessOneStepDelete(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site);
+ // void ProcessTwoStepInsert(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site, cGenome& mod_genome);
// void ProcessTwoStepDelete(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site, cGenome& mod_genome);
// 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);
@@ -251,43 +263,164 @@
if (m_base_tasks.GetSize()) return m_base_tasks[m_target]; else return false;
}
- inline int GetSingleTotal() const { return m_op.total; }
- 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_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 int Get1SAggregateTotal() const { return m_ot.total; }
- inline double GetSingleTotalEntropy() const { return m_op.total_entropy; }
- inline double GetSingleComplexity() const { return m_op.complexity; }
+ inline double Get1SAggregateAverageFitness() const { return m_ot.total_fitness / m_ot.total; }
+ inline double Get1SAggregateAverageSqrFitness() const { return m_ot.total_sqr_fitness / m_ot.total; }
+ inline const cGenome& Get1SAggregatePeakGenome() const { return m_ot.peak_genome; }
+ inline double Get1SAggregatePeakFitness() const { return m_ot.peak_fitness; }
+
+ inline double Get1SAggregateProbBeneficial() const { return double(m_ot.pos) / m_ot.total; }
+ inline double Get1SAggregateProbDeleterious() const { return double(m_ot.neg) / m_ot.total; }
+ inline double Get1SAggregateProbNeutral() const { return double(m_ot.neut) / m_ot.total; }
+ inline double Get1SAggregateProbLethal() const { return double(m_ot.dead) / m_ot.total; }
+ inline double Get1SAggregateAverageSizeBeneficial() const { if (m_ot.pos == 0) return 0.0; else return m_ot.size_pos / m_ot.pos; }
+ inline double Get1SAggregateAverageSizeDeleterious() const { if (m_ot.neg == 0) return 0.0; else return m_ot.size_neg / m_ot.neg; }
+
+ //inline double Get1SAggregateTotalEntropy() const { return m_ot.total_entropy; }
+ //inline double Get1SAggregateComplexity() const { return m_ot.complexity; }
+
+ inline int Get1SAggregateTargetTask() const { return m_ot.task_target; }
+ inline double Get1SAggregateProbTargetTask() const { return double(m_ot.task_target) / m_ot.total; }
+ inline double Get1SAggregateAverageSizeTargetTask() const
+ {
+ if (m_ot.task_target == 0) return 0.0; else return double(m_ot.task_size_target) / m_ot.task_target;
+ }
+ inline int Get1SAggregateTask() const { return m_ot.task_total; }
+ inline double Get1SAggregateProbTask() const { return double(m_ot.task_total) / m_ot.total; }
+ inline double Get1SAggregateAverageSizeTask() const
+ {
+ if (m_ot.task_total == 0) return 0.0; else return double(m_ot.task_size_total) / m_ot.task_total;
+ }
+ inline int Get1SAggregateKnockout() const { return m_ot.task_knockout; }
+ inline double Get1SAggregateProbKnockout() const { return double(m_ot.task_knockout) / m_ot.total; }
+ inline double Get1SAggregateAverageSizeKnockout() const
+ {
+ if (m_ot.task_knockout == 0) return 0.0; else return double(m_ot.task_size_knockout) / m_ot.task_knockout;
+ }
+
+
+
+
+ inline int Get1SPointTotal() const { return m_op.total; }
+
+ inline double Get1SPointAverageFitness() const { return m_op.total_fitness / m_op.total; }
+ inline double Get1SPointAverageSqrFitness() const { return m_op.total_sqr_fitness / m_op.total; }
+ inline const cGenome& Get1SPointPeakGenome() const { return m_op.peak_genome; }
+ inline double Get1SPointPeakFitness() const { return m_op.peak_fitness; }
+
+ inline double Get1SPointProbBeneficial() const { return double(m_op.pos) / m_op.total; }
+ inline double Get1SPointProbDeleterious() const { return double(m_op.neg) / m_op.total; }
+ inline double Get1SPointProbNeutral() const { return double(m_op.neut) / m_op.total; }
+ inline double Get1SPointProbLethal() const { return double(m_op.dead) / m_op.total; }
+ inline double Get1SPointAverageSizeBeneficial() const { if (m_op.pos == 0) return 0.0; else return m_op.size_pos / m_op.pos; }
+ inline double Get1SPointAverageSizeDeleterious() const { if (m_op.neg == 0) return 0.0; else return m_op.size_neg / m_op.neg; }
+
+ inline double Get1SPointTotalEntropy() const { return m_op.total_entropy; }
+ inline double Get1SPointComplexity() const { return m_op.complexity; }
- 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
+ inline int Get1SPointTargetTask() const { return m_op.task_target; }
+ inline double Get1SPointProbTargetTask() const { return double(m_op.task_target) / m_op.total; }
+ inline double Get1SPointAverageSizeTargetTask() const
{
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_op.task_total; }
- inline double GetSingleProbTask() const { return double(m_op.task_total) / m_op.total; }
- inline double GetSingleAverageSizeTask() const
+ inline int Get1SPointTask() const { return m_op.task_total; }
+ inline double Get1SPointProbTask() const { return double(m_op.task_total) / m_op.total; }
+ inline double Get1SPointAverageSizeTask() const
{
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_op.task_knockout; }
- inline double GetSingleProbKnockout() const { return double(m_op.task_knockout) / m_op.total; }
- inline double GetSingleAverageSizeKnockout() const
+ inline int Get1SPointKnockout() const { return m_op.task_knockout; }
+ inline double Get1SPointProbKnockout() const { return double(m_op.task_knockout) / m_op.total; }
+ inline double Get1SPointAverageSizeKnockout() const
{
if (m_op.task_knockout == 0) return 0.0; else return double(m_op.task_size_knockout) / m_op.task_knockout;
}
+
+
+ inline int Get1SInsertTotal() const { return m_oi.total; }
+
+ inline double Get1SInsertAverageFitness() const { return m_oi.total_fitness / m_oi.total; }
+ inline double Get1SInsertAverageSqrFitness() const { return m_oi.total_sqr_fitness / m_oi.total; }
+ inline const cGenome& Get1SInsertPeakGenome() const { return m_oi.peak_genome; }
+ inline double Get1SInsertPeakFitness() const { return m_oi.peak_fitness; }
+
+ inline double Get1SInsertProbBeneficial() const { return double(m_oi.pos) / m_oi.total; }
+ inline double Get1SInsertProbDeleterious() const { return double(m_oi.neg) / m_oi.total; }
+ inline double Get1SInsertProbNeutral() const { return double(m_oi.neut) / m_oi.total; }
+ inline double Get1SInsertProbLethal() const { return double(m_oi.dead) / m_oi.total; }
+ inline double Get1SInsertAverageSizeBeneficial() const { if (m_oi.pos == 0) return 0.0; else return m_oi.size_pos / m_oi.pos; }
+ inline double Get1SInsertAverageSizeDeleterious() const { if (m_oi.neg == 0) return 0.0; else return m_oi.size_neg / m_oi.neg; }
+
+ inline double Get1SInsertTotalEntropy() const { return m_oi.total_entropy; }
+ inline double Get1SInsertComplexity() const { return m_oi.complexity; }
+
+ inline int Get1SInsertTargetTask() const { return m_oi.task_target; }
+ inline double Get1SInsertProbTargetTask() const { return double(m_oi.task_target) / m_oi.total; }
+ inline double Get1SInsertAverageSizeTargetTask() const
+ {
+ if (m_oi.task_target == 0) return 0.0; else return double(m_oi.task_size_target) / m_oi.task_target;
+ }
+ inline int Get1SInsertTask() const { return m_oi.task_total; }
+ inline double Get1SInsertProbTask() const { return double(m_oi.task_total) / m_oi.total; }
+ inline double Get1SInsertAverageSizeTask() const
+ {
+ if (m_oi.task_total == 0) return 0.0; else return double(m_oi.task_size_total) / m_oi.task_total;
+ }
+ inline int Get1SInsertKnockout() const { return m_oi.task_knockout; }
+ inline double Get1SInsertProbKnockout() const { return double(m_oi.task_knockout) / m_oi.total; }
+ inline double Get1SInsertAverageSizeKnockout() const
+ {
+ if (m_oi.task_knockout == 0) return 0.0; else return double(m_oi.task_size_knockout) / m_oi.task_knockout;
+ }
+
+
+
+
+ inline int Get1SDeleteTotal() const { return m_od.total; }
+
+ inline double Get1SDeleteAverageFitness() const { return m_od.total_fitness / m_od.total; }
+ inline double Get1SDeleteAverageSqrFitness() const { return m_od.total_sqr_fitness / m_od.total; }
+ inline const cGenome& Get1SDeletePeakGenome() const { return m_od.peak_genome; }
+ inline double Get1SDeletePeakFitness() const { return m_od.peak_fitness; }
+
+ inline double Get1SDeleteProbBeneficial() const { return double(m_od.pos) / m_od.total; }
+ inline double Get1SDeleteProbDeleterious() const { return double(m_od.neg) / m_od.total; }
+ inline double Get1SDeleteProbNeutral() const { return double(m_od.neut) / m_od.total; }
+ inline double Get1SDeleteProbLethal() const { return double(m_od.dead) / m_od.total; }
+ inline double Get1SDeleteAverageSizeBeneficial() const { if (m_od.pos == 0) return 0.0; else return m_od.size_pos / m_od.pos; }
+ inline double Get1SDeleteAverageSizeDeleterious() const { if (m_od.neg == 0) return 0.0; else return m_od.size_neg / m_od.neg; }
+
+ inline double Get1SDeleteTotalEntropy() const { return m_od.total_entropy; }
+ inline double Get1SDeleteComplexity() const { return m_od.complexity; }
+
+ inline int Get1SDeleteTargetTask() const { return m_od.task_target; }
+ inline double Get1SDeleteProbTargetTask() const { return double(m_od.task_target) / m_od.total; }
+ inline double Get1SDeleteAverageSizeTargetTask() const
+ {
+ if (m_od.task_target == 0) return 0.0; else return double(m_od.task_size_target) / m_od.task_target;
+ }
+ inline int Get1SDeleteTask() const { return m_od.task_total; }
+ inline double Get1SDeleteProbTask() const { return double(m_od.task_total) / m_od.total; }
+ inline double Get1SDeleteAverageSizeTask() const
+ {
+ if (m_od.task_total == 0) return 0.0; else return double(m_od.task_size_total) / m_od.task_total;
+ }
+ inline int Get1SDeleteKnockout() const { return m_od.task_knockout; }
+ inline double Get1SDeleteProbKnockout() const { return double(m_od.task_knockout) / m_od.total; }
+ inline double Get1SDeleteAverageSizeKnockout() const
+ {
+ if (m_od.task_knockout == 0) return 0.0; else return double(m_od.task_size_knockout) / m_od.task_knockout;
+ }
+
+
+
+
inline int GetDoubleTotal() const { return m_t_total; }
inline double GetDoubleAverageFitness() const { return m_t_total_fitness / m_t_total; }
Modified: development/source/analyze/cMutationalNeighborhoodResults.h
===================================================================
--- development/source/analyze/cMutationalNeighborhoodResults.h 2007-07-27 18:27:53 UTC (rev 1856)
+++ development/source/analyze/cMutationalNeighborhoodResults.h 2007-07-27 19:30:12 UTC (rev 1857)
@@ -63,31 +63,133 @@
inline double GetBaseGestation() const { return m_src.GetBaseGestation(); }
inline bool GetBaseTargetTask() const { return m_src.GetBaseTargetTask(); }
- inline int GetSingleTotal() const { return m_src.GetSingleTotal(); }
- inline double GetSingleAverageFitness() const { return m_src.GetSingleAverageFitness(); }
- inline double GetSingleAverageSqrFitness() const { return m_src.GetSingleAverageSqrFitness(); }
- inline const cGenome& GetSinglePeakGenome() const { return m_src.GetSinglePeakGenome(); }
- inline double GetSinglePeakFitness() const { return m_src.GetSinglePeakFitness(); }
+
+
+ inline int Get1SAggregateTotal() const { return m_src.Get1SAggregateTotal(); }
+
+ inline double Get1SAggregateAverageFitness() const { return m_src.Get1SAggregateAverageFitness(); }
+ inline double Get1SAggregateAverageSqrFitness() const { return m_src.Get1SAggregateAverageSqrFitness(); }
+ inline const cGenome& Get1SAggregatePeakGenome() const { return m_src.Get1SAggregatePeakGenome(); }
+ inline double Get1SAggregatePeakFitness() const { return m_src.Get1SAggregatePeakFitness(); }
- inline double GetSingleProbBeneficial() const { return m_src.GetSingleProbBeneficial(); }
- inline double GetSingleProbDeleterious() const { return m_src.GetSingleProbDeleterious(); }
- inline double GetSingleProbNeutral() const { return m_src.GetSingleProbNeutral(); }
- inline double GetSingleProbLethal() const { return m_src.GetSingleProbLethal(); }
- inline double GetSingleAverageSizeBeneficial() const { return m_src.GetSingleAverageSizeBeneficial(); }
- inline double GetSingleAverageSizeDeleterious() const { return m_src.GetSingleAverageSizeDeleterious(); }
+ inline double Get1SAggregateProbBeneficial() const { return m_src.Get1SAggregateProbBeneficial(); }
+ inline double Get1SAggregateProbDeleterious() const { return m_src.Get1SAggregateProbDeleterious(); }
+ inline double Get1SAggregateProbNeutral() const { return m_src.Get1SAggregateProbNeutral(); }
+ inline double Get1SAggregateProbLethal() const { return m_src.Get1SAggregateProbLethal(); }
+ inline double Get1SAggregateAverageSizeBeneficial() const { return m_src.Get1SAggregateAverageSizeBeneficial(); }
+ inline double Get1SAggregateAverageSizeDeleterious() const { return m_src.Get1SAggregateAverageSizeDeleterious(); }
- inline double GetSingleTotalEntropy() const { return m_src.GetSingleTotalEntropy(); }
- inline double GetSingleComplexity() const { return m_src.GetSingleComplexity(); }
+// inline double Get1SAggregateTotalEntropy() const { return m_src.Get1SAggregateTotalEntropy(); }
+// inline double Get1SAggregateComplexity() const { return m_src.Get1SAggregateComplexity(); }
- inline int GetSingleTargetTask() const { return m_src.GetSingleTargetTask(); }
- inline double GetSingleProbTargetTask() const { return m_src.GetSingleProbTargetTask(); }
- inline int GetSingleTask() const { return m_src.GetSingleTask(); }
- inline double GetSingleProbTask() const { return m_src.GetSingleProbTask(); }
- inline int GetSingleKnockout() const { return m_src.GetSingleKnockout(); }
- inline double GetSingleProbKnockout() const { return m_src.GetSingleProbKnockout(); }
+ inline int Get1SAggregateTargetTask() const { return m_src.Get1SAggregateTargetTask(); }
+ inline double Get1SAggregateProbTargetTask() const { return m_src.Get1SAggregateProbTargetTask(); }
+ inline double Get1SAggregateAverageSizeTargetTask() const { return m_src.Get1SAggregateAverageSizeTargetTask(); }
+ inline int Get1SAggregateTask() const { return m_src.Get1SAggregateTask(); }
+ inline double Get1SAggregateProbTask() const { return m_src.Get1SAggregateProbTask(); }
+ inline double Get1SAggregateAverageSizeTask() const { return m_src.Get1SAggregateAverageSizeTask(); }
+ inline int Get1SAggregateKnockout() const { return m_src.Get1SAggregateKnockout(); }
+ inline double Get1SAggregateProbKnockout() const { return m_src.Get1SAggregateProbKnockout(); }
+ inline double Get1SAggregateAverageSizeKnockout() const { return m_src.Get1SAggregateAverageSizeKnockout(); }
+
+
+
+ inline int Get1SPointTotal() const { return m_src.Get1SPointTotal(); }
+
+ inline double Get1SPointAverageFitness() const { return m_src.Get1SPointAverageFitness(); }
+ inline double Get1SPointAverageSqrFitness() const { return m_src.Get1SPointAverageSqrFitness(); }
+ inline const cGenome& Get1SPointPeakGenome() const { return m_src.Get1SPointPeakGenome(); }
+ inline double Get1SPointPeakFitness() const { return m_src.Get1SPointPeakFitness(); }
+
+ inline double Get1SPointProbBeneficial() const { return m_src.Get1SPointProbBeneficial(); }
+ inline double Get1SPointProbDeleterious() const { return m_src.Get1SPointProbDeleterious(); }
+ inline double Get1SPointProbNeutral() const { return m_src.Get1SPointProbNeutral(); }
+ inline double Get1SPointProbLethal() const { return m_src.Get1SPointProbLethal(); }
+ inline double Get1SPointAverageSizeBeneficial() const { return m_src.Get1SPointAverageSizeBeneficial(); }
+ inline double Get1SPointAverageSizeDeleterious() const { return m_src.Get1SPointAverageSizeDeleterious(); }
+
+ inline double Get1SPointTotalEntropy() const { return m_src.Get1SPointTotalEntropy(); }
+ inline double Get1SPointComplexity() const { return m_src.Get1SPointComplexity(); }
+
+ inline int Get1SPointTargetTask() const { return m_src.Get1SPointTargetTask(); }
+ inline double Get1SPointProbTargetTask() const { return m_src.Get1SPointProbTargetTask(); }
+ inline double Get1SPointAverageSizeTargetTask() const { return m_src.Get1SPointAverageSizeTargetTask(); }
+ inline int Get1SPointTask() const { return m_src.Get1SPointTask(); }
+ inline double Get1SPointProbTask() const { return m_src.Get1SPointProbTask(); }
+ inline double Get1SPointAverageSizeTask() const { return m_src.Get1SPointAverageSizeTask(); }
+ inline int Get1SPointKnockout() const { return m_src.Get1SPointKnockout(); }
+ inline double Get1SPointProbKnockout() const { return m_src.Get1SPointProbKnockout(); }
+ inline double Get1SPointAverageSizeKnockout() const { return m_src.Get1SPointAverageSizeKnockout(); }
+
+
+
+
+
+ inline int Get1SInsertTotal() const { return m_src.Get1SInsertTotal(); }
+
+ inline double Get1SInsertAverageFitness() const { return m_src.Get1SInsertAverageFitness(); }
+ inline double Get1SInsertAverageSqrFitness() const { return m_src.Get1SInsertAverageSqrFitness(); }
+ inline const cGenome& Get1SInsertPeakGenome() const { return m_src.Get1SInsertPeakGenome(); }
+ inline double Get1SInsertPeakFitness() const { return m_src.Get1SInsertPeakFitness(); }
+
+ inline double Get1SInsertProbBeneficial() const { return m_src.Get1SInsertProbBeneficial(); }
+ inline double Get1SInsertProbDeleterious() const { return m_src.Get1SInsertProbDeleterious(); }
+ inline double Get1SInsertProbNeutral() const { return m_src.Get1SInsertProbNeutral(); }
+ inline double Get1SInsertProbLethal() const { return m_src.Get1SInsertProbLethal(); }
+ inline double Get1SInsertAverageSizeBeneficial() const { return m_src.Get1SInsertAverageSizeBeneficial(); }
+ inline double Get1SInsertAverageSizeDeleterious() const { return m_src.Get1SInsertAverageSizeDeleterious(); }
+
+ inline double Get1SInsertTotalEntropy() const { return m_src.Get1SInsertTotalEntropy(); }
+ inline double Get1SInsertComplexity() const { return m_src.Get1SInsertComplexity(); }
+
+ inline int Get1SInsertTargetTask() const { return m_src.Get1SInsertTargetTask(); }
+ inline double Get1SInsertProbTargetTask() const { return m_src.Get1SInsertProbTargetTask(); }
+ inline double Get1SInsertAverageSizeTargetTask() const { return m_src.Get1SInsertAverageSizeTargetTask(); }
+ inline int Get1SInsertTask() const { return m_src.Get1SInsertTask(); }
+ inline double Get1SInsertProbTask() const { return m_src.Get1SInsertProbTask(); }
+ inline double Get1SInsertAverageSizeTask() const { return m_src.Get1SInsertAverageSizeTask(); }
+ inline int Get1SInsertKnockout() const { return m_src.Get1SInsertKnockout(); }
+ inline double Get1SInsertProbKnockout() const { return m_src.Get1SInsertProbKnockout(); }
+ inline double Get1SInsertAverageSizeKnockout() const { return m_src.Get1SInsertAverageSizeKnockout(); }
+
+
+
+
+
+ inline int Get1SDeleteTotal() const { return m_src.Get1SDeleteTotal(); }
+
+ inline double Get1SDeleteAverageFitness() const { return m_src.Get1SDeleteAverageFitness(); }
+ inline double Get1SDeleteAverageSqrFitness() const { return m_src.Get1SDeleteAverageSqrFitness(); }
+ inline const cGenome& Get1SDeletePeakGenome() const { return m_src.Get1SDeletePeakGenome(); }
+ inline double Get1SDeletePeakFitness() const { return m_src.Get1SDeletePeakFitness(); }
+
+ inline double Get1SDeleteProbBeneficial() const { return m_src.Get1SDeleteProbBeneficial(); }
+ inline double Get1SDeleteProbDeleterious() const { return m_src.Get1SDeleteProbDeleterious(); }
+ inline double Get1SDeleteProbNeutral() const { return m_src.Get1SDeleteProbNeutral(); }
+ inline double Get1SDeleteProbLethal() const { return m_src.Get1SDeleteProbLethal(); }
+ inline double Get1SDeleteAverageSizeBeneficial() const { return m_src.Get1SDeleteAverageSizeBeneficial(); }
+ inline double Get1SDeleteAverageSizeDeleterious() const { return m_src.Get1SDeleteAverageSizeDeleterious(); }
+
+ inline double Get1SDeleteTotalEntropy() const { return m_src.Get1SDeleteTotalEntropy(); }
+ inline double Get1SDeleteComplexity() const { return m_src.Get1SDeleteComplexity(); }
+
+ inline int Get1SDeleteTargetTask() const { return m_src.Get1SDeleteTargetTask(); }
+ inline double Get1SDeleteProbTargetTask() const { return m_src.Get1SDeleteProbTargetTask(); }
+ inline double Get1SDeleteAverageSizeTargetTask() const { return m_src.Get1SDeleteAverageSizeTargetTask(); }
+ inline int Get1SDeleteTask() const { return m_src.Get1SDeleteTask(); }
+ inline double Get1SDeleteProbTask() const { return m_src.Get1SDeleteProbTask(); }
+ inline double Get1SDeleteAverageSizeTask() const { return m_src.Get1SDeleteAverageSizeTask(); }
+ inline int Get1SDeleteKnockout() const { return m_src.Get1SDeleteKnockout(); }
+ inline double Get1SDeleteProbKnockout() const { return m_src.Get1SDeleteProbKnockout(); }
+ inline double Get1SDeleteAverageSizeKnockout() const { return m_src.Get1SDeleteAverageSizeKnockout(); }
+
+
+
+
+
inline int GetDoubleTotal() const { return m_src.GetDoubleTotal(); }
inline double GetDoubleAverageFitness() const { return m_src.GetDoubleAverageFitness(); }
More information about the Avida-cvs
mailing list