ipog.rb in dither-0.0.6

- old
+ new

@@ -1,76 +1,11 @@
 # coding: utf-8
 
 module Dither
   class IPOG
-    attr_reader :params, :t, :constraints, :test_set, :orig_params, :unbound_param_pool
-    private :params, :t, :constraints, :test_set, :orig_params
+    include IPOGHelper
 
-    def initialize(params, t, opts = {})
-      init_params(params)
-      @t = t
-      unless opts[:constraints].nil?
-        @constraints = opts[:constraints].map(&:to_a)
-                       .map { |a| a.map { |b| @params[@map_to_orig_index.key(b[0])][b[1]] } }
-                       .map(&:to_set)
-      end
-
-      raise 't must be >= 2' if t < 2
-      raise 't must be <= params.length' if t > params.length
-      params.each do |param|
-        raise 'param length must be > 1' if param.length < 2
-      end
-    end
-
-    def init_params(user_params)
-      tmp = []
-      user_params.each_with_index { |e, i| tmp << [i, e] }
-      @orig_params = tmp.sort_by { |a| a[1].length }
-                     .reverse!
-
-      @map_to_orig_index = {}
-      @orig_params.each_with_index do |e, i|
-        @map_to_orig_index[i] = e[0]
-      end
-
-      @params = []
-      @unbound_param_pool = []
-      orig_params.each_with_index do |e, i|
-        @params << (0...e[1].length).map { |j| Param.new(i, j) }
-        @unbound_param_pool << UnboundParam.new(i)
-      end
-      params
-    end
-
-    # return nil if unable to satisfy constraints
-    def maximize_coverage(i, test_case, pi)
-      current_max = 0
-      current_max_j = 0
-      current_matches = []
-
-      (0...params[i].length).each do |j|
-        current_param = params[i][j]
-        test_case << current_param
-        unless violates_constraints?(test_case)
-          matches = pi.select { |a| a.subset?(test_case) }
-          count = matches.count
-
-          if count > current_max
-            current_max = count
-            current_max_j = j
-            current_matches = matches
-          end
-        end
-        test_case.delete(current_param)
-      end
-
-      test_case << params[i][current_max_j]
-      return nil if violates_constraints?(test_case)
-
-      current_matches
-    end
-
     def run
       # add into test set a test for each combination of values
       # of the first t parameter
       test_set = comb
 
@@ -92,11 +27,11 @@
           end
         end
 
         # vertical extension for parameter i
         pi.each do |a|
-          if test_set.any? { |test_case| a.subset?(test_case) }
+          if test_set.any? { |b| a.subset?(b) }
             pi.delete(a)
           else
 
             test_case = nil
             test_set.each do |b|
@@ -112,87 +47,12 @@
             pi.delete(a)
           end
         end
       end
 
-      test_set.map { |a| fill_unbound(a) }
+      @test_set = test_set.map { |a| fill_unbound(a) }
         .delete_if(&:nil?)
         .to_a
+      @test_set
     end
-
-    def violates_constraints?(params)
-      return false if constraints.nil?
-      constraints.any? { |b| b.subset?(params) }
-    end
-
-    def comb
-      ranges = (0...t).to_a.inject([]) do |a, i|
-        a << (0...params[i].length).map { |j| params[i][j] }
-      end
-
-      products = ranges[1..-1].inject(ranges[0]) do |a, b|
-        a = a.product(b)
-      end
-
-      products.map(&:flatten)
-        .map { |a| TestCase.create(params, unbound_param_pool, a) }
-    end
-
-    def comb_i(param_i)
-      values = (0...param_i).to_a.combination((t-1)).to_a
-      values.each do |a|
-        a << param_i
-      end
-      result = []
-      values.each do |a|
-        result += a[1..-1]
-                 .inject((0...params[a[0]].length).map { |b| params[0][b] }) { |p, i| p.product((0...params[i].length).to_a.map { |b| params[i][b] }) }
-                 .map(&:flatten)
-                 .map { |a| TestCase.create(params, unbound_param_pool, a) }
-      end
-      result
-    end
-
-    private
-
-    def fill_unbound(data)
-      arr = Array.new(params.length)
-      data.each do |param|
-        unless param.unbound?
-          orig_param = orig_params[param.i]
-          arr[orig_param[0]] = orig_param[1][param.j]
-        end
-      end
-
-      arr.each_with_index do |e, i|
-        if e.nil?
-          j = 0
-          orig_param = orig_params.find { |a| a[0] = i }
-          arr[i] = orig_param[1][j]
-        end
-      end
-
-      return nil if violates_constraints?(data)
-      arr
-    end
-
-    def find_unbound(param_array, stuff)
-      data = {}
-      stuff.each do |param|
-        data[param.i] = param.j
-      end
-
-      unbound = []
-      param_array.each do |param|
-        case data[param.i]
-        when param.j
-        when nil
-          unbound << param
-        else
-          unbound = nil
-          break
-        end
-      end
-      unbound
-    end
-  end
-end
+  end # IPOG
+end # Dither