dither 0.2.2 → 0.2.5

data/ext/dither/Pair.java

@@ -0,0 +1,61 @@
+package com.github.jesg.dither;
+
+/*
+ * #%L
+ * dither
+ * %%
+ * Copyright (C) 2015 Jason Gowan
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * #L%
+ */
+
+class Pair {
+    final int i;
+    final int j;
+
+    Pair(final int i, final int j) {
+        this.i = i;
+        this.j = j;
+    }
+
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + i;
+        result = prime * result + j;
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        Pair other = (Pair) obj;
+        if (j != other.j)
+            return false;
+        if (i != other.i)
+            return false;
+        return true;
+    }
+
+    public String toString() {
+        return "Pair i: " + i + " j: " + j;
+    }
+}

data/ext/dither/base_constraint_handler.h

@@ -20,7 +20,10 @@ namespace dither {
       BaseConstraintHandler(){};
       virtual ~BaseConstraintHandler(){};
       virtual bool violate_constraints(const dtest_case &test_case) { return false; }
-      virtual bool violate_constraints(const std::vector<param> &test_case) {
+      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) {

data/ext/dither/combinations.h

@@ -12,6 +12,8 @@
 
 #include <vector>
 #include <forward_list>
+#include <algorithm>
+#include <memory>
 #include "dither_types.h"
 
 namespace dither {
@@ -157,33 +159,40 @@ inline void product3(
   }
 }
 
-inline void product4(
-    std::forward_list<std::vector<param>>& results,
-    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::vector<param> scratch;
-  for(auto params : param_matrix) {
-    ranges.push_back(params.size() - 1);
-    scratch.push_back(params[0]);
+  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++) {
+    ranges.push_back(param_matrix[j]->size() - 1);
+    scratch[j] = &(*param_matrix[j])[0];
   }
-  std::vector<int> indexes(scratch.size(), 0);
+  std::vector<int> indexes(ranges.size(), 0);
 
   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++) {
-        scratch[i] = param_matrix[i][indexes[i]];
-        results.push_front(scratch);
+        scratch[i] = &(*param_matrix[i])[indexes[i]];
+        std::copy(scratch, scratch+length, param_cache);
+        results.push_front(param_cache);
+        param_cache += length;
         indexes[i]++;
+				j++;
       }
       indexes[i] = 0;
       i--;
     } else if(i == 0 && indexes[i] >= ranges[i]) {
-      return;
+      return j;
     } else if(indexes[i] < ranges[i]) {
       indexes[i]++;
-      scratch[i] = param_matrix[i][indexes[i]];
+      scratch[i] = &(*param_matrix[i])[indexes[i]];
       i++;
     } else {
       indexes[i] = -1;

data/ext/dither/ipog.cc

@@ -14,6 +14,7 @@
 #include <tuple>
 #include <limits.h>
 #include <cstddef>
+#include <memory>
 
 namespace dither {
 
@@ -27,9 +28,7 @@ Ipog::Ipog() {
   t_ = 2;
 }
 
-Ipog::Ipog(const unsigned int t) {
-  t_ = t;
-}
+Ipog::Ipog(const unsigned int t) : t_(t) {}
 
 void Ipog::init_bound() {
   using dither::product3;
@@ -56,7 +55,7 @@ void Ipog::init_bound() {
   }
 }
 
-std::forward_list<std::vector<param>> Ipog::cover(const int k) {
+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;
@@ -64,30 +63,35 @@ std::forward_list<std::vector<param>> Ipog::cover(const int k) {
 
   std::forward_list<std::vector<int>> output;
   combinations(t_ - 1, input, output);
-  std::forward_list<std::vector<std::vector<param>>> product_input;
-  const std::vector<param> k_param = param_cache_[k];
+  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) {
-      auto vals = param_cache_[*iit];
-      param_tuple.push_back(vals);
+      param_tuple.push_back(&param_cache_[*iit]);
+      inner_count *= param_cache_[*iit].size();
     }
+    count += inner_count;
     product_input.push_front(param_tuple);
   }
 
-  std::forward_list<std::vector<param>> coverage;
+  param **local_param_cache = new param*[count*t_];
+  std::size_t j = 0;
   for (auto it = product_input.begin(); it != product_input.end(); ++it) {
-    product4(coverage, *it);
+    j += t_*product4(coverage, local_param_cache+j, *it);
   }
-  coverage.remove_if([this](std::vector<param>& a) { return has_previously_tested(a); });
-  return coverage;
+  coverage.remove_if([this](param **a) { return has_previously_tested(a); });
+  return local_param_cache;
 }
 
 void Ipog::run() {
   init_bound();
   for (auto k = t_; k < input_params_.size(); k++) {
-    std::forward_list<std::vector<param>> pi = cover(k);
+    std::forward_list<param**> pi;
+    param **params = cover(k, pi);
+    std::unique_ptr<param*[]> params_ptr(params);
 
     {
       auto prev = bound_.cbefore_begin();
@@ -105,8 +109,8 @@ void Ipog::run() {
 
     /* vertical extension */
     for (auto pairs = pi.cbegin(); pairs != pi.cend(); ++pairs) {
-      const std::vector<param> &test_case = *pairs;
-      bool case_covered = constraint_handler->violate_constraints(test_case);
+      param **test_case = *pairs;
+      bool case_covered = constraint_handler->violate_constraints(test_case, t_);
 
       if(!case_covered) {
         for (auto it = unbound_.cbegin(); it != unbound_.cend(); ++it) {
@@ -125,8 +129,9 @@ void Ipog::run() {
 
           if (merge_result > 0) {
             dtest_case tmp = *next;
-            for (auto it = test_case.cbegin(); it != test_case.cend(); ++it) {
-              tmp[(*it).first] = (*it).second;
+            for(std::size_t i = 0; i < t_; i++) {
+              const param *it = test_case[i];
+              tmp[it->first] = it->second;
             }
             is_merged = true;
             break;
@@ -135,8 +140,9 @@ void Ipog::run() {
 
         if (!is_merged) {
           dtest_case unbound_test_case(param_cache_.size(), -1);
-          for (auto it = test_case.cbegin(); it != test_case.cend(); ++it) {
-            unbound_test_case[(*it).first] = (*it).second;
+          for(std::size_t i = 0; i < t_; i++) {
+            const param *it = test_case[i];
+            unbound_test_case[it->first] = it->second;
           }
           if (!constraint_handler->violate_constraints(unbound_test_case)) {
             unbound_.push_front(unbound_test_case);
@@ -150,18 +156,20 @@ 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,
-    const std::vector<param> &pairs) {
-  for (auto it = pairs.cbegin(); it != pairs.cend(); ++it) {
-    auto value = test_case[(*it).first];
-    if (!(value == -1 || value == (*it).second)) {
+    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)) {
       return -1;
     }
   }
 
   std::copy(test_case.cbegin(), test_case.cend(), merge_scratch_.begin());
 
-  for (auto it = pairs.cbegin(); it != pairs.cend(); ++it) {
-    merge_scratch_[(*it).first] = (*it).second;
+  for(std::size_t i = 0; i < t_; i++) {
+    const param *it = pairs[i];
+    merge_scratch_[it->first] = it->second;
   }
 
   if (constraint_handler->violate_constraints(merge_scratch_)) {
@@ -178,24 +186,34 @@ inline const int Ipog::merge(const int k, dtest_case &test_case,
 }
 
 inline bool Ipog::is_covered(const dtest_case &test_case,
-    const std::vector<param> &params) {
+    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;
+    }
+  }
+  return true;
+}
+inline bool Ipog::is_covered(const dtest_case &test_case,
+    const std::vector<param*> &params) {
   for (auto param = params.cbegin(); param != params.cend(); ++param) {
-    if (test_case[(*param).first] != (*param).second) {
+    if (test_case[(*param)->first] != (*param)->second) {
       return false;
     }
   }
   return true;
 }
 
-const int Ipog::maximize_coverage(const int k, dtest_case &test_case,
-    std::forward_list<std::vector<param>> &pi) {
+inline const int Ipog::maximize_coverage(const int k, dtest_case &test_case,
+    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<std::vector<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<std::vector<param>>::iterator>
+    std::forward_list<std::forward_list<param**>::iterator>
       tmp_covered;
     const param current_param = *it;
 
@@ -203,12 +221,11 @@ const int Ipog::maximize_coverage(const int k, dtest_case &test_case,
     if (!constraint_handler->violate_constraints(test_case)) {
       int count = 0;
       auto prev = pi.before_begin();
-      for (auto params = pi.cbegin(); params != pi.cend(); ++params) {
+      for (auto params = pi.begin(); params != pi.end(); ++params, ++prev) {
         if (is_covered(test_case, *params)) {
           tmp_covered.push_front(prev);
           count++;
         }
-        ++prev;
       }
 
       if (count > current_max) {
@@ -367,7 +384,7 @@ std::string *Ipog::header() {
     constraints.push_back(tmp);
   }
 
-void Ipog::ground_solutions() {
+inline void Ipog::ground_solutions() {
 	std::size_t solution_count = 0;
   std::vector<dval> transform_scratch(param_cache_.size(), 0);
 
@@ -414,11 +431,28 @@ void Ipog::add_previously_tested(const int values[], const std::size_t length) {
 	original_previously_tested_.push_back(tmp);
 }
 
-  inline bool Ipog::has_previously_tested(std::vector<param>& test_case) {
+  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) {
+        if((*it)[(*iit)->first] != (*iit)->second) {
+          flag = false;
+          break;
+        }
+      }
+      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;
         }

data/ext/dither/ipog.h

@@ -16,6 +16,7 @@
 #include <algorithm>
 #include <string>
 #include <unordered_map>
+#include <memory>
 #include "combinations.h"
 #include "dither_types.h"
 #include "base_constraint_handler.h"
@@ -52,9 +53,10 @@ class Ipog {
     std::copy(scratch.cbegin(), scratch.cend(), test_case.begin());
   }
 
-  inline bool has_previously_tested(std::vector<param>& 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:
   Ipog();
@@ -69,17 +71,20 @@ class Ipog {
   void run();
   int size();
   std::string *header();
-  void ground_solutions();
+  inline void ground_solutions();
   inline bool is_valid() { return t_ <= param_cache_.size(); }
-  std::forward_list<std::vector<param>> cover(int);
-  const int maximize_coverage(const int, dtest_case &,
-                              std::forward_list<std::vector<param>> &);
+  inline param** cover(int,std::forward_list<param**>&);
+  inline const int maximize_coverage(const int, dtest_case &,
+                              std::forward_list<param**> &);
   void add_constraint(const int[], const unsigned int);
 	void add_previously_tested(const int[], const std::size_t);
   inline bool is_covered(const dtest_case &test_case,
-                         const std::vector<param> &params);
+                         param** params);
+  inline bool is_covered(const param** params);
+  inline bool is_covered(const dtest_case &test_case,
+                         const std::vector<param*> &params);
   inline bool is_covered(const std::vector<param> &params);
-  inline const int merge(const int, dtest_case &, const std::vector<param> &);
+  inline const int merge(const int, dtest_case &, param**);
   void display_raw_solution();
   void fill(int[]);
   inline void display_header() {

data/ext/dither/simple_constraint_handler.cc

@@ -53,10 +53,22 @@ namespace dither {
     return true;
   }
 
-  bool SimpleConstraintHandler::violate_constraints(const std::vector<param> &test_case) {
+  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;
+      scratch[p->first] = p->second;
     }
     if(violate_constraints_(scratch)) {
       return true;

data/ext/dither/simple_constraint_handler.h

@@ -30,7 +30,8 @@ namespace dither {
     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(const std::vector<param*> &test_case);
+      bool violate_constraints(param** test_case, const std::size_t length);
       bool ground(dtest_case &test_case);
   };
 }

data/lib/dither.rb

@@ -96,8 +96,7 @@ require 'dither/graph'
 
 if RUBY_PLATFORM =~ /java/
   require 'java'
-  require 'choco-solver-3.3.1-with-dependencies.jar'
-  require 'dither-0.1.5.jar'
+  require 'dither.jar'
 
   require 'dither/java_ext/dither'
 else