dither 0.1.5 → 0.2.0.rc3

data/lib/dither/mipog.rb

@@ -1,85 +0,0 @@
-# coding: utf-8
-
-module Dither
-  class MIPOG
-    include Dither::IPOGHelper
-
-    def maximize_unbound_coverage(i, test_case, pi)
-      all_unbound = test_case.unbound
-                    .map { |a| a.create_params(params[a.i].length) }
-                    .flatten
-
-      current_max = 0
-      current_max_j = 0
-      current_outer_param = all_unbound[0]
-      current_matches = []
-
-      all_unbound.each do |outer_param|
-        test_case << outer_param
-
-        (0...params[i].length).each do |j|
-          current_param = params[i][j]
-          test_case << current_param
-          count = pi.count { |a| a.subset?(test_case) }
-
-          if count > current_max
-            current_max = count
-            current_max_j = j
-            current_outer_param = outer_param
-          end
-          test_case.delete(current_param)
-        end
-        test_case.delete(outer_param)
-      end
-
-      test_case << params[i][current_max_j]
-      test_case << current_outer_param
-      test_case.delete(unbound_param_pool[current_outer_param.i])
-
-      current_matches
-    end
-
-    def run
-      # add into test set a test for each combination of values
-      # of the first t parameter
-      test_set = comb
-
-      (t...params.length).each do |i|
-        # let pi
-        # be the set of t-way combinations of values involving
-        # parameter Pi and t -1 parameters among the first i – 1
-        # parameters
-        pi = comb_i(i)
-
-        # horizontal extension for parameter i
-        test_set.each do |test_case|
-          if !test_case.contains_unbound?
-            cover = maximize_coverage(i, test_case, pi)
-          else
-            cover = maximize_unbound_coverage(i, test_case, pi)
-          end
-
-          # remove covered combinations
-          pi -= cover
-        end
-
-        # vertical extension for parameter i
-        until pi.empty?
-          pi.sort!
-          test_case, coverage = maximize_vertical_coverage(i, pi[0].dup, pi)
-          test_set << test_case.create_unbound(i)
-          pi -= coverage
-        end
-      end
-      test_set.map { |a| fill_unbound(a) }
-    end
-
-    def maximize_vertical_coverage(i, test_case, pi)
-      coverage = [pi[0]]
-      pi[1..-1].each do |a|
-        coverage << a unless test_case.merge_without_conflict(i, a).nil?
-      end
-      [test_case, coverage]
-    end
-  end # MIPOG
-end # Dither

data/lib/dither/param.rb

@@ -1,19 +0,0 @@
-
-module Dither
-  Param = Struct.new(:i, :j) do
-    def <=>(param)
-      return 1 if param.unbound?
-
-      a = i <=> param.i
-      if a == 0
-        return j <=> param.j
-      else
-        return a
-      end
-    end
-
-    def unbound?
-      false
-    end
-  end # Param
-end # Dither

data/lib/dither/test_case.rb

@@ -1,80 +0,0 @@
-
-module Dither
-  class TestCase < Set
-
-    attr_accessor :bound_param_pool, :unbound_param_pool
-
-    def self.create(bound_param_pool, unbound_param_pool, params)
-      test_case = TestCase.new(params)
-      test_case.bound_param_pool = bound_param_pool
-      test_case.unbound_param_pool = unbound_param_pool
-      test_case
-    end
-
-    def contains_unbound?
-      self.any?(&:unbound?)
-    end
-
-    def unbound
-      self.select(&:unbound?)
-    end
-
-    def <=>(test_case)
-      result = 0
-      l = length <= test_case.length ? length : test_case.length
-      self.zip(test_case)[0...l].each do |arr|
-        first, second = arr
-        result = first <=> second
-        break if result != 0
-      end
-      result
-    end
-
-    def create_unbound(i)
-      bound_params = self.reject(&:unbound?).map(&:i)
-      ((0..i).to_a - bound_params).each do |a|
-        self << unbound_param_pool[a]
-      end
-      self
-    end
-
-    def to_ipog_array(i)
-      arr = Array.new(i)
-      self.each do |param|
-        arr[param.i] = param.j unless param.unbound?
-      end
-      arr
-    end
-
-    # return nil if there is a conflict
-    # return self if no conflict
-    def merge_without_conflict(i, test_case, &block)
-      new_elements = []
-      self.to_ipog_array(i).zip(test_case.to_ipog_array(i))
-        .each_with_index do |arr, a|
-        first, second = arr
-
-        if first.nil? && second.nil?
-          new_elements << unbound_param_pool[a]
-        elsif (first == second) || second.nil?
-          next
-        elsif first.nil?
-          new_elements << bound_param_pool[a][second]
-        else
-          return nil
-        end
-      end
-
-      new_self = self.clone
-      new_elements.each { |a| new_self << a }
-
-      return nil if block_given? && block.call(new_self)
-
-      new_elements.each do |a|
-        self.delete(unbound_param_pool[a.i]) unless a.unbound?
-        self << a
-      end
-      self
-    end
-  end # TestCase
-end # Dither

data/lib/dither/unbound_param.rb

@@ -1,17 +0,0 @@
-
-module Dither
-  UnboundParam = Struct.new(:i) do
-    def <=>(param)
-      return -1 unless param.unbound?
-      i <=> param.i
-    end
-
-    def unbound?
-      true
-    end
-
-    def create_params(j)
-      (0...j).map { |a| Param.new(i, a) }
-    end
-  end # UnboundParam
-end # Dither