dither 0.1.5-java → 0.2.0-java

data/lib/dither/ipog_helper.rb

@@ -1,161 +0,0 @@
-# coding: utf-8
-
-module Dither
-  module IPOGHelper
-    attr_reader :params, :t, :constraints, :test_set, :orig_params, :unbound_param_pool, :tested
-    private :params, :t, :constraints, :test_set, :orig_params, :unbound_param_pool, :tested
-
-    def initialize(params, opts = {})
-      init_params(params, (opts[:previously_tested] || []))
-      @t = opts[: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 Dither::Error, 't must be >= 2' if opts[:t] < 2
-      raise Dither::Error, 't must be <= params.length' if opts[:t] > params.length
-      params.each do |param|
-        raise Dither::Error, 'param length must be > 1' if param.length < 2
-      end
-    end
-
-    def init_params(user_params, previously_tested)
-      tmp = []
-      @input_params = user_params
-      user_params.each_with_index { |e, i| tmp << [i, e] }
-      @orig_params = tmp.sort_by { |a| a[1].length }
-                     .reverse!
-
-      orig_param_map = {}
-      @map_to_orig_index = {}
-      @orig_params.each_with_index do |e, i|
-        @map_to_orig_index[i] = e[0]
-        orig_param_map[e[0]] = {}
-      end
-
-      @params = []
-      @unbound_param_pool = []
-      orig_params.each_with_index do |e, i|
-        @params << (0...e[1].length).map do |j|
-          local_param = Param.new(i, j)
-          orig_param_map[e[0]][e[1][j]] = local_param
-          local_param
-        end
-        @unbound_param_pool << UnboundParam.new(i)
-      end
-
-      @tested = []
-      previously_tested.each do |a|
-        local_params = []
-        a.each_with_index do |e, i|
-          local_params << orig_param_map[i][e]
-        end
-        @tested << TestCase.create(params, unbound_param_pool, local_params)
-      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
-
-      return nil if violates_constraints?(test_case)
-      test_case << params[i][current_max_j]
-
-      current_matches
-    end
-
-    def violates_constraints?(params)
-      return false if constraints.nil?
-      constraints.any? { |b| b.subset?(params) }
-    end
-
-    private
-
-    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
-
-      result = products.map(&:flatten)
-        .map { |a| TestCase.create(params, unbound_param_pool, a) }
-      result.reject { |a| tested?(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[a[0]][b] }) { |p, i| p.product((0...params[i].length).to_a.map { |c| params[i][c] }) }
-                 .map(&:flatten)
-                 .map { |b| TestCase.create(params, unbound_param_pool, b) }
-      end
-      result.reject { |a| tested?(a) }.to_set
-    end
-
-    def tested?(test_case)
-      @tested.any? { |a| test_case.subset?(a) }
-    end
-
-    def fill_unbound(data)
-      arr = Array.new(params.length)
-      data.each do |param|
-        unless param.unbound?
-          i = @map_to_orig_index[param.i]
-          arr[i] = @input_params[i][param.j]
-        end
-      end
-
-      arr.each_with_index do |e, i|
-        next unless e.nil?
-
-        orig_param = @input_params[i]
-        (0...orig_param.length).each do |j|
-          data << params[@map_to_orig_index.key(i)][j]
-          if violates_constraints?(data)
-            data.delete(params[@map_to_orig_index.key(i)][j])
-            next
-          else
-            arr[i] = orig_param[j]
-            break
-          end
-        end
-        return nil if arr[i].nil?
-      end
-
-      return nil if violates_constraints?(data)
-      return nil if tested?(data)
-
-      arr
-    end
-  end # IPOGHelper
-end # Dither

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