Merge pull request #308 from anyaevostinar/nand-switch

Nand switch

Author: anyaevostinar

source/sgp_mode/ProgramBuilder.h

@@ -362,9 +362,10 @@ class ProgramBuilder {
       "Global Anchor",
       start_tag
     );
-    // Add not instruction
+    // Add nand instruction
     AddInst(program, io_op);
     AddInst(program, io_op, 1);
+    AddInst(program, io_op);
     AddTask_Nand(program);
     // Nop filler is length minus current size + repro instructions
     // const size_t nop_filler = length - (program.size() + 1);

source/sgp_mode/SGPWorldSetup.cc

@@ -383,19 +383,19 @@ void SGPWorld::SetupHosts(long unsigned int* POP_SIZE) {
   );
 
   // TODO - inject initial population at fixed positions (unless configured otherwise)
-  size_t not_task_id = task_env.GetTaskSet().GetSize();
-  if (task_env.GetTaskSet().HasTask("NOT")) {
-    not_task_id = task_env.GetTaskSet().GetID("NOT");
-  } else if (task_env.GetTaskSet().HasTask("not")) {
-    not_task_id = task_env.GetTaskSet().GetID("not");
+  size_t nand_task_id = task_env.GetTaskSet().GetSize();
+  if (task_env.GetTaskSet().HasTask("NAND")) {
+    nand_task_id = task_env.GetTaskSet().GetID("NAND");
+  } else if (task_env.GetTaskSet().HasTask("nand")) {
+    nand_task_id = task_env.GetTaskSet().GetID("nand");
   }
 
 
   const size_t init_pop_size = *POP_SIZE;
   for (size_t i = 0; i < init_pop_size; ++i) {
     emp::Ptr<sgp_host_t> new_host;
     sgp_prog_t init_prog(
-      prog_builder.CreateNotProgram(PROGRAM_LENGTH)
+      prog_builder.CreateNandProgram(PROGRAM_LENGTH)
     );
     switch (sgp_org_type) {
       case org_mode_t::DEFAULT:
@@ -419,7 +419,7 @@ void SGPWorld::SetupHosts(long unsigned int* POP_SIZE) {
     // - these endosymbionts have empty programs?
     if (sgp_config.START_MOI() == 1) {
       sgp_prog_t sym_prog(
-        prog_builder.CreateNotProgram(PROGRAM_LENGTH)
+        prog_builder.CreateNandProgram(PROGRAM_LENGTH)
       );
       emp::Ptr<sgp_sym_t> new_sym = emp::NewPtr<sgp_sym_t>(
         random_ptr,
@@ -432,19 +432,19 @@ void SGPWorld::SetupHosts(long unsigned int* POP_SIZE) {
       // NOTE - Move env io assignment to different signal that is triggered on inject?
       // AssignNewEnvIO(new_sym->GetHardware().GetCPUState()); // Add to AddSymbiont
       // Set sym's parent task
-      if (task_env.IsSymTask(not_task_id)) {
-        new_sym->GetHardware().GetCPUState().SetParentTaskPerformed(not_task_id, true);
-        new_sym->GetHardware().GetCPUState().SetParentFirstTaskPerformed(not_task_id, true);
-        new_sym->GetHardware().GetCPUState().MarkTaskPerformed(not_task_id);
+      if (task_env.IsSymTask(nand_task_id)) {
+        new_sym->GetHardware().GetCPUState().SetParentTaskPerformed(nand_task_id, true);
+        new_sym->GetHardware().GetCPUState().SetParentFirstTaskPerformed(nand_task_id, true);
+        new_sym->GetHardware().GetCPUState().MarkTaskPerformed(nand_task_id);
       }
       // NOTE - Do we need to set location in cpu state here?
       new_host->AddSymbiont(new_sym);
     }
     // TODO - Add SGPWorld function to wrap inject host function
     // AssignNewEnvIO(new_host->GetHardware().GetCPUState()); // This is in OnPlacement now, so should be fine
-    if (task_env.IsHostTask(not_task_id)) {
-      new_host->GetHardware().GetCPUState().SetParentTaskPerformed(not_task_id, true);
-      new_host->GetHardware().GetCPUState().SetParentFirstTaskPerformed(not_task_id, true);
+    if (task_env.IsHostTask(nand_task_id)) {
+      new_host->GetHardware().GetCPUState().SetParentTaskPerformed(nand_task_id, true);
+      new_host->GetHardware().GetCPUState().SetParentFirstTaskPerformed(nand_task_id, true);
     }
     InjectHost(new_host);
   }

source/test/sgp_mode_test/functional_tests/HealthMode.test.cc

@@ -599,45 +599,44 @@ TEST_CASE("Health hosts evolve", "[sgp][sgp-functional]") {
   emp::Random random(config.SEED());
   world_t world(random, &config);
 
-  size_t no_mut_NOT_rate_per_100 = 3400; // 3400 NOTs per 100 updates from empirical runs.
+  size_t no_mut_NAND_rate_per_100 = 3700; // Approx 3700 NANDs per 100 updates from empirical runs.
   size_t run_updates = 3000; // The mutation population initially dips and then recovers around 2k updates.
 
   WHEN("Mutation size is 0") {
     config.SGP_MUT_PER_BIT_RATE(0);
     world.Setup();
-    size_t not_task_id = world.GetTaskEnv().GetTaskSet().GetID("NOT");
-    size_t total_NOTs = 0;
+    size_t nand_task_id = world.GetTaskEnv().GetTaskSet().GetID("NAND");
+    size_t total_NANDs = 0;
     for (size_t i = 0; i < run_updates; i++) {
       world.Update();
       if(i >= (run_updates-100)) {
         //Only considering last 100 updates to make it easier to compare reasonable numbers
-        total_NOTs += world.GetHostTaskSuccesses().at(not_task_id);
+        total_NANDs += world.GetHostTaskSuccesses().at(nand_task_id);
       }
     }
     THEN("Health hosts do not accrue mutations late in an experiment") {
       REQUIRE(world.GetNumOrgs() == world_size);
-      REQUIRE(total_NOTs > no_mut_NOT_rate_per_100 - no_mut_NOT_rate_per_100*0.25);
-      REQUIRE(total_NOTs < no_mut_NOT_rate_per_100 + no_mut_NOT_rate_per_100*0.25);
+      REQUIRE(total_NANDs > no_mut_NAND_rate_per_100 - no_mut_NAND_rate_per_100*0.25);
+      REQUIRE(total_NANDs < no_mut_NAND_rate_per_100 + no_mut_NAND_rate_per_100*0.25);
     }
   }
 
   WHEN("Mutation size is greater than 0") {
     config.SGP_MUT_PER_BIT_RATE(0.001);
     world.Setup();
-    size_t not_task_id = world.GetTaskEnv().GetTaskSet().GetID("NOT");
-    size_t total_NOTs = 0;
+    size_t nand_task_id = world.GetTaskEnv().GetTaskSet().GetID("NAND");
     size_t total_NANDs = 0;
 
     for (size_t i = 0; i < run_updates; i++) {
       world.Update();
       if(i >= (run_updates-100)) {
         //Only considering last 100 updates to make it easier to compare reasonable numbers
-        total_NOTs += world.GetHostTaskSuccesses().at(not_task_id);
+        total_NANDs += world.GetHostTaskSuccesses().at(nand_task_id);
       }
     }
     THEN("Health hosts accrue more mutations late in an experiment") {
       REQUIRE(world.GetNumOrgs() == world_size);
-      REQUIRE(total_NOTs > no_mut_NOT_rate_per_100 * 3);
+      REQUIRE(total_NANDs > no_mut_NAND_rate_per_100);
     }
   }
 }

source/test/sgp_mode_test/functional_tests/SGPHardware_Tasks.test.cc

@@ -58,16 +58,16 @@ TEST_CASE("Ancestor hardware can attempt reproduction and do NOT", "[sgp]") {
 
     REQUIRE(sgp_host.GetPoints() == 0);
     sgp_host.ProcessOutputBuffer();
-    // Hardware should also have completed NOT task seven times, which is also checking that they 
+    // Hardware should also have completed NAND task seven times, which is also checking that they 
     // are able to fully cycle through all possible inputs (they don't do the last one because they need to go back to their first IO to get it)
-    const size_t not_task_id = world.GetTaskEnv().GetTaskSet().GetID("NOT");
-    REQUIRE(hw.GetCPUState().GetTaskPerformed(not_task_id));
+    const size_t start_task_id = world.GetTaskEnv().GetTaskSet().GetID("NAND");
+    REQUIRE(hw.GetCPUState().GetTaskPerformed(start_task_id));
     REQUIRE(output_buffer.size() == 0);
-    REQUIRE(sgp_host.GetPoints() == 5); // should have done NOT 1 time for 5 points
+    REQUIRE(sgp_host.GetPoints() == 5); // should have done NAND 1 time for 5 points
 
     // Reset should clear CPU state, etc
     hw.Reset();
-    REQUIRE(!hw.GetCPUState().GetTaskPerformed(not_task_id));
+    REQUIRE(!hw.GetCPUState().GetTaskPerformed(start_task_id));
   }
 
 

source/test/sgp_mode_test/functional_tests/SGPHost_Reproduce.test.cc

@@ -143,10 +143,10 @@ TEST_CASE("SGPHost Reproduce function results in correct parental task tracking"
   // Assert that added host is what we expect
   REQUIRE(hw.GetCPUState().GetNumTasks() == 9);
 
-  REQUIRE(world.GetTaskEnv().GetTaskSet().HasTask("NOT"));
-  const size_t not_task_id = world.GetTaskEnv().GetTaskSet().GetID("NOT");
+  REQUIRE(world.GetTaskEnv().GetTaskSet().HasTask("NAND"));
+  const size_t start_task_id = world.GetTaskEnv().GetTaskSet().GetID("NAND");
 
-  WHEN("A host can only perform NOT") {
+  WHEN("A host can only perform NAND") {
     WHEN("It is one of the first generation (does not have parents)") {
 
       auto& host_parent_tasks = hw.GetCPUState().GetParentTasksPerformed();
@@ -157,18 +157,18 @@ TEST_CASE("SGPHost Reproduce function results in correct parental task tracking"
       }
 
       THEN("Its parent's tasks are marked with initial not task") {
-        REQUIRE(host_parent_tasks.Get(not_task_id));
+        REQUIRE(host_parent_tasks.Get(start_task_id));
       }
 
       // Run world for enough updates to evaluate full genome
       for (size_t i = 0; i < 26; ++i) {
         world.Update();
       }
 
-      THEN("After running for 25 updates, host tasks should show NOT completed") {
-        REQUIRE(host_tasks.Get(not_task_id));
+      THEN("After running for 25 updates, host tasks should show NAND completed") {
+        REQUIRE(host_tasks.Get(start_task_id));
         REQUIRE(host_tasks.CountOnes() == 1);
-        // REQUIRE(hw.GetCPUState().GetTaskPerformanceCount(not_task_id) == 1);
+        // REQUIRE(hw.GetCPUState().GetTaskPerformanceCount(start_task_id) == 1);
       }
 
       THEN("Offspring should have correct parent tasks marked as completed") {
@@ -178,7 +178,7 @@ TEST_CASE("SGPHost Reproduce function results in correct parental task tracking"
         auto& offspring_tasks = offspring_hw.GetCPUState().GetTasksPerformed();
         REQUIRE(offspring_tasks.None());
         REQUIRE(offspring_parent_tasks.CountOnes() == 1);
-        REQUIRE(offspring_parent_tasks.Get(not_task_id));
+        REQUIRE(offspring_parent_tasks.Get(start_task_id));
         offspring.Delete();
       }
     }

source/test/sgp_mode_test/functional_tests/StressMode.test.cc

@@ -139,37 +139,37 @@ TEST_CASE("Stress hosts evolve", "[sgp][sgp-functional]") {
   emp::Random random(config.SEED());
   world_t world(random, &config);
 
-  size_t no_mut_NOT_rate = 40000;
+  size_t no_mut_NAND_rate = 40000;
   size_t run_updates = 1000;
 
   WHEN("Mutation size is 0") {
     config.SGP_MUT_PER_BIT_RATE(0);
     world.Setup();
-    size_t not_task_id = world.GetTaskEnv().GetTaskSet().GetID("NOT");
-    size_t total_NOTs = 0;
+    size_t nand_task_id = world.GetTaskEnv().GetTaskSet().GetID("NAND");
+    size_t total_NANDs = 0;
     for (size_t i = 0; i < run_updates; i++) {
       world.Update();
-      total_NOTs += world.GetHostTaskSuccesses().at(not_task_id);
+      total_NANDs += world.GetHostTaskSuccesses().at(nand_task_id);
     }
     THEN("Stress hosts do not accrue mutations late in an experiment") {
       REQUIRE(world.GetNumOrgs() == world_size);
-      REQUIRE(total_NOTs > no_mut_NOT_rate - no_mut_NOT_rate*0.25);
-      REQUIRE(total_NOTs < no_mut_NOT_rate + no_mut_NOT_rate*0.25);
+      REQUIRE(total_NANDs > no_mut_NAND_rate - no_mut_NAND_rate*0.25);
+      REQUIRE(total_NANDs < no_mut_NAND_rate + no_mut_NAND_rate*0.25);
     }
   }
 
   WHEN("Mutation size is greater than 0") {
     config.SGP_MUT_PER_BIT_RATE(0.01);
     world.Setup();
-    size_t not_task_id = world.GetTaskEnv().GetTaskSet().GetID("NOT");
-    size_t total_NOTs = 0;
+    size_t nand_task_id = world.GetTaskEnv().GetTaskSet().GetID("NAND");
+    size_t total_NANDs = 0;
     for (size_t i = 0; i < run_updates; i++) {
       world.Update();
-      total_NOTs += world.GetHostTaskSuccesses().at(not_task_id);
+      total_NANDs += world.GetHostTaskSuccesses().at(nand_task_id);
     }
     THEN("Stress hosts accrue more mutations late in an experiment") {
       REQUIRE(world.GetNumOrgs() == world_size);
-      REQUIRE(total_NOTs > no_mut_NOT_rate * 3);
+      REQUIRE(total_NANDs > no_mut_NAND_rate);
     }
   }
 }

source/test/sgp_mode_test/unit_tests/ProgramBuilder.test.cc

@@ -489,14 +489,15 @@ TEST_CASE("CreateNandProgram()", "[sgp][sgp-unit]"){
         REQUIRE(program[0].op_code == sgpmode::Library::GetOpCode("Global Anchor"));
       }
 
-      THEN("The program contains IO, IO, Nand"){
+      THEN("The program contains IO, IO, IO, Nand"){
         REQUIRE(program[1].op_code == sgpmode::Library::GetOpCode("IO"));
         REQUIRE(program[2].op_code == sgpmode::Library::GetOpCode("IO"));
-        REQUIRE(program[3].op_code == sgpmode::Library::GetOpCode("Nand"));
+        REQUIRE(program[3].op_code == sgpmode::Library::GetOpCode("IO"));
+        REQUIRE(program[4].op_code == sgpmode::Library::GetOpCode("Nand"));
       }
 
-      THEN("The program contains 94 nop instructions in a row"){
-        for (size_t i = 4; i < (program.size() - 1); ++i) {
+      THEN("The program contains 93 nop instructions in a row"){
+        for (size_t i = 5; i < (program.size() - 1); ++i) {
           REQUIRE(program[i].op_code == 0);
         }
       }