[Avida-SVN] r1864 - development/source/analyze
brysonda at myxo.css.msu.edu
brysonda at myxo.css.msu.edu
Sun Jul 29 19:29:36 PDT 2007
Author: brysonda
Date: 2007-07-29 22:29:36 -0400 (Sun, 29 Jul 2007)
New Revision: 1864
Modified:
development/source/analyze/cMutationalNeighborhood.cc
development/source/analyze/cMutationalNeighborhood.h
development/source/analyze/cMutationalNeighborhoodResults.h
Log:
MutationalNeighborhood: Two Step results reporting and access.
Modified: development/source/analyze/cMutationalNeighborhood.cc
===================================================================
--- development/source/analyze/cMutationalNeighborhood.cc 2007-07-30 02:08:14 UTC (rev 1863)
+++ development/source/analyze/cMutationalNeighborhood.cc 2007-07-30 02:29:36 UTC (rev 1864)
@@ -708,37 +708,133 @@
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");
- df.Write(GetDoubleProbNeutral(), "Two Step Probability Neutral");
- df.Write(GetDoubleProbLethal(), "Two Step Probability Lethal");
- df.Write(GetDoubleAverageSizeBeneficial(), "Two Step Average Beneficial Size");
- df.Write(GetDoubleAverageSizeDeleterious(), "Two Step Average Deleterious Size");
- df.Write(GetDoublePeakFitness(), "Two Step Peak Fitness");
- df.Write(GetDoubleAverageFitness(), "Two Step Average Fitness");
- df.Write(GetDoubleAverageSqrFitness(), "Two Step Average Square Fitness");
- df.Write(GetDoubleTotalEntropy(), "Two Step Total Entropy");
- df.Write(GetDoubleComplexity(), "Two Step Total Complexity");
- df.Write(GetDoubleTargetTask(), "Two Step Confers Target Task");
- df.Write(GetDoubleProbTargetTask(), "Two Step Probability Confers Target Task");
- df.Write(GetDoubleAverageSizeTargetTask(), "Two Step Average Size of Target Task Conferral");
- df.Write(GetDoubleTargetTaskBeneficial(), "Two Step Confers Target - Previous Beneficial");
- df.Write(GetDoubleProbTargetTaskBeneficial(), "Two Step Prob. Confers Target - Previous Beneficial");
- df.Write(GetDoubleAverageSizeTargetTaskBeneficial(), "Two Step Ave. Size of Previous Beneficial in Target Conferral");
- df.Write(GetDoubleTargetTaskDeleterious(), "Two Step Confers Target - Previous Deleterious");
- df.Write(GetDoubleProbTargetTaskDeleterious(), "Two Step Prob. Confers Target - Previous Deleterious");
- df.Write(GetDoubleAverageSizeTargetTaskDeleterious(), "Two Step Ave. Size of Previous Deleterious in Target Conferral");
- df.Write(GetDoubleTargetTaskNeutral(), "Two Step Confers Target - Previous Neutral");
- df.Write(GetDoubleProbTargetTaskNeutral(), "Two Step Prob. Confers Target - Previous Neutral");
- df.Write(GetDoubleTargetTaskLethal(), "Two Step Confers Target - Previous Lethal");
- df.Write(GetDoubleProbTargetTaskLethal(), "Two Step Prob. Confers Target - Previous Lethal");
- df.Write(GetDoubleTask(), "Two Step Confers Any Task");
- df.Write(GetDoubleProbTask(), "Two Step Probability Confers Any Task");
- df.Write(GetDoubleAverageSizeTask(), "Two Step Average Size of Any Task Conferral");
- df.Write(GetDoubleKnockout(), "Two Step Knockout Task");
- df.Write(GetDoubleProbKnockout(), "Two Step Probability Knockout Task");
- df.Write(GetDoubleAverageSizeKnockout(), "Two Step Average Size of Task Knockout");
+ df.Write(Get2SAggregateTotal(), "Total 2-Step Mutants");
+ df.Write(Get2SAggregateProbBeneficial(), "2-Step Probability Beneficial");
+ df.Write(Get2SAggregateProbDeleterious(), "2-Step Probability Deleterious");
+ df.Write(Get2SAggregateProbNeutral(), "2-Step Probability Neutral");
+ df.Write(Get2SAggregateProbLethal(), "2-Step Probability Lethal");
+ df.Write(Get2SAggregateAverageSizeBeneficial(), "2-Step Average Beneficial Size");
+ df.Write(Get2SAggregateAverageSizeDeleterious(), "2-Step Average Deleterious Size");
+ df.Write(Get2SAggregatePeakFitness(), "2-Step Peak Fitness");
+ df.Write(Get2SAggregateAverageFitness(), "2-Step Average Fitness");
+ df.Write(Get2SAggregateAverageSqrFitness(), "2-Step Average Square Fitness");
+// df.Write(Get2SAggregateTotalEntropy(), "2-Step Total Entropy");
+// df.Write(Get2SAggregateComplexity(), "2-Step Total Complexity");
+ df.Write(Get2SAggregateTargetTask(), "2-Step Confers Target Task");
+ df.Write(Get2SAggregateProbTargetTask(), "2-Step Probability Confers Target Task");
+ df.Write(Get2SAggregateAverageSizeTargetTask(), "2-Step Average Size of Target Task Conferral");
+ df.Write(Get2SAggregateTargetTaskBeneficial(), "2-Step Confers Target - Previous Beneficial");
+ df.Write(Get2SAggregateProbTargetTaskBeneficial(), "2-Step Prob. Confers Target - Previous Beneficial");
+ df.Write(Get2SAggregateAverageSizeTargetTaskBeneficial(), "2-Step Ave. Size of Previous Beneficial in Target Conferral");
+ df.Write(Get2SAggregateTargetTaskDeleterious(), "2-Step Confers Target - Previous Deleterious");
+ df.Write(Get2SAggregateProbTargetTaskDeleterious(), "2-Step Prob. Confers Target - Previous Deleterious");
+ df.Write(Get2SAggregateAverageSizeTargetTaskDeleterious(), "2-Step Ave. Size of Previous Deleterious in Target Conferral");
+ df.Write(Get2SAggregateTargetTaskNeutral(), "2-Step Confers Target - Previous Neutral");
+ df.Write(Get2SAggregateProbTargetTaskNeutral(), "2-Step Prob. Confers Target - Previous Neutral");
+ df.Write(Get2SAggregateTargetTaskLethal(), "2-Step Confers Target - Previous Lethal");
+ df.Write(Get2SAggregateProbTargetTaskLethal(), "2-Step Prob. Confers Target - Previous Lethal");
+ df.Write(Get2SAggregateTask(), "2-Step Confers Any Task");
+ df.Write(Get2SAggregateProbTask(), "2-Step Probability Confers Any Task");
+ df.Write(Get2SAggregateAverageSizeTask(), "2-Step Average Size of Any Task Conferral");
+ df.Write(Get2SAggregateKnockout(), "2-Step Knockout Task");
+ df.Write(Get2SAggregateProbKnockout(), "2-Step Probability Knockout Task");
+ df.Write(Get2SAggregateAverageSizeKnockout(), "2-Step Average Size of Task Knockout");
+ df.Write(Get2SPointTotal(), "Total 2-Step Point Mutants");
+ df.Write(Get2SPointProbBeneficial(), "2-Step Point Probability Beneficial");
+ df.Write(Get2SPointProbDeleterious(), "2-Step Point Probability Deleterious");
+ df.Write(Get2SPointProbNeutral(), "2-Step Point Probability Neutral");
+ df.Write(Get2SPointProbLethal(), "2-Step Point Probability Lethal");
+ df.Write(Get2SPointAverageSizeBeneficial(), "2-Step Point Average Beneficial Size");
+ df.Write(Get2SPointAverageSizeDeleterious(), "2-Step Point Average Deleterious Size");
+ df.Write(Get2SPointPeakFitness(), "2-Step Point Peak Fitness");
+ df.Write(Get2SPointAverageFitness(), "2-Step Point Average Fitness");
+ df.Write(Get2SPointAverageSqrFitness(), "2-Step Point Average Square Fitness");
+ df.Write(Get2SPointTotalEntropy(), "2-Step Point Total Entropy");
+ df.Write(Get2SPointComplexity(), "2-Step Point Total Complexity");
+ df.Write(Get2SPointTargetTask(), "2-Step Point Confers Target Task");
+ df.Write(Get2SPointProbTargetTask(), "2-Step Point Probability Confers Target Task");
+ df.Write(Get2SPointAverageSizeTargetTask(), "2-Step Point Average Size of Target Task Conferral");
+ df.Write(Get2SPointTargetTaskBeneficial(), "2-Step Point Confers Target - Previous Beneficial");
+ df.Write(Get2SPointProbTargetTaskBeneficial(), "2-Step Point Prob. Confers Target - Previous Beneficial");
+ df.Write(Get2SPointAverageSizeTargetTaskBeneficial(), "2-Step Point Ave. Size of Previous Beneficial in Target Conferral");
+ df.Write(Get2SPointTargetTaskDeleterious(), "2-Step Point Confers Target - Previous Deleterious");
+ df.Write(Get2SPointProbTargetTaskDeleterious(), "2-Step Point Prob. Confers Target - Previous Deleterious");
+ df.Write(Get2SPointAverageSizeTargetTaskDeleterious(), "2-Step Point Ave. Size of Previous Deleterious in Target Conferral");
+ df.Write(Get2SPointTargetTaskNeutral(), "2-Step Point Confers Target - Previous Neutral");
+ df.Write(Get2SPointProbTargetTaskNeutral(), "2-Step Point Prob. Confers Target - Previous Neutral");
+ df.Write(Get2SPointTargetTaskLethal(), "2-Step Point Confers Target - Previous Lethal");
+ df.Write(Get2SPointProbTargetTaskLethal(), "2-Step Point Prob. Confers Target - Previous Lethal");
+ df.Write(Get2SPointTask(), "2-Step Point Confers Any Task");
+ df.Write(Get2SPointProbTask(), "2-Step Point Probability Confers Any Task");
+ df.Write(Get2SPointAverageSizeTask(), "2-Step Point Average Size of Any Task Conferral");
+ df.Write(Get2SPointKnockout(), "2-Step Point Knockout Task");
+ df.Write(Get2SPointProbKnockout(), "2-Step Point Probability Knockout Task");
+ df.Write(Get2SPointAverageSizeKnockout(), "2-Step Point Average Size of Task Knockout");
+
+ df.Write(Get2SInsertTotal(), "Total 2-Step Insert Mutants");
+ df.Write(Get2SInsertProbBeneficial(), "2-Step Insert Probability Beneficial");
+ df.Write(Get2SInsertProbDeleterious(), "2-Step Insert Probability Deleterious");
+ df.Write(Get2SInsertProbNeutral(), "2-Step Insert Probability Neutral");
+ df.Write(Get2SInsertProbLethal(), "2-Step Insert Probability Lethal");
+ df.Write(Get2SInsertAverageSizeBeneficial(), "2-Step Insert Average Beneficial Size");
+ df.Write(Get2SInsertAverageSizeDeleterious(), "2-Step Insert Average Deleterious Size");
+ df.Write(Get2SInsertPeakFitness(), "2-Step Insert Peak Fitness");
+ df.Write(Get2SInsertAverageFitness(), "2-Step Insert Average Fitness");
+ df.Write(Get2SInsertAverageSqrFitness(), "2-Step Insert Average Square Fitness");
+ df.Write(Get2SInsertTotalEntropy(), "2-Step Insert Total Entropy");
+ df.Write(Get2SInsertComplexity(), "2-Step Insert Total Complexity");
+ df.Write(Get2SInsertTargetTask(), "2-Step Insert Confers Target Task");
+ df.Write(Get2SInsertProbTargetTask(), "2-Step Insert Probability Confers Target Task");
+ df.Write(Get2SInsertAverageSizeTargetTask(), "2-Step Insert Average Size of Target Task Conferral");
+ df.Write(Get2SInsertTargetTaskBeneficial(), "2-Step Insert Confers Target - Previous Beneficial");
+ df.Write(Get2SInsertProbTargetTaskBeneficial(), "2-Step Insert Prob. Confers Target - Previous Beneficial");
+ df.Write(Get2SInsertAverageSizeTargetTaskBeneficial(), "2-Step Insert Ave. Size of Previous Beneficial in Target Conferral");
+ df.Write(Get2SInsertTargetTaskDeleterious(), "2-Step Insert Confers Target - Previous Deleterious");
+ df.Write(Get2SInsertProbTargetTaskDeleterious(), "2-Step Insert Prob. Confers Target - Previous Deleterious");
+ df.Write(Get2SInsertAverageSizeTargetTaskDeleterious(), "2-Step Insert Ave. Size of Previous Deleterious in Target Conferral");
+ df.Write(Get2SInsertTargetTaskNeutral(), "2-Step Insert Confers Target - Previous Neutral");
+ df.Write(Get2SInsertProbTargetTaskNeutral(), "2-Step Insert Prob. Confers Target - Previous Neutral");
+ df.Write(Get2SInsertTargetTaskLethal(), "2-Step Insert Confers Target - Previous Lethal");
+ df.Write(Get2SInsertProbTargetTaskLethal(), "2-Step Insert Prob. Confers Target - Previous Lethal");
+ df.Write(Get2SInsertTask(), "2-Step Insert Confers Any Task");
+ df.Write(Get2SInsertProbTask(), "2-Step Insert Probability Confers Any Task");
+ df.Write(Get2SInsertAverageSizeTask(), "2-Step Insert Average Size of Any Task Conferral");
+ df.Write(Get2SInsertKnockout(), "2-Step Insert Knockout Task");
+ df.Write(Get2SInsertProbKnockout(), "2-Step Insert Probability Knockout Task");
+ df.Write(Get2SInsertAverageSizeKnockout(), "2-Step Insert Average Size of Task Knockout");
+
+ df.Write(Get2SDeleteTotal(), "Total 2-Step Delete Mutants");
+ df.Write(Get2SDeleteProbBeneficial(), "2-Step Delete Probability Beneficial");
+ df.Write(Get2SDeleteProbDeleterious(), "2-Step Delete Probability Deleterious");
+ df.Write(Get2SDeleteProbNeutral(), "2-Step Delete Probability Neutral");
+ df.Write(Get2SDeleteProbLethal(), "2-Step Delete Probability Lethal");
+ df.Write(Get2SDeleteAverageSizeBeneficial(), "2-Step Delete Average Beneficial Size");
+ df.Write(Get2SDeleteAverageSizeDeleterious(), "2-Step Delete Average Deleterious Size");
+ df.Write(Get2SDeletePeakFitness(), "2-Step Delete Peak Fitness");
+ df.Write(Get2SDeleteAverageFitness(), "2-Step Delete Average Fitness");
+ df.Write(Get2SDeleteAverageSqrFitness(), "2-Step Delete Average Square Fitness");
+ df.Write(Get2SDeleteTotalEntropy(), "2-Step Delete Total Entropy");
+ df.Write(Get2SDeleteComplexity(), "2-Step Delete Total Complexity");
+ df.Write(Get2SDeleteTargetTask(), "2-Step Delete Confers Target Task");
+ df.Write(Get2SDeleteProbTargetTask(), "2-Step Delete Probability Confers Target Task");
+ df.Write(Get2SDeleteAverageSizeTargetTask(), "2-Step Delete Average Size of Target Task Conferral");
+ df.Write(Get2SDeleteTargetTaskBeneficial(), "2-Step Delete Confers Target - Previous Beneficial");
+ df.Write(Get2SDeleteProbTargetTaskBeneficial(), "2-Step Delete Prob. Confers Target - Previous Beneficial");
+ df.Write(Get2SDeleteAverageSizeTargetTaskBeneficial(), "2-Step Delete Ave. Size of Previous Beneficial in Target Conferral");
+ df.Write(Get2SDeleteTargetTaskDeleterious(), "2-Step Delete Confers Target - Previous Deleterious");
+ df.Write(Get2SDeleteProbTargetTaskDeleterious(), "2-Step Delete Prob. Confers Target - Previous Deleterious");
+ df.Write(Get2SDeleteAverageSizeTargetTaskDeleterious(), "2-Step Delete Ave. Size of Previous Deleterious in Target Conferral");
+ df.Write(Get2SDeleteTargetTaskNeutral(), "2-Step Delete Confers Target - Previous Neutral");
+ df.Write(Get2SDeleteProbTargetTaskNeutral(), "2-Step Delete Prob. Confers Target - Previous Neutral");
+ df.Write(Get2SDeleteTargetTaskLethal(), "2-Step Delete Confers Target - Previous Lethal");
+ df.Write(Get2SDeleteProbTargetTaskLethal(), "2-Step Delete Prob. Confers Target - Previous Lethal");
+ df.Write(Get2SDeleteTask(), "2-Step Delete Confers Any Task");
+ df.Write(Get2SDeleteProbTask(), "2-Step Delete Probability Confers Any Task");
+ df.Write(Get2SDeleteAverageSizeTask(), "2-Step Delete Average Size of Any Task Conferral");
+ df.Write(Get2SDeleteKnockout(), "2-Step Delete Knockout Task");
+ df.Write(Get2SDeleteProbKnockout(), "2-Step Delete Probability Knockout Task");
+ df.Write(Get2SDeleteAverageSizeKnockout(), "2-Step Delete Average Size of Task Knockout");
+
df.Endl();
}
Modified: development/source/analyze/cMutationalNeighborhood.h
===================================================================
--- development/source/analyze/cMutationalNeighborhood.h 2007-07-30 02:08:14 UTC (rev 1863)
+++ development/source/analyze/cMutationalNeighborhood.h 2007-07-30 02:29:36 UTC (rev 1864)
@@ -443,69 +443,269 @@
- inline int GetDoubleTotal() const { return m_tp.total; }
+ inline int Get2SAggregateTotal() const { return m_tt.total; }
- 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 Get2SAggregateAverageFitness() const { return m_tt.total_fitness / m_tt.total; }
+ inline double Get2SAggregateAverageSqrFitness() const { return m_tt.total_sqr_fitness / m_tt.total; }
+ inline const cGenome& Get2SAggregatePeakGenome() const { return m_tt.peak_genome; }
+ inline double Get2SAggregatePeakFitness() const { return m_tt.peak_fitness; }
- 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 Get2SAggregateProbBeneficial() const { return double(m_tt.pos) / m_tt.total; }
+ inline double Get2SAggregateProbDeleterious() const { return double(m_tt.neg) / m_tt.total; }
+ inline double Get2SAggregateProbNeutral() const { return double(m_tt.neut) / m_tt.total; }
+ inline double Get2SAggregateProbLethal() const { return double(m_tt.dead) / m_tt.total; }
+ inline double Get2SAggregateAverageSizeBeneficial() const { if (m_tt.pos == 0) return 0.0; else return m_tt.size_pos / m_tt.pos; }
+ inline double Get2SAggregateAverageSizeDeleterious() const { if (m_tt.neg == 0) return 0.0; else return m_tt.size_neg / m_tt.neg; }
- inline double GetDoubleTotalEntropy() const { return m_tp.total_entropy; }
- inline double GetDoubleComplexity() const { return m_tp.complexity; }
+// inline double Get2SAggregateTotalEntropy() const { return m_tt.total_entropy; }
+// inline double Get2SAggregateComplexity() const { return m_tt.complexity; }
- 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
+ inline int Get2SAggregateTargetTask() const { return m_tt.task_target; }
+ inline double Get2SAggregateProbTargetTask() const { return double(m_tt.task_target) / m_tt.total; }
+ inline double Get2SAggregateAverageSizeTargetTask() const
{
+ if (m_tt.task_target == 0) return 0.0; else return double(m_tt.task_size_target) / m_tt.task_target;
+ }
+ inline int Get2SAggregateTargetTaskBeneficial() const { return m_tt.task_target_pos; }
+ inline double Get2SAggregateProbTargetTaskBeneficial() const
+ {
+ if (m_tt.task_target == 0) return 0.0; else return double(m_tt.task_target_pos) / (2 * m_tt.task_target);
+ }
+ inline double Get2SAggregateAverageSizeTargetTaskBeneficial() const
+ {
+ if (m_tt.task_target == 0) return 0.0; else return double(m_tt.task_size_target_pos) / (2 * m_tt.task_target);
+ }
+ inline int Get2SAggregateTargetTaskDeleterious() const { return m_tt.task_target_neg; }
+ inline double Get2SAggregateProbTargetTaskDeleterious() const
+ {
+ if (m_tt.task_target == 0) return 0.0; else return double(m_tt.task_target_neg) / (2 * m_tt.task_target);
+ }
+ inline double Get2SAggregateAverageSizeTargetTaskDeleterious() const
+ {
+ if (m_tt.task_target == 0) return 0.0; else return double(m_tt.task_size_target_neg) / (2 * m_tt.task_target);
+ }
+ inline int Get2SAggregateTargetTaskNeutral() const { return m_tt.task_target_neut; }
+ inline double Get2SAggregateProbTargetTaskNeutral() const
+ {
+ if (m_tt.task_target == 0) return 0.0; else return double(m_tt.task_target_neut) / (2 * m_tt.task_target);
+ }
+ inline int Get2SAggregateTargetTaskLethal() const { return m_tt.task_target_dead; }
+ inline double Get2SAggregateProbTargetTaskLethal() const
+ {
+ if (m_tt.task_target == 0) return 0.0; else return double(m_tt.task_target_dead) / (2 * m_tt.task_target);
+ }
+ inline int Get2SAggregateTask() const { return m_tt.task_total; }
+ inline double Get2SAggregateProbTask() const { return double(m_tt.task_total) / m_tt.total; }
+ inline double Get2SAggregateAverageSizeTask() const
+ {
+ if (m_tt.task_total == 0) return 0.0; else return double(m_tt.task_size_total) / m_tt.task_total;
+ }
+ inline int Get2SAggregateKnockout() const { return m_tt.task_knockout; }
+ inline double Get2SAggregateProbKnockout() const { return double(m_tt.task_knockout) / m_tt.total; }
+ inline double Get2SAggregateAverageSizeKnockout() const
+ {
+ if (m_tt.task_knockout == 0) return 0.0; else return double(m_tt.task_size_knockout) / m_tt.task_knockout;
+ }
+
+
+
+
+ inline int Get2SPointTotal() const { return m_tp.total; }
+
+ inline double Get2SPointAverageFitness() const { return m_tp.total_fitness / m_tp.total; }
+ inline double Get2SPointAverageSqrFitness() const { return m_tp.total_sqr_fitness / m_tp.total; }
+ inline const cGenome& Get2SPointPeakGenome() const { return m_tp.peak_genome; }
+ inline double Get2SPointPeakFitness() const { return m_tp.peak_fitness; }
+
+ inline double Get2SPointProbBeneficial() const { return double(m_tp.pos) / m_tp.total; }
+ inline double Get2SPointProbDeleterious() const { return double(m_tp.neg) / m_tp.total; }
+ inline double Get2SPointProbNeutral() const { return double(m_tp.neut) / m_tp.total; }
+ inline double Get2SPointProbLethal() const { return double(m_tp.dead) / m_tp.total; }
+ inline double Get2SPointAverageSizeBeneficial() const { if (m_tp.pos == 0) return 0.0; else return m_tp.size_pos / m_tp.pos; }
+ inline double Get2SPointAverageSizeDeleterious() const { if (m_tp.neg == 0) return 0.0; else return m_tp.size_neg / m_tp.neg; }
+
+ inline double Get2SPointTotalEntropy() const { return m_tp.total_entropy; }
+ inline double Get2SPointComplexity() const { return m_tp.complexity; }
+
+ inline int Get2SPointTargetTask() const { return m_tp.task_target; }
+ inline double Get2SPointProbTargetTask() const { return double(m_tp.task_target) / m_tp.total; }
+ inline double Get2SPointAverageSizeTargetTask() const
+ {
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_tp.task_target_pos; }
- inline double GetDoubleProbTargetTaskBeneficial() const
+ inline int Get2SPointTargetTaskBeneficial() const { return m_tp.task_target_pos; }
+ inline double Get2SPointProbTargetTaskBeneficial() const
{
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
+ inline double Get2SPointAverageSizeTargetTaskBeneficial() const
{
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_tp.task_target_neg; }
- inline double GetDoubleProbTargetTaskDeleterious() const
+ inline int Get2SPointTargetTaskDeleterious() const { return m_tp.task_target_neg; }
+ inline double Get2SPointProbTargetTaskDeleterious() const
{
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
+ inline double Get2SPointAverageSizeTargetTaskDeleterious() const
{
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_tp.task_target_neut; }
- inline double GetDoubleProbTargetTaskNeutral() const
+ inline int Get2SPointTargetTaskNeutral() const { return m_tp.task_target_neut; }
+ inline double Get2SPointProbTargetTaskNeutral() const
{
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_tp.task_target_dead; }
- inline double GetDoubleProbTargetTaskLethal() const
+ inline int Get2SPointTargetTaskLethal() const { return m_tp.task_target_dead; }
+ inline double Get2SPointProbTargetTaskLethal() const
{
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_tp.task_total; }
- inline double GetDoubleProbTask() const { return double(m_tp.task_total) / m_tp.total; }
- inline double GetDoubleAverageSizeTask() const
+ inline int Get2SPointTask() const { return m_tp.task_total; }
+ inline double Get2SPointProbTask() const { return double(m_tp.task_total) / m_tp.total; }
+ inline double Get2SPointAverageSizeTask() const
{
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_tp.task_knockout; }
- inline double GetDoubleProbKnockout() const { return double(m_tp.task_knockout) / m_tp.total; }
- inline double GetDoubleAverageSizeKnockout() const
+ inline int Get2SPointKnockout() const { return m_tp.task_knockout; }
+ inline double Get2SPointProbKnockout() const { return double(m_tp.task_knockout) / m_tp.total; }
+ inline double Get2SPointAverageSizeKnockout() const
{
if (m_tp.task_knockout == 0) return 0.0; else return double(m_tp.task_size_knockout) / m_tp.task_knockout;
}
+
+
+
+ inline int Get2SInsertTotal() const { return m_ti.total; }
+
+ inline double Get2SInsertAverageFitness() const { return m_ti.total_fitness / m_ti.total; }
+ inline double Get2SInsertAverageSqrFitness() const { return m_ti.total_sqr_fitness / m_ti.total; }
+ inline const cGenome& Get2SInsertPeakGenome() const { return m_ti.peak_genome; }
+ inline double Get2SInsertPeakFitness() const { return m_ti.peak_fitness; }
+
+ inline double Get2SInsertProbBeneficial() const { return double(m_ti.pos) / m_ti.total; }
+ inline double Get2SInsertProbDeleterious() const { return double(m_ti.neg) / m_ti.total; }
+ inline double Get2SInsertProbNeutral() const { return double(m_ti.neut) / m_ti.total; }
+ inline double Get2SInsertProbLethal() const { return double(m_ti.dead) / m_ti.total; }
+ inline double Get2SInsertAverageSizeBeneficial() const { if (m_ti.pos == 0) return 0.0; else return m_ti.size_pos / m_ti.pos; }
+ inline double Get2SInsertAverageSizeDeleterious() const { if (m_ti.neg == 0) return 0.0; else return m_ti.size_neg / m_ti.neg; }
+
+ inline double Get2SInsertTotalEntropy() const { return m_ti.total_entropy; }
+ inline double Get2SInsertComplexity() const { return m_ti.complexity; }
+
+ inline int Get2SInsertTargetTask() const { return m_ti.task_target; }
+ inline double Get2SInsertProbTargetTask() const { return double(m_ti.task_target) / m_ti.total; }
+ inline double Get2SInsertAverageSizeTargetTask() const
+ {
+ if (m_ti.task_target == 0) return 0.0; else return double(m_ti.task_size_target) / m_ti.task_target;
+ }
+ inline int Get2SInsertTargetTaskBeneficial() const { return m_ti.task_target_pos; }
+ inline double Get2SInsertProbTargetTaskBeneficial() const
+ {
+ if (m_ti.task_target == 0) return 0.0; else return double(m_ti.task_target_pos) / (2 * m_ti.task_target);
+ }
+ inline double Get2SInsertAverageSizeTargetTaskBeneficial() const
+ {
+ if (m_ti.task_target == 0) return 0.0; else return double(m_ti.task_size_target_pos) / (2 * m_ti.task_target);
+ }
+ inline int Get2SInsertTargetTaskDeleterious() const { return m_ti.task_target_neg; }
+ inline double Get2SInsertProbTargetTaskDeleterious() const
+ {
+ if (m_ti.task_target == 0) return 0.0; else return double(m_ti.task_target_neg) / (2 * m_ti.task_target);
+ }
+ inline double Get2SInsertAverageSizeTargetTaskDeleterious() const
+ {
+ if (m_ti.task_target == 0) return 0.0; else return double(m_ti.task_size_target_neg) / (2 * m_ti.task_target);
+ }
+ inline int Get2SInsertTargetTaskNeutral() const { return m_ti.task_target_neut; }
+ inline double Get2SInsertProbTargetTaskNeutral() const
+ {
+ if (m_ti.task_target == 0) return 0.0; else return double(m_ti.task_target_neut) / (2 * m_ti.task_target);
+ }
+ inline int Get2SInsertTargetTaskLethal() const { return m_ti.task_target_dead; }
+ inline double Get2SInsertProbTargetTaskLethal() const
+ {
+ if (m_ti.task_target == 0) return 0.0; else return double(m_ti.task_target_dead) / (2 * m_ti.task_target);
+ }
+ inline int Get2SInsertTask() const { return m_ti.task_total; }
+ inline double Get2SInsertProbTask() const { return double(m_ti.task_total) / m_ti.total; }
+ inline double Get2SInsertAverageSizeTask() const
+ {
+ if (m_ti.task_total == 0) return 0.0; else return double(m_ti.task_size_total) / m_ti.task_total;
+ }
+ inline int Get2SInsertKnockout() const { return m_ti.task_knockout; }
+ inline double Get2SInsertProbKnockout() const { return double(m_ti.task_knockout) / m_ti.total; }
+ inline double Get2SInsertAverageSizeKnockout() const
+ {
+ if (m_ti.task_knockout == 0) return 0.0; else return double(m_ti.task_size_knockout) / m_ti.task_knockout;
+ }
+
+
+
+
+ inline int Get2SDeleteTotal() const { return m_td.total; }
+
+ inline double Get2SDeleteAverageFitness() const { return m_td.total_fitness / m_td.total; }
+ inline double Get2SDeleteAverageSqrFitness() const { return m_td.total_sqr_fitness / m_td.total; }
+ inline const cGenome& Get2SDeletePeakGenome() const { return m_td.peak_genome; }
+ inline double Get2SDeletePeakFitness() const { return m_td.peak_fitness; }
+
+ inline double Get2SDeleteProbBeneficial() const { return double(m_td.pos) / m_td.total; }
+ inline double Get2SDeleteProbDeleterious() const { return double(m_td.neg) / m_td.total; }
+ inline double Get2SDeleteProbNeutral() const { return double(m_td.neut) / m_td.total; }
+ inline double Get2SDeleteProbLethal() const { return double(m_td.dead) / m_td.total; }
+ inline double Get2SDeleteAverageSizeBeneficial() const { if (m_td.pos == 0) return 0.0; else return m_td.size_pos / m_td.pos; }
+ inline double Get2SDeleteAverageSizeDeleterious() const { if (m_td.neg == 0) return 0.0; else return m_td.size_neg / m_td.neg; }
+
+ inline double Get2SDeleteTotalEntropy() const { return m_td.total_entropy; }
+ inline double Get2SDeleteComplexity() const { return m_td.complexity; }
+
+ inline int Get2SDeleteTargetTask() const { return m_td.task_target; }
+ inline double Get2SDeleteProbTargetTask() const { return double(m_td.task_target) / m_td.total; }
+ inline double Get2SDeleteAverageSizeTargetTask() const
+ {
+ if (m_td.task_target == 0) return 0.0; else return double(m_td.task_size_target) / m_td.task_target;
+ }
+ inline int Get2SDeleteTargetTaskBeneficial() const { return m_td.task_target_pos; }
+ inline double Get2SDeleteProbTargetTaskBeneficial() const
+ {
+ if (m_td.task_target == 0) return 0.0; else return double(m_td.task_target_pos) / (2 * m_td.task_target);
+ }
+ inline double Get2SDeleteAverageSizeTargetTaskBeneficial() const
+ {
+ if (m_td.task_target == 0) return 0.0; else return double(m_td.task_size_target_pos) / (2 * m_td.task_target);
+ }
+ inline int Get2SDeleteTargetTaskDeleterious() const { return m_td.task_target_neg; }
+ inline double Get2SDeleteProbTargetTaskDeleterious() const
+ {
+ if (m_td.task_target == 0) return 0.0; else return double(m_td.task_target_neg) / (2 * m_td.task_target);
+ }
+ inline double Get2SDeleteAverageSizeTargetTaskDeleterious() const
+ {
+ if (m_td.task_target == 0) return 0.0; else return double(m_td.task_size_target_neg) / (2 * m_td.task_target);
+ }
+ inline int Get2SDeleteTargetTaskNeutral() const { return m_td.task_target_neut; }
+ inline double Get2SDeleteProbTargetTaskNeutral() const
+ {
+ if (m_td.task_target == 0) return 0.0; else return double(m_td.task_target_neut) / (2 * m_td.task_target);
+ }
+ inline int Get2SDeleteTargetTaskLethal() const { return m_td.task_target_dead; }
+ inline double Get2SDeleteProbTargetTaskLethal() const
+ {
+ if (m_td.task_target == 0) return 0.0; else return double(m_td.task_target_dead) / (2 * m_td.task_target);
+ }
+ inline int Get2SDeleteTask() const { return m_td.task_total; }
+ inline double Get2SDeleteProbTask() const { return double(m_td.task_total) / m_td.total; }
+ inline double Get2SDeleteAverageSizeTask() const
+ {
+ if (m_td.task_total == 0) return 0.0; else return double(m_td.task_size_total) / m_td.task_total;
+ }
+ inline int Get2SDeleteKnockout() const { return m_td.task_knockout; }
+ inline double Get2SDeleteProbKnockout() const { return double(m_td.task_knockout) / m_td.total; }
+ inline double Get2SDeleteAverageSizeKnockout() const
+ {
+ if (m_td.task_knockout == 0) return 0.0; else return double(m_td.task_size_knockout) / m_td.task_knockout;
+ }
};
Modified: development/source/analyze/cMutationalNeighborhoodResults.h
===================================================================
--- development/source/analyze/cMutationalNeighborhoodResults.h 2007-07-30 02:08:14 UTC (rev 1863)
+++ development/source/analyze/cMutationalNeighborhoodResults.h 2007-07-30 02:29:36 UTC (rev 1864)
@@ -190,37 +190,165 @@
- inline int GetDoubleTotal() const { return m_src.GetDoubleTotal(); }
+ inline int Get2SAggregateTotal() const { return m_src.Get2SAggregateTotal(); }
- inline double GetDoubleAverageFitness() const { return m_src.GetDoubleAverageFitness(); }
- inline double GetDoubleAverageSqrFitness() const { return m_src.GetDoubleAverageSqrFitness(); }
- inline const cGenome& GetDoublePeakGenome() const { return m_src.GetDoublePeakGenome(); }
- inline double GetDoublePeakFitness() const { return m_src.GetDoublePeakFitness(); }
+ inline double Get2SAggregateAverageFitness() const { return m_src.Get2SAggregateAverageFitness(); }
+ inline double Get2SAggregateAverageSqrFitness() const { return m_src.Get2SAggregateAverageSqrFitness(); }
+ inline const cGenome& Get2SAggregatePeakGenome() const { return m_src.Get2SAggregatePeakGenome(); }
+ inline double Get2SAggregatePeakFitness() const { return m_src.Get2SAggregatePeakFitness(); }
- inline double GetDoubleProbBeneficial() const { return m_src.GetDoubleProbBeneficial(); }
- inline double GetDoubleProbDeleterious() const { return m_src.GetDoubleProbDeleterious(); }
- inline double GetDoubleProbNeutral() const { return m_src.GetDoubleProbNeutral(); }
- inline double GetDoubleProbLethal() const { return m_src.GetDoubleProbLethal(); }
- inline double GetDoubleAverageSizeBeneficial() const { return m_src.GetDoubleAverageSizeBeneficial(); }
- inline double GetDoubleAverageSizeDeleterious() const { return m_src.GetDoubleAverageSizeDeleterious(); }
+ inline double Get2SAggregateProbBeneficial() const { return m_src.Get2SAggregateProbBeneficial(); }
+ inline double Get2SAggregateProbDeleterious() const { return m_src.Get2SAggregateProbDeleterious(); }
+ inline double Get2SAggregateProbNeutral() const { return m_src.Get2SAggregateProbNeutral(); }
+ inline double Get2SAggregateProbLethal() const { return m_src.Get2SAggregateProbLethal(); }
+ inline double Get2SAggregateAverageSizeBeneficial() const { return m_src.Get2SAggregateAverageSizeBeneficial(); }
+ inline double Get2SAggregateAverageSizeDeleterious() const { return m_src.Get2SAggregateAverageSizeDeleterious(); }
- inline double GetDoubleTotalEntropy() const { return m_src.GetDoubleTotalEntropy(); }
- inline double GetDoubleComplexity() const { return m_src.GetDoubleComplexity(); }
+// inline double Get2SAggregateTotalEntropy() const { return m_src.Get2SAggregateTotalEntropy(); }
+// inline double Get2SAggregateComplexity() const { return m_src.Get2SAggregateComplexity(); }
- inline int GetDoubleTargetTask() const { return m_src.GetDoubleTargetTask(); }
- inline double GetDoubleProbTargetTask() const { return m_src.GetDoubleProbTargetTask(); }
- inline int GetDoubleTargetTaskBeneficial() const { return m_src.GetDoubleTargetTaskBeneficial(); }
- inline double GetDoubleProbTargetTaskBeneficial() const { return m_src.GetDoubleProbTargetTaskBeneficial(); }
- inline int GetDoubleTargetTaskDeleterious() const { return m_src.GetDoubleTargetTaskDeleterious(); }
- inline double GetDoubleProbTargetTaskDeleterious() const { return m_src.GetDoubleProbTargetTaskDeleterious(); }
- inline int GetDoubleTargetTaskNeutral() const { return m_src.GetDoubleTargetTaskNeutral(); }
- inline double GetDoubleProbTargetTaskNeutral() const { return m_src.GetDoubleProbTargetTaskNeutral(); }
- inline int GetDoubleTargetTaskLethal() const { return m_src.GetDoubleTargetTaskLethal(); }
- inline double GetDoubleProbTargetTaskLethal() const { return m_src.GetDoubleProbTargetTaskLethal(); }
- inline int GetDoubleTask() const { return m_src.GetDoubleTask(); }
- inline double GetDoubleProbTask() const { return m_src.GetDoubleProbTask(); }
- inline int GetDoubleKnockout() const { return m_src.GetDoubleKnockout(); }
- inline double GetDoubleProbKnockout() const { return m_src.GetDoubleProbKnockout(); }
+ inline int Get2SAggregateTargetTask() const { return m_src.Get2SAggregateTargetTask(); }
+ inline double Get2SAggregateProbTargetTask() const { return m_src.Get2SAggregateProbTargetTask(); }
+ inline double Get2SAggregateAverageSizeTargetTask() const { return m_src.Get2SAggregateAverageSizeTargetTask(); }
+ inline int Get2SAggregateTargetTaskBeneficial() const { return m_src.Get2SAggregateTargetTaskBeneficial(); }
+ inline double Get2SAggregateProbTargetTaskBeneficial() const { return m_src.Get2SAggregateProbTargetTaskBeneficial(); }
+ inline double Get2SAggregateAverageSizeTargetTaskBeneficial() const { return m_src.Get2SAggregateAverageSizeTargetTaskBeneficial(); }
+ inline int Get2SAggregateTargetTaskDeleterious() const { return m_src.Get2SAggregateTargetTaskDeleterious(); }
+ inline double Get2SAggregateProbTargetTaskDeleterious() const { return m_src.Get2SAggregateProbTargetTaskDeleterious(); }
+ inline double Get2SAggregateAverageSizeTargetTaskDeleterious() const { return m_src.Get2SAggregateAverageSizeTargetTaskDeleterious(); }
+ inline int Get2SAggregateTargetTaskNeutral() const { return m_src.Get2SAggregateTargetTaskNeutral(); }
+ inline double Get2SAggregateProbTargetTaskNeutral() const { return m_src.Get2SAggregateProbTargetTaskNeutral(); }
+ inline int Get2SAggregateTargetTaskLethal() const { return m_src.Get2SAggregateTargetTaskLethal(); }
+ inline double Get2SAggregateProbTargetTaskLethal() const { return m_src.Get2SAggregateProbTargetTaskLethal(); }
+ inline int Get2SAggregateTask() const { return m_src.Get2SAggregateTask(); }
+ inline double Get2SAggregateProbTask() const { return m_src.Get2SAggregateProbTask(); }
+ inline double Get2SAggregateAverageSizeTask() const { return m_src.Get2SAggregateAverageSizeTask(); }
+ inline int Get2SAggregateKnockout() const { return m_src.Get2SAggregateKnockout(); }
+ inline double Get2SAggregateProbKnockout() const { return m_src.Get2SAggregateProbKnockout(); }
+ inline double Get2SAggregateAverageSizeKnockout() const { return m_src.Get2SAggregateAverageSizeKnockout(); }
+
+
+
+
+
+ inline int Get2SPointTotal() const { return m_src.Get2SPointTotal(); }
+
+ inline double Get2SPointAverageFitness() const { return m_src.Get2SPointAverageFitness(); }
+ inline double Get2SPointAverageSqrFitness() const { return m_src.Get2SPointAverageSqrFitness(); }
+ inline const cGenome& Get2SPointPeakGenome() const { return m_src.Get2SPointPeakGenome(); }
+ inline double Get2SPointPeakFitness() const { return m_src.Get2SPointPeakFitness(); }
+
+ inline double Get2SPointProbBeneficial() const { return m_src.Get2SPointProbBeneficial(); }
+ inline double Get2SPointProbDeleterious() const { return m_src.Get2SPointProbDeleterious(); }
+ inline double Get2SPointProbNeutral() const { return m_src.Get2SPointProbNeutral(); }
+ inline double Get2SPointProbLethal() const { return m_src.Get2SPointProbLethal(); }
+ inline double Get2SPointAverageSizeBeneficial() const { return m_src.Get2SPointAverageSizeBeneficial(); }
+ inline double Get2SPointAverageSizeDeleterious() const { return m_src.Get2SPointAverageSizeDeleterious(); }
+
+ inline double Get2SPointTotalEntropy() const { return m_src.Get2SPointTotalEntropy(); }
+ inline double Get2SPointComplexity() const { return m_src.Get2SPointComplexity(); }
+
+ inline int Get2SPointTargetTask() const { return m_src.Get2SPointTargetTask(); }
+ inline double Get2SPointProbTargetTask() const { return m_src.Get2SPointProbTargetTask(); }
+ inline double Get2SPointAverageSizeTargetTask() const { return m_src.Get2SPointAverageSizeTargetTask(); }
+ inline int Get2SPointTargetTaskBeneficial() const { return m_src.Get2SPointTargetTaskBeneficial(); }
+ inline double Get2SPointProbTargetTaskBeneficial() const { return m_src.Get2SPointProbTargetTaskBeneficial(); }
+ inline double Get2SPointAverageSizeTargetTaskBeneficial() const { return m_src.Get2SPointAverageSizeTargetTaskBeneficial(); }
+ inline int Get2SPointTargetTaskDeleterious() const { return m_src.Get2SPointTargetTaskDeleterious(); }
+ inline double Get2SPointProbTargetTaskDeleterious() const { return m_src.Get2SPointProbTargetTaskDeleterious(); }
+ inline double Get2SPointAverageSizeTargetTaskDeleterious() const { return m_src.Get2SPointAverageSizeTargetTaskDeleterious(); }
+ inline int Get2SPointTargetTaskNeutral() const { return m_src.Get2SPointTargetTaskNeutral(); }
+ inline double Get2SPointProbTargetTaskNeutral() const { return m_src.Get2SPointProbTargetTaskNeutral(); }
+ inline int Get2SPointTargetTaskLethal() const { return m_src.Get2SPointTargetTaskLethal(); }
+ inline double Get2SPointProbTargetTaskLethal() const { return m_src.Get2SPointProbTargetTaskLethal(); }
+ inline int Get2SPointTask() const { return m_src.Get2SPointTask(); }
+ inline double Get2SPointProbTask() const { return m_src.Get2SPointProbTask(); }
+ inline double Get2SPointAverageSizeTask() const { return m_src.Get2SPointAverageSizeTask(); }
+ inline int Get2SPointKnockout() const { return m_src.Get2SPointKnockout(); }
+ inline double Get2SPointProbKnockout() const { return m_src.Get2SPointProbKnockout(); }
+ inline double Get2SPointAverageSizeKnockout() const { return m_src.Get2SPointAverageSizeKnockout(); }
+
+
+
+
+
+ inline int Get2SInsertTotal() const { return m_src.Get2SInsertTotal(); }
+
+ inline double Get2SInsertAverageFitness() const { return m_src.Get2SInsertAverageFitness(); }
+ inline double Get2SInsertAverageSqrFitness() const { return m_src.Get2SInsertAverageSqrFitness(); }
+ inline const cGenome& Get2SInsertPeakGenome() const { return m_src.Get2SInsertPeakGenome(); }
+ inline double Get2SInsertPeakFitness() const { return m_src.Get2SInsertPeakFitness(); }
+
+ inline double Get2SInsertProbBeneficial() const { return m_src.Get2SInsertProbBeneficial(); }
+ inline double Get2SInsertProbDeleterious() const { return m_src.Get2SInsertProbDeleterious(); }
+ inline double Get2SInsertProbNeutral() const { return m_src.Get2SInsertProbNeutral(); }
+ inline double Get2SInsertProbLethal() const { return m_src.Get2SInsertProbLethal(); }
+ inline double Get2SInsertAverageSizeBeneficial() const { return m_src.Get2SInsertAverageSizeBeneficial(); }
+ inline double Get2SInsertAverageSizeDeleterious() const { return m_src.Get2SInsertAverageSizeDeleterious(); }
+
+ inline double Get2SInsertTotalEntropy() const { return m_src.Get2SInsertTotalEntropy(); }
+ inline double Get2SInsertComplexity() const { return m_src.Get2SInsertComplexity(); }
+
+ inline int Get2SInsertTargetTask() const { return m_src.Get2SInsertTargetTask(); }
+ inline double Get2SInsertProbTargetTask() const { return m_src.Get2SInsertProbTargetTask(); }
+ inline double Get2SInsertAverageSizeTargetTask() const { return m_src.Get2SInsertAverageSizeTargetTask(); }
+ inline int Get2SInsertTargetTaskBeneficial() const { return m_src.Get2SInsertTargetTaskBeneficial(); }
+ inline double Get2SInsertProbTargetTaskBeneficial() const { return m_src.Get2SInsertProbTargetTaskBeneficial(); }
+ inline double Get2SInsertAverageSizeTargetTaskBeneficial() const { return m_src.Get2SInsertAverageSizeTargetTaskBeneficial(); }
+ inline int Get2SInsertTargetTaskDeleterious() const { return m_src.Get2SInsertTargetTaskDeleterious(); }
+ inline double Get2SInsertProbTargetTaskDeleterious() const { return m_src.Get2SInsertProbTargetTaskDeleterious(); }
+ inline double Get2SInsertAverageSizeTargetTaskDeleterious() const { return m_src.Get2SInsertAverageSizeTargetTaskDeleterious(); }
+ inline int Get2SInsertTargetTaskNeutral() const { return m_src.Get2SInsertTargetTaskNeutral(); }
+ inline double Get2SInsertProbTargetTaskNeutral() const { return m_src.Get2SInsertProbTargetTaskNeutral(); }
+ inline int Get2SInsertTargetTaskLethal() const { return m_src.Get2SInsertTargetTaskLethal(); }
+ inline double Get2SInsertProbTargetTaskLethal() const { return m_src.Get2SInsertProbTargetTaskLethal(); }
+ inline int Get2SInsertTask() const { return m_src.Get2SInsertTask(); }
+ inline double Get2SInsertProbTask() const { return m_src.Get2SInsertProbTask(); }
+ inline double Get2SInsertAverageSizeTask() const { return m_src.Get2SInsertAverageSizeTask(); }
+ inline int Get2SInsertKnockout() const { return m_src.Get2SInsertKnockout(); }
+ inline double Get2SInsertProbKnockout() const { return m_src.Get2SInsertProbKnockout(); }
+ inline double Get2SInsertAverageSizeKnockout() const { return m_src.Get2SInsertAverageSizeKnockout(); }
+
+
+
+
+
+ inline int Get2SDeleteTotal() const { return m_src.Get2SDeleteTotal(); }
+
+ inline double Get2SDeleteAverageFitness() const { return m_src.Get2SDeleteAverageFitness(); }
+ inline double Get2SDeleteAverageSqrFitness() const { return m_src.Get2SDeleteAverageSqrFitness(); }
+ inline const cGenome& Get2SDeletePeakGenome() const { return m_src.Get2SDeletePeakGenome(); }
+ inline double Get2SDeletePeakFitness() const { return m_src.Get2SDeletePeakFitness(); }
+
+ inline double Get2SDeleteProbBeneficial() const { return m_src.Get2SDeleteProbBeneficial(); }
+ inline double Get2SDeleteProbDeleterious() const { return m_src.Get2SDeleteProbDeleterious(); }
+ inline double Get2SDeleteProbNeutral() const { return m_src.Get2SDeleteProbNeutral(); }
+ inline double Get2SDeleteProbLethal() const { return m_src.Get2SDeleteProbLethal(); }
+ inline double Get2SDeleteAverageSizeBeneficial() const { return m_src.Get2SDeleteAverageSizeBeneficial(); }
+ inline double Get2SDeleteAverageSizeDeleterious() const { return m_src.Get2SDeleteAverageSizeDeleterious(); }
+
+ inline double Get2SDeleteTotalEntropy() const { return m_src.Get2SDeleteTotalEntropy(); }
+ inline double Get2SDeleteComplexity() const { return m_src.Get2SDeleteComplexity(); }
+
+ inline int Get2SDeleteTargetTask() const { return m_src.Get2SDeleteTargetTask(); }
+ inline double Get2SDeleteProbTargetTask() const { return m_src.Get2SDeleteProbTargetTask(); }
+ inline double Get2SDeleteAverageSizeTargetTask() const { return m_src.Get2SDeleteAverageSizeTargetTask(); }
+ inline int Get2SDeleteTargetTaskBeneficial() const { return m_src.Get2SDeleteTargetTaskBeneficial(); }
+ inline double Get2SDeleteProbTargetTaskBeneficial() const { return m_src.Get2SDeleteProbTargetTaskBeneficial(); }
+ inline double Get2SDeleteAverageSizeTargetTaskBeneficial() const { return m_src.Get2SDeleteAverageSizeTargetTaskBeneficial(); }
+ inline int Get2SDeleteTargetTaskDeleterious() const { return m_src.Get2SDeleteTargetTaskDeleterious(); }
+ inline double Get2SDeleteProbTargetTaskDeleterious() const { return m_src.Get2SDeleteProbTargetTaskDeleterious(); }
+ inline double Get2SDeleteAverageSizeTargetTaskDeleterious() const { return m_src.Get2SDeleteAverageSizeTargetTaskDeleterious(); }
+ inline int Get2SDeleteTargetTaskNeutral() const { return m_src.Get2SDeleteTargetTaskNeutral(); }
+ inline double Get2SDeleteProbTargetTaskNeutral() const { return m_src.Get2SDeleteProbTargetTaskNeutral(); }
+ inline int Get2SDeleteTargetTaskLethal() const { return m_src.Get2SDeleteTargetTaskLethal(); }
+ inline double Get2SDeleteProbTargetTaskLethal() const { return m_src.Get2SDeleteProbTargetTaskLethal(); }
+ inline int Get2SDeleteTask() const { return m_src.Get2SDeleteTask(); }
+ inline double Get2SDeleteProbTask() const { return m_src.Get2SDeleteProbTask(); }
+ inline double Get2SDeleteAverageSizeTask() const { return m_src.Get2SDeleteAverageSizeTask(); }
+ inline int Get2SDeleteKnockout() const { return m_src.Get2SDeleteKnockout(); }
+ inline double Get2SDeleteProbKnockout() const { return m_src.Get2SDeleteProbKnockout(); }
+ inline double Get2SDeleteAverageSizeKnockout() const { return m_src.Get2SDeleteAverageSizeKnockout(); }
};
#endif
More information about the Avida-cvs
mailing list