array_partition 0.1.0

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+.gem
+
+## PROJECT::SPECIFIC

data/README.md

@@ -0,0 +1,27 @@
+# Array Partition
+by Aish Fenton for [vWorkApp](http://www.vworkapp.com)
+
+A little gem that gives you all partitions of an array into at most *k* sub-arrays. Useful for generating test scenarios and solving certain kinds of optimisation problems. 
+
+    ["Apple", "Orange", "Pear"].partition(2)
+
+    [
+        [["Apple", "Orange", "Pear"]], 
+        [["Apple", "Orange"], ["Pear"]], 
+        [["Apple", "Pear"], ["Orange"]], 
+        [["Apple"], ["Orange", "Pear"]]
+    ]
+        
+The gem can also be used to provide the [Stirling Number of the Second Kind](http://en.wikipedia.org/wiki/Stirling_numbers_of_the_second_kind) of the array.
+
+## Install
+
+    sudo gem install array_partition
+
+## Usage
+
+See example/fuel_tanker.rb for a real-live application of partitions being used to solve a combinatorial optimisation problem.
+
+## Copyright
+
+Copyright (c) 2011 vWorkApp Inc.

data/array_partition.gemspec

@@ -0,0 +1,47 @@
+Gem::Specification.new do |s|
+  s.name = %q{array_partition}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Aish Fenton"]
+  s.date = %q{2011-01-20}
+  s.description = %q{A little gem that gives you all partitions of an array into at most k sub-arrays}
+  s.email = %q{aish@vworkapp.com}
+  s.extra_rdoc_files = [
+     "README.md"
+  ]
+  s.files = [
+     ".gitignore",
+     "README.md",
+     "lib/array_partition.rb",
+     "lib/array_partition/array.rb",
+     "lib/array_partition/partitions.rb",
+     "array_partition.gemspec",
+     "spec/array_ext_spec.rb",
+     "spec/partition_spec.rb",
+     "example/fuel_tanker.rb",
+  ]
+  s.homepage = %q{http://github.com/visfleet/array_partition}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{A little gem that gives you all partitions of an array into at most k sub-arrays}
+  s.test_files = [
+    "spec/array_ext_spec.rb",
+    "spec/partition_spec.rb",
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 2.3"])
+    else
+      s.add_dependency(%q<rspec>, [">= 2.3"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 2.3"])
+  end
+end
+

data/example/fuel_tanker.rb

@@ -0,0 +1,93 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib') unless $LOAD_PATH.include?(File.dirname(__FILE__) + '/../lib')
+require 'array_partition'
+require 'permutation'
+
+# A fuel tanker with 8 compartments (tanks). The tanker can be used to carry up to 8 separate 
+# products (e.g. gas, diesel, milk) but has the constraint that products can't be mixed in a compartment.
+# This class provides the method fit_to_tanks(products) which returns an ordering of which products
+# to put in which tanks, so that as much product is carried as possible. If the products can't fitted
+# to a combination of tanks then nil is returned.
+# 
+class FuelTanker
+  
+  TANKS = [900, 200, 200, 200, 200, 200, 700, 200]
+  
+  def fit_to_tanks(products)
+    partitions = TANKS.partition(products.size)
+    
+    best = nil
+    partitions.each do |p|
+      next if p.size < products.size
+      product_order = try_permutations(p, products)
+      next if product_order.nil?
+      best = [p, product_order]
+    end
+    best
+  end
+
+private
+
+  def try_permutations(partition, products)
+    perm = Permutation.for(products)
+    perm.each do |p|
+      products = p.project
+      next unless try_permutation(partition, products)
+      return products
+    end
+    nil
+  end
+
+  def try_permutation(partition, products) 
+    products.each_with_index do |product, idx|
+      return false unless fits(partition[idx], product)
+    end
+    true
+  end
+
+  def fits(tanks, amount)
+    left_over = tanks.inject(amount) { |amount, tank| amount - tank }
+    left_over <= 0
+  end
+  
+end
+
+class UI
+  def self.start
+    puts "Enter amounts to load (carrage return to end):"
+    products = []
+    while ((line = gets) != "\n")
+      products << line.to_i
+    end
+
+    partition, products = FuelTanker.new.fit_to_tanks(products)
+
+    if partition.nil?
+      puts "Sorry can't fit those amounts in the tanker"
+    else
+      puts "--------\n"
+      puts "Results:\n"
+      products.each_with_index do |product, idx|
+        puts "\tProduct: #{product} in tanks: #{partition[idx].join(",")}"
+      end
+    end
+  end
+end
+
+UI.start  
+
+# gem install permutation
+# 
+# $ ruby example/fuel_tanker.rb 
+# Enter amounts to load (carrage return to end):
+# 900
+# 1200
+# 700
+# 
+# --------
+# Results:
+#   Product: 900 in tanks: 900
+#   Product: 1200 in tanks: 200,200,200,200,200,200
+#   Product: 700 in tanks: 700
+
+
+p ["Apple", "Orange", "Pear"].partition(2)

data/lib/array_partition.rb

@@ -0,0 +1,2 @@
+require 'array_partition/partitions'
+require 'array_partition/array'

data/lib/array_partition/array.rb

@@ -0,0 +1,29 @@
+class Array
+ 
+  def partition(k)
+    partitions = ArrayPartition::Partitions.partitions(self.size, k)
+    
+    result = []
+    
+    partitions.each do |p|
+      r_part = []
+      p.each do |idxs|
+        r_block = []
+        idxs.each do |idx|
+          r_block << self[idx-1]
+        end
+        r_part << r_block
+      end
+      result << r_part
+    end
+    result
+  end
+  
+  def each_partition(k)
+    r = self.partition(k)
+    r.each do |p|
+      yield p
+    end
+  end
+
+end

data/lib/array_partition/partitions.rb

@@ -0,0 +1,31 @@
+
+module ArrayPartition
+    
+  # Partitions a set of size n into no more than k blocks. 
+  class Partitions
+    
+    def self.partitions(n,k)
+      rec_partition(n,k)
+    end
+      
+  private
+    
+    def self.rec_partition(n, k)
+      if n == 1
+        return [[[1]]]
+      else
+        partitions = rec_partition(n-1,k)
+        new_partitions = []
+        partitions.each do |p|
+          p.size.times do |offset|
+            np = p[0, offset] + [p[offset].clone << n] + p[offset+1..-1]
+            new_partitions << np
+          end
+          new_partitions << (p + [[n]]) if p.size < k
+        end
+      end
+      new_partitions
+    end
+  end
+
+end

data/spec/array_ext_spec.rb

@@ -0,0 +1,51 @@
+require 'array_partition'
+
+describe Array do
+
+  context "when calling partition(2) on [a,b,c,d]" do
+    subject do
+      arr = ['a', 'b', 'c', 'd']
+      arr.partition(2)
+    end
+
+    it "produces 8 partitions" do
+      subject.size.should == 8
+    end
+
+    it "has no blocks larger than 2" do
+      subject.each do |p|
+        p.size.should <= 2
+      end
+    end
+    
+    it "contains the right partitions" do
+      subject.should == [
+        [['a','b','c','d']],
+        [['a','b','c'],['d']],
+        [['a','b','d'],['c']],
+        [['a','b'],['c','d']],
+        [['a','c','d'],['b']],
+        [['a','c'],['b','d']],
+        [['a','d'],['b','c']],
+        [['a'],['b','c','d']]
+      ]
+    end    
+  end
+  
+  it "lets you enumerate over the partitions" do
+    arr = ['Apple', 'Orange', 'Pear']
+
+    result = []
+    arr.each_partition(2) do |p|
+      result << p
+    end
+
+    result.should == [
+      [['Apple', 'Orange', 'Pear']],
+      [['Apple', 'Orange'], ['Pear']],
+      [['Apple', 'Pear'], ['Orange']],
+      [['Apple'], ['Orange', 'Pear']],
+    ]
+  end
+
+end

data/spec/partition_spec.rb

@@ -0,0 +1,49 @@
+require 'array_partition'
+
+describe ArrayPartition::Partitions do
+
+  context "when partitioning (1,2,3,4) into 2 blocks" do
+    subject do
+      ArrayPartition::Partitions.partitions(4,2)
+    end
+
+    it "produces 8 partitions" do
+      subject.size.should == 8
+    end
+
+    it "has no blocks larger than 2" do
+      subject.each do |p|
+        p.size.should <= 2
+      end
+    end
+    
+    it "contains the right partitions" do
+      subject.should == [
+        [[1,2,3,4]],
+        [[1,2,3],[4]],
+        [[1,2,4],[3]],
+        [[1,2],[3,4]],
+        [[1,3,4],[2]],
+        [[1,3],[2,4]],
+        [[1,4],[2,3]],
+        [[1],[2,3,4]]
+      ]
+    end
+    
+  end
+
+  context "when partitioning larger sets and larger blocks" do
+  
+    it "produces the right number of partitions for n=8,k=3" do
+      result = ArrayPartition::Partitions.partitions(8,3)
+      result.size.should == 1094
+    end
+
+    it "produces the right number of partitions for n=10,k=6" do
+      result = ArrayPartition::Partitions.partitions(10,6)
+      result.size.should == 109299
+    end
+  
+  end
+
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: array_partition
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Aish Fenton
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-20 00:00:00 +13:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 2
+        - 3
+        version: "2.3"
+  type: :development
+  version_requirements: *id001
+description: A little gem that gives you all partitions of an array into at most k sub-arrays
+email: aish@vworkapp.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- .gitignore
+- README.md
+- lib/array_partition.rb
+- lib/array_partition/array.rb
+- lib/array_partition/partitions.rb
+- array_partition.gemspec
+- spec/array_ext_spec.rb
+- spec/partition_spec.rb
+- example/fuel_tanker.rb
+has_rdoc: true
+homepage: http://github.com/visfleet/array_partition
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  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 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A little gem that gives you all partitions of an array into at most k sub-arrays
+test_files: 
+- spec/array_ext_spec.rb
+- spec/partition_spec.rb