subset_sum 1.0.1 → 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7a847f3a3319373c99e460022e1b913e60b6ab1f
+  data.tar.gz: b89473242737cfea78bf878446da36cc528a125a
+SHA512:
+  metadata.gz: a6c6c942a74d5fc4adeba3f2b0686f3c7b96e7ae797bdf79adce4758e25b59262bd4985134a77b5de006ad0dfe7c5f011377de97738003194b56aff78d7ee5b9
+  data.tar.gz: e6a57ccd8c77aa493c2e38908d7b047cc66d843e26da625937aa21caa2b0601ad1b207c046f19d67fcf5bab076ef4bce1a18bda12b582174361189b71940272f

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008 Jeremy Evans
+Copyright (c) 2008,2010,2015,2016 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/spec/subset_sum_spec.rb

@@ -1,47 +1,48 @@
-#!/usr/bin/env spec
 require 'subset_sum'
+require 'minitest/autorun'
 
-context "SubsetSum.subset_sum" do
+describe "SubsetSum.subset_sum" do
   it "should raise TypeError unless the first argument is an array" do
-    proc{SubsetSum.subset_sum(1, 1)}.should raise_error(TypeError)
-    proc{SubsetSum.subset_sum(nil, 1)}.should raise_error(TypeError)
+    proc{SubsetSum.subset_sum(1, 1)}.must_raise(TypeError)
+    proc{SubsetSum.subset_sum(nil, 1)}.must_raise(TypeError)
   end
   
   it "should raise TypeError unless the second argument is an Integer" do
-    proc{SubsetSum.subset_sum([1,2,3], [1,2,3])}.should raise_error(TypeError)
-    proc{SubsetSum.subset_sum([1,2,3], nil)}.should raise_error(TypeError)
+    proc{SubsetSum.subset_sum([1,2,3], [1,2,3])}.must_raise(TypeError)
+    proc{SubsetSum.subset_sum([1,2,3], nil)}.must_raise(TypeError)
   end
   
   it "should return nil if no subset sums to the given amount" do
-    SubsetSum.subset_sum([1,2,3], -1).should == nil
-    SubsetSum.subset_sum([1,2,3], 7).should == nil
+    SubsetSum.subset_sum([1,2,3], -1).must_equal nil
+    SubsetSum.subset_sum([1,2,3], 7).must_equal nil
   end
   
   it "should return a subset of the given array summing to the given amount" do
-    SubsetSum.subset_sum([1,2,3], 0).should == []
-    SubsetSum.subset_sum([1,2,3], 1).should == [1]
-    SubsetSum.subset_sum([1,2,3], 2).should == [2]
-    [[1,2], [3]].should include(SubsetSum.subset_sum([1,2,3], 3))
-    SubsetSum.subset_sum([1,2,3], 4).should == [1,3]
-    SubsetSum.subset_sum([1,2,3], 5).should == [2,3]
-    SubsetSum.subset_sum([1,2,3], 6).should == [1,2,3]
+    SubsetSum.subset_sum([1,2,3], 0).must_equal []
+    SubsetSum.subset_sum([1,2,3], 1).must_equal [1]
+    SubsetSum.subset_sum([1,2,3], 2).must_equal [2]
+    [[1,2], [3]].must_include(SubsetSum.subset_sum([1,2,3], 3))
+    SubsetSum.subset_sum([1,2,3], 4).must_equal [1,3]
+    SubsetSum.subset_sum([1,2,3], 5).must_equal [2,3]
+    SubsetSum.subset_sum([1,2,3], 6).must_equal [1,2,3]
     
     a = [355104, 476077, 476303, 224658, -17532, -183480, -286788, 238271, 231845, -227454, 226199, 105438, 316870, 353652, 173563, 244958, 367896, 105046, 495797, 447209, 397810, -394348, 242527, 17532, -57224, -38084, 82375, 445376, -297793, 368660, -65413, 96325, -472195, -23826, -113982, -355574, 331821]
     b = [-17532, 226199, 105438, 353652, 173563, 244958, 397810, 242527, 17532, -38084, 82375, 445376, 368660, -65413, -23826, 331821]
     s = b.inject(0){|x,y|y+x}
-    SubsetSum.subset_sum(a, s).inject(0){|x,y|y+x}.should == s
+    SubsetSum.subset_sum(a, s).inject(0){|x,y|y+x}.must_equal s
   end
   
   it "should raise a SubsetSum::TimeoutError if the Timeout expires" do
     a = [333471, -81424, 168803, -14874, 269559, 276470, -112006, -73874, -122941, 137631, -28130, -158579, -422171, 27107, 320112, -36290, -285551, 8352, 148555, -191195, -378065, -98153, 446370, 364645, -410213, -18978, 473135, -86692, 220362, -131996, -350007, -151015, -406022, -357901, -180250, 234239, -342453, -355331, -288241, 14474, 389351, 98297, -241761, 96174, 21747, 231199, -473800, -172155, 65848, -36045, -449758, 255701, 366189, -181547, -334067, 61902, -369357, -444588, 196073, 173373, 348303, 445476, 233108, 146771, -124962, 426707, -443489, -147630, -40380, 462470, -460874, -488721, -316681, 58097, 374972, -35163, 101042, -143586, 176358, -443511, 262241, 79581, -251333, 432832, 216996, 290187, -216371, 412922, -250978, 282206, -379257, 240712, 245726, -478854, 185713, 187485, -213379, -185167, -475251, -127179, -158661]
     b = [333471, -14874, 276470, 137631, -28130, -158579, 27107, -36290, 148555, -191195, -378065, 473135, -86692, -350007, -151015, -406022, 234239, -355331, 21747, 231199, -172155, -36045, -449758, 366189, -334067, -369357, -444588, 348303, 445476, -124962, 426707, 462470, -460874, 58097, 374972, -35163, 101042, 79581, -216371, 240712, -213379, -185167]
     s = b.inject(0){|x,y|y+x}
-    proc{SubsetSum.subset_sum(a, s, 1).inject(0){|x,y|y+x}}.should raise_error(SubsetSum::TimeoutError)
+    proc{SubsetSum.subset_sum(a, s, 1).inject(0){|x,y|y+x}}.must_raise(SubsetSum::TimeoutError)
   end
   
   it "should not use the C version if the integers are Bignums" do
-    SubsetSum.should_not_receive(:_subset_sum)
-    SubsetSum.subset_sum([2**100, 1, 2,], 1+2**100).should == [2**100, 1]
+    SubsetSum.stub :_subset_sum, proc{raise} do
+      SubsetSum.subset_sum([2**100, 1, 2,], 1+2**100).must_equal [2**100, 1]
+    end
   end
 end
 

data/subset_sum.c

@@ -339,9 +339,21 @@ static VALUE rbss_main(VALUE self, VALUE numbers, VALUE result, VALUE max_second
     return answer;
 }
 
+#ifndef RB_FIXNUM_P
+#define RB_FIXNUM_P(v) FIXNUM_P(v)
+#endif
+
+static VALUE rbss_supported(VALUE self, VALUE want, VALUE pos, VALUE neg, VALUE max_seconds) {
+    if (RB_FIXNUM_P(want) && RB_FIXNUM_P(pos) && RB_FIXNUM_P(neg) && RB_FIXNUM_P(max_seconds)) {
+        return Qtrue;
+    }
+    return Qfalse;
+}
+
 void Init_subset_sum() {
     VALUE SubsetSum;
     SubsetSum = rb_define_module("SubsetSum");
     rb_define_module_function(SubsetSum, "_subset_sum", rbss_main, 3);
+    rb_define_module_function(SubsetSum, "_subset_sum_supported?", rbss_supported, 4);
     eTimeoutError = rb_define_class_under(SubsetSum, "TimeoutError", rb_eStandardError);
 }

data/subset_sum.rb

@@ -1,73 +1,77 @@
-# This module provides both a C and pure ruby simple subset sum problem solver.
-# The subset sum problem is, given a set of numbers, can the sum of any subset
-# of those numbers equal a given number.  This problem is NP-complete.
-# 
-# Both the C and pure ruby versions implement a fairly simple
-# meet-in-the-middle algorithm.  The C version uses an AVL tree to store the
-# data, while the pure ruby version uses a ruby hash. For the C version to be
-# used, the sum of the positive numbers and the sum of the negative numbers in
-# the set, as well as the wanted number, must all be Fixnums.  Additionally,
-# max_seconds should be nil or a Fixnum.
-module SubsetSum
-  # Exception raised when timeout expires
-  class TimeoutError < StandardError
-  end
-  
-  # Return first subset of values that sum to want, using the meet in the
-  # middle algorithm (O(n * 2^(n/2)).
-  def self.subset_sum(values, want, max_seconds=nil)
-    raise(TypeError, "values must be an array of Integers") unless values.is_a?(Array)
-    raise(TypeError, "want must be an Integer") unless want.is_a?(Integer)
-    
-    # Optimization by removing 0 values and doing some simple checks
-    values = values.reject{|x| x == 0}
-    values.each{|value| return [value] if value == want}
-    return values if sum(values) == want
-    pos, neg = values.partition{|x| x > 0}
-    sp, sn = sum(pos), sum(neg)
-    return pos if sp == want
-    return neg if sn == want
-    
-    # Use the C version if it exists and all values will be inside the machine
-    # limits
-    return _subset_sum(values, want, max_seconds.to_i) if \
-      respond_to?(:_subset_sum, true) and want.is_a?(Fixnum) and \
-      sum(pos).is_a?(Fixnum) and sum(neg).is_a?(Fixnum) and \
-      max_seconds.to_i.is_a?(Fixnum)
-
-    # The pure ruby version 
-    sums = {}
-    start_time = Time.now if max_seconds
-    l = values.length/2
-    subsets(values[0...l]) do |subset|
-      raise(TimeoutError, "timeout expired") if max_seconds and Time.now - start_time > max_seconds
-      sums[sum(subset)] = subset
-    end
-    subsets(values[l..-1]) do |subset|
-      raise(TimeoutError, "timeout expired") if max_seconds and Time.now - start_time > max_seconds
-      if subset2 = sums[want - sum(subset)]
-        return subset2 + subset
-      end
-    end
-    nil
-  end
-
-  # Yield all subsets of the array to the block.
-  def self.subsets(array, skip = 0, &block)
-    yield(array)
-    (array.length-1).downto(skip){|i| subsets(array[0...i] + array[i+1..-1], i, &block)}
-  end
-  
-  # Return the sum of the values.
-  def self.sum(values)
-    values.inject(0){|x,y| x+=y}
-  end
-  
-  private_class_method :subsets, :sum
-end
-
-begin
-  require 'subset_sum.so'
-  SubsetSum.send(:private_class_method, :_subset_sum)
-rescue LoadError
-end
+# ruby-subset_sum implements a subset sum solver for ruby.
+#
+# Homepage: http://ruby-subsetsum.jeremyevans.net
+# Source: https://github.com/jeremyevans/ruby-subset_sum
+
+# This module provides both a C and pure ruby simple subset sum problem solver.
+# The subset sum problem is, given a set of numbers, can the sum of any subset
+# of those numbers equal a given number.  This problem is NP-complete.
+# 
+# Both the C and pure ruby versions implement a fairly simple
+# meet-in-the-middle algorithm.  The C version uses an AVL tree to store the
+# data, while the pure ruby version uses a ruby hash. For the C version to be
+# used, the sum of the positive numbers and the sum of the negative numbers in
+# the set, as well as the wanted number, must all be Fixnums.  Additionally,
+# max_seconds should be nil or a Fixnum.
+module SubsetSum
+  # Exception raised when timeout expires
+  class TimeoutError < StandardError
+  end
+  
+  # Return first subset of values that sum to want, using the meet in the
+  # middle algorithm (O(n * 2^(n/2)).
+  def self.subset_sum(values, want, max_seconds=nil)
+    raise(TypeError, "values must be an array of Integers") unless values.is_a?(Array)
+    raise(TypeError, "want must be an Integer") unless want.is_a?(Integer)
+    
+    # Optimization by removing 0 values and doing some simple checks
+    values = values.reject{|x| x == 0}
+    values.each{|value| return [value] if value == want}
+    return values if sum(values) == want
+    pos, neg = values.partition{|x| x > 0}
+    sp, sn = sum(pos), sum(neg)
+    return pos if sp == want
+    return neg if sn == want
+    
+    # Use the C version if it exists and all values will be inside the machine
+    # limits
+    if respond_to?(:_subset_sum, true) && _subset_sum_supported?(want, sp, sn, max_seconds.to_i)
+      return _subset_sum(values, want, max_seconds.to_i)
+    end
+
+    # The pure ruby version 
+    sums = {}
+    start_time = Time.now if max_seconds
+    l = values.length/2
+    subsets(values[0...l]) do |subset|
+      raise(TimeoutError, "timeout expired") if max_seconds and Time.now - start_time > max_seconds
+      sums[sum(subset)] = subset
+    end
+    subsets(values[l..-1]) do |subset|
+      raise(TimeoutError, "timeout expired") if max_seconds and Time.now - start_time > max_seconds
+      if subset2 = sums[want - sum(subset)]
+        return subset2 + subset
+      end
+    end
+    nil
+  end
+
+  # Yield all subsets of the array to the block.
+  def self.subsets(array, skip = 0, &block)
+    yield(array)
+    (array.length-1).downto(skip){|i| subsets(array[0...i] + array[i+1..-1], i, &block)}
+  end
+  
+  # Return the sum of the values.
+  def self.sum(values)
+    values.inject(0){|x,y| x+=y}
+  end
+  
+  private_class_method :subsets, :sum
+end
+
+begin
+  require 'subset_sum.so'
+  SubsetSum.send(:private_class_method, :_subset_sum)
+rescue LoadError
+end

metadata

@@ -1,71 +1,49 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: subset_sum
-version: !ruby/object:Gem::Version 
-  hash: 21
-  prerelease: false
-  segments: 
-  - 1
-  - 0
-  - 1
-  version: 1.0.1
+version: !ruby/object:Gem::Version
+  version: 1.0.2
 platform: ruby
-authors: 
+authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-11-20 00:00:00 -08:00
-default_executable: 
+date: 2016-12-05 00:00:00.000000000 Z
 dependencies: []
-
 description: 
 email: code@jeremyevans.net
 executables: []
-
-extensions: 
+extensions:
 - extconf.rb
 extra_rdoc_files: []
-
-files: 
+files:
 - LICENSE
 - extconf.rb
+- spec/subset_sum_spec.rb
 - subset_sum.c
 - subset_sum.rb
-- spec/subset_sum_spec.rb
-has_rdoc: true
-homepage: http://subset-sum.rubyforge.org/
+homepage: http://ruby-subsetsum.jeremyevans.net/
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
-- .
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+require_paths:
+- "."
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: subset-sum
-rubygems_version: 1.3.7
+rubyforge_project: 
+rubygems_version: 2.6.8
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Simple Subset Sum Solver with C and Pure Ruby Versions
-test_files: 
+test_files:
 - spec/subset_sum_spec.rb