dither 0.1.5 → 0.2.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5cf3d06107ff71720bd301a055f17e297b1fc9dc
-  data.tar.gz: 97aba2dba84f7df46c605bbe3d6a8cc42677ebdf
+  metadata.gz: 378d5b7748d2b3993ef979f2e0ecc1e7f2f1866a
+  data.tar.gz: 6c3159e8073600044df182be4bd6dc201c9f45a1
 SHA512:
-  metadata.gz: acfe4787ee9c06fb27627cfb5af193c8e134433566a4dc336b384da8ff4275da0dea01134a204cb847e9172b674daaea8bed42dab1e0072b33bb284c28b545cb
-  data.tar.gz: e46899b9ee779cb56e67579a75eedde2595d46eabe97a7c55f4fa6c9be549c7a35be4936b569c00846a4c4bc6aabd8c04b4f3c16b0b13beca6954eb32509cebe
+  metadata.gz: 8ac2ff8f4c0110f4a3b5d81e361bb52c568eccb7bc32cb28a7eed55f0f36ae7f7b2f1689804c4ed5a4c2cddec162c3946fa8bc995980e1f9968b606368e132b3
+  data.tar.gz: 6c4cc50f3da60255d6f1065506a8d1b2a2d0b601e96af11d3f664ee2374c08bd06c2bbc40006c2403308d021dd84d96d15f8cb83a11be9e51d4663c52ef88dab

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    dither (0.1.4)
+    dither (0.1.5)
+      ffi (~> 1.0)
 
 GEM
   remote: https://rubygems.org/
@@ -14,10 +15,13 @@ GEM
       thor
     diff-lcs (1.2.5)
     docile (1.1.5)
+    ffi (1.9.6)
     mime-types (2.3)
     multi_json (1.10.1)
     netrc (0.7.7)
     rake (0.9.6)
+    rake-compiler (0.9.5)
+      rake
     rest-client (1.7.2)
       mime-types (>= 1.16, < 3.0)
       netrc (~> 0.7)
@@ -52,4 +56,5 @@ DEPENDENCIES
   coveralls
   dither!
   rake (~> 0.9.2)
+  rake-compiler
   rspec (~> 3.2)

data/README.md

@@ -1,6 +1,9 @@
 # Dither
 Collection of combinatorial test generation strategies.
 
+# Requirements
+a c++ compiler is required when installing on mri.
+
 # Usage
 
 ## Pairwise Testing

data/Rakefile

@@ -1,7 +1,11 @@
 require 'bundler'
+
 Bundler::GemHelper.install_tasks
 
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new
 
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('dither')
+
 task :default => :spec

data/dither.gemspec

@@ -16,6 +16,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency "rspec", "~> 3.2"
   s.add_development_dependency "rake", "~> 0.9.2"
+  s.add_development_dependency "rake-compiler"
   s.add_development_dependency "coveralls"
 
   files         = `git ls-files`.split("\n")
@@ -25,6 +26,9 @@ Gem::Specification.new do |s|
     # compile dither-java on jdk 8
     files << "lib/dither-0.1.3.jar"
     files << "lib/choco-solver-3.3.1-with-dependencies.jar"
+	else
+		s.add_dependency "ffi", "~> 1.0"
+		s.extensions = 'ext/dither/extconf.rb'
   end
   s.files = files
 

data/ext/dither/README.md

@@ -0,0 +1,2 @@
+
+sources copied from [dither-cxx](https://github.com/jesg/dither-cxx)

data/ext/dither/base_constraint_handler.h

@@ -0,0 +1,36 @@
+/*
+ *
+ * Copyright (C) 2015 Jason Gowan
+ * All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the BSD license.  See the LICENSE file for details.
+ */
+
+#ifndef BASE_CONSTRAINT_HANDLER_H_
+#define BASE_CONSTRAINT_HANDLER_H_
+
+#include <vector>
+#include "dither_types.h"
+
+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;
+      }
+      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;
+      }
+  };
+}
+#endif  // BASE_CONSTRAINT_HANDLER_H_

data/ext/dither/combinations.h

@@ -0,0 +1,127 @@
+/*
+ *
+ * Copyright (C) 2015 Jason Gowan
+ * All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the BSD license.  See the LICENSE file for details.
+ */
+
+#ifndef COMBINATIONS_H_
+#define COMBINATIONS_H_
+
+#include <vector>
+#include <forward_list>
+#include "dither_types.h"
+
+namespace dither {
+
+inline void product(
+    std::forward_list<dtest_case>& rvvi,           // final result
+    dtest_case& rvi,                               // current result
+    std::vector<dtest_case>::const_iterator me,    // current input
+    std::vector<dtest_case>::const_iterator end);  // final input
+
+inline void product2(
+    std::forward_list<std::vector<param>>& rvvi,           // final result
+    std::vector<param>& rvi,                               // current result
+    std::vector<std::vector<param>>::const_iterator me,    // current input
+    std::vector<std::vector<param>>::const_iterator end);  // final input
+
+inline void gcombinations_(const std::vector<int>&, std::vector<int>&,
+                           std::forward_list<std::vector<int>>&);
+
+inline void combinations(const int, const std::vector<int>&,
+                         std::forward_list<std::vector<int>>&);
+
+inline void product2(
+    std::forward_list<std::vector<param>>& rvvi,          // final result
+    std::vector<param>& rvi,                              // current result
+    std::vector<std::vector<param>>::const_iterator me,   // current input
+    std::vector<std::vector<param>>::const_iterator end)  // final input
+{
+  if (me == end) {
+    // terminal condition of the recursion. We no longer have
+    // any input vectors to manipulate. Add the current result (rvi)
+    // to the total set of results (rvvvi).
+    rvvi.push_front(rvi);
+    return;
+  }
+
+  // need an easy name for my vector-of-ints
+  const std::vector<param>& mevi = *me;
+  for (std::vector<param>::const_iterator it = mevi.begin(); it != mevi.end();
+       it++) {
+    // final rvi will look like "a, b, c, ME, d, e, f"
+    // At the moment, rvi already has "a, b, c"
+    rvi.push_back(*it);                // add ME
+    product2(rvvi, rvi, me + 1, end);  // add "d, e, f"
+    rvi.pop_back();                    // clean ME off for next round
+  }
+}
+
+void combinations(const int n, const std::vector<int>& input,
+                  std::forward_list<std::vector<int>>& output) {
+  std::vector<int> scratch(n);
+
+  if (n <= input.size()) {
+    for (int i = 0; i < n; i++) {
+      scratch[i] = i;
+    }
+
+    gcombinations_(input, scratch, output);
+    while (1) {
+      int i;
+      for (i = n - 1; (i >= 0) && (scratch[i] == (input.size() - n + i)); i--)
+        ;
+
+      if (i < 0) {
+        break;
+      } else {
+        scratch[i]++;
+        for (++i; i < n; i++) {
+          scratch[i] = scratch[i - 1] + 1;
+        }
+        gcombinations_(input, scratch, output);
+      }
+    }
+  }
+}
+
+inline void gcombinations_(const std::vector<int>& input,
+                           std::vector<int>& scratch,
+                           std::forward_list<std::vector<int>>& output) {
+  std::vector<int> result(scratch.size());
+  for (std::size_t i = 0; i < result.size(); i++) {
+    result[i] = input[scratch[i]];
+  }
+  output.push_front(result);
+}
+
+inline void product(
+    std::forward_list<dtest_case>& rvvi,          // final result
+    dtest_case& rvi,                              // current result
+    std::vector<dtest_case>::const_iterator me,   // current input
+    std::vector<dtest_case>::const_iterator end)  // final input
+{
+  if (me == end) {
+    // terminal condition of the recursion. We no longer have
+    // any input vectors to manipulate. Add the current result (rvi)
+    // to the total set of results (rvvvi).
+    rvvi.push_front(rvi);
+    return;
+  }
+
+  // need an easy name for my vector-of-ints
+  const dtest_case& mevi = *me;
+  for (dtest_case::const_iterator it = mevi.begin(); it != mevi.end(); it++) {
+    // final rvi will look like "a, b, c, ME, d, e, f"
+    // At the moment, rvi already has "a, b, c"
+    rvi.push_back(*it);               // add ME
+    product(rvvi, rvi, me + 1, end);  // add "d, e, f"
+    rvi.pop_back();                   // clean ME off for next round
+  }
+}
+}
+
+#endif

data/ext/dither/dither.cc

@@ -0,0 +1,47 @@
+/*
+ *
+ * Copyright (C) 2015 Jason Gowan
+ * All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the BSD license.  See the LICENSE file for details.
+ */
+
+#include "dither.h"
+
+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);
+}
+
+void dither_ipog_add_parameter_int(ipog_handle self, const int index,
+                                   const int *values, const int values_length) {
+  const std::string name = std::to_string(index);
+  static_cast<dither::Ipog *>(self)->add_parameter(name, values, values_length);
+}
+
+void dither_ipog_run(ipog_handle self) {
+  static_cast<dither::Ipog *>(self)->init_param_cache();
+  static_cast<dither::Ipog *>(self)->run();
+}
+
+int dither_ipog_size(ipog_handle self) {
+  return static_cast<dither::Ipog *>(self)->size();
+}
+
+void dither_ipog_display_raw_solution(ipog_handle self) {
+  static_cast<dither::Ipog *>(self)->display_raw_solution();
+}
+
+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) {
+  static_cast<dither::Ipog *>(self)->add_constraint(constraint, 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

@@ -0,0 +1,31 @@
+/*
+ *
+ * Copyright (C) 2015 Jason Gowan
+ * All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the BSD license.  See the LICENSE file for details.
+ */
+
+#ifndef DITHER_H_
+#define DITHER_H_
+
+#include <string>
+#include "ipog.h"
+
+extern "C" {
+
+typedef void* ipog_handle;
+
+ipog_handle dither_ipog_new(const unsigned int);
+void dither_ipog_add_parameter_int(ipog_handle, const int, const int[],
+                                   const int);
+void dither_ipog_run(ipog_handle);
+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 );
+}
+#endif  // DITHER_H_

data/ext/dither/dither_types.h

@@ -0,0 +1,32 @@
+/*
+ *
+ * Copyright (C) 2015 Jason Gowan
+ * All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the BSD license.  See the LICENSE file for details.
+ */
+
+#ifndef DITHER_TYPES_H_
+#define DITHER_TYPES_H_
+
+#include <string>
+
+namespace dither {
+
+typedef signed char dval;
+
+#define DITHER_BOOL_T 0
+#define DITHER_INT_T 1
+#define DITHER_STRING_T 2
+
+struct param {
+  std::size_t first;
+  dval second;
+  std::string name;
+  unsigned char type;
+};
+typedef std::vector<dval> dtest_case;
+}
+
+#endif

data/ext/dither/extconf.rb

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