knapsack_solver 0.1.0

data/lib/knapsack_solver/instance.rb

@@ -0,0 +1,48 @@
+module KnapsackSolver
+  # This class represents an instance of a 0/1 knapsack problem.
+  class Instance
+    # Initializes instance of a 0/1 knapsack problem.
+    #
+    # @param capacity [Integer] weight capacity of the knapsack
+    # @param things [Array<Thing>] things which can be put into the knapsack
+    def initialize(capacity, things)
+      @weight_capacity = capacity
+      @things = things
+    end
+
+    # Creates new instance of a 0/1 knapsack problem.
+    #
+    # @param line [String] line that describes an instance of a 0/1 knapsack problem
+    # @return [Instance] instance of the 0/1 knapsack problem
+    def self.parse(line)
+      thing = Struct.new(:price, :weight, :index)
+      # Rozdelit riadok na slova a previest na cisla
+      items = split_line(line)
+      # Inicializacia premennych
+      things = items.drop(1).each_slice(2).with_index.each_with_object([]) do |(s, i), o|
+        o << thing.new(s[0], s[1], i)
+      end
+      Instance.new(items[0], things)
+    end
+
+    # Splits line that describes an instance of a 0/1 knapsack problem to
+    # individual numbers.
+    #
+    # @param line [String] line that describes an instance of a 0/1 knapsack problem
+    # @return [Array<Integer>] integer numbers from the line
+    def self.split_line(line)
+      items = line.split.map! do |i|
+        n = Integer(i)
+        raise StandardError, 'dataset: instance desctiption contains negative number' if n < 0
+        n
+      end
+      raise StandardError, 'dataset: missing knapsack capacity' if items.empty?
+      raise StandardError, 'dataset: missing pairs (price, weight)' if items.size.even?
+      items
+    rescue ArgumentError
+      raise StandardError, 'dataset: instance desctiption does not contain only integers'
+    end
+
+    attr_reader :weight_capacity, :things
+  end
+end

data/lib/knapsack_solver/output_printer.rb

@@ -0,0 +1,97 @@
+module KnapsackSolver
+  # This class provides support for printing results and statistics of a
+  # dataset solving either to stdout or to a text file.
+  class OutputPrinter
+    # Initializes printer for output log (results, statistics).
+    #
+    # @param dataset_filenames [Array<String>] dataset filenames
+    # @param suffix [String] suffix of the created files
+    # @param results [Hash] results of solving or statistics to print
+    def initialize(dataset_filenames, suffix, results)
+      @dataset_basenames = file_basenames(dataset_filenames)
+      @suffix = suffix
+      @results = results
+    end
+
+    # Prints results or statistics to stdout or to files in output directory.
+    #
+    # @param out_dir [String] path to output directory
+    def print(out_dir = nil)
+      @results.each_value.with_index do |results, index|
+        results.each do |method, res|
+          print_solving_method_results(method, res, out_dir, @dataset_basenames[index])
+        end
+      end
+    end
+
+    protected
+
+    # Prints results of solving or statistics.
+    #
+    # @param method [Symbol] symbol for solving method
+    # @param res [Hash] results of the solving method
+    # @param out_dir [String] path to output directory
+    # @param basename [String] basename of dataset input file corresponding to the results
+    def print_solving_method_results(method, res, out_dir, basename)
+      of = output_filename(out_dir, basename, method.to_s)
+      os = output_stream(out_dir, of)
+      print_header(os, of, res)
+      res.each do |r|
+        os.puts r.values.each_with_object([]) { |v, a| a << v.to_s }.join(' ')
+      end
+      os.puts if out_dir.nil?
+    end
+
+    # Opens output file and turns on synchronized writes (this is neede for
+    # testing with Rspec).
+    #
+    # @param fname [String] path to the output file
+    # @return [#puts] output stream
+    def open_output_file(fname)
+      f = File.new(fname, 'w')
+      f.sync = true
+      f
+    end
+
+    # Sets output stream to stdout or to a file if path to it was provided.
+    #
+    # @param out_dir [String] directory for output files
+    # @param out_file [String] output file
+    def output_stream(out_dir, out_file)
+      return $stdout if out_dir.nil?
+      open_output_file(out_file)
+    end
+
+    # Prints header of output log file.
+    #
+    # @param out_stream [#puts] stream to which output will be printed
+    # @param out_file [String] name of output file
+    # @param results [Hash] results of solving or statistics
+    def print_header(out_stream, out_file, results)
+      out_stream.puts "# #{out_file}"
+      out_stream.puts "# #{results.first.keys.join('    ')}"
+    end
+
+    # Gets basenames of supplied file paths.
+    #
+    # @param paths [Array<String>] path to files
+    # @return [Array<String>] basenames of the paths
+    def file_basenames(paths)
+      paths.each_with_object([]) do |path, basenames|
+        basenames << File.basename(path, File.extname(path))
+      end
+    end
+
+    # Construct filename for output log.
+    #
+    # @param output_dir [String] output directory
+    # @param basename [String] basename of the output file
+    # @param solving_method [String] name of solving method
+    # @return [String] filename for output log
+    def output_filename(output_dir, basename, solving_method)
+      filename = basename + '_' + solving_method + @suffix
+      return filename if output_dir.nil?
+      File.join(output_dir, filename)
+    end
+  end
+end

data/lib/knapsack_solver/solver.rb

@@ -0,0 +1,118 @@
+require 'benchmark'
+
+require 'knapsack_solver/dataset'
+require 'knapsack_solver/solving_methods/heuristic_price_weight'
+require 'knapsack_solver/solving_methods/branch_and_bound'
+require 'knapsack_solver/solving_methods/dynamic_programming'
+require 'knapsack_solver/solving_methods/fptas'
+
+module KnapsackSolver
+  # This class solves datasets of 0/1 knapsack problem instances using a
+  # requested solving methods. It measures execution time of a solving and
+  # computes relative error if some exact solving method is requested.
+  class Solver
+    # Initializes solver for use of user selected solving methods.
+    #
+    # @param opts [Hash] parser command-line options
+    # @param datasets [Hash] parsed sets of 0/1 knapsack problem instances
+    def initialize(opts, datasets)
+      @opts = opts
+      @datasets = datasets
+      @solver_objects = {}
+      { branch_and_bound: 'KnapsackSolver::BranchAndBound',
+        dynamic_programming: 'KnapsackSolver::DynamicProgramming',
+        heuristic: 'KnapsackSolver::HeuristicPriceToWeight',
+        fptas: 'KnapsackSolver::Fptas' }.each do |symbol, class_name|
+        @solver_objects[symbol] = Object.const_get(class_name) if opts[symbol]
+      end
+    end
+
+    # Solve datasets using all selected method of solving, measure their
+    # execution time and compute relative errors if some exact method was
+    # requested.
+    #
+    # @return [Hash] results of dataset solving
+    def run
+      results = @datasets.each_with_object({}) do |dataset, res|
+        res[dataset.id] = @solver_objects.each_with_object({}) do |(solver, object), r|
+          r[solver] = dataset.instances.each_with_object([]) do |inst, a|
+            o = object.new(inst) unless solver == :fptas
+            o = object.new(inst, @opts[:fptas_epsilon]) if solver == :fptas
+            a << execution_time { o.run }
+          end
+        end
+      end
+      add_relative_error(results)
+    end
+
+    # Creates statistics (average price, execution times, relative error) from
+    # results of solving.
+    #
+    # @param results [Hash] solving results of datasets and solving methods
+    # @return [Hash] statistics for datasets and solving methods
+    def stats(results)
+      results.each_with_object({}) do |(dataset_id, method_results), q|
+        q[dataset_id] = method_results.each_with_object({}) do |(met, res), p|
+          p[met] = averages(res)
+        end
+      end
+    end
+
+    protected
+
+    # Computes average values from the results.
+    #
+    # @param res [Hash] results for one dataset and one method
+    # @return [Array<Hash>] array of computed average values
+    def averages(res)
+      [res.first.keys.reject { |k| k == :config }.each_with_object({}) do |v, o|
+         values = res.map { |i| i[v] }
+         o[('avg_' + v.to_s).to_sym] = values.reduce(:+).to_f / values.size
+       end]
+    end
+
+    # Adds relative error to results of solving if some exact method of
+    # solving was requested.
+    #
+    # @param results [Hash] results of solving using requested methods
+    # @return [Hash] the results with relative error added
+    def add_relative_error(results)
+      return results unless @opts[:branch_and_bound] || @opts[:dynamic_programming]
+      exact_method = @opts[:branch_and_bound] ? :branch_and_bound : :dynamic_programming
+      results.each_value do |method_results|
+        method_results.each_value do |res|
+          res.each_with_index do |r, i|
+            r[:relative_error] = relative_error(method_results[exact_method][i][:price], r[:price])
+          end
+        end
+      end
+      results
+    end
+
+    # Measure execution time of provided block so that measured time is non-zero.
+    #
+    # @yieldparam block for which execution time will be measured
+    # @return [Hash] solving results with cpu time and wall clock time of execution
+    def execution_time
+      exec_count = 1
+      result = nil
+      cpu_time = wall_clock_time = 0.0
+      while cpu_time.zero? || wall_clock_time.zero?
+        b = Benchmark.measure { exec_count.times { result = yield } }
+        cpu_time += b.total
+        wall_clock_time += b.real
+        exec_count *= 2
+      end
+      result.merge(cpu_time: cpu_time, wall_clock_time: wall_clock_time)
+    end
+
+    # Computes relative error of approximate solution.
+    #
+    # @param opt [Numeric] Optimal price.
+    # @param apx [Numeric] Approximate price.
+    # @return [Float] Relative error.
+    def relative_error(opt, apx)
+      (opt.to_f - apx.to_f) / opt.to_f
+    end
+  end
+end

data/lib/knapsack_solver/solving_methods/branch_and_bound.rb

@@ -0,0 +1,111 @@
+module KnapsackSolver
+  # This class implements methods for solving 0/1 knapsack problem using
+  # Branch and Bound method.
+  class BranchAndBound
+    # Initializes instance of Brand and Bound 0/1 knapsack problem solver.
+    #
+    # @param instance [Instance] 0/1 knapsack problem instance
+    def initialize(instance)
+      @instance = instance
+      @config = Array.new(instance.things.size)
+    end
+
+    # Solve the instance of 0/1 knapsack problem.
+    #
+    # @return [Hash] resulting price and thing configuration (0 = thing is not in the knapsack, 1 = thing is there)
+    def run
+      solve(0)
+      { price: @best_price, config: @best_config }
+    end
+
+    protected
+
+    # Solve the problem starting at specified thing.
+    #
+    # @param index [Integer] index of thing which will be decided (put in or out from the knapsack) the next
+    def solve(index)
+      @config[index] = 0
+      solve(index + 1) unless stop(index)
+      @config[index] = 1
+      solve(index + 1) unless stop(index)
+    end
+
+    # Determine if solving of current branch should continue.
+    #
+    # @param index [Integer] index of the last decided thing so far
+    # @return [true, false] weather to continue with solving current branch.
+    def stop(index)
+      # Update of the best price so far
+      weight = config_weight(0, index)
+      price = config_price(0, index)
+      update_best_price(price, weight, index)
+      # No more things to put into the knapsack
+      return true if index >= (@instance.things.size - 1)
+      # The knapsack is overloaded, do not continue this branch
+      return true if weight > @instance.weight_capacity
+      if instance_variable_defined?('@best_price') &&
+         ((price + get_price_of_remaining_things(index + 1)) <= @best_price)
+        # Adding all the ramining things does not produce better price
+        return true
+      end
+      false
+    end
+
+    # Update the best price achieved so far.
+    #
+    # @param price [Integer] price of the current configuration
+    # @param weight [Integer] weight of the current configuration
+    # @param index [Integer] index of the next thing presence of which will be decided
+    def update_best_price(price, weight, index)
+      if !instance_variable_defined?('@best_price') ||
+         ((weight <= @instance.weight_capacity) && (price > @best_price))
+        @best_price = price
+        valid_len = index + 1
+        remaining = @config.size - index - 1
+        # All undecided things will not be put into the knapsack
+        @best_config = @config.slice(0, valid_len).fill(0, valid_len, remaining)
+        @best_config_index = index
+      end
+    end
+
+    # Gets weight of set of things. The set is subset of the things ordered by
+    # their index.
+    #
+    # @param start_index [Integer] index of the first thing included in the set
+    # @param end_index [Integer] index of the last thing included in the set
+    # @return [Integer] weight of the things
+    def config_weight(start_index, end_index)
+      weight = 0
+      @config[start_index..end_index].each_with_index do |presence, index|
+        weight += presence * @instance.things[index].weight
+      end
+      weight
+    end
+
+    # Gets price of set of things. The set is subset of the things ordered by
+    # their index.
+    #
+    # @param start_index [Integer] index of the first thing included in the set
+    # @param end_index [Integer] index of the last thing included in the set
+    # @return [Integer] price of the things
+    def config_price(start_index, end_index)
+      price = 0
+      @config[start_index..end_index].each_with_index do |presence, index|
+        price += presence * @instance.things[index].price
+      end
+      price
+    end
+
+    # Gets sum of prices of things for which their presence in the knapsack
+    # was not decided yet.
+    #
+    # @param from_index [Integer] index of the first undecided thing
+    # @return [Integer] price of the remaining things
+    def get_price_of_remaining_things(from_index)
+      price = 0
+      to_index = @instance.things.size - 1
+      @instance.things[from_index..to_index].each { |t| price += t.price }
+      price
+    end
+  end
+end

data/lib/knapsack_solver/solving_methods/dynamic_programming.rb

@@ -0,0 +1,116 @@
+module KnapsackSolver
+  # This class implements methods for solving 0/1 knapsack problem using
+  # dynamic programming with decomposition by price.
+  class DynamicProgramming
+    # Initializes instance of 0/1 knapsack problem solver based on dynamic
+    # programming with decomposition by price.
+    #
+    # @param instance [Instance] 0/1 knapsack problem instance
+    def initialize(instance)
+      @instance = instance
+      @config = Array.new(instance.things.size)
+    end
+
+    # Solve the instance of 0/1 knapsack problem.
+    #
+    # @return [Hash] resulting price and thing configuration (0 = thing is not in the knapsack, 1 = thing is there)
+    def run
+      solve
+      { price: @best_price, config: @best_config }
+    end
+
+    protected
+
+    # Solve the instance of 0/1 knapsack problem using dynamic programming.
+    def solve
+      # Dynamic programming table
+      c = all_things_price + 1 # height of array from 0 to max. price
+      n = @instance.things.size + 1 # width of array, from 0th thing to Nth
+      # Value used as infinity in the dynamic programming table
+      @infinity = (all_things_weight + 1).freeze
+      @weight_array = Array.new(n) { Array.new(c, @infinity) }
+      @weight_array[0][0] = 0
+      fill_table
+      find_best_price
+      configuration_vector
+    end
+
+    # Fill the dynamic programming table.
+    def fill_table
+      (1..@instance.things.size).each do |ni|
+        (0..all_things_price).each do |ci|
+          @weight_array[ni][ci] = minimum_weight(ni, ci)
+        end
+      end
+    end
+
+    # Find the value of cell in dynamic programming table.
+    #
+    # @param ni [Integer] X axis coordinate
+    # @param ci [Integer] Y axis coordinate
+    # @return [Integer]
+    def minimum_weight(ni, ci)
+      b = weight_of(ni - 1, ci - @instance.things[ni - 1].price)
+      b += @instance.things[ni - 1].weight
+      [weight_of(ni - 1, ci), b].min
+    end
+
+    # Find the best price from the filled dynamic programming table.
+    def find_best_price
+      @best_price = @weight_array.last[0]
+      (1..all_things_price).each do |i|
+        @best_price = i if @weight_array.last[i] <= @instance.weight_capacity
+      end
+    end
+
+    # Reconstructs configuration vector from dynamic programming table.
+    def configuration_vector
+      @best_config = []
+      ci = @best_price
+      @instance.things.size.downto(1) do |i|
+        ci = determine_config_variable(i, ci)
+      end
+    end
+
+    # Determine value of one scalar for the configuration vector.
+    #
+    # return [Integer] next Y index to the dynamic programming table
+    def determine_config_variable(i, ci)
+      if @weight_array[i][ci] == @weight_array[i - 1][ci]
+        @best_config[i - 1] = 0
+      else
+        @best_config[i - 1] = 1
+        ci -= @instance.things[i - 1].price
+      end
+      ci
+    end
+
+    # Gets weight from dynamic programming table.
+    #
+    # @param i [Integer] Y index of dynamic programming table
+    # @param c [Integer] X index of dynamic programming table
+    # @return [Integer] the value from the array
+    def weight_of(i, c)
+      return @infinity if (i < 0) || (c < 0)
+      @weight_array[i][c]
+    end
+
+    # Computes total price of all things of the instance.
+    #
+    # @return [Integer] total price
+    def all_things_price
+      price = 0
+      @instance.things.each { |t| price += t.price }
+      price
+    end
+
+    # Computes total weight of all things of the instance.
+    #
+    # @return [Integer] total weight
+    def all_things_weight
+      weight = 0
+      @instance.things.each { |t| weight += t.weight }
+      weight
+    end
+  end
+end