refactor minimizer (#158)

Author: ckrause

src/include/minimizer.hpp

@@ -1,13 +1,14 @@
 #pragma once
 
+#include "evaluator.hpp"
 #include "optimizer.hpp"
 #include "program.hpp"
 #include "util.hpp"
 
 class Minimizer {
  public:
   Minimizer(const Settings &settings)
-      : settings(settings), optimizer(settings) {}
+      : settings(settings), optimizer(settings), evaluator(settings) {}
 
   bool minimize(Program &p, size_t num_terms) const;
 
@@ -18,6 +19,9 @@ class Minimizer {
  private:
   bool removeClr(Program &p) const;
 
+  bool check(const Program &p, const Sequence &seq, size_t max_total) const;
+
   Settings settings;
   Optimizer optimizer;
+  mutable Evaluator evaluator;
 };

src/minimizer.cpp

@@ -2,7 +2,6 @@
 
 #include <fstream>
 
-#include "evaluator.hpp"
 #include "file.hpp"
 #include "optimizer.hpp"
 #include "program_util.hpp"
@@ -12,7 +11,6 @@
 
 bool Minimizer::minimize(Program& p, size_t num_terms) const {
   Log::get().debug("Minimizing program");
-  Evaluator evaluator(settings);
 
   // calculate target sequence
   Sequence target_sequence;
@@ -37,15 +35,7 @@ bool Minimizer::minimize(Program& p, size_t num_terms) const {
       continue;
     } else if (op.type == Operation::Type::TRN) {
       p.ops[i].type = Operation::Type::SUB;
-      bool can_replace;
-      try {
-        auto res = evaluator.check(p, target_sequence);
-        can_replace = (res.first == status_t::OK) &&
-                      (res.second.total <= target_steps.total);
-      } catch (const std::exception&) {
-        can_replace = false;
-      }
-      if (can_replace) {
+      if (check(p, target_sequence, target_steps.total)) {
         local_change = true;
       } else {
         // revert change
@@ -54,15 +44,7 @@ bool Minimizer::minimize(Program& p, size_t num_terms) const {
     } else if (op.type == Operation::Type::LPB) {
       if (op.source.type != Operand::Type::CONSTANT || op.source.value != 1) {
         p.ops[i].source = Operand(Operand::Type::CONSTANT, 1);
-        bool can_reset;
-        try {
-          auto res = evaluator.check(p, target_sequence);
-          can_reset = (res.first == status_t::OK) &&
-                      (res.second.total <= target_steps.total);
-        } catch (const std::exception&) {
-          can_reset = false;
-        }
-        if (can_reset) {
+        if (check(p, target_sequence, target_steps.total)) {
           local_change = true;
         } else {
           // revert change
@@ -73,15 +55,7 @@ bool Minimizer::minimize(Program& p, size_t num_terms) const {
       // try to remove the current operation (if there is at least one
       // operation, see A000004)
       p.ops.erase(p.ops.begin() + i, p.ops.begin() + i + 1);
-      bool can_remove;
-      try {
-        auto res = evaluator.check(p, target_sequence);
-        can_remove = (res.first == status_t::OK) &&
-                     (res.second.total <= target_steps.total);
-      } catch (const std::exception&) {
-        can_remove = false;
-      }
-      if (can_remove) {
+      if (check(p, target_sequence, target_steps.total)) {
         local_change = true;
         --i;
       } else {
@@ -120,16 +94,8 @@ bool Minimizer::minimize(Program& p, size_t num_terms) const {
             p.ops.insert(p.ops.begin() + i + 5,
                          Operation(Operation::Type::MOV, op.target, tmp));
 
-            bool can_rewrite;
-            try {
-              auto res = evaluator.check(p, target_sequence);
-              can_rewrite =
-                  (res.first ==
-                   status_t::OK);  // we don't check the number of steps here!
-            } catch (const std::exception&) {
-              can_rewrite = false;
-            }
-            if (can_rewrite) {
+            // we don't check the number of steps here!
+            if (check(p, target_sequence, 0)) {
               local_change = true;
             } else {
               // revert change
@@ -145,6 +111,22 @@ bool Minimizer::minimize(Program& p, size_t num_terms) const {
   return global_change;
 }
 
+bool Minimizer::check(const Program& p, const Sequence& seq,
+                      size_t max_total) const {
+  try {
+    auto res = evaluator.check(p, seq);
+    if (res.first != status_t::OK) {
+      return false;
+    }
+    if (max_total > 0 && res.second.total > max_total) {
+      return false;
+    }
+  } catch (const std::exception&) {
+    return false;
+  }
+  return true;
+}
+
 int64_t Minimizer::getPowerOf(const Number& v) {
   if (Number(9) < Semantics::getPowerOf(v, 2)) {
     return 2;