knapsack_solver 0.1.0

data/lib/knapsack_solver/solving_methods/fptas.rb

@@ -0,0 +1,47 @@
+require 'knapsack_solver/solving_methods/dynamic_programming'
+
+module KnapsackSolver
+  # This class implements methods for solving 0/1 knapsack problem using Fully
+  # Polynomial Time Approximation Scheme.
+  class Fptas
+    # Initializes 0/1 knapsack FPTAS solver.
+    #
+    # @param instance [Instance] Instance of a 0/1 knapsack problem.
+    # @param epsilon [Instances] Maximum allowed relative error of the resulting price.
+    def initialize(instance, epsilon)
+      @instance = instance
+      @epsilon = epsilon.to_f
+      @orig_prices = @instance.things.map(&:price)
+    end
+
+    # Solve the instance of 0/1 knapsack problem using FPTAS.
+    #
+    # @return [Hash] resulting price and thing configuration (0 = thing is not in the knapsack, 1 = thing is there)
+    def run
+      modify_prices_for_epsilon!
+      r = DynamicProgramming.new(@instance).run
+      p = get_normal_price_from_fptas(r[:config])
+      { price: p, config: r[:config] }
+    end
+
+    protected
+
+    # Modifies prices of the things according to the supplied epsilon constant
+    # to achieve max. allowed relative error.
+    def modify_prices_for_epsilon!
+      m = @instance.things.max_by(&:price).price
+      k = (@epsilon * m) / @instance.things.size
+      @instance.things.each { |t| t.price = (t.price.to_f / k).floor }
+    end
+
+    # Computes resulting price using original unmodified prices of things.
+    #
+    # @param presenve [Array] configuration variables vector
+    # @return [Integer] total price of things in the knapsack
+    def get_normal_price_from_fptas(presence)
+      @instance.things.reduce(0) do |price, t|
+        price + ((presence[t.index] != 0 ? @orig_prices[t.index] : 0))
+      end
+    end
+  end
+end

data/lib/knapsack_solver/solving_methods/heuristic_price_weight.rb

@@ -0,0 +1,56 @@
+module KnapsackSolver
+  # This class implements methods for solving 0/1 knapsack problem using
+  # simple heuristic by price to weight ratio. Things with the best price to
+  # weight ratio are selected first.
+  class HeuristicPriceToWeight
+    # Initializes instance of 0/1 knapsack problem solver using simple
+    # heuristic by price to weight ratio.
+    #
+    # @param instance [Instance] 0/1 knapsack problem instance
+    def initialize(instance)
+      @instance = instance
+      @config = Array.new(instance.things.size) { 0 }
+      @sorted_things = instance.things.sort do |a, b|
+        (b.price.to_f / b.weight) <=> (a.price.to_f / a.weight)
+      end
+    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.
+    def solve
+      @sorted_things.each do |thing|
+        break if (config_weight + thing.weight) > @instance.weight_capacity
+        @config[thing.index] = 1
+      end
+      @best_price = config_price
+      @best_config = @config.dup
+    end
+
+    # Gets total weight of things present in the knapsack.
+    #
+    # @return [Integer] total weight
+    def config_weight
+      @config.each_with_index.reduce(0) do |weight, (presence, index)|
+        weight + presence * @instance.things[index].weight
+      end
+    end
+
+    # Gets total price of things present in the knapsack.
+    #
+    # @return [Integer] total price
+    def config_price
+      @config.each_with_index.reduce(0) do |price, (presence, index)|
+        price + presence * @instance.things[index].price
+      end
+    end
+  end
+end

data/lib/knapsack_solver/version.rb

@@ -0,0 +1,5 @@
+# Namespace for classes and modules for 0/1 knapsack problem utility.
+module KnapsackSolver
+  # Version of this comman-line utility for solving 0/1 knapsack problem.
+  VERSION = '0.1.0'.freeze
+end

data/test/knapsack_solver_matchers.rb

@@ -0,0 +1,103 @@
+require 'rspec/expectations'
+
+def comment_lines(file_path)
+  File.open(file_path, 'r').each_line.select { |l| l.chars.first == '#' }
+end
+
+def data_lines(file_path)
+  File.open(file_path, 'r').each_line.select { |l| l.chars.first != '#' }
+end
+
+
+RSpec::Matchers.define :be_a_regular_file do
+  match do |actual|
+    File.file?(actual)
+  end
+end
+
+RSpec::Matchers.define :be_an_empty_directory do
+  match do |actual|
+    Dir.empty?(actual)
+  end
+end
+
+RSpec::Matchers.define :be_a_valid_results_file do
+  match do |actual|
+    begin
+      comment_lines = comment_lines(actual)
+      data_lines = data_lines(actual)
+      # It must have 3 lines: 2 comments and >= 1 data line
+      return false if comment_lines.size != 2 || data_lines.size < 1
+      # Data line must consist of non-negative numbers and array 1 and 0
+      data_lines.each do |l|
+        l.scan(/\[[^\]]*\]/).first.tr('[]', '').split(',').map { |n| n.to_i }.each do |i|
+          return false if i != 0 && i != 1
+        end
+        l.scan(/[0-9\.]+/).map { |n| n.to_f }.each do |i|
+          return false if i < 0
+        end
+      end
+      true
+    rescue
+      false
+    end
+  end
+end  
+
+RSpec::Matchers.define :be_a_equal_to_results_file do |good|
+  match do |actual|
+    begin
+      lines = data_lines(actual)
+      good_lines = data_lines(good)
+      return false if lines.size != good_lines.size
+      lines.each_with_index do |l, i|
+        # Check price and configuration
+        return false if l.split(']').first != good_lines[i].split(']').first
+        # Check relative error
+        return false if l.split().last != good_lines[i].split().last
+        return false if l.split().size != good_lines[i].split().size
+      end
+      true
+    rescue
+      false
+    end
+  end
+end
+
+RSpec::Matchers.define :be_a_equal_to_stats_file do |good|
+  match do |actual|
+    begin
+      lines = data_lines(actual)
+      good_lines = data_lines(good)
+      return false if lines.size != good_lines.size
+      lines.each_with_index do |l, i|
+        # Check average price
+        return false if l.split().first != good_lines[i].split().first
+        # Check average relative error
+        return false if l.split().last != good_lines[i].split().last
+        return false if l.split().size != good_lines[i].split().size
+      end
+      true
+    rescue
+      false
+    end
+  end
+end
+
+RSpec::Matchers.define :be_a_valid_stats_file do
+  match do |actual|
+    begin
+      comment_lines = comment_lines(actual)
+      data_lines = data_lines(actual)
+      # It must have 3 lines: 2 comments and 1 data line
+      return false if comment_lines.size != 2 || data_lines.size != 1
+      # Data line must consist of non-negative numbers
+      data_lines.first.split.map { |i| i.to_f }.each do |n|
+        return false if n < 0
+      end
+      true
+    rescue
+      false
+    end
+  end
+end

data/test/knapsack_solver_spec.rb

@@ -0,0 +1,261 @@
+require 'rspec'
+require 'tmpdir'
+require_relative 'spec_helper'
+require_relative 'knapsack_solver_matchers'
+require_relative '../lib/knapsack_solver/cli.rb'
+require_relative '../lib/knapsack_solver/version.rb'
+
+module FileHelper
+  def file_list(directory, files)
+    files.map { |f| File.join(directory, f) }
+  end
+end
+
+module ArgumentHelper
+  def args(args_string = nil)
+    return [] if args_string.nil?
+    args_string.split
+  end
+
+  def args_in_dataset_out_file(args_string, tmpdir)
+    args(args_string) + ['-o', tmpdir, 'test/datasets/size_4.dataset', 'test/datasets/size_10.dataset']
+  end
+end
+
+describe KnapsackSolver::CLI do
+  include FileHelper
+  include ArgumentHelper
+
+  subject(:cli) { KnapsackSolver::CLI }
+
+  context 'options' do
+    it 'recognizes invalid options' do
+      expect { cli.run(args('-a')) }.to raise_error(OptionParser::InvalidOption)
+      expect { cli.run(args('-k -h')) }.to raise_error(OptionParser::InvalidOption)
+      expect { cli.run(args('-x -b')) }.to raise_error(OptionParser::InvalidOption)
+    end
+
+    it 'detects missing arguments' do
+      expect { cli.run(args('-o')) }.to raise_error(OptionParser::MissingArgument)
+      expect { cli.run(args('-g')) }.to raise_error(OptionParser::MissingArgument)
+    end
+    
+    it '-h has the top priority among valid options' do
+      expect { cli.run(args('-b -v -h')) }.to output(/Usage:/).to_stdout
+      expect { cli.run(args('-b -h -v')) }.to output(/Usage:/).to_stdout
+      expect { cli.run(args('-h -b -v')) }.to output(/Usage:/).to_stdout
+    end
+
+    it '-v has a second from the top priority among valid options' do
+      expect { cli.run(args('-v -h')) }.to output(/Usage:/).to_stdout
+      expect { cli.run(args('-v -b')) }.to output(/knapsack_solver #{KnapsackSolver::VERSION}/).to_stdout
+    end
+
+    it 'at least one method of solving must be selected' do
+      Dir.mktmpdir() do |tmpdir|
+        expect { cli.run(args()) }.to raise_error(/At least one method of solving must be requested/)
+        expect { cli.run(args_in_dataset_out_file('-b', tmpdir)) }.not_to raise_error
+      end
+    end
+    
+    it 'FPTAS must have epsilon constant provided' do
+      Dir.mktmpdir() do |tmpdir|
+        expect { cli.run(args_in_dataset_out_file('-f', tmpdir)) }.to raise_error(/Missing FPTAS epsilon constant/)
+        expect { cli.run(args_in_dataset_out_file('-f -e 0.5', tmpdir)) }.not_to raise_error
+      end      
+    end
+
+    it 'FPTAS epsilon constant must be number from range (0,1)' do
+      Dir.mktmpdir() do |tmpdir|
+        expect { cli.run(args_in_dataset_out_file('-f -e asdf', tmpdir)) }.to raise_error(/FPTAS epsilon must be number from range \(0,1\)/)
+        expect { cli.run(args_in_dataset_out_file('-f -e 0.5x', tmpdir)) }.to raise_error(/FPTAS epsilon must be number from range \(0,1\)/)
+        expect { cli.run(args_in_dataset_out_file('-f -e -0.3', tmpdir)) }.to raise_error(/FPTAS epsilon must be number from range \(0,1\)/)
+        expect { cli.run(args_in_dataset_out_file('-f -e 0', tmpdir)) }.to raise_error(/FPTAS epsilon must be number from range \(0,1\)/)
+        expect { cli.run(args_in_dataset_out_file('-f -e 0.01', tmpdir)) }.not_to raise_error
+        expect { cli.run(args_in_dataset_out_file('-f -e 0.99', tmpdir)) }.not_to raise_error
+        expect { cli.run(args_in_dataset_out_file('-f -e 1', tmpdir)) }.to raise_error(/FPTAS epsilon must be number from range \(0,1\)/)
+      end      
+    end
+
+    it 'epsilon constant must not be provided when FPTAS is not selected' do
+      Dir.mktmpdir() do |tmpdir|
+        expect { cli.run(args_in_dataset_out_file('-b -e 0.5', tmpdir)) }.to raise_error(/epsilon constant must not be provided when FPTAS is not selected/)
+        expect { cli.run(args_in_dataset_out_file('-b -f -e 0.5', tmpdir)) }.not_to raise_error
+      end      
+    end
+
+  end
+  
+  context 'positional arguments' do
+    it 'must have at least one dataset provided' do
+      expect { cli.run(args('-b')) }.to raise_error(/Missing datset file\(s\)/)
+    end
+
+    it 'dataset path must be a path to a regular file' do
+      Dir.mktmpdir do |tmpdir|
+        expect { cli.run(args('-b ' + tmpdir)) }.to raise_error(/is not a regular file/)
+      end      
+    end
+
+    it 'dataset file must exist' do
+      Dir.mktmpdir do |tmpdir|
+        not_existent_file = File.join(tmpdir, 'size_4.dataset')
+        expect { cli.run(args('-b ' + not_existent_file)) }.to raise_error(/does not exists/)
+      end      
+    end
+    
+    it 'dataset file must be readable' do
+      Dir.mktmpdir do |tmpdir|
+        FileUtils.cp('test/datasets/size_4.dataset', tmpdir)
+        not_readable_file = File.join(tmpdir, 'size_4.dataset')
+        FileUtils.chmod('a-r', not_readable_file)
+        expect { cli.run(args('-b ' + not_readable_file)) }.to raise_error(/is not readable/)
+      end      
+    end
+
+    it 'dataset file must have correct format' do
+      Dir.mktmpdir do |tmpdir|
+        invalid_files = %w(invalid_1.dataset
+                           invalid_2.dataset
+                           invalid_3.dataset
+                           invalid_4.dataset
+                           invalid_5.dataset
+                           invalid_6.dataset
+                           invalid_7.dataset
+                           invalid_8.dataset)
+        error_messages = ['missing ID',
+                          'first line does not contain ID',
+                          'ID is negative',
+                          'ID is not an integer',
+                          'missing knapsack capacity',
+                          'missing pairs \(price, weight\)',
+                          'instance desctiption contains negative number',
+                          'instance desctiption does not contain only integers']
+        file_list('test/invalid_datasets', invalid_files).each_with_index do |f, i|
+          expect { cli.run(args('-d ' + f)) }.to raise_error(/#{error_messages[i]}/)
+        end
+      end      
+    end
+  end
+  
+  context 'output of results' do
+    it 'directory for the output logs must exist' do
+      Dir.mktmpdir do |tmpdir|
+        not_existent_file = File.join(tmpdir, 'size_4.dataset')
+        expect { cli.run(args('-b -o ' + not_existent_file)) }.to raise_error(/does not exists/)
+      end      
+    end
+
+    it 'path to a directory for the output logs must point to a directory' do
+      Dir.mktmpdir do |tmpdir|
+        FileUtils.cp('test/datasets/size_4.dataset', tmpdir)
+        file = File.join(tmpdir, 'size_4.dataset')
+        expect { cli.run(args('-b -o ' + file)) }.to raise_error(/is not a directory/)
+      end      
+    end
+
+    it 'directory for the output logs must be writable' do
+      Dir.mktmpdir do |tmpdir|
+        not_writable_dir = File.join(tmpdir, 'dir')
+        Dir.mkdir(not_writable_dir)
+        FileUtils.chmod('a-w', not_writable_dir)
+        expect { cli.run(args('-b -o ' + not_writable_dir)) }.to raise_error(/is not writable/)
+      end      
+    end
+
+    it 'directory for the graph files must exist' do
+      Dir.mktmpdir do |tmpdir|
+        not_existent_file = File.join(tmpdir, 'size_4.dataset')
+        expect { cli.run(args('-b -g ' + not_existent_file)) }.to raise_error(/does not exists/)
+      end      
+    end
+
+    it 'path to a directory for the graph files must point to a directory' do
+      Dir.mktmpdir do |tmpdir|
+        FileUtils.cp('test/datasets/size_4.dataset', tmpdir)
+        file = File.join(tmpdir, 'size_4.dataset')
+        expect { cli.run(args('-b -g ' + file)) }.to raise_error(/is not a directory/)
+      end      
+    end
+
+    it 'directory for the graph files must be writable' do
+      Dir.mktmpdir do |tmpdir|
+        not_writable_dir = File.join(tmpdir, 'dir')
+        Dir.mkdir(not_writable_dir)
+        FileUtils.chmod('a-w', not_writable_dir)
+        expect { cli.run(args('-b -g ' + not_writable_dir)) }.to raise_error(/is not writable/)
+      end      
+    end
+
+    it 'writes graph files' do
+      Dir.mktmpdir do |tmpdir|
+        png_files = %w(avg_price.png avg_cpu_time.png avg_wall_clock_time.png avg_relative_error.png)
+        gnuplot_files = %w(avg_price.gnuplot avg_cpu_time.gnuplot avg_wall_clock_time.gnuplot avg_relative_error.gnuplot)
+        files = png_files + gnuplot_files
+        cli.run(args_in_dataset_out_file('-b -g ' + tmpdir, tmpdir))
+        expect(file_list(tmpdir, files)).to all be_a_regular_file
+      end      
+    end
+
+    it 'writes results and stats to files' do
+      Dir.mktmpdir do |tmpdir|
+        results_files = %w(size_4_branch_and_bound.results size_10_branch_and_bound.results)
+        stats_files = %w(size_4_branch_and_bound.stats size_10_branch_and_bound.stats)
+        files = results_files + stats_files
+        cli.run(args_in_dataset_out_file('-b', tmpdir))
+        expect(file_list(tmpdir, files)).to all be_a_regular_file
+      end
+    end
+
+    it 'writes results and stats to stdout' do
+      results_files = %w(size_4_branch_and_bound.results size_10_branch_and_bound.results)
+      stats_files = %w(size_4_branch_and_bound.stats size_10_branch_and_bound.stats)
+      files = results_files + stats_files
+      files.each do |f|
+        expect { cli.run(args('-b test/datasets/size_4.dataset test/datasets/size_10.dataset')) }.to output(/#{f}/).to_stdout
+      end
+    end
+
+    it 'adds relative error if an exact solving method is selected' do
+      expect { cli.run(args('-r test/datasets/size_4.dataset test/datasets/size_10.dataset')) }.not_to output(/avg_relative_error/).to_stdout
+      expect { cli.run(args('-f -e 0.5 -r test/datasets/size_4.dataset test/datasets/size_10.dataset')) }.not_to output(/avg_relative_error/).to_stdout
+      expect { cli.run(args('-b -r test/datasets/size_4.dataset test/datasets/size_10.dataset')) }.to output(/avg_relative_error/).to_stdout
+      expect { cli.run(args('-d -r test/datasets/size_4.dataset test/datasets/size_10.dataset')) }.to output(/avg_relative_error/).to_stdout
+    end
+
+    it 'produces correct results' do
+      Dir.mktmpdir do |tmpdir|
+        results_files = %w(size_10_dynamic_programming.results
+                           size_10_fptas.results
+                           size_10_heuristic.results
+                           size_4_dynamic_programming.results
+                           size_4_fptas.results
+                           size_4_heuristic.results)
+        stats_files = %w(size_10_dynamic_programming.stats
+                         size_10_fptas.stats
+                         size_10_heuristic.stats
+                         size_4_dynamic_programming.stats
+                         size_4_fptas.stats
+                         size_4_heuristic.stats)
+        good_results_files = results_files.map { |f| File.join('test/output_logs', f) }
+        good_stats_files = stats_files.map { |f| File.join('test/output_logs', f) }
+        files = results_files + stats_files
+        cli.run(args_in_dataset_out_file('-b -d -r -f -e 0.5', tmpdir))
+        expect(file_list(tmpdir, files)).to all be_a_regular_file
+        expect(file_list(tmpdir, results_files)).to all be_a_valid_results_file
+        expect(file_list(tmpdir, stats_files)).to all be_a_valid_stats_file
+
+        file_list(tmpdir, results_files).each_with_index do |f, i|
+          expect(f).to be_a_equal_to_results_file(good_results_files[i])
+        end
+
+        file_list(tmpdir, stats_files).each_with_index do |f, i|
+          expect(f).to be_a_equal_to_stats_file(good_stats_files[i])
+        end
+      end
+     
+    end
+
+  end
+
+end