subset_sum 1.0.0

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2008 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
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+  
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+   
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile("subset_sum")

data/spec/subset_sum_spec.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env spec
+require 'subset_sum'
+
+context "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)
+  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)
+  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
+  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]
+    
+    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
+  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)
+  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]
+  end
+end
+

data/subset_sum.c

@@ -0,0 +1,347 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "ruby.h"
+
+static VALUE eTimeoutError;
+
+typedef struct _sum_node {
+    long sum;
+    long length;
+    long height;
+    long* numbers;
+    struct _sum_node *left;
+    struct _sum_node *right;
+} sum_node;
+
+static long rbss_sum(long* numbers, long length) {
+    long i;
+    long sum = 0;
+    for(i=0; i<length; i++) {
+        sum += numbers[i];
+    }
+    return sum;
+}
+
+/*
+static void rbss_print(long* numbers, long length) {
+    long i;
+    long sum = 0;
+    printf("[");
+    for(i=0; i<length; i++) {
+        printf("%ld,", numbers[i]);
+    }
+    printf("]\n");
+    return;
+}
+*/
+
+static void rbss_free_nodes(sum_node* node) {
+    if(node != NULL) {
+        rbss_free_nodes(node->left);
+        node->left = NULL;
+        rbss_free_nodes(node->right);
+        node->right = NULL;
+        free(node->numbers);
+        node->numbers = NULL;
+        free(node);
+        node = NULL;
+    }
+}
+
+static sum_node* rbss_new_node(long* numbers, long length) {
+    sum_node* node;
+    
+    if((node = (sum_node*)calloc(1, sizeof(sum_node))) == NULL) {
+        return NULL;
+    }
+    if((node->numbers = (long*)calloc(length, sizeof(long))) == NULL) {
+        free(node);
+        return NULL;
+    }
+    node->sum = rbss_sum(numbers, length);
+    node->length = length;
+    node->height = 0;
+    memcpy(node->numbers, numbers, length*sizeof(long));
+    node->left = NULL;
+    node->right = NULL;
+    return node;
+}
+
+static long rbss_height(sum_node* node) {
+    return node == NULL ? -1 : node->height;
+}
+
+static long rbss_max(long h1, long h2) {
+    return h1 > h2 ? h1 : h2;
+}
+
+static void rbss_reset_height(sum_node* node) {
+    node->height = rbss_max(rbss_height(node->left), rbss_height(node->right)) + 1;
+}
+
+static sum_node* rbss_rotate_left_1(sum_node* node2) {
+    sum_node* node1;
+    
+    node1 = node2->left;
+    node2->left = node1->right;
+    node1->right = node2;
+    
+    rbss_reset_height(node2);
+    rbss_reset_height(node1);
+    return node1;
+}
+
+static sum_node* rbss_rotate_right_1(sum_node* node1) {
+    sum_node* node2;
+    
+    node2 = node1->right;
+    node1->right = node2->left;
+    node2->left = node1;
+    
+    rbss_reset_height(node1);
+    rbss_reset_height(node2);
+    return node2;
+}
+
+static sum_node* rbss_rotate_left_2(sum_node* node) {
+    node->left = rbss_rotate_right_1(node->left);
+    return rbss_rotate_left_1(node);
+}
+
+static sum_node* rbss_rotate_right_2(sum_node* node) {
+    node->right = rbss_rotate_left_1(node->right);
+    return rbss_rotate_right_1(node);
+}
+
+/* Insert a new node in the AVL tree */
+static sum_node* rbss_insert(sum_node* node, long sum, long* numbers, long length) {
+    sum_node* t;
+    
+    if(node == NULL) {
+        node = rbss_new_node(numbers, length);
+        return node;
+    }
+    if(sum < node->sum) {
+        if((t = rbss_insert(node->left, sum, numbers, length)) == NULL) {
+            return NULL;
+        }
+        node->left = t;
+        if(rbss_height(node->left) - rbss_height(node->right) == 2) {
+            if(sum < node->left->sum) {
+                node = rbss_rotate_left_1(node);
+            } else {
+                node = rbss_rotate_left_2(node);
+            }
+        }
+    } else if (sum > node->sum) {
+        if((t = rbss_insert(node->right, sum, numbers, length)) == NULL) {
+            return NULL;
+        }
+        node->right = t;
+        if(rbss_height(node->right) - rbss_height(node->left) == 2) {
+            if(sum > node->right->sum) {
+                node = rbss_rotate_right_1(node);
+            } else {
+                node = rbss_rotate_right_2(node);
+            }
+        }
+    }
+    rbss_reset_height(node);
+    return node;
+}
+
+/* Look in the tree to see if there is a node with the matching sum. */
+static sum_node* rbss_lookup(sum_node* node, long sum) {
+    if(node == NULL) {
+        return NULL;
+    }
+    return sum == node->sum ? node : rbss_lookup(sum < node->sum ? node->left : node->right, sum);
+}
+
+/* Add a node to the tree associating the sum of the numbers with the numbers */
+static int rbss_add(sum_node** table, long* numbers, long length, long* temp, long want) {
+    sum_node* t;
+    t = rbss_insert(*table, rbss_sum(numbers, length), numbers, length);
+    if(t == NULL) {
+        return -1;
+    }
+    *table = t;
+    return 0;
+}
+
+/* Check and see if the difference between the sum of the numbers and the
+   number we want is in the tree.  If so, update temp to be the current
+   array of numbers plus the matching value in the tree. */
+static int rbss_check(sum_node** table, long* numbers, long length, long* temp, long want) {
+    long sum;
+    long diff;
+    sum_node* node;
+    
+    sum = rbss_sum(numbers, length);
+    diff = want - sum;
+    if((node = rbss_lookup(*table, diff)) == NULL) {
+        return 0;
+    }
+    memcpy(temp, node->numbers, node->length*sizeof(long));
+    memcpy(temp+node->length, numbers, length*sizeof(long));
+    return 1;
+}
+
+/* For each subset of the array of numbers, execute the function, passing
+   the table, subset, length of subset, and the temp and want variables to
+   the function. */
+static int rbss_subsets(int(*func)(sum_node**, long*, long, long*, long), sum_node** table, long* numbers, long length, long skip, long* temp, long want, time_t start_time, time_t max_seconds) {
+    int result;
+    time_t current_time;
+    long i;
+    long limit;
+    long* temp_numbers;
+    
+    limit = length - 1;
+    if((result = (*func)(table, numbers, length, temp, want)) != 0) {
+        return result;
+    }
+    if(limit > 0) {
+        if(max_seconds){
+            if((current_time = time(NULL)) == -1) {
+                return -3;
+            }
+            if(current_time - start_time > max_seconds) {
+                return -2;
+            }
+        }
+        if((temp_numbers = (long*)calloc(limit, sizeof(long))) == NULL) {
+            rb_raise(rb_eNoMemError, "calloc");
+        }
+        for(i=limit; i>=skip; i--) {
+            memcpy(temp_numbers, numbers, i*sizeof(long));
+            memcpy(temp_numbers+i, numbers+i+1, (limit-i)*sizeof(long));
+            if((result = rbss_subsets(func, table, temp_numbers, limit, i, temp, want, start_time, max_seconds)) != 0) {
+                free(temp_numbers);
+                return result;
+            }
+        }
+        free(temp_numbers);
+    }
+    return 0;
+}
+
+/* Build a ruby array of Fixnums from the C array of longs */
+static VALUE rbss_array(long* numbers, long length) {
+    long i;
+    VALUE array;
+    
+    array = rb_ary_new();
+    for(i=0;i<length;i++) {
+        if(numbers[i] != 0) {
+            rb_ary_push(array, LONG2NUM(numbers[i]));
+        }
+    }
+    return array;
+}
+
+/* Raise a ruby exception based on the result of res.
+   Should only be run after the all memory has been cleaned up. */
+static void rbss_raise_error(int res) {
+    if(res == -1) {
+        rb_raise(rb_eNoMemError, "calloc");
+    }
+    if(res == -2) {
+        rb_raise(eTimeoutError, "timeout expired");
+    }
+    if(res == -3) {
+        rb_raise(rb_eStandardError, "can't get current time");
+    }
+}
+
+/*
+Document-method: subset_sum
+
+call-seq:
+  SubsetSum.subset_sum(array, num) -> subset_of_array || nil
+
+If a subset of the numbers in array sum to num, the subset is returned.
+Otherwise, nil is returned.
+*/
+static VALUE rbss_main(VALUE self, VALUE numbers, VALUE result, VALUE max_seconds) {
+    int res;
+    time_t start_time = 0;
+    time_t c_max_seconds;
+    long i;
+    long length;
+    long half_length;
+    long c_result;
+    long* c_numbers;
+    long* c_numbers_tmp;
+    sum_node* table = NULL;
+    VALUE answer;
+    
+    Check_Type(numbers, T_ARRAY);
+    
+    c_result = NUM2LONG(result);
+    c_max_seconds = NUM2INT(max_seconds);
+    length = RARRAY(numbers)->len;
+    half_length = length/2;
+    
+    if(c_max_seconds < 0) {
+        c_max_seconds = 0;
+    }
+    if(c_max_seconds) {
+        if((start_time = time(NULL)) == -1) {
+            rb_raise(rb_eStandardError, "can't get current time");
+        }
+    }
+    
+    if((c_numbers = (long*)calloc(length*2, sizeof(long))) == NULL) {
+        rb_raise(rb_eNoMemError, "calloc");
+    }
+    c_numbers_tmp = c_numbers+length;
+
+    for(i=0; i<length; i++) {
+        c_numbers[i] = NUM2LONG(rb_ary_entry(numbers, i));
+    }
+    
+    /* Initialize the tree with an empty subset */
+    table = rbss_insert(table, 0, NULL, 0);
+
+    /* Add a node to the tree for each subset of the first half of the set */
+    if((res = rbss_subsets(&rbss_add, &table, c_numbers, half_length, 0, \
+      c_numbers_tmp, c_result, start_time, c_max_seconds)) != 0) {
+        rbss_free_nodes(table);
+        free(c_numbers);
+        rbss_raise_error(res);
+    }
+
+    /* See if one of the subsets in the first half sums to the result */
+    if((res = rbss_check(&table, NULL, 0, c_numbers_tmp, c_result)) == 0) {
+       /* Check all subsets in the second half, and see if the difference
+          between their sum and the result is a sum of one of the subsets
+          in the first half */
+        res = rbss_subsets(&rbss_check, &table, c_numbers+half_length, \
+          length-half_length, 0, c_numbers_tmp, c_result, start_time, \
+          c_max_seconds);
+    }
+    if(res < 1) {
+        rbss_free_nodes(table);
+        free(c_numbers);
+        if(res < 0) {
+            rbss_raise_error(res);
+        }
+        return Qnil;
+    }
+
+    rbss_free_nodes(table);
+    answer = rbss_array(c_numbers_tmp, length);
+    free(c_numbers);
+    return answer;
+}
+
+void Init_subset_sum() {
+    VALUE SubsetSum;
+    SubsetSum = rb_define_module("SubsetSum");
+    rb_define_module_function(SubsetSum, "_subset_sum", rbss_main, 3);
+    eTimeoutError = rb_define_class_under(SubsetSum, "TimeoutError", rb_eStandardError);
+}

data/subset_sum.rb

@@ -0,0 +1,73 @@
+# 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

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: subset_sum
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Jeremy Evans
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-08 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: code@jeremyevans.net
+executables: []
+
+extensions: 
+- extconf.rb
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- extconf.rb
+- subset_sum.c
+- subset_sum.rb
+- spec/subset_sum_spec.rb
+has_rdoc: true
+homepage: http://subset-sum.rubyforge.org/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: subset-sum
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Simple Subset Sum Solver in C
+test_files: 
+- spec/subset_sum_spec.rb