dither 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d71e5bd41e308d0224d6902f1c0698739e1ea399
-  data.tar.gz: adef3f1c923b2611da8ed6cf47f3d7dec5ffb8d3
+  metadata.gz: b006159a1b729a73db618c798df025d7ac71584f
+  data.tar.gz: d53268fc1aaa144bedd5e216d887235cc573af4d
 SHA512:
-  metadata.gz: d1ca534cc0dfe49379470dfda625d115ae6af9a0e7bf1ed9ca9a4dca784b095a55e5dfcc7d290f45aeea3723797426df6a69da1ffafa43877c9a7cb010e29c7a
-  data.tar.gz: 4333165dad0c5a001e58acea7b3c421e691e5c90c52ae10baaf3c4a67b43acf6ef43d1ae2f20805c29b086a71a179a3137e1d12b74ec08f06c07f0fa054cbd8e
+  metadata.gz: e06c1afdd9e517e00c70a8dcf8984425059d4024ec86cc0fafc1a0a8a1049c7de825dd0daf5bcafeacc5f8ea04b2f441c29b6ddf679b394787a4f89e83a096bc
+  data.tar.gz: af4aa4e4434de024b19b50552aa63ed3cf29a50aaf8646a2278f8418e3fbffa95271af6bf1bc6497fc69c4124e2d3d0822edaa9e8c49d13acdbb1f5bd16da7fd

data/ext/dither/Ipog.java

@@ -231,37 +231,31 @@ iter:
                 // remove constraint violation
                 boolean isCaseCovered = violateConstraints(testCase);
                 if(!isCaseCovered) {
-                    for (final int[] innerTestCase : testSet) {
-                        boolean match = true;
+
+match_unbound_label:
+                    for (final int[] innerTestCase : unbound) {
                         for(final Pair pair : testCase) {
                             if(innerTestCase[pair.i] != pair.j) {
-                                match = false;
-                                break;
+                                continue match_unbound_label;
                             }
                         }
-                        if(match) {
-                            isCaseCovered = true;
-                            break;
-                        }
+                        isCaseCovered = true;
+                        break;
                     }
                 }
 
                 if (!isCaseCovered) {
-                    final ListIterator<int[]> unboundIter = unbound.listIterator();
                     boolean isMerged = false;
-                    int[] innerTestCase = null;
-                    while(unboundIter.hasNext()) {
-                        innerTestCase = unboundIter.next();
+                    for(final int[] innerTestCase : unbound) {
                         // -1 => no merge, 0 perfect merge (no unbound), 1 partial merge
                         final int mergeResult = merge(k, testCase, innerTestCase);
-                        if(mergeResult == 0) {
-                            unboundIter.remove();
-                            testSet.add(innerTestCase);
-                            isMerged = true;
-                            break;
-                        } else if(mergeResult == 1) {
+                        if(mergeResult > 0){
+                            for(final Pair localComb : testCase) {
+                                innerTestCase[localComb.i] = localComb.j;
+                            }
                             isMerged = true;
                             break;
+
                         }
                     }
 
@@ -304,14 +298,9 @@ iter:
             return -1;
         }
 
-        // merge
-        for(final Pair pair : pairs) {
-            testCase[pair.i] = pair.j;
-        }
-
         // find unbound
         for(int i = 0; i < k; i++) {
-            if(testCase[i] == -1) { return 1; }
+            if(mergeScratch[i] == -1) { return 1; }
         }
         return 0;
     }

data/ext/dither/base_constraint_handler.h

@@ -15,25 +15,28 @@
 
 namespace dither {
 
-  class BaseConstraintHandler {
-    public:
-      BaseConstraintHandler(){};
-      virtual ~BaseConstraintHandler(){};
-      virtual bool violate_constraints(const dtest_case &test_case) { return false; }
-      virtual bool violate_constraints(const std::vector<param*> &test_case) {
-        return false;
+class BaseConstraintHandler {
+ public:
+  BaseConstraintHandler(){};
+  virtual ~BaseConstraintHandler(){};
+  virtual bool violate_constraints(const dtest_case &test_case) {
+    return false;
+  }
+  virtual bool violate_constraints(const std::vector<param *> &test_case) {
+    return false;
+  }
+  virtual bool violate_constraints(param **test_case,
+                                   const std::size_t length) {
+    return false;
+  }
+  virtual bool ground(dtest_case &test_case) {
+    for (auto it = test_case.begin(); it != test_case.end(); ++it) {
+      if ((*it) == -1) {
+        *it = 0;
       }
-      virtual bool violate_constraints(param** test_case, const std::size_t length) {
-        return false;
-      }
-      virtual bool ground(dtest_case &test_case) {
-        for (auto it = test_case.begin(); it != test_case.end(); ++it) {
-          if ((*it) == -1) {
-            *it = 0;
-          }
-        }
-        return true;
-      }
-  };
+    }
+    return true;
+  }
+};
 }
 #endif  // BASE_CONSTRAINT_HANDLER_H_

data/ext/dither/combinations.h

@@ -125,12 +125,11 @@ inline void product(
   }
 }
 
-inline void product3(
-    std::forward_list<dtest_case>& results,
-    std::vector<dtest_case>::const_iterator begin,
-    std::vector<dtest_case>::const_iterator end) {
+inline void product3(std::forward_list<dtest_case>& results,
+                     std::vector<dtest_case>::const_iterator begin,
+                     std::vector<dtest_case>::const_iterator end) {
   dtest_case ranges;
-  for(auto it = begin; it != end; ++it) {
+  for (auto it = begin; it != end; ++it) {
     const dval tmp = (*it).size() - 1;
     ranges.push_back(tmp);
   }
@@ -138,18 +137,17 @@ inline void product3(
   dtest_case scratch(ranges.size(), 0);
 
   const std::size_t max = ranges.size() - 1;
-  for(std::size_t i = max;;) {
-
-    if(i == max) {
-      for(dval val = 0; val <= ranges[i]; val++) {
+  for (std::size_t i = max;;) {
+    if (i == max) {
+      for (dval val = 0; val <= ranges[i]; val++) {
         results.push_front(scratch);
         scratch[i]++;
       }
       scratch[i] = 0;
       i--;
-    } else if(i == 0 && scratch[i] >= ranges[i]) {
+    } else if (i == 0 && scratch[i] >= ranges[i]) {
       return;
-    } else if(scratch[i] < ranges[i]) {
+    } else if (scratch[i] < ranges[i]) {
       scratch[i]++;
       i++;
     } else {
@@ -159,14 +157,13 @@ inline void product3(
   }
 }
 
-inline std::size_t product4(
-    std::forward_list<param**>& results,
-    param** param_cache,
-    std::vector<std::vector<param>*>& param_matrix) {
+inline std::size_t product4(std::forward_list<param**>& results,
+                            param** param_cache,
+                            std::vector<std::vector<param>*>& param_matrix) {
   std::vector<int> ranges;
-  std::unique_ptr<param*[]> scratch_ptr(new param*[param_matrix.size()]);
+  std::unique_ptr<param* []> scratch_ptr(new param*[param_matrix.size()]);
   auto scratch = scratch_ptr.get();
-  for(std::size_t j = 0; j < param_matrix.size(); j++) {
+  for (std::size_t j = 0; j < param_matrix.size(); j++) {
     ranges.push_back(param_matrix[j]->size() - 1);
     scratch[j] = &(*param_matrix[j])[0];
   }
@@ -174,23 +171,22 @@ inline std::size_t product4(
 
   const std::size_t max = ranges.size() - 1;
   const std::size_t length = ranges.size();
-	std::size_t j = 0;
-  for(std::size_t i = max;;) {
-
-    if(i == max) {
-      for(std::size_t val = 0; val <= ranges[i]; val++) {
+  std::size_t j = 0;
+  for (std::size_t i = max;;) {
+    if (i == max) {
+      for (std::size_t val = 0; val <= ranges[i]; val++) {
         scratch[i] = &(*param_matrix[i])[indexes[i]];
-        std::copy(scratch, scratch+length, param_cache);
+        std::copy(scratch, scratch + length, param_cache);
         results.push_front(param_cache);
         param_cache += length;
         indexes[i]++;
-				j++;
+        j++;
       }
       indexes[i] = 0;
       i--;
-    } else if(i == 0 && indexes[i] >= ranges[i]) {
+    } else if (i == 0 && indexes[i] >= ranges[i]) {
       return j;
-    } else if(indexes[i] < ranges[i]) {
+    } else if (indexes[i] < ranges[i]) {
       indexes[i]++;
       scratch[i] = &(*param_matrix[i])[indexes[i]];
       i++;

data/ext/dither/dither.cc

@@ -9,7 +9,9 @@
 
 #include "dither.h"
 
-ipog_handle dither_ipog_new(const unsigned int t) { return new dither::Ipog(t); }
+ipog_handle dither_ipog_new(const unsigned int t) {
+  return new dither::Ipog(t);
+}
 
 void dither_ipog_delete(ipog_handle self) {
   delete static_cast<dither::Ipog *>(self);
@@ -38,10 +40,12 @@ void dither_ipog_fill(ipog_handle self, int *solution) {
   static_cast<dither::Ipog *>(self)->fill(solution);
 }
 
-void dither_ipog_add_constraint(ipog_handle self, const int constraint[], const int length) {
+void dither_ipog_add_constraint(ipog_handle self, const int constraint[],
+                                const int length) {
   static_cast<dither::Ipog *>(self)->add_constraint(constraint, length);
 }
 
-void dither_ipog_add_previously_tested(ipog_handle self, const int tested[], const int length) {
+void dither_ipog_add_previously_tested(ipog_handle self, const int tested[],
+                                       const int length) {
   static_cast<dither::Ipog *>(self)->add_previously_tested(tested, length);
 }

data/ext/dither/dither.h

@@ -25,7 +25,8 @@ int dither_ipog_size(ipog_handle);
 void dither_ipog_display_raw_solution(ipog_handle);
 void dither_ipog_fill(ipog_handle, int[]);
 void dither_ipog_delete(ipog_handle self);
-void dither_ipog_add_constraint(ipog_handle self, const int[], const int );
-void dither_ipog_add_previously_tested(ipog_handle self, const int[], const int );
+void dither_ipog_add_constraint(ipog_handle self, const int[], const int);
+void dither_ipog_add_previously_tested(ipog_handle self, const int[],
+                                       const int);
 }
 #endif  // DITHER_H_

data/ext/dither/extconf.rb

@@ -1,4 +1,4 @@
 
 require 'mkmf'
-$CPPFLAGS += ' -std=c++11 -O3 '
+$CPPFLAGS += ' -std=c++0x -O3 '
 create_makefile('dither')

data/ext/dither/ipog.cc

@@ -19,14 +19,12 @@
 namespace dither {
 
 Ipog::~Ipog() {
-  if(constraint_handler != NULL) {
+  if (constraint_handler != NULL) {
     delete constraint_handler;
   }
 }
 
-Ipog::Ipog() {
-  t_ = 2;
-}
+Ipog::Ipog() { t_ = 2; }
 
 Ipog::Ipog(const unsigned int t) : t_(t) {}
 
@@ -40,12 +38,12 @@ void Ipog::init_bound() {
     (*it).resize(size, -1);
     (*it).shrink_to_fit();
   }
-  bound_.remove_if([this](dtest_case& a) { return has_previously_tested(a); });
+  bound_.remove_if([this](dtest_case &a) { return has_previously_tested(a); });
 
   merge_scratch_.resize(param_cache_.size(), -1);
 
-  if(constraints.size() > 0) {
-    for(auto it = param_cache_.cbegin(); it != param_cache_.cend(); ++it) {
+  if (constraints.size() > 0) {
+    for (auto it = param_cache_.cbegin(); it != param_cache_.cend(); ++it) {
       const dval tmp = (*it).size() - 1;
       ranges.push_back(tmp);
     }
@@ -55,7 +53,7 @@ void Ipog::init_bound() {
   }
 }
 
-inline param** Ipog::cover(const int k, std::forward_list<param**> &coverage) {
+inline param **Ipog::cover(const int k, std::forward_list<param **> &coverage) {
   std::vector<int> input(k);
   for (std::size_t i = 0; i < k; i++) {
     input[i] = i;
@@ -63,10 +61,10 @@ inline param** Ipog::cover(const int k, std::forward_list<param**> &coverage) {
 
   std::forward_list<std::vector<int>> output;
   combinations(t_ - 1, input, output);
-  std::forward_list<std::vector<std::vector<param>*>> product_input;
+  std::forward_list<std::vector<std::vector<param> *>> product_input;
   int count = 0;
   for (auto it = output.begin(); it != output.end(); ++it) {
-    std::vector<std::vector<param>*> param_tuple;
+    std::vector<std::vector<param> *> param_tuple;
     (*it).push_back(k);
     int inner_count = 1;
     for (auto iit = (*it).begin(); iit != (*it).end(); ++iit) {
@@ -77,10 +75,10 @@ inline param** Ipog::cover(const int k, std::forward_list<param**> &coverage) {
     product_input.push_front(param_tuple);
   }
 
-  param **local_param_cache = new param*[count*t_];
+  param **local_param_cache = new param *[count * t_];
   std::size_t j = 0;
   for (auto it = product_input.begin(); it != product_input.end(); ++it) {
-    j += t_*product4(coverage, local_param_cache+j, *it);
+    j += t_ * product4(coverage, local_param_cache + j, *it);
   }
   coverage.remove_if([this](param **a) { return has_previously_tested(a); });
   return local_param_cache;
@@ -89,9 +87,9 @@ inline param** Ipog::cover(const int k, std::forward_list<param**> &coverage) {
 void Ipog::run() {
   init_bound();
   for (auto k = t_; k < input_params_.size(); k++) {
-    std::forward_list<param**> pi;
+    std::forward_list<param **> pi;
     param **params = cover(k, pi);
-    std::unique_ptr<param*[]> params_ptr(params);
+    std::unique_ptr<param *[]> params_ptr(params);
 
     {
       auto prev = bound_.cbefore_begin();
@@ -110,11 +108,12 @@ void Ipog::run() {
     /* vertical extension */
     for (auto pairs = pi.cbegin(); pairs != pi.cend(); ++pairs) {
       param **test_case = *pairs;
-      bool case_covered = constraint_handler->violate_constraints(test_case, t_);
+      bool case_covered =
+          constraint_handler->violate_constraints(test_case, t_);
 
-      if(!case_covered) {
+      if (!case_covered) {
         for (auto it = unbound_.cbegin(); it != unbound_.cend(); ++it) {
-          if(is_covered(*it, test_case)) {
+          if (is_covered(*it, test_case)) {
             case_covered = true;
             break;
           }
@@ -124,12 +123,12 @@ void Ipog::run() {
       if (!case_covered) {
         bool is_merged = false;
 
-        for(auto next = unbound_.begin(); next != unbound_.end(); ++next) {
+        for (auto next = unbound_.begin(); next != unbound_.end(); ++next) {
           const int merge_result = merge(k, *next, test_case);
 
           if (merge_result > 0) {
             dtest_case tmp = *next;
-            for(std::size_t i = 0; i < t_; i++) {
+            for (std::size_t i = 0; i < t_; i++) {
               const param *it = test_case[i];
               tmp[it->first] = it->second;
             }
@@ -140,7 +139,7 @@ void Ipog::run() {
 
         if (!is_merged) {
           dtest_case unbound_test_case(param_cache_.size(), -1);
-          for(std::size_t i = 0; i < t_; i++) {
+          for (std::size_t i = 0; i < t_; i++) {
             const param *it = test_case[i];
             unbound_test_case[it->first] = it->second;
           }
@@ -156,8 +155,8 @@ void Ipog::run() {
 
 /* -1 no merge, 0 perfect merge (no unbound), 1 partial merge */
 inline const int Ipog::merge(const int k, dtest_case &test_case,
-    param** pairs) {
-  for(std::size_t i = 0; i < t_; i++) {
+                             param **pairs) {
+  for (std::size_t i = 0; i < t_; i++) {
     const param *it = pairs[i];
     auto value = test_case[it->first];
     if (!(value == -1 || value == it->second)) {
@@ -167,7 +166,7 @@ inline const int Ipog::merge(const int k, dtest_case &test_case,
 
   std::copy(test_case.cbegin(), test_case.cend(), merge_scratch_.begin());
 
-  for(std::size_t i = 0; i < t_; i++) {
+  for (std::size_t i = 0; i < t_; i++) {
     const param *it = pairs[i];
     merge_scratch_[it->first] = it->second;
   }
@@ -185,9 +184,8 @@ inline const int Ipog::merge(const int k, dtest_case &test_case,
   return 0;
 }
 
-inline bool Ipog::is_covered(const dtest_case &test_case,
-    param** params) {
-  for(std::size_t i = 0; i < t_; i++) {
+inline bool Ipog::is_covered(const dtest_case &test_case, param **params) {
+  for (std::size_t i = 0; i < t_; i++) {
     const param *my_param = params[i];
     if (test_case[my_param->first] != my_param->second) {
       return false;
@@ -196,7 +194,7 @@ inline bool Ipog::is_covered(const dtest_case &test_case,
   return true;
 }
 inline bool Ipog::is_covered(const dtest_case &test_case,
-    const std::vector<param*> &params) {
+                             const std::vector<param *> &params) {
   for (auto param = params.cbegin(); param != params.cend(); ++param) {
     if (test_case[(*param)->first] != (*param)->second) {
       return false;
@@ -206,15 +204,14 @@ inline bool Ipog::is_covered(const dtest_case &test_case,
 }
 
 inline const int Ipog::maximize_coverage(const int k, dtest_case &test_case,
-    std::forward_list<param**> &pi) {
+                                         std::forward_list<param **> &pi) {
   const std::vector<param> &param_range = param_cache_[k];
   int current_max = -1;
   param max_param = param_range[0];
-  std::forward_list<std::forward_list<param**>::iterator> covered;
+  std::forward_list<std::forward_list<param **>::iterator> covered;
 
   for (auto it = param_range.cbegin(); it != param_range.cend(); ++it) {
-    std::forward_list<std::forward_list<param**>::iterator>
-      tmp_covered;
+    std::forward_list<std::forward_list<param **>::iterator> tmp_covered;
     const param current_param = *it;
 
     test_case[current_param.first] = current_param.second;
@@ -258,7 +255,7 @@ void Ipog::display_raw_solution() {
 }
 
 void Ipog::add_parameter(const std::string name, const int *terms,
-    const unsigned int terms_length) {
+                         const unsigned int terms_length) {
   std::vector<int> tmp(terms, terms + terms_length);
   std::pair<std::string, std::vector<int>> key_value(name, tmp);
   int_params_.insert(key_value);
@@ -266,7 +263,7 @@ void Ipog::add_parameter(const std::string name, const int *terms,
 }
 
 void Ipog::add_parameter(const std::string name, const std::string *terms,
-    const unsigned int terms_length) {
+                         const unsigned int terms_length) {
   std::vector<std::string> tmp(terms, terms + terms_length);
   std::pair<std::string, std::vector<std::string>> key_value(name, tmp);
   str_params_.insert(key_value);
@@ -288,7 +285,7 @@ void Ipog::init_param_cache() {
       continue;
     }
     tmp.push_back(
-	std::make_tuple((*it).first, DITHER_INT_T, (*it).second.size()));
+        std::make_tuple((*it).first, DITHER_INT_T, (*it).second.size()));
   }
 
   for (auto it = str_params_.cbegin(); it != str_params_.cend(); ++it) {
@@ -296,7 +293,7 @@ void Ipog::init_param_cache() {
       continue;
     }
     tmp.push_back(
-	std::make_tuple((*it).first, DITHER_STRING_T, (*it).second.size()));
+        std::make_tuple((*it).first, DITHER_STRING_T, (*it).second.size()));
   }
 
   for (auto it = bool_params_.cbegin(); it != bool_params_.cend(); ++it) {
@@ -304,17 +301,18 @@ void Ipog::init_param_cache() {
       continue;
     }
     tmp.push_back(
-	std::make_tuple((*it).first, DITHER_BOOL_T, (*it).second.size()));
+        std::make_tuple((*it).first, DITHER_BOOL_T, (*it).second.size()));
   }
 
   std::sort(tmp.begin(), tmp.end(), [](std::tuple<std::string, int, int> a,
-        std::tuple<std::string, int, int> b) {
+                                       std::tuple<std::string, int, int> b) {
     return std::get<2>(a) > std::get<2>(b);
   });
 
   std::unordered_map<std::string, int> original_name_to_index;
   int count = 0;
-  for(auto it = ordered_param_names_.cbegin(); it != ordered_param_names_.cend(); ++it, count++) {
+  for (auto it = ordered_param_names_.cbegin();
+       it != ordered_param_names_.cend(); ++it, count++) {
     original_name_to_index.insert({{*it, count}});
   }
   ordered_param_index_.resize(tmp.size());
@@ -328,7 +326,8 @@ void Ipog::init_param_cache() {
     auto type = std::get<1>(*it);
     reverse_param_index_.insert({{count, name}});
     ordered_param_index_[count] = original_name_to_index.find(name)->second;
-    reverse_ordered_param_index_[original_name_to_index.find(name)->second] = count;
+    reverse_ordered_param_index_[original_name_to_index.find(name)->second] =
+        count;
 
     for (dval i = 0; i < SCHAR_MAX && i < std::get<2>(*it); i++) {
       param my_param;
@@ -344,26 +343,25 @@ void Ipog::init_param_cache() {
     input_params_.push_back(dvals);
   }
 
-	std::vector<dval> scratch(param_cache_.size());
-	for(auto it = original_previously_tested_.cbegin(); it != original_previously_tested_.cend(); ++it) {
-		for(std::size_t i = 0; i < scratch.size(); i++) {
-			scratch[reverse_ordered_param_index_[i]] = (*it)[i];
-		}
-		previously_tested_.push_back(scratch);
-	}
+  std::vector<dval> scratch(param_cache_.size());
+  for (auto it = original_previously_tested_.cbegin();
+       it != original_previously_tested_.cend(); ++it) {
+    for (std::size_t i = 0; i < scratch.size(); i++) {
+      scratch[reverse_ordered_param_index_[i]] = (*it)[i];
+    }
+    previously_tested_.push_back(scratch);
+  }
 
   // transform constraints
-  for(std::size_t j = 0; j < constraints.size(); j++) {
-    for(std::size_t i = 0; i < scratch.size(); i++) {
+  for (std::size_t j = 0; j < constraints.size(); j++) {
+    for (std::size_t i = 0; i < scratch.size(); i++) {
       scratch[reverse_ordered_param_index_[i]] = constraints[j][i];
     }
     std::copy(scratch.begin(), scratch.end(), constraints[j].begin());
   }
 }
 
-int Ipog::size() {
-  return solution_size;
-}
+int Ipog::size() { return solution_size; }
 
 std::string *Ipog::header() {
   std::string *result = new std::string[param_cache_.size()];
@@ -373,39 +371,41 @@ std::string *Ipog::header() {
   return result;
 }
 
-  void Ipog::add_constraint(const int* constraint, const unsigned int length) {
-    std::vector<dval> tmp(length);
-    std::copy(constraint, constraint+length, tmp.begin());
-    for(auto it = tmp.cbegin(); it != tmp.cend(); ++it) {
-      if((*it) > SCHAR_MAX) {
-        std::cerr << "WARNING: constraint value > " << SCHAR_MAX << " behavior undefined" << std::endl;
-      }
+void Ipog::add_constraint(const int *constraint, const unsigned int length) {
+  std::vector<dval> tmp(length);
+  std::copy(constraint, constraint + length, tmp.begin());
+  for (auto it = tmp.cbegin(); it != tmp.cend(); ++it) {
+    if ((*it) > SCHAR_MAX) {
+      std::cerr << "WARNING: constraint value > " << SCHAR_MAX
+                << " behavior undefined" << std::endl;
     }
-    constraints.push_back(tmp);
   }
+  constraints.push_back(tmp);
+}
 
 inline void Ipog::ground_solutions() {
-	std::size_t solution_count = 0;
+  std::size_t solution_count = 0;
   std::vector<dval> transform_scratch(param_cache_.size(), 0);
 
   auto prev = bound_.cbefore_begin();
   auto next = bound_.begin();
   auto end = bound_.cend();
   while (next != end) {
-    if (constraint_handler->violate_constraints(*next) || has_previously_tested(*next)) {
+    if (constraint_handler->violate_constraints(*next) ||
+        has_previously_tested(*next)) {
       next = bound_.erase_after(prev);
     } else {
       transform(transform_scratch, *next);
-			solution_count++;
+      solution_count++;
       ++prev;
       ++next;
     }
   }
 
-  while(!unbound_.empty()) {
+  while (!unbound_.empty()) {
     dtest_case first = unbound_.front();
-    if(constraint_handler->ground(first)) {
-      if(!has_previously_tested(first)) {
+    if (constraint_handler->ground(first)) {
+      if (!has_previously_tested(first)) {
         transform(transform_scratch, first);
         solution_count++;
         bound_.push_front(first);
@@ -413,72 +413,77 @@ inline void Ipog::ground_solutions() {
     }
     unbound_.pop_front();
   }
-	solution_size = solution_count;
-  }
+  solution_size = solution_count;
+}
 
 void Ipog::fill(int *solution) {
   std::size_t i = 0;
-  for(auto it = bound_.cbegin(); it != bound_.cend(); ++it) {
-    for(auto iit = (*it).cbegin(); iit != (*it).cend(); ++iit, i++) {
+  for (auto it = bound_.cbegin(); it != bound_.cend(); ++it) {
+    for (auto iit = (*it).cbegin(); iit != (*it).cend(); ++iit, i++) {
       solution[i] = *iit;
     }
   }
 }
 
 void Ipog::add_previously_tested(const int values[], const std::size_t length) {
-	std::vector<dval> tmp(length);
-	std::copy(values, values+length, tmp.begin());
-	original_previously_tested_.push_back(tmp);
+  std::vector<dval> tmp(length);
+  std::copy(values, values + length, tmp.begin());
+  original_previously_tested_.push_back(tmp);
 }
 
-  inline bool Ipog::has_previously_tested(std::vector<param*>& test_case) {
-    for(auto it = previously_tested_.cbegin(); it != previously_tested_.cend(); ++it) {
-      bool flag = true;
-      for(auto iit = test_case.cbegin(); iit != test_case.cend(); ++iit) {
-        if((*it)[(*iit)->first] != (*iit)->second) {
-          flag = false;
-          break;
-        }
-      }
-      if(flag) {
-        return true;
+inline bool Ipog::has_previously_tested(std::vector<param *> &test_case) {
+  for (auto it = previously_tested_.cbegin(); it != previously_tested_.cend();
+       ++it) {
+    bool flag = true;
+    for (auto iit = test_case.cbegin(); iit != test_case.cend(); ++iit) {
+      if ((*it)[(*iit)->first] != (*iit)->second) {
+        flag = false;
+        break;
       }
     }
-    return false;
+    if (flag) {
+      return true;
+    }
   }
+  return false;
+}
 
-  inline bool Ipog::has_previously_tested(param **params) {
-    for(auto it = previously_tested_.cbegin(); it != previously_tested_.cend(); ++it) {
-      bool flag = true;
-      for(std::size_t i = 0; i < t_; i++) {
-        const param *iit = params[i];
-        if((*it)[iit->first] != iit->second) {
-          flag = false;
-          break;
-        }
-      }
-      if(flag) {
-        return true;
+inline bool Ipog::has_previously_tested(param **params) {
+  for (auto it = previously_tested_.cbegin(); it != previously_tested_.cend();
+       ++it) {
+    bool flag = true;
+    for (std::size_t i = 0; i < t_; i++) {
+      const param *iit = params[i];
+      if ((*it)[iit->first] != iit->second) {
+        flag = false;
+        break;
       }
     }
-    return false;
+    if (flag) {
+      return true;
+    }
   }
+  return false;
+}
 
-  inline bool Ipog::has_previously_tested(dtest_case& test_case) {
-    for(auto it = previously_tested_.cbegin(); it != previously_tested_.cend(); ++it) {
-      if(std::equal(test_case.cbegin(), test_case.cend(), (*it).cbegin())) {
-        return true;
-      }
+inline bool Ipog::has_previously_tested(dtest_case &test_case) {
+  for (auto it = previously_tested_.cbegin(); it != previously_tested_.cend();
+       ++it) {
+    if (std::equal(test_case.cbegin(), test_case.cend(), (*it).cbegin())) {
+      return true;
     }
-    return false;
   }
+  return false;
+}
 
-  inline bool Ipog::has_previously_tested(const int k, dtest_case& test_case) {
-    for(auto it = previously_tested_.cbegin(); it != previously_tested_.cend(); ++it) {
-      if(std::equal(test_case.cbegin(), test_case.cbegin()+k, (*it).cbegin())) {
-        return true;
-      }
+inline bool Ipog::has_previously_tested(const int k, dtest_case &test_case) {
+  for (auto it = previously_tested_.cbegin(); it != previously_tested_.cend();
+       ++it) {
+    if (std::equal(test_case.cbegin(), test_case.cbegin() + k,
+                   (*it).cbegin())) {
+      return true;
     }
-    return false;
   }
+  return false;
+}
 }

data/ext/dither/ipog.h

@@ -39,23 +39,24 @@ class Ipog {
   std::unordered_map<std::string, int> param_index_;
   std::unordered_map<int, std::string> reverse_param_index_;
   dtest_case merge_scratch_;
-  BaseConstraintHandler* constraint_handler;
+  BaseConstraintHandler *constraint_handler;
   std::vector<std::vector<dval>> constraints;
   std::vector<dval> ranges;
-	std::size_t solution_size;
-	std::vector<std::vector<dval>> original_previously_tested_;
-	std::vector<std::vector<dval>> previously_tested_;
+  std::size_t solution_size;
+  std::vector<std::vector<dval>> original_previously_tested_;
+  std::vector<std::vector<dval>> previously_tested_;
 
-  inline void transform(std::vector<dval>& scratch, std::vector<dval>& test_case) {
-    for(std::size_t i = 0; i < test_case.size(); i++) {
+  inline void transform(std::vector<dval> &scratch,
+                        std::vector<dval> &test_case) {
+    for (std::size_t i = 0; i < test_case.size(); i++) {
       scratch[ordered_param_index_[i]] = test_case[i];
     }
     std::copy(scratch.cbegin(), scratch.cend(), test_case.begin());
   }
 
-  inline bool has_previously_tested(std::vector<param*>& test_case);
-  inline bool has_previously_tested(dtest_case& test_case);
-  inline bool has_previously_tested(const int, dtest_case& test_case);
+  inline bool has_previously_tested(std::vector<param *> &test_case);
+  inline bool has_previously_tested(dtest_case &test_case);
+  inline bool has_previously_tested(const int, dtest_case &test_case);
   inline bool has_previously_tested(param **params);
 
  public:
@@ -64,7 +65,8 @@ class Ipog {
   Ipog(const unsigned int);
   void set_t(const unsigned int t) { t_ = t; }
   void add_parameter(const std::string, const int[], const unsigned int);
-  void add_parameter(const std::string, const std::string[], const unsigned int);
+  void add_parameter(const std::string, const std::string[],
+                     const unsigned int);
   void add_parameter(const std::string);
   void init_bound();
   void init_param_cache();
@@ -73,18 +75,17 @@ class Ipog {
   std::string *header();
   inline void ground_solutions();
   inline bool is_valid() { return t_ <= param_cache_.size(); }
-  inline param** cover(int,std::forward_list<param**>&);
+  inline param **cover(int, std::forward_list<param **> &);
   inline const int maximize_coverage(const int, dtest_case &,
-                              std::forward_list<param**> &);
+                                     std::forward_list<param **> &);
   void add_constraint(const int[], const unsigned int);
-	void add_previously_tested(const int[], const std::size_t);
+  void add_previously_tested(const int[], const std::size_t);
+  inline bool is_covered(const dtest_case &test_case, param **params);
+  inline bool is_covered(const param **params);
   inline bool is_covered(const dtest_case &test_case,
-                         param** params);
-  inline bool is_covered(const param** params);
-  inline bool is_covered(const dtest_case &test_case,
-                         const std::vector<param*> &params);
+                         const std::vector<param *> &params);
   inline bool is_covered(const std::vector<param> &params);
-  inline const int merge(const int, dtest_case &, param**);
+  inline const int merge(const int, dtest_case &, param **);
   void display_raw_solution();
   void fill(int[]);
   inline void display_header() {
@@ -107,7 +108,8 @@ class Ipog {
         }
         continue;
       }
-      const param my_param = param_cache_[reverse_ordered_param_index_[i]][value];
+      const param my_param =
+          param_cache_[reverse_ordered_param_index_[i]][value];
       switch (my_param.type) {
         case DITHER_INT_T:
           std::cout << int_params_[my_param.name][my_param.second];
@@ -127,7 +129,6 @@ class Ipog {
     std::cout << std::endl;
   }
 };
-
 }
 
 #endif

data/ext/dither/simple_constraint_handler.cc

@@ -12,106 +12,118 @@
 
 namespace dither {
 
-  SimpleConstraintHandler::SimpleConstraintHandler(std::vector<dval>& ranges, std::vector<std::vector<dval>>& pconstraints) : params(ranges), scratch(ranges.size(), -1) {
-    for(auto it = pconstraints.cbegin(); it != pconstraints.cend(); ++it) {
-      std::vector<std::pair<std::size_t, dval>> constraint;
-      std::size_t i = 0;
-      for(auto iit = (*it).cbegin(); iit != (*it).cend(); ++iit, i++) {
-        if((*iit) != -1) {
-          constraint.push_back(std::make_pair(i, *iit));
-        }
+SimpleConstraintHandler::SimpleConstraintHandler(
+    std::vector<dval>& ranges, std::vector<std::vector<dval>>& pconstraints)
+    : params(ranges), scratch(ranges.size(), -1) {
+  for (auto it = pconstraints.cbegin(); it != pconstraints.cend(); ++it) {
+    std::vector<std::pair<std::size_t, dval>> constraint;
+    std::size_t i = 0;
+    for (auto iit = (*it).cbegin(); iit != (*it).cend(); ++iit, i++) {
+      if ((*iit) != -1) {
+        constraint.push_back(std::make_pair(i, *iit));
       }
-      constraints.push_back(constraint);
     }
-    std::sort(constraints.begin(), constraints.end(), [](std::vector<std::pair<std::size_t, dval>>& a, std::vector<std::pair<std::size_t, dval>>& b) { return a.size() < b.size(); });
+    constraints.push_back(constraint);
+  }
+  std::sort(constraints.begin(), constraints.end(),
+            [](const std::vector<std::pair<std::size_t, dval>>& a,
+               const std::vector<std::pair<std::size_t, dval>>& b) {
+              return a.size() < b.size();
+            });
+}
+
+bool SimpleConstraintHandler::violate_constraints(const dtest_case& test_case) {
+  if (violate_constraints_(test_case)) {
+    return true;
   }
+  std::copy(test_case.cbegin(), test_case.cend(), scratch.begin());
+  return !ground(scratch);
+}
 
-  bool SimpleConstraintHandler::violate_constraints(const dtest_case &test_case) {
-    if(violate_constraints_(test_case)) {
+inline bool SimpleConstraintHandler::violate_constraints_(
+    const dtest_case& test_case) {
+  for (auto constraint = constraints.cbegin(); constraint != constraints.cend();
+       ++constraint) {
+    if (violate_constraint(test_case, *constraint)) {
       return true;
     }
-    std::copy(test_case.cbegin(), test_case.cend(), scratch.begin());
-    return !ground(scratch);
   }
+  return false;
+}
 
-  inline bool SimpleConstraintHandler::violate_constraints_(const dtest_case &test_case) {
-    for(auto constraint = constraints.cbegin(); constraint != constraints.cend(); ++constraint) {
-      if(violate_constraint(test_case, *constraint)) {
-        return true;
-      }
+inline bool SimpleConstraintHandler::violate_constraint(
+    const dtest_case& test_case,
+    const std::vector<std::pair<std::size_t, dval>>& constraint) {
+  for (auto it = constraint.cbegin(); it != constraint.cend(); ++it) {
+    auto value = test_case[(*it).first];
+    if (value == -1 || value != (*it).second) {
+      return false;
     }
-    return false;
   }
+  return true;
+}
 
-  inline bool SimpleConstraintHandler::violate_constraint(const dtest_case& test_case, const std::vector<std::pair<std::size_t, dval>>& constraint) {
-    for(auto it = constraint.cbegin(); it != constraint.cend(); ++it) {
-      auto value = test_case[(*it).first];
-      if(value == -1 || value != (*it).second) {
-        return false;
-      }
-    }
+bool SimpleConstraintHandler::violate_constraints(param** test_case,
+                                                  const std::size_t length) {
+  std::fill(scratch.begin(), scratch.end(), -1);
+  for (std::size_t i = 0; i < length; i++) {
+    const param* p = test_case[i];
+    scratch[p->first] = p->second;
+  }
+  if (violate_constraints_(scratch)) {
     return true;
   }
+  return !ground(scratch);
+}
 
-  bool SimpleConstraintHandler::violate_constraints(param** test_case, const std::size_t length) {
-    std::fill(scratch.begin(), scratch.end(), -1);
-    for(std::size_t i = 0; i < length; i++) {
-      const param *p = test_case[i];
-      scratch[p->first] = p->second;
-    }
-    if(violate_constraints_(scratch)) {
-      return true;
-    }
-    return !ground(scratch);
+bool SimpleConstraintHandler::violate_constraints(
+    const std::vector<param*>& test_case) {
+  std::fill(scratch.begin(), scratch.end(), -1);
+  for (auto p : test_case) {
+    scratch[p->first] = p->second;
+  }
+  if (violate_constraints_(scratch)) {
+    return true;
   }
+  return !ground(scratch);
+}
 
-  bool SimpleConstraintHandler::violate_constraints(const std::vector<param*> &test_case) {
-    std::fill(scratch.begin(), scratch.end(), -1);
-    for(auto p : test_case) {
-      scratch[p->first] = p->second;
-    }
-    if(violate_constraints_(scratch)) {
-      return true;
+bool SimpleConstraintHandler::ground(dtest_case& test_case) {
+  std::vector<std::size_t> indexes;
+
+  // find unbound indexes
+  std::size_t i = 0;
+  for (auto it = test_case.begin(); it != test_case.end(); ++it, i++) {
+    if ((*it) == -1) {
+      indexes.push_back(i);
     }
-    return !ground(scratch);
   }
+  std::vector<dval> bound_values(indexes.size(), -1);
+  i = 0;
 
-  bool SimpleConstraintHandler::ground(dtest_case &test_case) {
-    std::vector<std::size_t> indexes;
-
-    // find unbound indexes
-    std::size_t i = 0;
-    for (auto it = test_case.begin(); it != test_case.end(); ++it, i++) {
-      if ((*it) == -1) {
-        indexes.push_back(i);
+LOOP:
+  while (i < indexes.size()) {
+    const dval max = params[indexes[i]];
+    for (dval value = bound_values[i] + 1; value <= max; value++) {
+      test_case[indexes[i]] = value;
+      if (violate_constraints_(test_case)) {
+        continue;
       }
+      bound_values[i] = value;
+      i++;
+      goto LOOP;
     }
-    std::vector<dval> bound_values(indexes.size(), -1);
-    i = 0;
-
-LOOP:while(i < indexes.size()) {
-
-       const dval max = params[indexes[i]];
-       for(dval value = bound_values[i] + 1; value <= max; value++) {
-         test_case[indexes[i]] = value;
-         if(violate_constraints_(test_case)) {
-           continue;
-         }
-         bound_values[i] = value;
-         i++;
-         goto LOOP;
-       }
-
-       if(i == 0) {
-         return false;
-       }
 
-       // unwind
-       bound_values[i] = -1;
-       test_case[indexes[i]] = -1;
-       i--;
-     }
+    if (i == 0) {
+      return false;
+    }
 
-     return true;
+    // unwind
+    bound_values[i] = -1;
+    test_case[indexes[i]] = -1;
+    i--;
   }
+
+  return true;
+}
 }

data/ext/dither/simple_constraint_handler.h

@@ -18,23 +18,25 @@
 
 namespace dither {
 
-  class SimpleConstraintHandler : public BaseConstraintHandler {
-    protected:
-      std::vector<std::vector<std::pair<std::size_t, dval>>> constraints;
-      std::vector<dval> params;
-      std::vector<dval> scratch;
-
-      inline bool violate_constraint(const dtest_case& test_case, const std::vector<std::pair<std::size_t, dval>>& constraint);
-      inline bool violate_constraints_(const dtest_case &test_case);
-
-    public:
-      SimpleConstraintHandler(std::vector<dval>& ranges, std::vector<std::vector<dval>>& pconstraints);
-      bool violate_constraints(const dtest_case &test_case);
-      bool violate_constraints(const std::vector<param*> &test_case);
-      bool violate_constraints(param** test_case, const std::size_t length);
-      bool ground(dtest_case &test_case);
-  };
+class SimpleConstraintHandler : public BaseConstraintHandler {
+ protected:
+  std::vector<std::vector<std::pair<std::size_t, dval>>> constraints;
+  std::vector<dval> params;
+  std::vector<dval> scratch;
+
+  inline bool violate_constraint(
+      const dtest_case& test_case,
+      const std::vector<std::pair<std::size_t, dval>>& constraint);
+  inline bool violate_constraints_(const dtest_case& test_case);
+
+ public:
+  SimpleConstraintHandler(std::vector<dval>& ranges,
+                          std::vector<std::vector<dval>>& pconstraints);
+  bool violate_constraints(const dtest_case& test_case);
+  bool violate_constraints(const std::vector<param*>& test_case);
+  bool violate_constraints(param** test_case, const std::size_t length);
+  bool ground(dtest_case& test_case);
+};
 }
 
 #endif  // SIMPLE_CONSTRAINT_HANDLER_H_
-

data/lib/dither/version.rb

@@ -1,4 +1,4 @@
 
 module Dither
-  VERSION = '0.2.5'
+  VERSION = '0.2.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dither
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Jason Gowan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-28 00:00:00.000000000 Z
+date: 2016-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec