[Avida-SVN] r1865 - development/source/analyze
brysonda at myxo.css.msu.edu
brysonda at myxo.css.msu.edu
Sun Jul 29 21:04:06 PDT 2007
Author: brysonda
Date: 2007-07-30 00:04:06 -0400 (Mon, 30 Jul 2007)
New Revision: 1865
Modified:
development/source/analyze/cMutationalNeighborhood.cc
development/source/analyze/cMutationalNeighborhood.h
development/source/analyze/cMutationalNeighborhoodResults.h
Log:
MutationalNeighborhood: Combination two step pathways.
Modified: development/source/analyze/cMutationalNeighborhood.cc
===================================================================
--- development/source/analyze/cMutationalNeighborhood.cc 2007-07-30 02:29:36 UTC (rev 1864)
+++ development/source/analyze/cMutationalNeighborhood.cc 2007-07-30 04:04:06 UTC (rev 1865)
@@ -88,6 +88,22 @@
tddata.site_count.Resize(m_base_genome.GetSize(), 0);
+ sStep& tipdata = m_insert_point[cur_site];
+ tipdata.peak_fitness = m_base_fitness;
+ tipdata.peak_genome = m_base_genome;
+ tipdata.site_count.Resize(m_base_genome.GetSize() + 1, 0);
+
+ sStep& tdpdata = m_insert_delete[cur_site];
+ tdpdata.peak_fitness = m_base_fitness;
+ tdpdata.peak_genome = m_base_genome;
+ tdpdata.site_count.Resize(m_base_genome.GetSize() + 1, 0);
+
+ sStep& tdidata = m_delete_point[cur_site];
+ tdidata.peak_fitness = m_base_fitness;
+ tdidata.peak_genome = m_base_genome;
+ tdidata.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);
@@ -196,6 +212,8 @@
m_fitness_insert[cur_site][inst_num] = ProcessOneStepGenome(ctx, testcpu, test_info, mod_genome, odata, cur_site);
ProcessTwoStepInsert(ctx, testcpu, test_info, cur_site, mod_genome);
+ ProcessInsertPointCombo(ctx, testcpu, test_info, cur_site, mod_genome);
+ ProcessInsertDeleteCombo(ctx, testcpu, test_info, cur_site, mod_genome);
}
}
@@ -208,6 +226,7 @@
mod_genome.Remove(cur_site);
m_fitness_delete[cur_site] = ProcessOneStepGenome(ctx, testcpu, test_info, mod_genome, odata, cur_site);
ProcessTwoStepDelete(ctx, testcpu, test_info, cur_site, mod_genome);
+ ProcessDeletePointCombo(ctx, testcpu, test_info, cur_site, mod_genome);
}
@@ -322,12 +341,77 @@
for (int line_num = cur_site; line_num < mod_size; line_num++) {
int cur_inst = mod_genome[line_num].GetOp();
mod_genome.Remove(line_num);
+ ProcessTwoStepGenome(ctx, testcpu, test_info, mod_genome, tdata, line_num + 1, cur_site);
+ mod_genome.Insert(line_num, cInstruction(cur_inst));
+ }
+}
+
+
+void cMutationalNeighborhood::ProcessInsertPointCombo(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info,
+ int cur_site, cGenome& mod_genome)
+{
+ const int inst_size = m_inst_set.GetSize();
+ sTwoStep& tdata = m_insert_point[cur_site];
+
+ // Loop through all lines of genome, testing trying all combinations.
+ for (int line_num = 0; line_num < mod_genome.GetSize(); line_num++) {
+ if (line_num == cur_site) continue; // Skip the site of the insertion
+
+ int cur_inst = mod_genome[line_num].GetOp();
+
+ // Loop through all instructions...
+ for (int inst_num = 0; inst_num < inst_size; inst_num++) {
+ if (cur_inst == inst_num) continue;
+
+ mod_genome[line_num].SetOp(inst_num);
+ ProcessTwoStepGenome(ctx, testcpu, test_info, mod_genome, tdata, line_num, cur_site);
+ }
+
+ mod_genome[line_num].SetOp(cur_inst);
+ }
+}
+
+
+void cMutationalNeighborhood::ProcessInsertDeleteCombo(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info,
+ int cur_site, cCPUMemory& mod_genome)
+{
+ sTwoStep& tdata = m_insert_delete[cur_site];
+
+ // Loop through all lines of genome, testing trying all combinations.
+ for (int line_num = 0; line_num < mod_genome.GetSize(); line_num++) {
+ if (line_num == cur_site) continue; // Skip the site of the insertion
+
+ int cur_inst = mod_genome[line_num].GetOp();
+ mod_genome.Remove(line_num);
ProcessTwoStepGenome(ctx, testcpu, test_info, mod_genome, tdata, line_num, cur_site);
mod_genome.Insert(line_num, cInstruction(cur_inst));
}
}
+void cMutationalNeighborhood::ProcessDeletePointCombo(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info,
+ int cur_site, cGenome& mod_genome)
+{
+ const int inst_size = m_inst_set.GetSize();
+ sTwoStep& tdata = m_delete_point[cur_site];
+
+ // Loop through all lines of genome, testing trying all combinations.
+ for (int line_num = 0; line_num < mod_genome.GetSize(); line_num++) {
+ int cur_inst = mod_genome[line_num].GetOp();
+
+ // Loop through all instructions...
+ for (int inst_num = 0; inst_num < inst_size; inst_num++) {
+ if (cur_inst == inst_num) continue;
+
+ mod_genome[line_num].SetOp(inst_num);
+ ProcessTwoStepGenome(ctx, testcpu, test_info, mod_genome, tdata, line_num, cur_site);
+ }
+
+ mod_genome[line_num].SetOp(cur_inst);
+ }
+}
+
+
double cMutationalNeighborhood::ProcessTwoStepGenome(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info,
const cGenome& mod_genome, sTwoStep& tdata, int cur_site, int oth_site)
{
@@ -442,59 +526,105 @@
m_tp.peak_fitness = m_base_fitness;
- m_tp.peak_genome = m_base_genome;
+ m_tp.peak_genome = m_base_genome;
m_tp.site_count.Resize(m_base_genome.GetSize(), 0);
AggregateTwoStep(m_twostep_point, m_tp);
m_ti.peak_fitness = m_base_fitness;
- m_ti.peak_genome = m_base_genome;
+ m_ti.peak_genome = m_base_genome;
m_ti.site_count.Resize(m_base_genome.GetSize() + 2, 0);
AggregateTwoStep(m_twostep_insert, m_ti);
m_td.peak_fitness = m_base_fitness;
- m_td.peak_genome = m_base_genome;
+ m_td.peak_genome = m_base_genome;
m_td.site_count.Resize(m_base_genome.GetSize(), 0);
AggregateTwoStep(m_twostep_delete, m_td);
+
+ m_tip.peak_fitness = m_base_fitness;
+ m_tip.peak_genome = m_base_genome;
+ m_tip.site_count.Resize(m_base_genome.GetSize() + 1, 0);
+ AggregateTwoStep(m_insert_point, m_tip);
+ m_tid.peak_fitness = m_base_fitness;
+ m_tid.peak_genome = m_base_genome;
+ m_tid.site_count.Resize(m_base_genome.GetSize() + 1, 0);
+ AggregateTwoStep(m_insert_delete, m_tid);
+
+ m_tdp.peak_fitness = m_base_fitness;
+ m_tdp.peak_genome = m_base_genome;
+ m_tdp.site_count.Resize(m_base_genome.GetSize(), 0);
+ AggregateTwoStep(m_delete_point, m_tdp);
+
+
// 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;
+ m_tt.total = m_tp.total + m_ti.total + m_td.total + m_tip.total + m_tid.total + m_tdp.total;
+ m_tt.total_fitness = m_tp.total_fitness + m_ti.total_fitness + m_td.total_fitness
+ + m_tip.total_fitness + m_tid.total_fitness + m_tdp.total_fitness;
+ m_tt.total_sqr_fitness = m_tp.total_sqr_fitness + m_ti.total_sqr_fitness + m_td.total_sqr_fitness
+ + m_tip.total_sqr_fitness + m_tid.total_sqr_fitness + m_tdp.total_sqr_fitness;
- if (m_tp.peak_fitness >= m_ti.peak_fitness && m_tp.peak_fitness >= m_td.peak_fitness) {
+ const double pftp = m_tp.peak_fitness;
+ const double pfti = m_ti.peak_fitness;
+ const double pftd = m_td.peak_fitness;
+ const double pftip = m_tip.peak_fitness;
+ const double pftid = m_tid.peak_fitness;
+ const double pftdp = m_tdp.peak_fitness;
+
+ if (pftp >= pfti && pftp >= pftd && pftp >= pftip && pftp >= pftid && pftp >= pftdp) {
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) {
+ } else if (pfti >= pftd && pfti >= pftip && pfti >= pftid && pfti >= pftdp) {
m_tt.peak_fitness = m_ti.peak_fitness;
m_tt.peak_genome = m_ti.peak_genome;
- } else {
+ } else if (pftd >= pftip && pftd >= pftid && pftd >= pftdp) {
m_tt.peak_fitness = m_td.peak_fitness;
m_tt.peak_genome = m_td.peak_genome;
+ } else if (pftip >= pftid && pftip >= pftdp) {
+ m_tt.peak_fitness = m_tip.peak_fitness;
+ m_tt.peak_genome = m_tip.peak_genome;
+ } else if (pftid >= pftdp) {
+ m_tt.peak_fitness = m_tid.peak_fitness;
+ m_tt.peak_genome = m_tid.peak_genome;
+ } else {
+ m_tt.peak_fitness = m_tdp.peak_fitness;
+ m_tt.peak_genome = m_tdp.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;
+ m_tt.pos = m_tp.pos + m_ti.pos + m_td.pos + m_tip.pos + m_tid.pos + m_tdp.pos;
+ m_tt.neg = m_tp.neg + m_ti.neg + m_td.neg + m_tip.neg + m_tid.neg + m_tdp.neg;
+ m_tt.neut = m_tp.neut + m_ti.neut + m_td.neut + m_tip.neut + m_tid.neut + m_tdp.neut;
+ m_tt.dead = m_tp.dead + m_ti.dead + m_td.dead + m_tip.dead + m_tid.dead + m_tdp.dead;
+ m_tt.size_pos = m_tp.size_pos + m_ti.size_pos + m_td.size_pos + m_tip.size_pos + m_tid.size_pos + m_tdp.size_pos;
+ m_tt.size_neg = m_tp.size_neg + m_ti.size_neg + m_td.size_neg + m_tip.size_neg + m_tid.size_neg + m_tdp.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_target = m_tp.task_target + m_ti.task_target + m_td.task_target
+ + m_tip.task_target + m_tid.task_target + m_tdp.task_target;
+ m_tt.task_target_pos = m_tp.task_target_pos + m_ti.task_target_pos + m_td.task_target_pos
+ + m_tip.task_target_pos + m_tid.task_target_pos + m_tdp.task_target_pos;
+ m_tt.task_target_neg = m_tp.task_target_neg + m_ti.task_target_neg + m_td.task_target_neg
+ + m_tip.task_target_neg + m_tid.task_target_neg + m_tdp.task_target_neg;
+ m_tt.task_target_neut = m_tp.task_target_neut + m_ti.task_target_neut + m_td.task_target_neut
+ + m_tip.task_target_neut + m_tid.task_target_neut + m_tdp.task_target_neut;
+ m_tt.task_target_dead = m_tp.task_target_dead + m_ti.task_target_dead + m_td.task_target_dead
+ + m_tip.task_target_dead + m_tid.task_target_dead + m_tdp.task_target_dead;
+ m_tt.task_total = m_tp.task_total + m_ti.task_total + m_td.task_total
+ + m_tip.task_total + m_tid.task_total + m_tdp.task_total;
+ m_tt.task_knockout = m_tp.task_knockout + m_ti.task_knockout + m_td.task_knockout
+ + m_tip.task_knockout + m_tid.task_knockout + m_tdp.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;
+ m_tt.task_size_target = m_tp.task_size_target + m_ti.task_size_target + m_td.task_size_target
+ + m_tip.task_size_target + m_tid.task_size_target + m_tdp.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_tip.task_size_target_pos + m_tid.task_size_target_pos + m_tdp.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_tip.task_size_target_neg + m_tid.task_size_target_neg + m_tdp.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_tip.task_size_total + m_tid.task_size_total + m_tdp.task_size_total;
+ m_tt.task_size_knockout = m_tp.task_size_knockout + m_ti.task_size_knockout + m_td.task_size_knockout
+ + m_tip.task_size_knockout + m_tid.task_size_knockout + m_tdp.task_size_knockout;
@@ -836,5 +966,101 @@
df.Write(Get2SDeleteProbKnockout(), "2-Step Delete Probability Knockout Task");
df.Write(Get2SDeleteAverageSizeKnockout(), "2-Step Delete Average Size of Task Knockout");
+ df.Write(GetInsPntTotal(), "Total Insert/Point Mutants");
+ df.Write(GetInsPntProbBeneficial(), "Insert/Point Probability Beneficial");
+ df.Write(GetInsPntProbDeleterious(), "Insert/Point Probability Deleterious");
+ df.Write(GetInsPntProbNeutral(), "Insert/Point Probability Neutral");
+ df.Write(GetInsPntProbLethal(), "Insert/Point Probability Lethal");
+ df.Write(GetInsPntAverageSizeBeneficial(), "Insert/Point Average Beneficial Size");
+ df.Write(GetInsPntAverageSizeDeleterious(), "Insert/Point Average Deleterious Size");
+ df.Write(GetInsPntPeakFitness(), "Insert/Point Peak Fitness");
+ df.Write(GetInsPntAverageFitness(), "Insert/Point Average Fitness");
+ df.Write(GetInsPntAverageSqrFitness(), "Insert/Point Average Square Fitness");
+ df.Write(GetInsPntTotalEntropy(), "Insert/Point Total Entropy");
+ df.Write(GetInsPntComplexity(), "Insert/Point Total Complexity");
+ df.Write(GetInsPntTargetTask(), "Insert/Point Confers Target Task");
+ df.Write(GetInsPntProbTargetTask(), "Insert/Point Probability Confers Target Task");
+ df.Write(GetInsPntAverageSizeTargetTask(), "Insert/Point Average Size of Target Task Conferral");
+ df.Write(GetInsPntTargetTaskBeneficial(), "Insert/Point Confers Target - Previous Beneficial");
+ df.Write(GetInsPntProbTargetTaskBeneficial(), "Insert/Point Prob. Confers Target - Previous Beneficial");
+ df.Write(GetInsPntAverageSizeTargetTaskBeneficial(), "Insert/Point Ave. Size of Previous Beneficial in Target Conferral");
+ df.Write(GetInsPntTargetTaskDeleterious(), "Insert/Point Confers Target - Previous Deleterious");
+ df.Write(GetInsPntProbTargetTaskDeleterious(), "Insert/Point Prob. Confers Target - Previous Deleterious");
+ df.Write(GetInsPntAverageSizeTargetTaskDeleterious(), "Insert/Point Ave. Size of Previous Deleterious in Target Conferral");
+ df.Write(GetInsPntTargetTaskNeutral(), "Insert/Point Confers Target - Previous Neutral");
+ df.Write(GetInsPntProbTargetTaskNeutral(), "Insert/Point Prob. Confers Target - Previous Neutral");
+ df.Write(GetInsPntTargetTaskLethal(), "Insert/Point Confers Target - Previous Lethal");
+ df.Write(GetInsPntProbTargetTaskLethal(), "Insert/Point Prob. Confers Target - Previous Lethal");
+ df.Write(GetInsPntTask(), "Insert/Point Confers Any Task");
+ df.Write(GetInsPntProbTask(), "Insert/Point Probability Confers Any Task");
+ df.Write(GetInsPntAverageSizeTask(), "Insert/Point Average Size of Any Task Conferral");
+ df.Write(GetInsPntKnockout(), "Insert/Point Knockout Task");
+ df.Write(GetInsPntProbKnockout(), "Insert/Point Probability Knockout Task");
+ df.Write(GetInsPntAverageSizeKnockout(), "Insert/Point Average Size of Task Knockout");
+
+ df.Write(GetInsDelTotal(), "Total Insert/Delete Mutants");
+ df.Write(GetInsDelProbBeneficial(), "Insert/Delete Probability Beneficial");
+ df.Write(GetInsDelProbDeleterious(), "Insert/Delete Probability Deleterious");
+ df.Write(GetInsDelProbNeutral(), "Insert/Delete Probability Neutral");
+ df.Write(GetInsDelProbLethal(), "Insert/Delete Probability Lethal");
+ df.Write(GetInsDelAverageSizeBeneficial(), "Insert/Delete Average Beneficial Size");
+ df.Write(GetInsDelAverageSizeDeleterious(), "Insert/Delete Average Deleterious Size");
+ df.Write(GetInsDelPeakFitness(), "Insert/Delete Peak Fitness");
+ df.Write(GetInsDelAverageFitness(), "Insert/Delete Average Fitness");
+ df.Write(GetInsDelAverageSqrFitness(), "Insert/Delete Average Square Fitness");
+ df.Write(GetInsDelTotalEntropy(), "Insert/Delete Total Entropy");
+ df.Write(GetInsDelComplexity(), "Insert/Delete Total Complexity");
+ df.Write(GetInsDelTargetTask(), "Insert/Delete Confers Target Task");
+ df.Write(GetInsDelProbTargetTask(), "Insert/Delete Probability Confers Target Task");
+ df.Write(GetInsDelAverageSizeTargetTask(), "Insert/Delete Average Size of Target Task Conferral");
+ df.Write(GetInsDelTargetTaskBeneficial(), "Insert/Delete Confers Target - Previous Beneficial");
+ df.Write(GetInsDelProbTargetTaskBeneficial(), "Insert/Delete Prob. Confers Target - Previous Beneficial");
+ df.Write(GetInsDelAverageSizeTargetTaskBeneficial(), "Insert/Delete Ave. Size of Previous Beneficial in Target Conferral");
+ df.Write(GetInsDelTargetTaskDeleterious(), "Insert/Delete Confers Target - Previous Deleterious");
+ df.Write(GetInsDelProbTargetTaskDeleterious(), "Insert/Delete Prob. Confers Target - Previous Deleterious");
+ df.Write(GetInsDelAverageSizeTargetTaskDeleterious(), "Insert/Delete Ave. Size of Previous Deleterious in Target Conferral");
+ df.Write(GetInsDelTargetTaskNeutral(), "Insert/Delete Confers Target - Previous Neutral");
+ df.Write(GetInsDelProbTargetTaskNeutral(), "Insert/Delete Prob. Confers Target - Previous Neutral");
+ df.Write(GetInsDelTargetTaskLethal(), "Insert/Delete Confers Target - Previous Lethal");
+ df.Write(GetInsDelProbTargetTaskLethal(), "Insert/Delete Prob. Confers Target - Previous Lethal");
+ df.Write(GetInsDelTask(), "Insert/Delete Confers Any Task");
+ df.Write(GetInsDelProbTask(), "Insert/Delete Probability Confers Any Task");
+ df.Write(GetInsDelAverageSizeTask(), "Insert/Delete Average Size of Any Task Conferral");
+ df.Write(GetInsDelKnockout(), "Insert/Delete Knockout Task");
+ df.Write(GetInsDelProbKnockout(), "Insert/Delete Probability Knockout Task");
+ df.Write(GetInsDelAverageSizeKnockout(), "Insert/Delete Average Size of Task Knockout");
+
+ df.Write(GetDelPntTotal(), "Total Delete/Point Mutants");
+ df.Write(GetDelPntProbBeneficial(), "Delete/Point Probability Beneficial");
+ df.Write(GetDelPntProbDeleterious(), "Delete/Point Probability Deleterious");
+ df.Write(GetDelPntProbNeutral(), "Delete/Point Probability Neutral");
+ df.Write(GetDelPntProbLethal(), "Delete/Point Probability Lethal");
+ df.Write(GetDelPntAverageSizeBeneficial(), "Delete/Point Average Beneficial Size");
+ df.Write(GetDelPntAverageSizeDeleterious(), "Delete/Point Average Deleterious Size");
+ df.Write(GetDelPntPeakFitness(), "Delete/Point Peak Fitness");
+ df.Write(GetDelPntAverageFitness(), "Delete/Point Average Fitness");
+ df.Write(GetDelPntAverageSqrFitness(), "Delete/Point Average Square Fitness");
+ df.Write(GetDelPntTotalEntropy(), "Delete/Point Total Entropy");
+ df.Write(GetDelPntComplexity(), "Delete/Point Total Complexity");
+ df.Write(GetDelPntTargetTask(), "Delete/Point Confers Target Task");
+ df.Write(GetDelPntProbTargetTask(), "Delete/Point Probability Confers Target Task");
+ df.Write(GetDelPntAverageSizeTargetTask(), "Delete/Point Average Size of Target Task Conferral");
+ df.Write(GetDelPntTargetTaskBeneficial(), "Delete/Point Confers Target - Previous Beneficial");
+ df.Write(GetDelPntProbTargetTaskBeneficial(), "Delete/Point Prob. Confers Target - Previous Beneficial");
+ df.Write(GetDelPntAverageSizeTargetTaskBeneficial(), "Delete/Point Ave. Size of Previous Beneficial in Target Conferral");
+ df.Write(GetDelPntTargetTaskDeleterious(), "Delete/Point Confers Target - Previous Deleterious");
+ df.Write(GetDelPntProbTargetTaskDeleterious(), "Delete/Point Prob. Confers Target - Previous Deleterious");
+ df.Write(GetDelPntAverageSizeTargetTaskDeleterious(), "Delete/Point Ave. Size of Previous Deleterious in Target Conferral");
+ df.Write(GetDelPntTargetTaskNeutral(), "Delete/Point Confers Target - Previous Neutral");
+ df.Write(GetDelPntProbTargetTaskNeutral(), "Delete/Point Prob. Confers Target - Previous Neutral");
+ df.Write(GetDelPntTargetTaskLethal(), "Delete/Point Confers Target - Previous Lethal");
+ df.Write(GetDelPntProbTargetTaskLethal(), "Delete/Point Prob. Confers Target - Previous Lethal");
+ df.Write(GetDelPntTask(), "Delete/Point Confers Any Task");
+ df.Write(GetDelPntProbTask(), "Delete/Point Probability Confers Any Task");
+ df.Write(GetDelPntAverageSizeTask(), "Delete/Point Average Size of Any Task Conferral");
+ df.Write(GetDelPntKnockout(), "Delete/Point Knockout Task");
+ df.Write(GetDelPntProbKnockout(), "Delete/Point Probability Knockout Task");
+ df.Write(GetDelPntAverageSizeKnockout(), "Delete/Point Average Size of Task Knockout");
+
df.Endl();
}
Modified: development/source/analyze/cMutationalNeighborhood.h
===================================================================
--- development/source/analyze/cMutationalNeighborhood.h 2007-07-30 02:29:36 UTC (rev 1864)
+++ development/source/analyze/cMutationalNeighborhood.h 2007-07-30 04:04:06 UTC (rev 1865)
@@ -151,7 +151,11 @@
tArray<sTwoStep> m_twostep_insert;
tArray<sTwoStep> m_twostep_delete;
+ tArray<sTwoStep> m_insert_point;
+ tArray<sTwoStep> m_insert_delete;
+ tArray<sTwoStep> m_delete_point;
+
// One Step Fitness Data
// -----------------------------------------------------------------------------------------------------------------------
tMatrix<double> m_fitness_point;
@@ -220,11 +224,15 @@
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_tp; // Two Step Point Mutants
+ sTwoStepAggregate m_ti; // Two Step Insert Mutants
+ sTwoStepAggregate m_td; // Two Step Delete Mutants
- sTwoStepAggregate m_tt;
+ sTwoStepAggregate m_tip; // Two Step Insert/Point Combo Mutants
+ sTwoStepAggregate m_tid; // Two Step Insert/Delete Combo Mutants
+ sTwoStepAggregate m_tdp; // Two Step Delete/Point Combo Mutants
+
+ sTwoStepAggregate m_tt; // Two Step Total
@@ -261,7 +269,9 @@
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);
+ void ProcessInsertPointCombo(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site, cGenome& mod_genome);
+ void ProcessInsertDeleteCombo(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site, cCPUMemory& mod_genome);
+ void ProcessDeletePointCombo(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);
@@ -706,6 +716,207 @@
{
if (m_td.task_knockout == 0) return 0.0; else return double(m_td.task_size_knockout) / m_td.task_knockout;
}
+
+
+
+
+ inline int GetInsPntTotal() const { return m_tip.total; }
+
+ inline double GetInsPntAverageFitness() const { return m_tip.total_fitness / m_tip.total; }
+ inline double GetInsPntAverageSqrFitness() const { return m_tip.total_sqr_fitness / m_tip.total; }
+ inline const cGenome& GetInsPntPeakGenome() const { return m_tip.peak_genome; }
+ inline double GetInsPntPeakFitness() const { return m_tip.peak_fitness; }
+
+ inline double GetInsPntProbBeneficial() const { return double(m_tip.pos) / m_tip.total; }
+ inline double GetInsPntProbDeleterious() const { return double(m_tip.neg) / m_tip.total; }
+ inline double GetInsPntProbNeutral() const { return double(m_tip.neut) / m_tip.total; }
+ inline double GetInsPntProbLethal() const { return double(m_tip.dead) / m_tip.total; }
+ inline double GetInsPntAverageSizeBeneficial() const { if (m_tip.pos == 0) return 0.0; else return m_tip.size_pos / m_tip.pos; }
+ inline double GetInsPntAverageSizeDeleterious() const { if (m_tip.neg == 0) return 0.0; else return m_tip.size_neg / m_tip.neg; }
+
+ inline double GetInsPntTotalEntropy() const { return m_tip.total_entropy; }
+ inline double GetInsPntComplexity() const { return m_tip.complexity; }
+
+ inline int GetInsPntTargetTask() const { return m_tip.task_target; }
+ inline double GetInsPntProbTargetTask() const { return double(m_tip.task_target) / m_tip.total; }
+ inline double GetInsPntAverageSizeTargetTask() const
+ {
+ if (m_tip.task_target == 0) return 0.0; else return double(m_tip.task_size_target) / m_tip.task_target;
+ }
+ inline int GetInsPntTargetTaskBeneficial() const { return m_tip.task_target_pos; }
+ inline double GetInsPntProbTargetTaskBeneficial() const
+ {
+ if (m_tip.task_target == 0) return 0.0; else return double(m_tip.task_target_pos) / (2 * m_tip.task_target);
+ }
+ inline double GetInsPntAverageSizeTargetTaskBeneficial() const
+ {
+ if (m_tip.task_target == 0) return 0.0; else return double(m_tip.task_size_target_pos) / (2 * m_tip.task_target);
+ }
+ inline int GetInsPntTargetTaskDeleterious() const { return m_tip.task_target_neg; }
+ inline double GetInsPntProbTargetTaskDeleterious() const
+ {
+ if (m_tip.task_target == 0) return 0.0; else return double(m_tip.task_target_neg) / (2 * m_tip.task_target);
+ }
+ inline double GetInsPntAverageSizeTargetTaskDeleterious() const
+ {
+ if (m_tip.task_target == 0) return 0.0; else return double(m_tip.task_size_target_neg) / (2 * m_tip.task_target);
+ }
+ inline int GetInsPntTargetTaskNeutral() const { return m_tip.task_target_neut; }
+ inline double GetInsPntProbTargetTaskNeutral() const
+ {
+ if (m_tip.task_target == 0) return 0.0; else return double(m_tip.task_target_neut) / (2 * m_tip.task_target);
+ }
+ inline int GetInsPntTargetTaskLethal() const { return m_tip.task_target_dead; }
+ inline double GetInsPntProbTargetTaskLethal() const
+ {
+ if (m_tip.task_target == 0) return 0.0; else return double(m_tip.task_target_dead) / (2 * m_tip.task_target);
+ }
+ inline int GetInsPntTask() const { return m_tip.task_total; }
+ inline double GetInsPntProbTask() const { return double(m_tip.task_total) / m_tip.total; }
+ inline double GetInsPntAverageSizeTask() const
+ {
+ if (m_tip.task_total == 0) return 0.0; else return double(m_tip.task_size_total) / m_tip.task_total;
+ }
+ inline int GetInsPntKnockout() const { return m_tip.task_knockout; }
+ inline double GetInsPntProbKnockout() const { return double(m_tip.task_knockout) / m_tip.total; }
+ inline double GetInsPntAverageSizeKnockout() const
+ {
+ if (m_tip.task_knockout == 0) return 0.0; else return double(m_tip.task_size_knockout) / m_tip.task_knockout;
+ }
+
+
+
+
+ inline int GetInsDelTotal() const { return m_tid.total; }
+
+ inline double GetInsDelAverageFitness() const { return m_tid.total_fitness / m_tid.total; }
+ inline double GetInsDelAverageSqrFitness() const { return m_tid.total_sqr_fitness / m_tid.total; }
+ inline const cGenome& GetInsDelPeakGenome() const { return m_tid.peak_genome; }
+ inline double GetInsDelPeakFitness() const { return m_tid.peak_fitness; }
+
+ inline double GetInsDelProbBeneficial() const { return double(m_tid.pos) / m_tid.total; }
+ inline double GetInsDelProbDeleterious() const { return double(m_tid.neg) / m_tid.total; }
+ inline double GetInsDelProbNeutral() const { return double(m_tid.neut) / m_tid.total; }
+ inline double GetInsDelProbLethal() const { return double(m_tid.dead) / m_tid.total; }
+ inline double GetInsDelAverageSizeBeneficial() const { if (m_tid.pos == 0) return 0.0; else return m_tid.size_pos / m_tid.pos; }
+ inline double GetInsDelAverageSizeDeleterious() const { if (m_tid.neg == 0) return 0.0; else return m_tid.size_neg / m_tid.neg; }
+
+ inline double GetInsDelTotalEntropy() const { return m_tid.total_entropy; }
+ inline double GetInsDelComplexity() const { return m_tid.complexity; }
+
+ inline int GetInsDelTargetTask() const { return m_tid.task_target; }
+ inline double GetInsDelProbTargetTask() const { return double(m_tid.task_target) / m_tid.total; }
+ inline double GetInsDelAverageSizeTargetTask() const
+ {
+ if (m_tid.task_target == 0) return 0.0; else return double(m_tid.task_size_target) / m_tid.task_target;
+ }
+ inline int GetInsDelTargetTaskBeneficial() const { return m_tid.task_target_pos; }
+ inline double GetInsDelProbTargetTaskBeneficial() const
+ {
+ if (m_tid.task_target == 0) return 0.0; else return double(m_tid.task_target_pos) / (2 * m_tid.task_target);
+ }
+ inline double GetInsDelAverageSizeTargetTaskBeneficial() const
+ {
+ if (m_tid.task_target == 0) return 0.0; else return double(m_tid.task_size_target_pos) / (2 * m_tid.task_target);
+ }
+ inline int GetInsDelTargetTaskDeleterious() const { return m_tid.task_target_neg; }
+ inline double GetInsDelProbTargetTaskDeleterious() const
+ {
+ if (m_tid.task_target == 0) return 0.0; else return double(m_tid.task_target_neg) / (2 * m_tid.task_target);
+ }
+ inline double GetInsDelAverageSizeTargetTaskDeleterious() const
+ {
+ if (m_tid.task_target == 0) return 0.0; else return double(m_tid.task_size_target_neg) / (2 * m_tid.task_target);
+ }
+ inline int GetInsDelTargetTaskNeutral() const { return m_tid.task_target_neut; }
+ inline double GetInsDelProbTargetTaskNeutral() const
+ {
+ if (m_tid.task_target == 0) return 0.0; else return double(m_tid.task_target_neut) / (2 * m_tid.task_target);
+ }
+ inline int GetInsDelTargetTaskLethal() const { return m_tid.task_target_dead; }
+ inline double GetInsDelProbTargetTaskLethal() const
+ {
+ if (m_tid.task_target == 0) return 0.0; else return double(m_tid.task_target_dead) / (2 * m_tid.task_target);
+ }
+ inline int GetInsDelTask() const { return m_tid.task_total; }
+ inline double GetInsDelProbTask() const { return double(m_tid.task_total) / m_tid.total; }
+ inline double GetInsDelAverageSizeTask() const
+ {
+ if (m_tid.task_total == 0) return 0.0; else return double(m_tid.task_size_total) / m_tid.task_total;
+ }
+ inline int GetInsDelKnockout() const { return m_tid.task_knockout; }
+ inline double GetInsDelProbKnockout() const { return double(m_tid.task_knockout) / m_tid.total; }
+ inline double GetInsDelAverageSizeKnockout() const
+ {
+ if (m_tid.task_knockout == 0) return 0.0; else return double(m_tid.task_size_knockout) / m_tid.task_knockout;
+ }
+
+
+
+
+ inline int GetDelPntTotal() const { return m_tdp.total; }
+
+ inline double GetDelPntAverageFitness() const { return m_tdp.total_fitness / m_tdp.total; }
+ inline double GetDelPntAverageSqrFitness() const { return m_tdp.total_sqr_fitness / m_tdp.total; }
+ inline const cGenome& GetDelPntPeakGenome() const { return m_tdp.peak_genome; }
+ inline double GetDelPntPeakFitness() const { return m_tdp.peak_fitness; }
+
+ inline double GetDelPntProbBeneficial() const { return double(m_tdp.pos) / m_tdp.total; }
+ inline double GetDelPntProbDeleterious() const { return double(m_tdp.neg) / m_tdp.total; }
+ inline double GetDelPntProbNeutral() const { return double(m_tdp.neut) / m_tdp.total; }
+ inline double GetDelPntProbLethal() const { return double(m_tdp.dead) / m_tdp.total; }
+ inline double GetDelPntAverageSizeBeneficial() const { if (m_tdp.pos == 0) return 0.0; else return m_tdp.size_pos / m_tdp.pos; }
+ inline double GetDelPntAverageSizeDeleterious() const { if (m_tdp.neg == 0) return 0.0; else return m_tdp.size_neg / m_tdp.neg; }
+
+ inline double GetDelPntTotalEntropy() const { return m_tdp.total_entropy; }
+ inline double GetDelPntComplexity() const { return m_tdp.complexity; }
+
+ inline int GetDelPntTargetTask() const { return m_tdp.task_target; }
+ inline double GetDelPntProbTargetTask() const { return double(m_tdp.task_target) / m_tdp.total; }
+ inline double GetDelPntAverageSizeTargetTask() const
+ {
+ if (m_tdp.task_target == 0) return 0.0; else return double(m_tdp.task_size_target) / m_tdp.task_target;
+ }
+ inline int GetDelPntTargetTaskBeneficial() const { return m_tdp.task_target_pos; }
+ inline double GetDelPntProbTargetTaskBeneficial() const
+ {
+ if (m_tdp.task_target == 0) return 0.0; else return double(m_tdp.task_target_pos) / (2 * m_tdp.task_target);
+ }
+ inline double GetDelPntAverageSizeTargetTaskBeneficial() const
+ {
+ if (m_tdp.task_target == 0) return 0.0; else return double(m_tdp.task_size_target_pos) / (2 * m_tdp.task_target);
+ }
+ inline int GetDelPntTargetTaskDeleterious() const { return m_tdp.task_target_neg; }
+ inline double GetDelPntProbTargetTaskDeleterious() const
+ {
+ if (m_tdp.task_target == 0) return 0.0; else return double(m_tdp.task_target_neg) / (2 * m_tdp.task_target);
+ }
+ inline double GetDelPntAverageSizeTargetTaskDeleterious() const
+ {
+ if (m_tdp.task_target == 0) return 0.0; else return double(m_tdp.task_size_target_neg) / (2 * m_tdp.task_target);
+ }
+ inline int GetDelPntTargetTaskNeutral() const { return m_tdp.task_target_neut; }
+ inline double GetDelPntProbTargetTaskNeutral() const
+ {
+ if (m_tdp.task_target == 0) return 0.0; else return double(m_tdp.task_target_neut) / (2 * m_tdp.task_target);
+ }
+ inline int GetDelPntTargetTaskLethal() const { return m_tdp.task_target_dead; }
+ inline double GetDelPntProbTargetTaskLethal() const
+ {
+ if (m_tdp.task_target == 0) return 0.0; else return double(m_tdp.task_target_dead) / (2 * m_tdp.task_target);
+ }
+ inline int GetDelPntTask() const { return m_tdp.task_total; }
+ inline double GetDelPntProbTask() const { return double(m_tdp.task_total) / m_tdp.total; }
+ inline double GetDelPntAverageSizeTask() const
+ {
+ if (m_tdp.task_total == 0) return 0.0; else return double(m_tdp.task_size_total) / m_tdp.task_total;
+ }
+ inline int GetDelPntKnockout() const { return m_tdp.task_knockout; }
+ inline double GetDelPntProbKnockout() const { return double(m_tdp.task_knockout) / m_tdp.total; }
+ inline double GetDelPntAverageSizeKnockout() const
+ {
+ if (m_tdp.task_knockout == 0) return 0.0; else return double(m_tdp.task_size_knockout) / m_tdp.task_knockout;
+ }
};
Modified: development/source/analyze/cMutationalNeighborhoodResults.h
===================================================================
--- development/source/analyze/cMutationalNeighborhoodResults.h 2007-07-30 02:29:36 UTC (rev 1864)
+++ development/source/analyze/cMutationalNeighborhoodResults.h 2007-07-30 04:04:06 UTC (rev 1865)
@@ -349,6 +349,129 @@
inline int Get2SDeleteKnockout() const { return m_src.Get2SDeleteKnockout(); }
inline double Get2SDeleteProbKnockout() const { return m_src.Get2SDeleteProbKnockout(); }
inline double Get2SDeleteAverageSizeKnockout() const { return m_src.Get2SDeleteAverageSizeKnockout(); }
+
+
+
+
+
+ inline int GetInsPntTotal() const { return m_src.GetInsPntTotal(); }
+
+ inline double GetInsPntAverageFitness() const { return m_src.GetInsPntAverageFitness(); }
+ inline double GetInsPntAverageSqrFitness() const { return m_src.GetInsPntAverageSqrFitness(); }
+ inline const cGenome& GetInsPntPeakGenome() const { return m_src.GetInsPntPeakGenome(); }
+ inline double GetInsPntPeakFitness() const { return m_src.GetInsPntPeakFitness(); }
+
+ inline double GetInsPntProbBeneficial() const { return m_src.GetInsPntProbBeneficial(); }
+ inline double GetInsPntProbDeleterious() const { return m_src.GetInsPntProbDeleterious(); }
+ inline double GetInsPntProbNeutral() const { return m_src.GetInsPntProbNeutral(); }
+ inline double GetInsPntProbLethal() const { return m_src.GetInsPntProbLethal(); }
+ inline double GetInsPntAverageSizeBeneficial() const { return m_src.GetInsPntAverageSizeBeneficial(); }
+ inline double GetInsPntAverageSizeDeleterious() const { return m_src.GetInsPntAverageSizeDeleterious(); }
+
+ inline double GetInsPntTotalEntropy() const { return m_src.GetInsPntTotalEntropy(); }
+ inline double GetInsPntComplexity() const { return m_src.GetInsPntComplexity(); }
+
+ inline int GetInsPntTargetTask() const { return m_src.GetInsPntTargetTask(); }
+ inline double GetInsPntProbTargetTask() const { return m_src.GetInsPntProbTargetTask(); }
+ inline double GetInsPntAverageSizeTargetTask() const { return m_src.GetInsPntAverageSizeTargetTask(); }
+ inline int GetInsPntTargetTaskBeneficial() const { return m_src.GetInsPntTargetTaskBeneficial(); }
+ inline double GetInsPntProbTargetTaskBeneficial() const { return m_src.GetInsPntProbTargetTaskBeneficial(); }
+ inline double GetInsPntAverageSizeTargetTaskBeneficial() const { return m_src.GetInsPntAverageSizeTargetTaskBeneficial(); }
+ inline int GetInsPntTargetTaskDeleterious() const { return m_src.GetInsPntTargetTaskDeleterious(); }
+ inline double GetInsPntProbTargetTaskDeleterious() const { return m_src.GetInsPntProbTargetTaskDeleterious(); }
+ inline double GetInsPntAverageSizeTargetTaskDeleterious() const { return m_src.GetInsPntAverageSizeTargetTaskDeleterious(); }
+ inline int GetInsPntTargetTaskNeutral() const { return m_src.GetInsPntTargetTaskNeutral(); }
+ inline double GetInsPntProbTargetTaskNeutral() const { return m_src.GetInsPntProbTargetTaskNeutral(); }
+ inline int GetInsPntTargetTaskLethal() const { return m_src.GetInsPntTargetTaskLethal(); }
+ inline double GetInsPntProbTargetTaskLethal() const { return m_src.GetInsPntProbTargetTaskLethal(); }
+ inline int GetInsPntTask() const { return m_src.GetInsPntTask(); }
+ inline double GetInsPntProbTask() const { return m_src.GetInsPntProbTask(); }
+ inline double GetInsPntAverageSizeTask() const { return m_src.GetInsPntAverageSizeTask(); }
+ inline int GetInsPntKnockout() const { return m_src.GetInsPntKnockout(); }
+ inline double GetInsPntProbKnockout() const { return m_src.GetInsPntProbKnockout(); }
+ inline double GetInsPntAverageSizeKnockout() const { return m_src.GetInsPntAverageSizeKnockout(); }
+
+
+
+
+
+ inline int GetInsDelTotal() const { return m_src.GetInsDelTotal(); }
+
+ inline double GetInsDelAverageFitness() const { return m_src.GetInsDelAverageFitness(); }
+ inline double GetInsDelAverageSqrFitness() const { return m_src.GetInsDelAverageSqrFitness(); }
+ inline const cGenome& GetInsDelPeakGenome() const { return m_src.GetInsDelPeakGenome(); }
+ inline double GetInsDelPeakFitness() const { return m_src.GetInsDelPeakFitness(); }
+
+ inline double GetInsDelProbBeneficial() const { return m_src.GetInsDelProbBeneficial(); }
+ inline double GetInsDelProbDeleterious() const { return m_src.GetInsDelProbDeleterious(); }
+ inline double GetInsDelProbNeutral() const { return m_src.GetInsDelProbNeutral(); }
+ inline double GetInsDelProbLethal() const { return m_src.GetInsDelProbLethal(); }
+ inline double GetInsDelAverageSizeBeneficial() const { return m_src.GetInsDelAverageSizeBeneficial(); }
+ inline double GetInsDelAverageSizeDeleterious() const { return m_src.GetInsDelAverageSizeDeleterious(); }
+
+ inline double GetInsDelTotalEntropy() const { return m_src.GetInsDelTotalEntropy(); }
+ inline double GetInsDelComplexity() const { return m_src.GetInsDelComplexity(); }
+
+ inline int GetInsDelTargetTask() const { return m_src.GetInsDelTargetTask(); }
+ inline double GetInsDelProbTargetTask() const { return m_src.GetInsDelProbTargetTask(); }
+ inline double GetInsDelAverageSizeTargetTask() const { return m_src.GetInsDelAverageSizeTargetTask(); }
+ inline int GetInsDelTargetTaskBeneficial() const { return m_src.GetInsDelTargetTaskBeneficial(); }
+ inline double GetInsDelProbTargetTaskBeneficial() const { return m_src.GetInsDelProbTargetTaskBeneficial(); }
+ inline double GetInsDelAverageSizeTargetTaskBeneficial() const { return m_src.GetInsDelAverageSizeTargetTaskBeneficial(); }
+ inline int GetInsDelTargetTaskDeleterious() const { return m_src.GetInsDelTargetTaskDeleterious(); }
+ inline double GetInsDelProbTargetTaskDeleterious() const { return m_src.GetInsDelProbTargetTaskDeleterious(); }
+ inline double GetInsDelAverageSizeTargetTaskDeleterious() const { return m_src.GetInsDelAverageSizeTargetTaskDeleterious(); }
+ inline int GetInsDelTargetTaskNeutral() const { return m_src.GetInsDelTargetTaskNeutral(); }
+ inline double GetInsDelProbTargetTaskNeutral() const { return m_src.GetInsDelProbTargetTaskNeutral(); }
+ inline int GetInsDelTargetTaskLethal() const { return m_src.GetInsDelTargetTaskLethal(); }
+ inline double GetInsDelProbTargetTaskLethal() const { return m_src.GetInsDelProbTargetTaskLethal(); }
+ inline int GetInsDelTask() const { return m_src.GetInsDelTask(); }
+ inline double GetInsDelProbTask() const { return m_src.GetInsDelProbTask(); }
+ inline double GetInsDelAverageSizeTask() const { return m_src.GetInsDelAverageSizeTask(); }
+ inline int GetInsDelKnockout() const { return m_src.GetInsDelKnockout(); }
+ inline double GetInsDelProbKnockout() const { return m_src.GetInsDelProbKnockout(); }
+ inline double GetInsDelAverageSizeKnockout() const { return m_src.GetInsDelAverageSizeKnockout(); }
+
+
+
+
+
+ inline int GetDelPntTotal() const { return m_src.GetDelPntTotal(); }
+
+ inline double GetDelPntAverageFitness() const { return m_src.GetDelPntAverageFitness(); }
+ inline double GetDelPntAverageSqrFitness() const { return m_src.GetDelPntAverageSqrFitness(); }
+ inline const cGenome& GetDelPntPeakGenome() const { return m_src.GetDelPntPeakGenome(); }
+ inline double GetDelPntPeakFitness() const { return m_src.GetDelPntPeakFitness(); }
+
+ inline double GetDelPntProbBeneficial() const { return m_src.GetDelPntProbBeneficial(); }
+ inline double GetDelPntProbDeleterious() const { return m_src.GetDelPntProbDeleterious(); }
+ inline double GetDelPntProbNeutral() const { return m_src.GetDelPntProbNeutral(); }
+ inline double GetDelPntProbLethal() const { return m_src.GetDelPntProbLethal(); }
+ inline double GetDelPntAverageSizeBeneficial() const { return m_src.GetDelPntAverageSizeBeneficial(); }
+ inline double GetDelPntAverageSizeDeleterious() const { return m_src.GetDelPntAverageSizeDeleterious(); }
+
+ inline double GetDelPntTotalEntropy() const { return m_src.GetDelPntTotalEntropy(); }
+ inline double GetDelPntComplexity() const { return m_src.GetDelPntComplexity(); }
+
+ inline int GetDelPntTargetTask() const { return m_src.GetDelPntTargetTask(); }
+ inline double GetDelPntProbTargetTask() const { return m_src.GetDelPntProbTargetTask(); }
+ inline double GetDelPntAverageSizeTargetTask() const { return m_src.GetDelPntAverageSizeTargetTask(); }
+ inline int GetDelPntTargetTaskBeneficial() const { return m_src.GetDelPntTargetTaskBeneficial(); }
+ inline double GetDelPntProbTargetTaskBeneficial() const { return m_src.GetDelPntProbTargetTaskBeneficial(); }
+ inline double GetDelPntAverageSizeTargetTaskBeneficial() const { return m_src.GetDelPntAverageSizeTargetTaskBeneficial(); }
+ inline int GetDelPntTargetTaskDeleterious() const { return m_src.GetDelPntTargetTaskDeleterious(); }
+ inline double GetDelPntProbTargetTaskDeleterious() const { return m_src.GetDelPntProbTargetTaskDeleterious(); }
+ inline double GetDelPntAverageSizeTargetTaskDeleterious() const { return m_src.GetDelPntAverageSizeTargetTaskDeleterious(); }
+ inline int GetDelPntTargetTaskNeutral() const { return m_src.GetDelPntTargetTaskNeutral(); }
+ inline double GetDelPntProbTargetTaskNeutral() const { return m_src.GetDelPntProbTargetTaskNeutral(); }
+ inline int GetDelPntTargetTaskLethal() const { return m_src.GetDelPntTargetTaskLethal(); }
+ inline double GetDelPntProbTargetTaskLethal() const { return m_src.GetDelPntProbTargetTaskLethal(); }
+ inline int GetDelPntTask() const { return m_src.GetDelPntTask(); }
+ inline double GetDelPntProbTask() const { return m_src.GetDelPntProbTask(); }
+ inline double GetDelPntAverageSizeTask() const { return m_src.GetDelPntAverageSizeTask(); }
+ inline int GetDelPntKnockout() const { return m_src.GetDelPntKnockout(); }
+ inline double GetDelPntProbKnockout() const { return m_src.GetDelPntProbKnockout(); }
+ inline double GetDelPntAverageSizeKnockout() const { return m_src.GetDelPntAverageSizeKnockout(); }
};
#endif
More information about the Avida-cvs
mailing list