[Avida-SVN] r1876 - in branches/energy_dev: . Avida.xcodeproj source/actions source/analyze source/cpu source/main tests
beckma24 at myxo.css.msu.edu
beckma24 at myxo.css.msu.edu
Tue Jul 31 13:50:26 PDT 2007
Author: beckma24
Date: 2007-07-31 16:50:25 -0400 (Tue, 31 Jul 2007)
New Revision: 1876
Added:
branches/energy_dev/source/main/cPhenPlastGenotype.cc
branches/energy_dev/source/main/cPhenPlastGenotype.h
branches/energy_dev/source/main/cPlasticPhenotype.cc
branches/energy_dev/source/main/cPlasticPhenotype.h
branches/energy_dev/tests/spatial_res_100u/
Modified:
branches/energy_dev/Avida.xcodeproj/project.pbxproj
branches/energy_dev/CMakeLists.txt
branches/energy_dev/source/actions/PrintActions.cc
branches/energy_dev/source/analyze/cAnalyze.cc
branches/energy_dev/source/analyze/cAnalyze.h
branches/energy_dev/source/analyze/cMutationalNeighborhood.cc
branches/energy_dev/source/analyze/cMutationalNeighborhood.h
branches/energy_dev/source/analyze/cMutationalNeighborhoodResults.h
branches/energy_dev/source/cpu/cHardwareCPU.cc
branches/energy_dev/source/cpu/cHardwareCPU.h
branches/energy_dev/source/cpu/cTestCPU.h
branches/energy_dev/source/cpu/cTestCPUInterface.cc
branches/energy_dev/source/cpu/cTestCPUInterface.h
branches/energy_dev/source/main/cAvidaConfig.h
branches/energy_dev/source/main/cDeme.h
branches/energy_dev/source/main/cOrgInterface.h
branches/energy_dev/source/main/cOrganism.cc
branches/energy_dev/source/main/cPhenotype.cc
branches/energy_dev/source/main/cPhenotype.h
branches/energy_dev/source/main/cPopulation.cc
branches/energy_dev/source/main/cPopulationCell.h
branches/energy_dev/source/main/cPopulationInterface.cc
branches/energy_dev/source/main/cPopulationInterface.h
branches/energy_dev/source/main/cResource.cc
branches/energy_dev/source/main/cResourceCount.cc
branches/energy_dev/source/main/cSpatialResCount.cc
branches/energy_dev/source/main/cStats.cc
branches/energy_dev/source/main/cStats.h
Log:
Merged development branch into energy_dev branch
Modified: branches/energy_dev/Avida.xcodeproj/project.pbxproj
===================================================================
--- branches/energy_dev/Avida.xcodeproj/project.pbxproj 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/Avida.xcodeproj/project.pbxproj 2007-07-31 20:50:25 UTC (rev 1876)
@@ -194,6 +194,8 @@
70D046610C32EA90000614E7 /* cBirthChamber.h in CopyFiles */ = {isa = PBXBuildFile; fileRef = 702D4F3908DA61E2007BA469 /* cBirthChamber.h */; };
70DCAC9C097AF7C0002F8733 /* primitive.cc in Sources */ = {isa = PBXBuildFile; fileRef = 70DCAC9B097AF7C0002F8733 /* primitive.cc */; };
70F9FC100C469DD70083B788 /* cASTDumpVisitor.cc in Sources */ = {isa = PBXBuildFile; fileRef = 70F9FC0F0C469DC10083B788 /* cASTDumpVisitor.cc */; };
+ B4FA258A0C5EB65E0086D4B5 /* cPlasticPhenotype.cc in Sources */ = {isa = PBXBuildFile; fileRef = B4FA25810C5EB6510086D4B5 /* cPlasticPhenotype.cc */; };
+ B4FA25A90C5EB7880086D4B5 /* cPhenPlastGenotype.cc in Sources */ = {isa = PBXBuildFile; fileRef = B4FA259E0C5EB7600086D4B5 /* cPhenPlastGenotype.cc */; };
/* End PBXBuildFile section */
/* Begin PBXBuildRule section */
@@ -830,6 +832,10 @@
70F9FC0F0C469DC10083B788 /* cASTDumpVisitor.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cASTDumpVisitor.cc; sourceTree = "<group>"; };
70F9FD990C4E89C40083B788 /* tAutoRelease.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tAutoRelease.h; sourceTree = "<group>"; };
70FB86A908BFAFEC00BDF589 /* CMakeLists.txt */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text; path = CMakeLists.txt; sourceTree = "<group>"; };
+ B4FA25800C5EB6510086D4B5 /* cPhenPlastGenotype.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = cPhenPlastGenotype.h; sourceTree = "<group>"; };
+ B4FA25810C5EB6510086D4B5 /* cPlasticPhenotype.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = cPlasticPhenotype.cc; sourceTree = "<group>"; };
+ B4FA25820C5EB6510086D4B5 /* cPlasticPhenotype.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = cPlasticPhenotype.h; sourceTree = "<group>"; };
+ B4FA259E0C5EB7600086D4B5 /* cPhenPlastGenotype.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = cPhenPlastGenotype.cc; sourceTree = "<group>"; };
DCC30FCF0762539D008F7A48 /* Doxyfile */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text; path = Doxyfile; sourceTree = "<group>"; };
DCC3109C0762539E008F7A48 /* avida.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = avida.cc; sourceTree = "<group>"; };
DCC31547076253A4008F7A48 /* cCycleCheck.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = cCycleCheck.cc; sourceTree = "<group>"; };
@@ -1375,6 +1381,10 @@
DCC310040762539D008F7A48 /* main */ = {
isa = PBXGroup;
children = (
+ B4FA259E0C5EB7600086D4B5 /* cPhenPlastGenotype.cc */,
+ B4FA25800C5EB6510086D4B5 /* cPhenPlastGenotype.h */,
+ B4FA25810C5EB6510086D4B5 /* cPlasticPhenotype.cc */,
+ B4FA25820C5EB6510086D4B5 /* cPlasticPhenotype.h */,
42490EFE0BE2472800318058 /* cGermline.h */,
706C6F480B83E69D003174C1 /* cSaleItem.h */,
708BF3010AB65DD300A923BF /* cEventList.h */,
@@ -1964,6 +1974,8 @@
7023ECA10C0A431B00362B9C /* SaveLoadActions.cc in Sources */,
70436B280C36C64400A05ABA /* cThread.cc in Sources */,
70436B6C0C36C98900A05ABA /* PlatformExpert.cc in Sources */,
+ B4FA258A0C5EB65E0086D4B5 /* cPlasticPhenotype.cc in Sources */,
+ B4FA25A90C5EB7880086D4B5 /* cPhenPlastGenotype.cc in Sources */,
);
runOnlyForDeploymentPostprocessing = 0;
};
Modified: branches/energy_dev/CMakeLists.txt
===================================================================
--- branches/energy_dev/CMakeLists.txt 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/CMakeLists.txt 2007-07-31 20:50:25 UTC (rev 1876)
@@ -219,6 +219,8 @@
${MAIN_DIR}/cMxCodeArray.cc
${MAIN_DIR}/cOrganism.cc
${MAIN_DIR}/cPhenotype.cc
+ ${MAIN_DIR}/cPhenPlastGenotype.cc
+ ${MAIN_DIR}/cPlasticPhenotype.cc
${MAIN_DIR}/cPopulation.cc
${MAIN_DIR}/cPopulationCell.cc
${MAIN_DIR}/cPopulationInterface.cc
Modified: branches/energy_dev/source/actions/PrintActions.cc
===================================================================
--- branches/energy_dev/source/actions/PrintActions.cc 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/actions/PrintActions.cc 2007-07-31 20:50:25 UTC (rev 1876)
@@ -867,6 +867,7 @@
cCPUTestInfo test_info;
double fitness = 0.0;
if (mode == "TEST_CPU" || mode == "ACTUAL"){
+ test_info.UseManualInputs( (*oit)->GetOrgInterface().GetInputs() );
testcpu->TestGenome(ctx, test_info, (*git)->GetGenome());
}
@@ -882,19 +883,26 @@
}
else
world->GetDriver().RaiseFatalException(1, "PrintLogFitnessHistogram::MakeHistogram: Invalid fitness mode requested.");
-
+
//Update the histogram
- const double log_fitness = log10(fitness);
- int update_bin = (errno == ERANGE) ? 0 : //If we have a log of zero, this will be true.
- static_cast<int>((log_fitness - min) / step);
+ int update_bin = (fitness == 0) ? 0 :
+ static_cast<int>((log10(fitness) - min) / step);
- if (update_bin < 0) //Non-zero bins
- update_bin = 1; //Below range
- else if (update_bin >= num_bins - 3)
- update_bin = num_bins - 1; //Above range
- else
- update_bin = update_bin + 2; //Within range
-
+ // Bin 0 Inviable
+ // 1 Below Range
+ // 2 [min, min+step)
+ // #bin-1 [max-step, max)
+ // num_bin Above Range
+
+ if (fitness == 0)
+ update_bin = 0;
+ else if (log10(fitness) < min)
+ update_bin = 1;
+ else if (log10(fitness) > max)
+ update_bin = num_bins - 1;
+ else
+ update_bin = static_cast<int>(log10(fitness) - min / step) + 2;
+
histogram[update_bin]++;
}
delete testcpu;
@@ -911,6 +919,8 @@
cerr << "Parameters: " << m_filename << ", " << m_mode << ", " << m_hist_fmin << ":" << m_hist_fstep << ":" << m_hist_fmax << endl;
return;
}
+ cerr << "Parameters: " << m_filename << ", " << m_mode << ", " << m_hist_fmin << ":" << m_hist_fstep << ":" << m_hist_fmax << endl;
+
//Gather data objects
cPopulation& pop = m_world->GetPopulation();
@@ -1036,6 +1046,7 @@
double fitness = 0.0;
double parent_fitness = ( (*git)->GetParentID() > 0) ? (*git)->GetParentGenotype()->GetFitness() : 1.0;
if (mode == "TEST_CPU" || mode == "ACTUAL"){
+ test_info.UseManualInputs( (*oit)->GetOrgInterface().GetInputs() );
testcpu->TestGenome(ctx, test_info, (*git)->GetGenome());
}
@@ -1054,19 +1065,20 @@
//Update the histogram
if (parent_fitness <= 0.0)
- world->GetDriver().RaiseFatalException(1, cString("PrintRelativeFitness::MakeHistogram: Parent fitness is zero.") + cStringUtil::Convert((*git)->GetParentID()) + cString(":") + cStringUtil::Convert( (*git)->GetParentGenotype()->GetMerit() ));
+ world->GetDriver().RaiseFatalException(1, cString("PrintRelativeFitness::MakeHistogram reports a parent fitness is zero.") + cStringUtil::Convert((*git)->GetParentID()) + cString(":") + cStringUtil::Convert( (*git)->GetParentGenotype()->GetMerit() ));
- double rfitness = fitness/parent_fitness;
- int update_bin = (rfitness == 0) ? 0 :
- static_cast<int>( ((fitness/parent_fitness) - min) / step);
+ int update_bin = 0;
+ double rfitness = fitness/parent_fitness;
+
+ if (fitness == 0.0)
+ update_bin = 0;
+ else if (rfitness < min)
+ update_bin = 1;
+ else if (rfitness > max)
+ update_bin = num_bins - 1;
+ else
+ update_bin = static_cast<int>( ((fitness/parent_fitness) - min) / step) + 2;
- if (update_bin < 0 && fitness > 0) //Non-zero bins
- update_bin = 1; //Below range
- else if (update_bin >= num_bins - 3)
- update_bin = num_bins - 1; //Above range
- else
- update_bin = update_bin + 2; //Within range
-
histogram[update_bin]++;
}
delete testcpu;
@@ -1217,12 +1229,13 @@
fp << endl << endl;
}
if (oit == org_map.begin()) //Print update and clade count if first clade
- fp << update << " " << org_map.size();
+ fp << update << " " << org_map.size() << " ";
fp << oit->first << " [";
for (int k = 0; k < hist.GetSize(); k++)
fp << " " << hist[k];
- fp << " ]" << endl;
+ fp << " ] ";
}
+ fp << endl;
}
};
@@ -1333,12 +1346,13 @@
fp << endl << endl;
}
if (oit == org_map.begin()) //Print update and clade count if first clade
- fp << update << " " << org_map.size();
+ fp << update << " " << org_map.size() << " ";
fp << oit->first << " [";
for (int k = 0; k < hist.GetSize(); k++)
fp << " " << hist[k];
- fp << " ]" << endl;
+ fp << " ] ";
}
+ fp << endl;
}
};
Modified: branches/energy_dev/source/analyze/cAnalyze.cc
===================================================================
--- branches/energy_dev/source/analyze/cAnalyze.cc 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/analyze/cAnalyze.cc 2007-07-31 20:50:25 UTC (rev 1876)
@@ -54,6 +54,8 @@
#include "cInstSet.h"
#include "cLandscape.h"
#include "cPhenotype.h"
+#include "cPhenPlastGenotype.h"
+#include "cPlasticPhenotype.h"
#include "cProbSchedule.h"
#include "cSchedule.h"
#include "cSpecies.h"
@@ -7031,6 +7033,24 @@
}
+void cAnalyze::CommandAnalyzePlasticity(cString cur_string)
+{
+ tListIterator<cAnalyzeGenotype> batch_it(batch[cur_batch].List());
+ cAnalyzeGenotype* genotype;
+ while ( (genotype = batch_it.Next()) != NULL ){
+ cerr << "Using Genome: " << genotype->GetGenome().AsString() << endl;
+ cPhenPlastGenotype PPG(genotype->GetGenome(), 1000, m_world, m_ctx);
+ cerr << "There are " << PPG.GetNumPhenotypes() << " phenotype(s) for this genome.\n";
+ for (int k = 0; k < PPG.GetNumPhenotypes(); k++)
+ cerr << "\t Phenotype " << k << " has fitness " << PPG.GetPlasticPhenotype(k).GetFitness()
+ << " with frequency " << PPG.GetPlasticPhenotype(k).GetFrequency() << endl;
+ cerr << endl;
+ }
+ cerr << "here" << endl;
+
+}
+
+
//////////////// Control...
void cAnalyze::VarSet(cString cur_string)
@@ -8173,6 +8193,9 @@
}
+
+
+
void cAnalyze::AddLibraryDef(const cString & name,
void (cAnalyze::*_fun)(cString))
{
@@ -8239,7 +8262,8 @@
AddLibraryDef("ANALYZE_KNOCKOUTS", &cAnalyze::AnalyzeKnockouts);
AddLibraryDef("ANALYZE_POP_COMPLEXITY", &cAnalyze::AnalyzePopComplexity);
AddLibraryDef("MAP_DEPTH", &cAnalyze::CommandMapDepth);
- AddLibraryDef("PAIRWISE_ENTROPY", &cAnalyze::CommandPairwiseEntropy); //@MRR
+ // (Untested) AddLibraryDef("PAIRWISE_ENTROPY", &cAnalyze::CommandPairwiseEntropy);
+ AddLibraryDef("ANALYZE_PLASTICITY", &cAnalyze::CommandAnalyzePlasticity);
// Population comparison commands...
AddLibraryDef("HAMMING", &cAnalyze::CommandHamming);
Modified: branches/energy_dev/source/analyze/cAnalyze.h
===================================================================
--- branches/energy_dev/source/analyze/cAnalyze.h 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/analyze/cAnalyze.h 2007-07-31 20:50:25 UTC (rev 1876)
@@ -250,6 +250,7 @@
void CommandMapMutations(cString cur_string);
void CommandMapDepth(cString cur_string);
void CommandPairwiseEntropy(cString cur_string);
+ void CommandAnalyzePlasticity(cString cur_string);
// Population Comparison Commands...
void CommandHamming(cString cur_string);
Modified: branches/energy_dev/source/analyze/cMutationalNeighborhood.cc
===================================================================
--- branches/energy_dev/source/analyze/cMutationalNeighborhood.cc 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/analyze/cMutationalNeighborhood.cc 2007-07-31 20:50:25 UTC (rev 1876)
@@ -55,20 +55,87 @@
cCPUTestInfo test_info;
// Setup One Step Data
- sStep& odata = m_onestep[cur_site];
- odata.peak_fitness = m_base_fitness;
- odata.peak_genome = m_base_genome;
- odata.site_count.Resize(m_base_genome.GetSize(), 0);
+ sStep& opdata = m_onestep_point[cur_site];
+ opdata.peak_fitness = m_base_fitness;
+ opdata.peak_genome = m_base_genome;
+ opdata.site_count.Resize(m_base_genome.GetSize(), 0);
+ sStep& oidata = m_onestep_insert[cur_site];
+ oidata.peak_fitness = m_base_fitness;
+ oidata.peak_genome = m_base_genome;
+ oidata.site_count.Resize(m_base_genome.GetSize() + 1, 0);
+
+ sStep& oddata = m_onestep_delete[cur_site];
+ oddata.peak_fitness = m_base_fitness;
+ oddata.peak_genome = m_base_genome;
+ oddata.site_count.Resize(m_base_genome.GetSize(), 0);
+
+
// Setup Data Used in Two Step
- sStep& tdata = m_twostep[cur_site];
- tdata.peak_fitness = m_base_fitness;
- tdata.peak_genome = m_base_genome;
- tdata.site_count.Resize(m_base_genome.GetSize(), 0);
+ sStep& tpdata = m_twostep_point[cur_site];
+ tpdata.peak_fitness = m_base_fitness;
+ tpdata.peak_genome = m_base_genome;
+ tpdata.site_count.Resize(m_base_genome.GetSize(), 0);
+ sStep& tidata = m_twostep_insert[cur_site];
+ tidata.peak_fitness = m_base_fitness;
+ tidata.peak_genome = m_base_genome;
+ tidata.site_count.Resize(m_base_genome.GetSize() + 2, 0);
+
+ sStep& tddata = m_twostep_delete[cur_site];
+ tddata.peak_fitness = m_base_fitness;
+ tddata.peak_genome = m_base_genome;
+ 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& tiddata = m_insert_delete[cur_site];
+ tiddata.peak_fitness = m_base_fitness;
+ tiddata.peak_genome = m_base_genome;
+ tiddata.site_count.Resize(m_base_genome.GetSize() + 1, 0);
+
+ sStep& tdpdata = m_delete_point[cur_site];
+ tdpdata.peak_fitness = m_base_fitness;
+ tdpdata.peak_genome = m_base_genome;
+ tdpdata.site_count.Resize(m_base_genome.GetSize(), 0);
+
+
// Do the processing, starting with One Step
- ProcessOneStep(ctx, testcpu, test_info, cur_site);
+ ProcessOneStepPoint(ctx, testcpu, test_info, cur_site);
+ ProcessOneStepInsert(ctx, testcpu, test_info, cur_site);
+ ProcessOneStepDelete(ctx, testcpu, test_info, cur_site);
+ // Process the hanging insertion on the first cycle through (to balance execution time)
+ if (cur_site == 0) {
+ cur_site = m_base_genome.GetSize();
+
+ sStep& oidata2 = m_onestep_insert[cur_site];
+ oidata2.peak_fitness = m_base_fitness;
+ oidata2.peak_genome = m_base_genome;
+ oidata2.site_count.Resize(m_base_genome.GetSize() + 1, 0);
+
+ sStep& tidata2 = m_twostep_insert[cur_site];
+ tidata2.peak_fitness = m_base_fitness;
+ tidata2.peak_genome = m_base_genome;
+ tidata2.site_count.Resize(m_base_genome.GetSize() + 2, 0);
+
+ sStep& tipdata2 = m_insert_point[cur_site];
+ tipdata2.peak_fitness = m_base_fitness;
+ tipdata2.peak_genome = m_base_genome;
+ tipdata2.site_count.Resize(m_base_genome.GetSize() + 1, 0);
+
+ sStep& tiddata2 = m_insert_delete[cur_site];
+ tiddata2.peak_fitness = m_base_fitness;
+ tiddata2.peak_genome = m_base_genome;
+ tiddata2.site_count.Resize(m_base_genome.GetSize() + 1, 0);
+
+ ProcessOneStepInsert(ctx, testcpu, test_info, cur_site);
+ }
+
// Cleanup
delete testcpu;
}
@@ -105,10 +172,22 @@
delete testcpu;
// Setup state to begin processing
- m_onestep.ResizeClear(m_base_genome.GetSize());
- m_twostep.ResizeClear(m_base_genome.GetSize());
- m_fitness.ResizeClear(m_base_genome.GetSize(), m_inst_set.GetSize());
+ 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_point.ResizeClear(m_base_genome.GetSize());
+ m_twostep_insert.ResizeClear(m_base_genome.GetSize() + 1);
+ m_twostep_delete.ResizeClear(m_base_genome.GetSize());
+
+ m_insert_point.ResizeClear(m_base_genome.GetSize() + 1);
+ m_insert_delete.ResizeClear(m_base_genome.GetSize() + 1);
+ m_delete_point.ResizeClear(m_base_genome.GetSize());
+
+ m_fitness_point.ResizeClear(m_base_genome.GetSize(), m_inst_set.GetSize());
+ m_fitness_insert.ResizeClear(m_base_genome.GetSize() + 1, m_inst_set.GetSize());
+ m_fitness_delete.ResizeClear(m_base_genome.GetSize(), 1);
+
m_cur_site = 0;
m_completed = 0;
m_initialized = true;
@@ -126,10 +205,10 @@
}
-void cMutationalNeighborhood::ProcessOneStep(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site)
+void cMutationalNeighborhood::ProcessOneStepPoint(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site)
{
const int inst_size = m_inst_set.GetSize();
- sStep& odata = m_onestep[cur_site];
+ sStep& odata = m_onestep_point[cur_site];
cGenome mod_genome(m_base_genome);
@@ -137,64 +216,183 @@
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();
+ 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);
+ }
+}
+
+
+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][0] = 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);
+}
+
+
+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;
+ }
+ }
+
+ 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)
+{
+ const int inst_size = m_inst_set.GetSize();
+ sTwoStep& tdata = m_twostep_point[cur_site];
+ sPendFit cur(m_fitness_point, cur_site, mod_genome[cur_site].GetOp());
+
+ // Loop through remaining lines of genome, testing trying all combinations.
+ for (int line_num = cur_site + 1; line_num < m_base_genome.GetSize(); line_num++) {
+ int cur_inst = mod_genome[line_num].GetOp();
- 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;
- }
+ // 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, sPendFit(m_fitness_point, line_num, inst_num), cur);
}
- if (test_fitness >= m_neut_min) odata.site_count[cur_site]++;
+ mod_genome[line_num].SetOp(cur_inst);
+ }
+}
+
+
+void cMutationalNeighborhood::ProcessTwoStepInsert(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info,
+ int cur_site, cCPUMemory& mod_genome)
+{
+ const int inst_size = m_inst_set.GetSize();
+ const int mod_size = mod_genome.GetSize();
+ sTwoStep& tdata = m_twostep_insert[cur_site];
+ sPendFit cur(m_fitness_insert, cur_site, mod_genome[cur_site].GetOp());
+
+ // Loop through all instructions...
+ for (int line_num = cur_site + 1; line_num <= mod_size; line_num++) {
+ mod_genome.Insert(line_num, cInstruction(0));
- m_fitness[cur_site][cur_inst] = test_fitness;
-
- 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++;
- if (anytask) odata.task_total++;
- if (m_base_tasks.GetSize() && !m_base_tasks[m_target] && cur_tasks[m_target]) odata.task_target++;
+ for (int inst_num = 0; inst_num < inst_size; inst_num++) {
+ mod_genome[cur_site].SetOp(inst_num);
+ ProcessTwoStepGenome(ctx, testcpu, test_info, mod_genome, tdata, sPendFit(m_fitness_insert, line_num - 1, inst_num), cur);
}
+ mod_genome.Remove(line_num);
+ }
+}
- ProcessTwoStep(ctx, testcpu, test_info, cur_site, mod_genome);
+
+void cMutationalNeighborhood::ProcessTwoStepDelete(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info,
+ int cur_site, cCPUMemory& mod_genome)
+{
+ const int mod_size = mod_genome.GetSize();
+ sTwoStep& tdata = m_twostep_delete[cur_site];
+ sPendFit cur(m_fitness_delete, cur_site, 0); // Delete 'inst' is always 0
+
+ // Loop through all instructions...
+ 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, sPendFit(m_fitness_delete, line_num + 1, 0), cur);
+ mod_genome.Insert(line_num, cInstruction(cur_inst));
}
}
-void cMutationalNeighborhood::ProcessTwoStep(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site, cGenome& mod_genome)
+
+void cMutationalNeighborhood::ProcessInsertPointCombo(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info,
+ int cur_site, cGenome& mod_genome)
{
const int inst_size = m_inst_set.GetSize();
- sStep& tdata = m_twostep[cur_site];
-
- // Loop through remaining lines of genome, testing trying all combinations.
- for (int line_num = cur_site + 1; line_num < m_base_genome.GetSize(); line_num++) {
+ sTwoStep& tdata = m_insert_point[cur_site];
+ sPendFit cur(m_fitness_insert, cur_site, mod_genome[cur_site].GetOp());
+
+ // 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 actual = (line_num < cur_site) ? line_num : (line_num - 1); // if at or past insertion site, adjust pending target site
+
int cur_inst = mod_genome[line_num].GetOp();
// Loop through all instructions...
@@ -202,49 +400,7 @@
if (cur_inst == inst_num) continue;
mod_genome[line_num].SetOp(inst_num);
- testcpu->TestGenome(ctx, test_info, mod_genome);
-
- double test_fitness = test_info.GetColonyFitness();
-
- tdata.total_fitness += test_fitness;
- tdata.total_sqr_fitness += test_fitness * test_fitness;
- tdata.total++;
- if (test_fitness == 0.0) {
- tdata.dead++;
- } else if (test_fitness < m_neut_min) {
- tdata.neg++;
- tdata.size_neg += test_fitness;
- } else if (test_fitness <= m_neut_max) {
- tdata.neut++;
- } else {
- tdata.pos++;
- tdata.size_pos += test_fitness;
- if (test_fitness > tdata.peak_fitness) {
- tdata.peak_fitness = test_fitness;
- tdata.peak_genome = mod_genome;
- }
- }
-
- if (test_fitness >= m_neut_min) tdata.site_count[line_num]++;
-
- 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) tdata.task_knockout++;
- if (anytask) tdata.task_total++;
- if (m_base_tasks.GetSize() && !m_base_tasks[m_target] && cur_tasks[m_target]) {
- tdata.task_target++;
- // Push both instructions as possible first mutations, for post determination of relative fitness
- m_pending.Push(new sPendingTarget(cur_site, mod_genome[cur_site].GetOp()));
- m_pending.Push(new sPendingTarget(line_num, inst_num));
- }
- }
-
+ ProcessTwoStepGenome(ctx, testcpu, test_info, mod_genome, tdata, sPendFit(m_fitness_point, actual, inst_num), cur);
}
mod_genome[line_num].SetOp(cur_inst);
@@ -252,134 +408,390 @@
}
-void cMutationalNeighborhood::ProcessComplete(cAvidaContext& ctx)
+void cMutationalNeighborhood::ProcessInsertDeleteCombo(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info,
+ int cur_site, cCPUMemory& mod_genome)
{
- // Initialize values
- m_o_total = 0;
- m_o_total_sqr_fitness = 0.0;
- m_o_pos = 0;
- m_o_neg = 0;
- m_o_neut = 0;
- m_o_dead = 0;
- m_o_size_pos = 0.0;
- m_o_size_neg = 0.0;
- m_o_peak_fitness = m_base_fitness;
- m_o_peak_genome = m_base_genome;
- m_o_site_count.Resize(m_base_genome.GetSize(), 0);
- m_o_total_entropy = 0;
- m_o_task_target = 0;
- m_o_task_total = 0;
- m_o_task_knockout = 0;
+ sTwoStep& tdata = m_insert_delete[cur_site];
+ sPendFit cur(m_fitness_insert, cur_site, mod_genome[cur_site].GetOp());
- for (int i = 0; i < m_onestep.GetSize(); i++) {
- sStep& odata = m_onestep[i];
- m_o_total += odata.total;
- m_o_total_fitness += odata.total_fitness;
- m_o_total_sqr_fitness += odata.total_sqr_fitness;
- m_o_pos += odata.pos;
- m_o_neg += odata.neg;
- m_o_neut += odata.neut;
- m_o_dead += odata.dead;
- m_o_size_pos += odata.size_pos;
- m_o_size_neg += odata.size_neg;
+ // 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 actual = (line_num < cur_site) ? line_num : (line_num - 1); // if at or past insertion site, adjust pending target site
+
+ int cur_inst = mod_genome[line_num].GetOp();
+ mod_genome.Remove(line_num);
+ ProcessTwoStepGenome(ctx, testcpu, test_info, mod_genome, tdata, sPendFit(m_fitness_delete, actual, 0), cur);
+ 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];
+ sPendFit cur(m_fitness_delete, cur_site, 0); // Delete 'inst' is always 0
- if (odata.peak_fitness > m_o_peak_fitness) {
- m_o_peak_genome = odata.peak_genome;
- m_o_peak_fitness = odata.peak_fitness;
+ // 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();
+ int actual = (line_num < cur_site) ? line_num : (line_num + 1); // if at or past deletion site, adjust pending target site
+
+ // 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, sPendFit(m_fitness_point, actual, inst_num), cur);
}
+
+ mod_genome[line_num].SetOp(cur_inst);
+ }
+}
+
+
+double cMutationalNeighborhood::ProcessTwoStepGenome(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info,
+ const cGenome& mod_genome, sTwoStep& tdata,
+ const sPendFit& cur, const sPendFit& oth)
+{
+ // 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();
- for (int j = 0; j < m_o_site_count.GetSize(); j++) {
- m_o_site_count[j] += odata.site_count[j];
+ tdata.total_fitness += test_fitness;
+ tdata.total_sqr_fitness += test_fitness * test_fitness;
+ tdata.total++;
+ if (test_fitness == 0.0) {
+ tdata.dead++;
+ } else if (test_fitness < m_neut_min) {
+ tdata.neg++;
+ tdata.size_neg += test_fitness;
+ } else if (test_fitness <= m_neut_max) {
+ tdata.neut++;
+ } else {
+ tdata.pos++;
+ tdata.size_pos += test_fitness;
+ if (test_fitness > tdata.peak_fitness) {
+ tdata.peak_fitness = test_fitness;
+ tdata.peak_genome = mod_genome;
}
+ }
+
+ if (test_fitness >= m_neut_min) tdata.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) {
+ tdata.task_knockout++;
+ tdata.task_size_knockout += test_fitness;
+ }
+ if (anytask) {
+ tdata.task_total++;
+ tdata.task_size_total += test_fitness;
+ }
+ if (m_base_tasks.GetSize() && !m_base_tasks[m_target] && cur_tasks[m_target]) {
+ tdata.task_target++;
+ tdata.task_size_target += test_fitness;
- m_o_task_target += odata.task_target;
- m_o_task_total += odata.task_total;
- m_o_task_knockout += odata.task_knockout;
+ // Push both instructions as possible first mutations, for post determination of first step fitness effect
+ tdata.pending.Push(new sPendFit(oth));
+ tdata.pending.Push(new sPendFit(cur));
+ }
}
- const double max_ent = log(static_cast<double>(m_inst_set.GetSize()));
- for (int i = 0; i < m_base_genome.GetSize(); i++) {
- // Per-site entropy is the log of the number of legal states for that
- // site. Add one to account for the unmutated state.
- m_o_total_entropy += log(static_cast<double>(m_o_site_count[i] + 1)) / max_ent;
+ return test_fitness;
+}
+
+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_o_complexity = m_base_genome.GetSize() - m_o_total_entropy;
+ 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;
- // Initialize values
- m_t_total = 0;
- m_t_total_sqr_fitness = 0.0;
- m_t_pos = 0;
- m_t_neg = 0;
- m_t_neut = 0;
- m_t_dead = 0;
- m_t_size_pos = 0.0;
- m_t_size_neg = 0.0;
- m_t_peak_fitness = m_base_fitness;
- m_t_peak_genome = m_base_genome;
- m_t_site_count.Resize(m_base_genome.GetSize(), 0);
- m_t_total_entropy = 0;
- m_t_task_target = 0;
- m_t_task_target_pos = 0;
- m_t_task_target_neg = 0;
- m_t_task_target_neut = 0;
- m_t_task_target_dead = 0;
- m_t_task_total = 0;
- m_t_task_knockout = 0;
+ // @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;
+
+
- for (int i = 0; i < m_twostep.GetSize(); i++) {
- sStep& tdata = m_twostep[i];
- m_t_total += tdata.total;
- m_t_total_fitness += tdata.total_fitness;
- m_t_total_sqr_fitness += tdata.total_sqr_fitness;
- m_t_pos += tdata.pos;
- m_t_neg += tdata.neg;
- m_t_neut += tdata.neut;
- m_t_dead += tdata.dead;
- m_t_size_pos += tdata.size_pos;
- m_t_size_neg += tdata.size_neg;
- if (tdata.peak_fitness > m_t_peak_fitness) {
- m_t_peak_genome = tdata.peak_genome;
- m_t_peak_fitness = tdata.peak_fitness;
- }
+ m_tp.peak_fitness = m_base_fitness;
+ 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.site_count.Resize(m_base_genome.GetSize() + 2, 0);
+ AggregateTwoStep(m_twostep_insert, m_ti);
- for (int j = 0; j < m_t_site_count.GetSize(); j++) {
- m_t_site_count[j] += tdata.site_count[j];
+ m_td.peak_fitness = m_base_fitness;
+ 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_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;
+
+ 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 (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 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_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_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_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;
+
+ // Unlock data for reading
+ m_rwlock.WriteUnlock();
+
+ // Cleanup state information
+ m_onestep_point.Resize(0);
+ m_onestep_insert.Resize(0);
+ m_onestep_delete.Resize(0);
+
+ m_twostep_point.Resize(0);
+ m_twostep_insert.Resize(0);
+ m_twostep_delete.Resize(0);
+
+ m_insert_point.Resize(0);
+ m_insert_delete.Resize(0);
+ m_delete_point.Resize(0);
+
+ m_fitness_point.Resize(0, 0);
+ m_fitness_insert.Resize(0, 0);
+ m_fitness_delete.Resize(0, 0);
+}
+
+void cMutationalNeighborhood::AggregateOneStep(tArray<sStep>& steps, sOneStepAggregate& osa)
+{
+ for (int i = 0; i < steps.GetSize(); i++) {
+ sStep& odata = steps[i];
+ osa.total += odata.total;
+ osa.total_fitness += odata.total_fitness;
+ osa.total_sqr_fitness += odata.total_sqr_fitness;
+ osa.pos += odata.pos;
+ osa.neg += odata.neg;
+ osa.neut += odata.neut;
+ osa.dead += odata.dead;
+ osa.size_pos += odata.size_pos;
+ osa.size_neg += odata.size_neg;
+
+ if (odata.peak_fitness > osa.peak_fitness) {
+ osa.peak_genome = odata.peak_genome;
+ osa.peak_fitness = odata.peak_fitness;
}
-
- m_t_task_target += tdata.task_target;
- m_t_task_total += tdata.task_total;
- m_t_task_knockout += tdata.task_knockout;
+
+
+ for (int j = 0; j < osa.site_count.GetSize(); j++) {
+ osa.site_count[j] += odata.site_count[j];
+ }
+
+ osa.task_target += odata.task_target;
+ osa.task_total += odata.task_total;
+ osa.task_knockout += odata.task_knockout;
+
+ osa.task_size_target += odata.task_size_target;
+ osa.task_size_total += odata.task_size_total;
+ osa.task_size_knockout += odata.task_size_knockout;
}
-
+
+ const double max_ent = log(static_cast<double>(m_inst_set.GetSize()));
for (int i = 0; i < m_base_genome.GetSize(); i++) {
// Per-site entropy is the log of the number of legal states for that
// site. Add one to account for the unmutated state.
- m_t_total_entropy += log(static_cast<double>(m_t_site_count[i] + 1)) / max_ent;
+ osa.total_entropy += log(static_cast<double>(osa.site_count[i] + 1)) / max_ent;
}
- m_t_complexity = m_base_genome.GetSize() - m_t_total_entropy;
+ osa.complexity = m_base_genome.GetSize() - osa.total_entropy;
+}
- // @TODO - Do post relative fitness determination for target task counts
- sPendingTarget* pend = NULL;
- while ((pend = m_pending.Pop())) {
- double fitness = m_fitness[pend->site][pend->inst];
+
+void cMutationalNeighborhood::AggregateTwoStep(tArray<sTwoStep>& steps, sTwoStepAggregate& tsa)
+{
+ sPendFit* pend = NULL;
+
+ for (int i = 0; i < steps.GetSize(); i++) {
+ sTwoStep& tdata = steps[i];
+ tsa.total += tdata.total;
+ tsa.total_fitness += tdata.total_fitness;
+ tsa.total_sqr_fitness += tdata.total_sqr_fitness;
+ tsa.pos += tdata.pos;
+ tsa.neg += tdata.neg;
+ tsa.neut += tdata.neut;
+ tsa.dead += tdata.dead;
+ tsa.size_pos += tdata.size_pos;
+ tsa.size_neg += tdata.size_neg;
- if (fitness == 0.0)
- m_t_task_target_dead++;
- else if (fitness < m_neut_min)
- m_t_task_target_neg++;
- else if (fitness <= m_neut_max)
- m_t_task_target_neut++;
- else
- m_t_task_target_pos++;
+ if (tdata.peak_fitness > tsa.peak_fitness) {
+ tsa.peak_genome = tdata.peak_genome;
+ tsa.peak_fitness = tdata.peak_fitness;
+ }
- delete pend;
+
+ for (int j = 0; j < tsa.site_count.GetSize(); j++) {
+ tsa.site_count[j] += tdata.site_count[j];
+ }
+
+ tsa.task_target += tdata.task_target;
+ tsa.task_total += tdata.task_total;
+ tsa.task_knockout += tdata.task_knockout;
+
+ tsa.task_size_target += tdata.task_size_target;
+ tsa.task_size_total += tdata.task_size_total;
+ tsa.task_size_knockout += tdata.task_size_knockout;
+
+ while ((pend = tdata.pending.Pop())) {
+ double fitness = pend->GetFitness();
+
+ if (fitness == 0.0) {
+ tsa.task_target_dead++;
+ } else if (fitness < m_neut_min) {
+ tsa.task_target_neg++;
+ tsa.task_size_target_neg += fitness;
+ } else if (fitness <= m_neut_max) {
+ tsa.task_target_neut++;
+ } else {
+ tsa.task_target_pos++;
+ tsa.task_size_target_pos += fitness;
+ }
+
+ delete pend;
+ }
}
- m_rwlock.WriteUnlock();
+ const double max_ent = log(static_cast<double>(m_inst_set.GetSize()));
+ for (int i = 0; i < m_base_genome.GetSize(); i++) {
+ // Per-site entropy is the log of the number of legal states for that
+ // site. Add one to account for the unmutated state.
+ tsa.total_entropy += log(static_cast<double>(tsa.site_count[i] + 1)) / max_ent;
+ }
+ tsa.complexity = m_base_genome.GetSize() - tsa.total_entropy;
+
}
@@ -395,51 +807,317 @@
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(GetSingleTask(), "One Step Confers Any Task");
- df.Write(GetSingleProbTask(), "One Step Probability Confers Any Task");
- df.Write(GetSingleKnockout(), "One Step Knockout Task");
- df.Write(GetSingleProbKnockout(), "One Step Probability Knockout Task");
+ 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(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(GetDoubleTargetTaskBeneficial(), "Two Step Confers Target - Previous Beneficial");
- df.Write(GetDoubleProbTargetTaskBeneficial(), "Two Step Prob. Confers Target - Previous Beneficial");
- df.Write(GetDoubleTargetTaskDeleterious(), "Two Step Confers Target - Previous Deleterious");
- df.Write(GetDoubleProbTargetTaskDeleterious(), "Two Step Prob. Confers Target - Previous Deleterious");
- 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(GetDoubleKnockout(), "Two Step Knockout Task");
- df.Write(GetDoubleProbKnockout(), "Two Step Probability Knockout Task");
+ 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(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.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: branches/energy_dev/source/analyze/cMutationalNeighborhood.h
===================================================================
--- branches/energy_dev/source/analyze/cMutationalNeighborhood.h 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/analyze/cMutationalNeighborhood.h 2007-07-31 20:50:25 UTC (rev 1876)
@@ -48,6 +48,7 @@
#endif
class cAvidaContext;
+class cCPUMemory;
class cCPUTestInfo;
class cDataFile;
class cInstSet;
@@ -64,7 +65,7 @@
cWorld* m_world;
// Internal state information
- // --------------------------------------------------------------------------
+ // -----------------------------------------------------------------------------------------------------------------------
cRWLock m_rwlock;
cMutex m_mutex;
@@ -72,6 +73,25 @@
int m_cur_site;
int m_completed;
+ const cInstSet& m_inst_set;
+ int m_target;
+
+
+
+ // Base data
+ // -----------------------------------------------------------------------------------------------------------------------
+ cGenome m_base_genome;
+ double m_base_fitness;
+ double m_base_merit;
+ double m_base_gestation;
+ tArray<int> m_base_tasks;
+ double m_neut_min; // These two variables are a range around the base
+ double m_neut_max; // fitness to be counted as neutral mutations.
+
+
+
+ // One Step Per-Site Data
+ // -----------------------------------------------------------------------------------------------------------------------
struct sStep
{
int total;
@@ -93,115 +113,180 @@
int task_target;
int task_total;
int task_knockout;
+
+ double task_size_target;
+ double task_size_total;
+ double task_size_knockout;
sStep() : total(0), total_fitness(0.0), total_sqr_fitness(0.0), peak_fitness(0.0), pos(0), neg(0), neut(0), dead(0),
- size_pos(0.0), size_neg(0.0), task_target(0), task_total(0), task_knockout(0) { ; }
+ size_pos(0.0), size_neg(0.0), task_target(0), task_total(0), task_knockout(0), task_size_target(0.0),
+ task_size_total(0.0), task_size_knockout(0.0) { ; }
};
- tArray<sStep> m_onestep;
- tArray<sStep> m_twostep;
+ tArray<sStep> m_onestep_point;
+ tArray<sStep> m_onestep_insert;
+ tArray<sStep> m_onestep_delete;
+
- tMatrix<double> m_fitness;
+ // Two Step Per-Site Data
+ // -----------------------------------------------------------------------------------------------------------------------
- struct sPendingTarget
+ // Based on sStep, the sTwoStep data structure adds a pending list to calculate fitness effects based single step
+ // fitness values that may not have been calculated yet. A pending list must be maintained for each site, as a
+ // list in the main class would be subject to a race condition should two separate threads try to write to it
+ // simultaneously.
+ struct sPendFit
{
+ tMatrix<double>& fmat;
int site;
int inst;
- sPendingTarget(int in_site, int in_inst) : site(in_site), inst(in_inst) { ; }
+
+ sPendFit(tMatrix<double>& in_fmat, int in_site, int in_inst) : fmat(in_fmat), site(in_site), inst(in_inst) { ; }
+ sPendFit(const sPendFit& in_pf) : fmat(in_pf.fmat), site(in_pf.site), inst(in_pf.inst) { ; }
+
+ inline double GetFitness() { return fmat[site][inst]; }
};
- tList<sPendingTarget> m_pending;
+ struct sTwoStep : public sStep
+ {
+ tList<sPendFit> pending;
+
+ sTwoStep() : sStep() { ; }
+ };
+ tArray<sTwoStep> m_twostep_point;
+ 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;
+ tMatrix<double> m_fitness_insert;
+ tMatrix<double> m_fitness_delete;
- const cInstSet& m_inst_set;
- int m_target;
-
- // Base data
- // --------------------------------------------------------------------------
- cGenome m_base_genome;
- double m_base_fitness;
- double m_base_merit;
- double m_base_gestation;
- tArray<int> m_base_tasks;
- double m_neut_min; // These two variables are a range around the base
- double m_neut_max; // fitness to be counted as neutral mutations.
-
+
+
// Aggregated One Step Data
- // --------------------------------------------------------------------------
- int m_o_total;
+ // -----------------------------------------------------------------------------------------------------------------------
+ struct sOneStepAggregate
+ {
+ int total;
+
+ double total_fitness;
+ double total_sqr_fitness;
+ cGenome peak_genome;
+ double peak_fitness;
+
+ int pos;
+ int neg;
+ int neut;
+ int dead;
+ double size_pos;
+ double size_neg;
+
+ tArray<int> site_count;
+
+ double total_entropy;
+ double complexity;
+
+ int task_target;
+ int task_total;
+ int task_knockout;
+
+ double task_size_target;
+ double task_size_total;
+ double task_size_knockout;
+
+ sOneStepAggregate() : total(0), total_fitness(0.0), total_sqr_fitness(0.0), peak_fitness(0.0), pos(0), neg(0), neut(0),
+ dead(0), size_pos(0.0), size_neg(0.0), total_entropy(0.0), complexity(0.0), task_target(0), task_total(0),
+ task_knockout(0), task_size_target(0.0), task_size_total(0.0), task_size_knockout(0.0) { ; }
+ };
- double m_o_total_fitness;
- double m_o_total_sqr_fitness;
- cGenome m_o_peak_genome;
- double m_o_peak_fitness;
+ 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
+
- int m_o_pos;
- int m_o_neg;
- int m_o_neut;
- int m_o_dead;
- double m_o_size_pos;
- double m_o_size_neg;
- tArray<int> m_o_site_count;
-
- double m_o_total_entropy;
- double m_o_complexity;
-
- int m_o_task_target;
- int m_o_task_total;
- int m_o_task_knockout;
-
// Aggregated Two Step Data
- // --------------------------------------------------------------------------
- int m_t_total;
+ // -----------------------------------------------------------------------------------------------------------------------
+ struct sTwoStepAggregate : public sOneStepAggregate
+ {
+ int task_target_pos;
+ int task_target_neg;
+ int task_target_neut;
+ int task_target_dead;
- double m_t_total_fitness;
- double m_t_total_sqr_fitness;
- cGenome m_t_peak_genome;
- double m_t_peak_fitness;
+ double task_size_target_pos;
+ double task_size_target_neg;
+
+ sTwoStepAggregate() : sOneStepAggregate(), task_target_pos(0), task_target_neg(0), task_target_neut(0),
+ task_target_dead(0), task_size_target_pos(0.0), task_size_target_neg(0.0) { ; }
+ };
- int m_t_pos;
- int m_t_neg;
- int m_t_neut;
- int m_t_dead;
- double m_t_size_pos;
- double m_t_size_neg;
+ sTwoStepAggregate m_tp; // Two Step Point Mutants
+ sTwoStepAggregate m_ti; // Two Step Insert Mutants
+ sTwoStepAggregate m_td; // Two Step Delete Mutants
- tArray<int> m_t_site_count;
+ 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
- double m_t_total_entropy;
- double m_t_complexity;
+ sTwoStepAggregate m_tt; // Two Step Total
- int m_t_task_target;
- int m_t_task_target_pos;
- int m_t_task_target_neg;
- int m_t_task_target_neut;
- int m_t_task_target_dead;
- int m_t_task_total;
- int m_t_task_knockout;
-
-
- void ProcessInitialize(cAvidaContext& ctx);
- void ProcessOneStep(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site);
- void ProcessTwoStep(cAvidaContext& ctx, cTestCPU* testcpu, cCPUTestInfo& test_info, int cur_site, cGenome& mod_genome);
- void ProcessComplete(cAvidaContext& ctx);
+
cMutationalNeighborhood(); // @not_implemented
cMutationalNeighborhood(const cMutationalNeighborhood&); // @not_implemented
cMutationalNeighborhood& operator=(const cMutationalNeighborhood&); // @not_implemented
public:
+ // Public Methods - Instantiate and Process Only. All results must be read with a cMutationalNeighborhood object.
+ // -----------------------------------------------------------------------------------------------------------------------
cMutationalNeighborhood(cWorld* world, const cGenome& genome, const cInstSet& inst_set, int target)
- : m_world(world), m_initialized(false), m_inst_set(inst_set), m_target(target), m_base_genome(genome)
+ : m_world(world), m_initialized(false), m_inst_set(inst_set), m_target(target), m_base_genome(genome)
{
- // Acquire write lock, to prevent any Results instances before computing
- m_rwlock.WriteLock();
+ // Acquire write lock, to prevent any cMutationalNeighborhoodResults instances before computing
+ m_rwlock.WriteLock();
}
~cMutationalNeighborhood() { ; }
void Process(cAvidaContext& ctx);
+
+private:
+ // Internal Calculation Methods
+ // -----------------------------------------------------------------------------------------------------------------------
+ void ProcessInitialize(cAvidaContext& ctx);
-// These methods can only be accessed via a cMutationalNeighborhoodResults object
-private:
+ 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 AggregateOneStep(tArray<sStep>& steps, sOneStepAggregate& osa);
+
+ 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 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, const sPendFit& cur, const sPendFit& oth);
+ void AggregateTwoStep(tArray<sTwoStep>& steps, sTwoStepAggregate& osa);
+
+ void ProcessComplete(cAvidaContext& ctx);
+
+
+
+ // cMutationalNeighborhoodResults Backing Methods
+ // -----------------------------------------------------------------------------------------------------------------------
void PrintStats(cDataFile& df, int update = -1) const;
inline int GetTargetTask() const { return m_target; }
@@ -215,86 +300,629 @@
if (m_base_tasks.GetSize()) return m_base_tasks[m_target]; else return false;
}
- inline int GetSingleTotal() const { return m_o_total; }
- inline double GetSingleAverageFitness() const { return m_o_total_fitness / m_o_total; }
- inline double GetSingleAverageSqrFitness() const { return m_o_total_sqr_fitness / m_o_total; }
- inline const cGenome& GetSinglePeakGenome() const { return m_o_peak_genome; }
- inline double GetSinglePeakFitness() const { return m_o_peak_fitness; }
- inline double GetSingleProbBeneficial() const { return static_cast<double>(m_o_pos) / m_o_total; }
- inline double GetSingleProbDeleterious() const { return static_cast<double>(m_o_neg) / m_o_total; }
- inline double GetSingleProbNeutral() const { return static_cast<double>(m_o_neut) / m_o_total; }
- inline double GetSingleProbLethal() const { return static_cast<double>(m_o_dead) / m_o_total; }
- inline double GetSingleAverageSizeBeneficial() const { if (m_o_pos == 0) return 0.0; else return m_o_size_pos / m_o_pos; }
- inline double GetSingleAverageSizeDeleterious() const { if (m_o_neg == 0) return 0.0; else return m_o_size_neg / m_o_neg; }
+ inline int Get1SAggregateTotal() const { return m_ot.total; }
- inline double GetSingleTotalEntropy() const { return m_o_total_entropy; }
- inline double GetSingleComplexity() const { return m_o_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_o_task_target; }
- inline double GetSingleProbTargetTask() const { return static_cast<double>(m_o_task_target) / m_o_total; }
- inline int GetSingleTask() const { return m_o_task_total; }
- inline double GetSingleProbTask() const { return static_cast<double>(m_o_task_total) / m_o_total; }
- inline int GetSingleKnockout() const { return m_o_task_knockout; }
- inline double GetSingleProbKnockout() const { return static_cast<double>(m_o_task_knockout) / m_o_total; }
+ 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 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 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 GetDoubleTotal() const { return m_t_total; }
- inline double GetDoubleAverageFitness() const { return m_t_total_fitness / m_t_total; }
- inline double GetDoubleAverageSqrFitness() const { return m_t_total_sqr_fitness / m_t_total; }
- inline const cGenome& GetDoublePeakGenome() const { return m_t_peak_genome; }
- inline double GetDoublePeakFitness() const { return m_t_peak_fitness; }
- inline double GetDoubleProbBeneficial() const { return static_cast<double>(m_t_pos) / m_t_total; }
- inline double GetDoubleProbDeleterious() const { return static_cast<double>(m_t_neg) / m_t_total; }
- inline double GetDoubleProbNeutral() const { return static_cast<double>(m_t_neut) / m_t_total; }
- inline double GetDoubleProbLethal() const { return static_cast<double>(m_t_dead) / m_t_total; }
- inline double GetDoubleAverageSizeBeneficial() const { if (m_t_pos == 0) return 0.0; else return m_t_size_pos / m_t_pos; }
- inline double GetDoubleAverageSizeDeleterious() const { if (m_t_neg == 0) return 0.0; else return m_t_size_neg / m_t_neg; }
+ inline int Get1SInsertTotal() const { return m_oi.total; }
- inline double GetDoubleTotalEntropy() const { return m_t_total_entropy; }
- inline double GetDoubleComplexity() const { return m_t_complexity; }
+ 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 Get2SAggregateTotal() const { return m_tt.total; }
+
+ 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 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 Get2SAggregateTotalEntropy() const { return m_tt.total_entropy; }
+// inline double Get2SAggregateComplexity() const { return m_tt.complexity; }
- inline int GetDoubleTargetTask() const { return m_t_task_target; }
- inline double GetDoubleProbTargetTask() const { return static_cast<double>(m_t_task_target) / m_t_total; }
- inline int GetDoubleTargetTaskBeneficial() const { return m_t_task_target_pos; }
- inline double GetDoubleProbTargetTaskBeneficial() 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_t_task_target == 0) return 0.0; else return static_cast<double>(m_t_task_target_pos) / (2 * m_t_task_target);
+ if (m_tt.task_target == 0) return 0.0; else return double(m_tt.task_size_target) / m_tt.task_target;
}
- inline int GetDoubleTargetTaskDeleterious() const { return m_t_task_target_neg; }
- inline double GetDoubleProbTargetTaskDeleterious() const
+ inline int Get2SAggregateTargetTaskBeneficial() const { return m_tt.task_target_pos; }
+ inline double Get2SAggregateProbTargetTaskBeneficial() const
{
- if (m_t_task_target == 0) return 0.0; else return static_cast<double>(m_t_task_target_neg) / (2 * m_t_task_target);
+ if (m_tt.task_target == 0) return 0.0; else return double(m_tt.task_target_pos) / (2 * m_tt.task_target);
}
- inline int GetDoubleTargetTaskNeutral() const { return m_t_task_target_neut; }
- inline double GetDoubleProbTargetTaskNeutral() const
+ inline double Get2SAggregateAverageSizeTargetTaskBeneficial() const
{
- if (m_t_task_target == 0) return 0.0; else return static_cast<double>(m_t_task_target_neut) / (2 * m_t_task_target);
+ 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 GetDoubleTargetTaskLethal() const { return m_t_task_target_dead; }
- inline double GetDoubleProbTargetTaskLethal() const
+ inline int Get2SAggregateTargetTaskDeleterious() const { return m_tt.task_target_neg; }
+ inline double Get2SAggregateProbTargetTaskDeleterious() const
{
- if (m_t_task_target == 0) return 0.0; else return static_cast<double>(m_t_task_target_dead) / (2 * m_t_task_target);
+ if (m_tt.task_target == 0) return 0.0; else return double(m_tt.task_target_neg) / (2 * m_tt.task_target);
}
- inline int GetDoubleTask() const { return m_t_task_total; }
- inline double GetDoubleProbTask() const { return static_cast<double>(m_t_task_total) / m_t_total; }
- inline int GetDoubleKnockout() const { return m_t_task_knockout; }
- inline double GetDoubleProbKnockout() const { return static_cast<double>(m_t_task_knockout) / m_t_total; }
+ 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 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 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 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 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 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 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 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 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;
+ }
+
+
+
+
+ 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;
+ }
};
-#ifdef ENABLE_UNIT_TESTS
-namespace nMutationalNeighborhood {
- /**
- * Run unit tests
- *
- * @param full Run full test suite; if false, just the fast tests.
- **/
- void UnitTests(bool full = false);
-}
-#endif
-
#endif
Modified: branches/energy_dev/source/analyze/cMutationalNeighborhoodResults.h
===================================================================
--- branches/energy_dev/source/analyze/cMutationalNeighborhoodResults.h 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/analyze/cMutationalNeighborhoodResults.h 2007-07-31 20:50:25 UTC (rev 1876)
@@ -63,62 +63,415 @@
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 GetDoubleTotal() const { return m_src.GetDoubleTotal(); }
+ inline int Get1SPointTotal() const { return m_src.Get1SPointTotal(); }
- 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 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 Get2SAggregateTotal() const { return m_src.Get2SAggregateTotal(); }
+
+ 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(); }
+
+
+
+
+
+ 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
Modified: branches/energy_dev/source/cpu/cHardwareCPU.cc
===================================================================
--- branches/energy_dev/source/cpu/cHardwareCPU.cc 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/cpu/cHardwareCPU.cc 2007-07-31 20:50:25 UTC (rev 1876)
@@ -330,6 +330,8 @@
tInstLibEntry<tMethod>("put-repro", &cHardwareCPU::Inst_TaskPutRepro),
tInstLibEntry<tMethod>("metabolize", &cHardwareCPU::Inst_TaskPutResetInputsRepro),
+ tInstLibEntry<tMethod>("sterilize", &cHardwareCPU::Inst_Sterilize),
+
tInstLibEntry<tMethod>("spawn-deme", &cHardwareCPU::Inst_SpawnDeme),
// Suicide
@@ -2580,6 +2582,13 @@
return true;
}
+
+bool cHardwareCPU::Inst_Sterilize(cAvidaContext& ctx)
+{
+ organism->GetPhenotype().IsFertile() = false;
+ return true;
+}
+
bool cHardwareCPU::Inst_Kazi5(cAvidaContext& ctx)
{
const int reg_used = FindModifiedRegister(REG_AX);
Modified: branches/energy_dev/source/cpu/cHardwareCPU.h
===================================================================
--- branches/energy_dev/source/cpu/cHardwareCPU.h 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/cpu/cHardwareCPU.h 2007-07-31 20:50:25 UTC (rev 1876)
@@ -392,6 +392,7 @@
bool Inst_Repro(cAvidaContext& ctx);
bool Inst_TaskPutRepro(cAvidaContext& ctx);
bool Inst_TaskPutResetInputsRepro(cAvidaContext& ctx);
+ bool Inst_Sterilize(cAvidaContext& ctx);
bool Inst_SpawnDeme(cAvidaContext& ctx);
bool Inst_Kazi(cAvidaContext& ctx);
Modified: branches/energy_dev/source/cpu/cTestCPU.h
===================================================================
--- branches/energy_dev/source/cpu/cTestCPU.h 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/cpu/cTestCPU.h 2007-07-31 20:50:25 UTC (rev 1876)
@@ -100,6 +100,7 @@
inline int GetInput();
inline int GetInputAt(int & input_pointer);
+ tArray<int> GetInputs() {return input_array;}
void ResetInputs(cAvidaContext& ctx);
inline int GetReceiveValue();
Modified: branches/energy_dev/source/cpu/cTestCPUInterface.cc
===================================================================
--- branches/energy_dev/source/cpu/cTestCPUInterface.cc 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/cpu/cTestCPUInterface.cc 2007-07-31 20:50:25 UTC (rev 1876)
@@ -60,6 +60,11 @@
m_testcpu->ResetInputs(ctx);
}
+tArray<int> cTestCPUInterface::GetInputs()
+{
+ return m_testcpu->GetInputs();
+}
+
int cTestCPUInterface::Debug()
{
return -1;
Modified: branches/energy_dev/source/cpu/cTestCPUInterface.h
===================================================================
--- branches/energy_dev/source/cpu/cTestCPUInterface.h 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/cpu/cTestCPUInterface.h 2007-07-31 20:50:25 UTC (rev 1876)
@@ -56,6 +56,7 @@
void Breakpoint() { ; }
int GetInputAt(int& input_pointer);
void ResetInputs(cAvidaContext& ctx);
+ tArray<int> GetInputs();
int Debug();
const tArray<double>& GetResources();
const tArray<double>& GetDemeResources(int deme_id);
Modified: branches/energy_dev/source/main/cAvidaConfig.h
===================================================================
--- branches/energy_dev/source/main/cAvidaConfig.h 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/main/cAvidaConfig.h 2007-07-31 20:50:25 UTC (rev 1876)
@@ -189,7 +189,7 @@
CONFIG_ADD_VAR(ANALYZE_MODE, int, 0, "0 = Disabled\n1 = Enabled\n2 = Interactive");
CONFIG_ADD_VAR(VIEW_MODE, int, 1, "Initial viewer screen");
CONFIG_ADD_VAR(CLONE_FILE, cString, "-", "Clone file to load");
- CONFIG_ADD_VAR(VERBOSITY, int, 1, "Control output verbosity");
+ CONFIG_ADD_VAR(VERBOSITY, int, 1, "0 = No output at all\n1=Normal output\n2 = Verbose output, detailing progress\n3 = High level of details, as available\n4 = Print Debug Information, as applicable");
CONFIG_ADD_GROUP(ARCH_GROUP, "Architecture Variables");
CONFIG_ADD_VAR(WORLD_X, int, 60, "Width of the Avida world");
@@ -302,7 +302,7 @@
CONFIG_ADD_VAR(MIN_GB_DONATE_THRESHOLD, int, -1, "threshold green beard donates only to orgs above this\ndonation attempt threshold; -1=no thresh");
CONFIG_ADD_VAR(DONATE_THRESH_QUANTA, int, 10, "The size of steps between quanta donate thresholds");
CONFIG_ADD_VAR(MAX_DONATES, int, 1000000, "Limit on number of donates organisms are allowed.");
- CONFIG_ADD_VAR(PRECALC_MERIT, int, 0, "Pre-calculate merit at birth (unlimited resources only).");
+ CONFIG_ADD_VAR(PRECALC_PHENOTYPE, int, 0, "0 = Disabled\n 1 = Assign precalculated merit at birth (unlimited resources only)\n 2 = Assign precalculated gestation time\n 3 = Assign precalculated merit AND gestation time.\nFitness will be evaluated for organism based on these settings.");
CONFIG_ADD_GROUP(GENEOLOGY_GROUP, "Geneology");
CONFIG_ADD_VAR(TRACK_MAIN_LINEAGE, int, 1, "Keep all ancestors of the active population?\n0=no, 1=yes, 2=yes,w/sexual population");
Modified: branches/energy_dev/source/main/cDeme.h
===================================================================
--- branches/energy_dev/source/main/cDeme.h 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/main/cDeme.h 2007-07-31 20:50:25 UTC (rev 1876)
@@ -47,7 +47,7 @@
cGermline _germline; //!< The germline for this deme, if used.
cDeme(const cDeme&); // @not_implemented
-
+
cResourceCount deme_resource_count; //!< Resources available to the deme
public:
Modified: branches/energy_dev/source/main/cOrgInterface.h
===================================================================
--- branches/energy_dev/source/main/cOrgInterface.h 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/main/cOrgInterface.h 2007-07-31 20:50:25 UTC (rev 1876)
@@ -65,6 +65,7 @@
virtual void Breakpoint() = 0;
virtual int GetInputAt(int& input_pointer) = 0;
virtual void ResetInputs(cAvidaContext& ctx) = 0;
+ virtual tArray<int> GetInputs() = 0;
virtual int Debug() = 0;
virtual const tArray<double>& GetResources() = 0;
virtual const tArray<double>& GetDemeResources(int deme_id) = 0;
Modified: branches/energy_dev/source/main/cOrganism.cc
===================================================================
--- branches/energy_dev/source/main/cOrganism.cc 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/main/cOrganism.cc 2007-07-31 20:50:25 UTC (rev 1876)
@@ -253,7 +253,7 @@
m_interface->UpdateMerit(newMerit);
}
}
-
+
m_interface->UpdateResources(global_res_change);
//update deme resources
Copied: branches/energy_dev/source/main/cPhenPlastGenotype.cc (from rev 1875, development/source/main/cPhenPlastGenotype.cc)
===================================================================
--- branches/energy_dev/source/main/cPhenPlastGenotype.cc (rev 0)
+++ branches/energy_dev/source/main/cPhenPlastGenotype.cc 2007-07-31 20:50:25 UTC (rev 1876)
@@ -0,0 +1,66 @@
+/*
+ * cPhenPlastGenotype.cpp
+ * Avida
+ *
+ * Created by Matthew Rupp on 7/29/07.
+ * Copyright 1999-2007 Michigan State University. All rights reserved.
+ *
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; version 2
+ * of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "cPhenPlastGenotype.h"
+#include <iostream>
+
+cPhenPlastGenotype::cPhenPlastGenotype(const cGenome& in_genome, int num_trials, cWorld* world, cAvidaContext& ctx)
+: m_genome(in_genome), m_num_trials(num_trials), m_world(world)
+{
+ cTestCPU* test_cpu = m_world->GetHardwareManager().CreateTestCPU();
+ for (int k = 0; k < m_num_trials; k++){
+ cCPUTestInfo test_info;
+ test_info.UseRandomInputs(true);
+ test_cpu->TestGenome(ctx, test_info, m_genome);
+
+ //Is this a new phenotype?
+ UniquePhenotypes::iterator uit = m_unique.find(&test_info.GetTestPhenotype());
+ if (uit == m_unique.end()){ // Yes, make a new entry for it
+ cPlasticPhenotype* new_phen = new cPlasticPhenotype(test_info, m_num_trials);
+ m_unique.insert( static_cast<cPhenotype*>(new_phen) );
+ } else{ // No, add an observation to existing entry, make sure it is equivalent
+ assert( static_cast<cPlasticPhenotype*>((*uit))->AddObservation(test_info) );
+ }
+ }
+ delete test_cpu;
+}
+
+cPhenPlastGenotype::~cPhenPlastGenotype()
+{
+ UniquePhenotypes::iterator it = m_unique.begin();
+ while (it != m_unique.end()){
+ delete *it;
+ ++it;
+ }
+}
+
+
+cPlasticPhenotype cPhenPlastGenotype::GetPlasticPhenotype(int num) const
+{
+ assert(num >= 0 && num < (int) m_unique.size());
+ UniquePhenotypes::iterator it = m_unique.begin();
+ for (int k = 0; k < num; k++, it++);
+ return *static_cast<cPlasticPhenotype*>(*it);
+}
+
Copied: branches/energy_dev/source/main/cPhenPlastGenotype.h (from rev 1875, development/source/main/cPhenPlastGenotype.h)
===================================================================
--- branches/energy_dev/source/main/cPhenPlastGenotype.h (rev 0)
+++ branches/energy_dev/source/main/cPhenPlastGenotype.h 2007-07-31 20:50:25 UTC (rev 1876)
@@ -0,0 +1,75 @@
+/*
+* cPhenPlastGenotype.h
+* Avida
+*
+* Created by Matthew Rupp on 7/27/07.
+*/
+
+
+#ifndef cPhenPlastGenotype_h
+#define cPhenPlastGenotype_h
+
+#include <set>
+#include <utility>
+
+#ifndef functions_h
+#include "functions.h"
+#endif
+#ifndef cCPUMemory_h
+#include "cCPUMemory.h"
+#endif
+#ifndef cGenome_h
+#include "cGenome.h"
+#endif
+#ifndef cString_h
+#include "cString.h"
+#endif
+#ifndef cStringList_h
+#include "cStringList.h"
+#endif
+#ifndef cStringUtil_h
+#include "cStringUtil.h"
+#endif
+#ifndef tArray_h
+#include "tArray.h"
+#endif
+#ifndef cPlasticPhenotype_h
+#include "cPlasticPhenotype.h"
+#endif
+#ifndef cPhenotype_h
+#include "cPhenotype.h"
+#endif
+#ifndef cHardwareManager_h
+#include "cHardwareManager.h"
+#endif
+
+class cAvidaContext;
+class cTestCPU;
+class cWorld;
+
+/**
+ * This class examines a genotype for evidence of phenotypic plasticity.
+**/
+
+
+class cPhenPlastGenotype
+{
+ private:
+
+ typedef set<cPhenotype*, cPhenotype::lt_phenotype > UniquePhenotypes; //Actually, these are cPlasticPhenotype*
+ cGenome m_genome;
+ int m_num_trials;
+ UniquePhenotypes m_unique;
+ cWorld* m_world;
+
+ public:
+ cPhenPlastGenotype(const cGenome& in_genome, int num_trials, cWorld* world, cAvidaContext& ctx);
+ ~cPhenPlastGenotype();
+
+ int GetNumPhenotypes() const { return m_unique.size(); }
+ cPlasticPhenotype GetPlasticPhenotype(int num) const;
+
+};
+
+#endif
+
Modified: branches/energy_dev/source/main/cPhenotype.cc
===================================================================
--- branches/energy_dev/source/main/cPhenotype.cc 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/main/cPhenotype.cc 2007-07-31 20:50:25 UTC (rev 1876)
@@ -32,6 +32,7 @@
#include "cTaskState.h"
#include "cTools.h"
#include "cWorld.h"
+#include "tList.h"
#include <fstream>
@@ -70,6 +71,155 @@
for (int i = 0; i < task_states.GetSize(); i++) delete task_states[i];
}
+
+cPhenotype::cPhenotype(const cPhenotype& in_phen)
+{
+ *this = in_phen;
+}
+
+
+cPhenotype& cPhenotype::operator=(const cPhenotype& in_phen)
+{
+
+ m_world = in_phen.m_world;
+ initialized = in_phen.initialized;
+
+
+ // 1. These are values calculated at the last divide (of self or offspring)
+ merit = in_phen.merit;
+ energy_store = in_phen.energy_store;
+ energy_tobe_applied = in_phen.energy_tobe_applied;
+ genome_length = in_phen.genome_length;
+ bonus_instruction_count = in_phen.bonus_instruction_count;
+ copied_size = in_phen.copied_size;
+ executed_size = in_phen.executed_size;
+ gestation_time = in_phen.gestation_time;
+
+ gestation_start = in_phen.gestation_start;
+ fitness = in_phen.fitness;
+ div_type = in_phen.div_type;
+
+ // 2. These are "in progress" variables, updated as the organism operates
+ cur_bonus = in_phen.cur_bonus;
+ cur_energy_bonus = in_phen.cur_energy_bonus;
+ cur_num_errors = in_phen.cur_num_errors;
+ cur_num_donates = in_phen.cur_num_donates;
+ cur_task_count = in_phen.cur_task_count;
+ eff_task_count = in_phen.eff_task_count;
+ cur_task_quality = in_phen.cur_task_quality;
+ cur_task_value = in_phen.cur_task_value;
+ cur_reaction_count = in_phen.cur_reaction_count;
+ cur_reaction_add_reward = in_phen.cur_reaction_add_reward;
+ cur_inst_count = in_phen.cur_inst_count;
+ cur_sense_count = in_phen.cur_sense_count;
+ sensed_resources = in_phen.sensed_resources;
+ cur_task_time = in_phen.cur_task_time;
+ active_transposons = in_phen.active_transposons;
+ base_promoter_weights = in_phen.base_promoter_weights;
+ cur_promoter_weights = in_phen.cur_promoter_weights;
+ promoter_activation = in_phen.promoter_activation;
+ promoter_repression = in_phen.promoter_repression;
+ promoter_last_inst_terminated = in_phen.promoter_last_inst_terminated;
+
+ // Dynamically allocated m_task_states requires special handling
+ tList<cTaskState*> hash_values;
+ tList<void*> hash_keys;
+ in_phen.m_task_states.AsLists(hash_keys, hash_values);
+ tListIterator<cTaskState*> vit(hash_values);
+ tListIterator<void*> kit(hash_keys);
+ while(vit.Next() && kit.Next())
+ {
+ cTaskState* new_ts = new cTaskState(**(vit.Get()));
+ m_task_states.Add(*(kit.Get()), new_ts);
+ }
+
+ // 3. These mark the status of "in progess" variables at the last divide.
+ last_merit_base = in_phen.last_merit_base;
+ last_bonus = in_phen.last_bonus;
+ last_energy_bonus = in_phen.last_energy_bonus;
+ last_num_errors = in_phen.last_num_errors;
+ last_num_donates = in_phen.last_num_donates;
+ last_task_count = in_phen.last_task_count;
+ last_task_quality = in_phen.last_task_quality;
+ last_task_value = in_phen.last_task_value;
+ last_reaction_count = in_phen.last_reaction_count;
+ last_reaction_add_reward = in_phen.last_reaction_add_reward;
+ last_inst_count = in_phen.last_inst_count;
+ last_sense_count = in_phen.last_sense_count;
+ last_fitness = in_phen.last_fitness;
+
+ // 4. Records from this organisms life...
+ num_divides = in_phen.num_divides;
+ generation = in_phen.generation;
+ cpu_cycles_used = in_phen.cpu_cycles_used;
+ time_used = in_phen.time_used;
+ age = in_phen.age;
+ fault_desc = in_phen.fault_desc;
+ neutral_metric = in_phen.neutral_metric;
+ life_fitness = in_phen.life_fitness;
+
+
+ // 5. Status Flags... (updated at each divide)
+ to_die = in_phen.to_die;
+ to_delete = in_phen.to_delete;
+ is_injected = in_phen.is_injected;
+ is_donor_cur = in_phen.is_donor_cur;
+ is_donor_last = in_phen.is_donor_last;
+ is_donor_rand = in_phen.is_donor_rand;
+ is_donor_rand_last = in_phen.is_donor_rand_last;
+ is_donor_null = in_phen.is_donor_null;
+ is_donor_null_last = in_phen.is_donor_null_last;
+ is_donor_kin = in_phen.is_donor_kin;
+ is_donor_kin_last = in_phen.is_donor_kin_last;
+ is_donor_edit = in_phen.is_donor_edit;
+ is_donor_edit_last = in_phen.is_donor_edit_last;
+ is_donor_gbg = in_phen.is_donor_gbg;
+ is_donor_gbg_last = in_phen.is_donor_gbg_last;
+ is_donor_truegb = in_phen.is_donor_truegb;
+ is_donor_truegb_last = in_phen.is_donor_truegb_last;
+ is_donor_threshgb = in_phen.is_donor_threshgb;
+ is_donor_threshgb_last = in_phen.is_donor_threshgb_last;
+ is_donor_quanta_threshgb = in_phen.is_donor_quanta_threshgb;
+ is_donor_quanta_threshgb_last = in_phen.is_donor_quanta_threshgb_last;
+ num_thresh_gb_donations = in_phen.num_thresh_gb_donations;
+ num_thresh_gb_donations_last = in_phen.num_thresh_gb_donations_last;
+ num_quanta_thresh_gb_donations = in_phen.num_quanta_thresh_gb_donations;
+ num_quanta_thresh_gb_donations_last = in_phen.num_quanta_thresh_gb_donations_last;
+ is_receiver = in_phen.is_receiver;
+ is_receiver_last = in_phen.is_receiver_last;
+ is_receiver_rand = in_phen.is_receiver_rand;
+ is_receiver_kin = in_phen.is_receiver_kin;
+ is_receiver_kin_last = in_phen.is_receiver_kin_last;
+ is_receiver_edit = in_phen.is_receiver_edit;
+ is_receiver_edit_last = in_phen.is_receiver_edit_last;
+ is_receiver_gbg = in_phen.is_receiver_gbg;
+ is_receiver_truegb = in_phen.is_receiver_truegb;
+ is_receiver_truegb_last = in_phen.is_receiver_truegb_last;
+ is_receiver_threshgb = in_phen.is_receiver_threshgb;
+ is_receiver_threshgb_last = in_phen.is_receiver_threshgb_last;
+ is_receiver_quanta_threshgb = in_phen.is_receiver_quanta_threshgb;
+ is_receiver_quanta_threshgb_last = in_phen.is_receiver_quanta_threshgb_last;
+ is_modifier = in_phen.is_modifier;
+ is_modified = in_phen.is_modified;
+ is_fertile = in_phen.is_fertile;
+ is_mutated = in_phen.is_mutated;
+ is_multi_thread = in_phen.is_multi_thread;
+ parent_true = in_phen.parent_true;
+ parent_sex = in_phen.parent_sex;
+ parent_cross_num = in_phen.parent_cross_num;
+
+ // 6. Child information...
+ copy_true = in_phen.copy_true;
+ divide_sex = in_phen.divide_sex;
+ mate_select_id = in_phen.mate_select_id;
+ cross_num = in_phen.cross_num;
+ child_fertile = in_phen.child_fertile;
+ last_child_fertile = in_phen.last_child_fertile;
+ child_copied_size = in_phen.child_copied_size;
+
+ return *this;
+}
+
bool cPhenotype::OK()
{
assert(genome_length >= 0);
@@ -1275,3 +1425,62 @@
cur_promoter_weights[i] = base_promoter_weights[i] * exp((1+promoter_activation[i])*log(2.0)) / exp((1+promoter_repression[i])*log(2.0));
}
+
+
+// C O M P A R I S O N O P E R A T O R S
+
+bool cPhenotype::operator<(const cPhenotype& rhs) const
+{
+ if (this->GetMerit() < rhs.GetMerit())
+ return true;
+
+ if ( this->GetGestationTime() < rhs.GetGestationTime() )
+ return true;
+
+ tArray<int> lhsTasks = this->GetCurTaskCount();
+ tArray<int> rhsTasks = rhs.GetCurTaskCount();
+ for (int k = 0; k < lhsTasks.GetSize(); k++)
+ if (lhsTasks[k] < rhsTasks[k])
+ return true;
+
+ return false;
+}
+
+bool cPhenotype::operator==(const cPhenotype& rhs) const
+{
+ if (this->GetMerit() != rhs.GetMerit())
+ return false;
+
+ if ( this->GetGestationTime() != rhs.GetGestationTime() )
+ return false;
+
+ tArray<int> lhsTasks = this->GetCurTaskCount();
+ tArray<int> rhsTasks = rhs.GetCurTaskCount();
+ for (int k = 0; k < lhsTasks.GetSize(); k++)
+ if (lhsTasks[k] != rhsTasks[k])
+ return false;
+
+ return true;
+}
+
+bool cPhenotype::operator!=(const cPhenotype& rhs) const
+{
+ return !(*this == rhs);
+}
+
+bool cPhenotype::operator>(const cPhenotype& rhs) const
+{
+ if (this->GetMerit() > rhs.GetMerit())
+ return true;
+
+ if ( this->GetGestationTime() > rhs.GetGestationTime() )
+ return true;
+
+ tArray<int> lhsTasks = this->GetCurTaskCount();
+ tArray<int> rhsTasks = rhs.GetCurTaskCount();
+ for (int k = 0; k < lhsTasks.GetSize(); k++)
+ if (lhsTasks[k] > rhsTasks[k])
+ return true;
+
+ return false;
+}
Modified: branches/energy_dev/source/main/cPhenotype.h
===================================================================
--- branches/energy_dev/source/main/cPhenotype.h 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/main/cPhenotype.h 2007-07-31 20:50:25 UTC (rev 1876)
@@ -217,9 +217,11 @@
cPhenotype(); // @not_implemented
- cPhenotype(const cPhenotype&); // @not_implemented
- cPhenotype& operator=(const cPhenotype&); // @not_implemented
+protected:
+ cPhenotype(const cPhenotype&);
+ cPhenotype& operator=(const cPhenotype&);
+
public:
cPhenotype(cWorld* world);
~cPhenotype();
@@ -379,6 +381,7 @@
//////////////////// Accessors -- Modifying ///////////////////
void SetMerit(const cMerit& in_merit) { merit = in_merit; }
+ void SetFitness(const double in_fit) { fitness = in_fit; }
void ReduceEnergy(const double cost);
void SetEnergy(const double value);
void SetGestationTime(int in_time) { gestation_time = in_time; }
@@ -452,6 +455,16 @@
void RefreshEnergy();
void ApplyToEnergyStore();
double ExtractParentEnergy();
+
+ bool operator<(const cPhenotype& rhs) const;
+ bool operator>(const cPhenotype& rhs) const;
+ bool operator==(const cPhenotype& rhs) const;
+ bool operator!=(const cPhenotype& rhs) const;
+
+ struct lt_phenotype{
+ bool operator()(const cPhenotype* lhs, const cPhenotype* rhs)
+ {return *lhs < *rhs;} // operator< in cPhenotype
+ };
};
Copied: branches/energy_dev/source/main/cPlasticPhenotype.cc (from rev 1875, development/source/main/cPlasticPhenotype.cc)
===================================================================
--- branches/energy_dev/source/main/cPlasticPhenotype.cc (rev 0)
+++ branches/energy_dev/source/main/cPlasticPhenotype.cc 2007-07-31 20:50:25 UTC (rev 1876)
@@ -0,0 +1,56 @@
+/*
+ * cPlasticCPUTestInfo.cpp
+ * Avida
+ *
+ * Created by Matthew Rupp on 7/27/07
+ * Copyright 1999-2007 Michigan State University. All rights reserved.
+ *
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; version 2
+ * of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "cPlasticPhenotype.h"
+
+
+bool cPlasticPhenotype::AddObservation( const cPhenotype& in_phen, const tArray<int>& env_inputs )
+{
+ if (in_phen == *this){
+ if (m_num_observations == 0)
+ m_env_inputs.Resize(1, env_inputs.GetSize());
+ else
+ m_env_inputs.Resize(m_env_inputs.GetNumRows()+1, env_inputs.GetSize());
+ m_env_inputs[m_env_inputs.GetNumRows()-1] = env_inputs;
+ m_num_observations++;
+ return true;
+ }
+ return false; //Wrong phenotype
+}
+
+bool cPlasticPhenotype::AddObservation( cCPUTestInfo& test_info )
+{
+ tArray<int> env_inputs = test_info.GetTestCPUInputs();
+ cPhenotype& test_phenotype = test_info.GetTestPhenotype();
+ if (test_phenotype == *this ){
+ if (m_num_observations == 0)
+ m_env_inputs.Resize(1, env_inputs.GetSize());
+ else
+ m_env_inputs.Resize(m_env_inputs.GetNumRows()+1, env_inputs.GetSize());
+ m_env_inputs[m_env_inputs.GetNumRows()-1] = env_inputs;
+ m_num_observations++;
+ return true;
+ }
+ return false; //Wrong phenotype
+}
Copied: branches/energy_dev/source/main/cPlasticPhenotype.h (from rev 1875, development/source/main/cPlasticPhenotype.h)
===================================================================
--- branches/energy_dev/source/main/cPlasticPhenotype.h (rev 0)
+++ branches/energy_dev/source/main/cPlasticPhenotype.h 2007-07-31 20:50:25 UTC (rev 1876)
@@ -0,0 +1,74 @@
+/*
+ * cPlasticCPUTestInfo.h
+ * Avida
+ *
+ * Created by Matthew Rupp on 7/27/07.
+ * Copyright 1999-2007 Michigan State University. All rights reserved.
+ *
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; version 2
+ * of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef cPlasticCPUTestInfo
+#define cPlasticCPUTestInfo
+
+
+#include <cassert>
+
+#ifndef cCPUTestInfo_h
+#include "cCPUTestInfo.h"
+#endif
+
+#ifndef cPhenotype_h
+#include "cPhenotype.h"
+#endif
+
+#ifndef tMatrix_h
+#include "tMatrix.h"
+#endif
+
+
+#include <iostream>
+
+class cPlasticPhenotype : public cPhenotype{
+
+ private:
+ int m_num_observations;
+ int m_num_trials;
+ tMatrix<int> m_env_inputs;
+
+ public:
+ cPlasticPhenotype(cCPUTestInfo& test_info, int num_trials) :
+ cPhenotype(test_info.GetTestPhenotype()), m_num_observations(1), m_num_trials(num_trials) { assert(m_num_trials > 0); }
+
+ ~cPlasticPhenotype() { ; }
+
+ //Modifiers
+ bool AddObservation( const cPhenotype& in_phen, const tArray<int>& env_inputs );
+ bool AddObservation( cCPUTestInfo& test_info );
+
+ //Accessors
+ int GetNumObservations() const { return m_num_observations; }
+ int GetNumTrials() const { return m_num_trials; }
+ double GetFrequency() const { return static_cast<double>(m_num_observations) / m_num_trials; }
+ tMatrix<int> GetEnvInputs() const { return m_env_inputs; }
+
+
+
+};
+
+#endif
+
Modified: branches/energy_dev/source/main/cPopulation.cc
===================================================================
--- branches/energy_dev/source/main/cPopulation.cc 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/main/cPopulation.cc 2007-07-31 20:50:25 UTC (rev 1876)
@@ -325,14 +325,19 @@
if (parent_alive == true) {
// Reset inputs and re-calculate merit if required
- if (m_world->GetConfig().RESET_INPUTS_ON_DIVIDE.Get() > 0){
+ if (m_world->GetConfig().RESET_INPUTS_ON_DIVIDE.Get() > 0){
environment.SetupInputs(ctx, parent_cell.input_array);
- if (m_world->GetConfig().PRECALC_MERIT.Get() > 0){
+ int pc_phenotype = m_world->GetConfig().PRECALC_PHENOTYPE.Get();
+ if (pc_phenotype){
cCPUTestInfo test_info;
cTestCPU* test_cpu = m_world->GetHardwareManager().CreateTestCPU();
test_info.UseManualInputs(parent_cell.input_array); // Test using what the environment will be
test_cpu->TestGenome(ctx, test_info, parent_organism.GetHardware().GetMemory()); // Use the true genome
- parent_phenotype.SetMerit(test_info.GetTestPhenotype().GetMerit()); // Update merit
+ if (pc_phenotype & 1) // If we must update the merit
+ parent_phenotype.SetMerit(test_info.GetTestPhenotype().GetMerit());
+ if (pc_phenotype & 2) // If we must update the gestation time
+ parent_phenotype.SetGestationTime(test_info.GetTestPhenotype().GetGestationTime());
+ parent_phenotype.SetFitness(parent_phenotype.GetMerit().CalcFitness(parent_phenotype.GetGestationTime())); //Update fitness
delete test_cpu;
}
}
@@ -442,15 +447,20 @@
// Setup the inputs in the target cell.
environment.SetupInputs(ctx, target_cell.input_array);
-
-
- // Precalculate the merit if requested
- if (m_world->GetConfig().PRECALC_MERIT.Get() > 0){
+
+ // Precalculate the phenotype if requested
+ int pc_phenotype = m_world->GetConfig().PRECALC_PHENOTYPE.Get();
+ if (pc_phenotype){
cCPUTestInfo test_info;
cTestCPU* test_cpu = m_world->GetHardwareManager().CreateTestCPU();
test_info.UseManualInputs(target_cell.input_array); // Test using what the environment will be
test_cpu->TestGenome(ctx, test_info, in_organism->GetHardware().GetMemory()); // Use the true genome
- in_organism->GetPhenotype().SetMerit(test_info.GetTestPhenotype().GetMerit()); // Update merit
+
+ if (pc_phenotype & 1)
+ in_organism->GetPhenotype().SetMerit(test_info.GetTestPhenotype().GetMerit());
+ if (pc_phenotype & 2)
+ in_organism->GetPhenotype().SetGestationTime(test_info.GetTestPhenotype().GetGestationTime());
+ in_organism->GetPhenotype().SetFitness(in_organism->GetPhenotype().GetMerit().CalcFitness(in_organism->GetPhenotype().GetGestationTime()));
delete test_cpu;
}
// Update the archive...
Modified: branches/energy_dev/source/main/cPopulationCell.h
===================================================================
--- branches/energy_dev/source/main/cPopulationCell.h 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/main/cPopulationCell.h 2007-07-31 20:50:25 UTC (rev 1876)
@@ -83,6 +83,7 @@
const cMutationRates & MutationRates() const { return *mutation_rates; }
cMutationRates & MutationRates() { return *mutation_rates; }
int GetInput(int);
+ tArray<int> GetInputs() {return input_array;}
int GetInputAt(int & input_pointer);
int GetInputSize() { return input_array.GetSize(); }
void ResetInputs(cAvidaContext& ctx);
Modified: branches/energy_dev/source/main/cPopulationInterface.cc
===================================================================
--- branches/energy_dev/source/main/cPopulationInterface.cc 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/main/cPopulationInterface.cc 2007-07-31 20:50:25 UTC (rev 1876)
@@ -92,6 +92,11 @@
m_world->GetPopulation().GetCell(m_cell_id).ResetInputs(ctx);
}
+tArray<int> cPopulationInterface::GetInputs()
+{
+ return m_world->GetPopulation().GetCell(m_cell_id).GetInputs();
+}
+
int cPopulationInterface::Debug()
{
cPopulationCell & cell = m_world->GetPopulation().GetCell(m_cell_id);
Modified: branches/energy_dev/source/main/cPopulationInterface.h
===================================================================
--- branches/energy_dev/source/main/cPopulationInterface.h 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/main/cPopulationInterface.h 2007-07-31 20:50:25 UTC (rev 1876)
@@ -67,6 +67,7 @@
void Breakpoint() { m_world->GetDriver().SignalBreakpoint(); }
int GetInputAt(int& input_pointer);
void ResetInputs(cAvidaContext& ctx);
+ tArray<int> GetInputs();
int Debug();
const tArray<double>& GetResources();
const tArray<double>& GetDemeResources(int deme_id);
Modified: branches/energy_dev/source/main/cResource.cc
===================================================================
--- branches/energy_dev/source/main/cResource.cc 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/main/cResource.cc 2007-07-31 20:50:25 UTC (rev 1876)
@@ -89,11 +89,8 @@
}
}
-bool cResource::SetDemeResource(cString _deme_resource)
-
/* Set if the resource is going to be accessable by demes */
-
-{
+bool cResource::SetDemeResource(cString _deme_resource) {
_deme_resource.ToLower();
if ((_deme_resource == "false") || (_deme_resource == "0")) {
deme_resource = false;
Modified: branches/energy_dev/source/main/cResourceCount.cc
===================================================================
--- branches/energy_dev/source/main/cResourceCount.cc 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/main/cResourceCount.cc 2007-07-31 20:50:25 UTC (rev 1876)
@@ -245,6 +245,7 @@
resource_count[id] = initial;
spatial_resource_count[id].RateAll
(initial/spatial_resource_count[id].GetSize());
+
spatial_resource_count[id].StateAll();
decay_rate[id] = decay;
inflow_rate[id] = inflow;
@@ -367,6 +368,7 @@
the organism demand to work immediately on the state of the resource */
spatial_resource_count[i].State(cell_id);
+ // cout << "BDB in cResourceCount::ModifyCell id = " << i << " cell = " << cell_id << " amount[41] = " << spatial_resource_count[i].GetAmount(41) << endl;
}
}
}
@@ -428,7 +430,7 @@
}
spatial_resource_count[i].FlowAll();
spatial_resource_count[i].StateAll();
- resource_count[i] = spatial_resource_count[i].SumAll();
+ // BDB: resource_count[i] = spatial_resource_count[i].SumAll();
}
}
}
Modified: branches/energy_dev/source/main/cSpatialResCount.cc
===================================================================
--- branches/energy_dev/source/main/cSpatialResCount.cc 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/main/cSpatialResCount.cc 2007-07-31 20:50:25 UTC (rev 1876)
@@ -18,8 +18,8 @@
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
Modified: branches/energy_dev/source/main/cStats.cc
===================================================================
--- branches/energy_dev/source/main/cStats.cc 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/main/cStats.cc 2007-07-31 20:50:25 UTC (rev 1876)
@@ -823,10 +823,21 @@
df.WriteComment("of the particular resource at that update.");
df.Write(m_update, "Update");
+
+ // Check for spatial resources if they exist total up the resource in each
+ // cell and print that total. Also call the routine to print the individual
+ // maps for each spatial resource
+
for (int i = 0; i < resource_count.GetSize(); i++) {
- df.Write(resource_count[i], resource_names[i] );
if (resource_geometry[i] != nGeometry::GLOBAL) {
+ double sum_spa_resource = 0;
+ for (int j = 0; j < spatial_res_count[i].GetSize(); j++) {
+ sum_spa_resource += spatial_res_count[i][j];
+ }
+ df.Write(sum_spa_resource, resource_names[i] );
PrintSpatialResData(filename, i);
+ } else {
+ df.Write(resource_count[i], resource_names[i] );
}
}
df.Endl();
@@ -835,7 +846,7 @@
void cStats::PrintSpatialResData(const cString& filename, int i)
{
- // Write spatial data to a file that can easily be read into Matlab
+ // Write spatial resource data to a file that can easily be read into Matlab
cString tmpfilename = "resource_";
tmpfilename += resource_names[i] + ".m";
Modified: branches/energy_dev/source/main/cStats.h
===================================================================
--- branches/energy_dev/source/main/cStats.h 2007-07-31 20:08:51 UTC (rev 1875)
+++ branches/energy_dev/source/main/cStats.h 2007-07-31 20:50:25 UTC (rev 1876)
@@ -575,7 +575,7 @@
int GetNumSenseSlots();
int getNumAsleep(int demeID) { return numAsleep[demeID]; }
- void incNumAsleep(int demeID) { numAsleep[demeID]+=1; }
+ void incNumAsleep(int demeID) { numAsleep[demeID]++; }
void decNumAsleep(int demeID) { numAsleep[demeID]--; }
// this value gets recorded when a creature with the particular
Copied: branches/energy_dev/tests/spatial_res_100u (from rev 1875, development/tests/spatial_res_100u)
More information about the Avida-cvs
mailing list