huge_enumerable 0.0.1 → 0.0.2

data/lib/huge_enumerable/huge_collection.rb

@@ -1,83 +1,83 @@
-require 'huge_enumerable'
-# The simplest form of a HugeEnumerable.
-# This class can be used for large arrays or anything else that responds to [].
-# It is not necessary for the enumerable to be completely mapped into memory.
-# It only has to be able to return the element mapped to the index given to [].
-# ==== Examples
-#
-# Using HugeCollection directly:
-#
-#    original_array = ('a'..'z').to_a
-#    collection = HugeCollection.new(original_array)
-#    collection.shuffle!
-#    original_array[0..4] # => ["a", "b", "c", "d", "e"]
-#    collection[0..4] # => ["j", "a", "r", "i", "z"]
-#
-#
-# Subclassing HugeCollection
-#
-#    class StringNext < HugeCollection
-#
-#      def initialize(size)
-#        @collection_size = size
-#        super ('a'..'z').to_a
-#      end
-#
-#      private
-#
-#      def fetch(index)
-#        result = ""
-#        index += 1
-#        while index > 0
-#          index -= 1
-#          result.prepend super(index % 26)
-#          index /= 26
-#        end
-#        result
-#      end
-#
-#    end
-#
-#    googol = 10*100
-#    collection = StringNext.new(googol)
-#    collection.size # => 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
-#    collection[0]          # => "a"
-#    collection[-1]         # => "zhxrtplbmwaiwcqlzpmglpziaegsdivmbvlnssusbjtbcgywaycqnhxztqwwikxvrsptazpp"
-#    collection[googol / 2] # => "dlijhfafxmqxnusmhfpshmdmopvodxfnkfgivwvnejaapyxmynutdlmjhxxqrykiiuizzhi"
-#    collection.shuffle!
-#    collection[0]          # => "bipzqqzayczkgsmaseflwktpsotzclcjsqlnnjaciaawufpojywxflknuddhqkilhoedacn"
-#    collecyion[-1]         # => "etneuebyurxgrvrfsreesxuvjaiyoqwplofsptacjdbhuhafdiwbwujvniokltgkjbfkiuy"
-class HugeCollection < HugeEnumerable
-
-  # Create a new HugeCollection
-  #
-  # ==== Attributes
-  #
-  # * +enumerable+ - Any enumerable that responds to []
-  #
-  # ==== Options
-  #
-  # * +:max_array_size+ - The default size of arrays when #to_a is called.
-  # * +:rng+ - The random number generator to use.
-  def initialize(enumerable, max_array_size = nil, rng = nil)
-    @enum = enumerable
-    super(max_array_size, rng)
-  end
-
-  private
-
-  attr_accessor :enum
-
-  def collection_size
-    @collection_size ||= enum_size
-  end
-
-  def enum_size
-    @enum_size ||= enum.size
-  end
-
-  def fetch(index)
-    enum[index]
-  end
-
-end
+require 'huge_enumerable'
+# The simplest form of a HugeEnumerable.
+# This class can be used for large arrays or anything else that responds to [].
+# It is not necessary for the enumerable to be completely mapped into memory.
+# It only has to be able to return the element mapped to the index given to [].
+# ==== Examples
+#
+# Using HugeCollection directly:
+#
+#    original_array = ('a'..'z').to_a
+#    collection = HugeCollection.new(original_array)
+#    collection.shuffle!
+#    original_array[0..4] # => ["a", "b", "c", "d", "e"]
+#    collection[0..4] # => ["j", "a", "r", "i", "z"]
+#
+#
+# Subclassing HugeCollection
+#
+#    class StringNext < HugeCollection
+#
+#      def initialize(size)
+#        @collection_size = size
+#        super ('a'..'z').to_a
+#      end
+#
+#      private
+#
+#      def fetch(index)
+#        result = ""
+#        index += 1
+#        while index > 0
+#          index -= 1
+#          result.prepend super(index % 26)
+#          index /= 26
+#        end
+#        result
+#      end
+#
+#    end
+#
+#    googol = 10*100
+#    collection = StringNext.new(googol)
+#    collection.size # => 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+#    collection[0]          # => "a"
+#    collection[-1]         # => "zhxrtplbmwaiwcqlzpmglpziaegsdivmbvlnssusbjtbcgywaycqnhxztqwwikxvrsptazpp"
+#    collection[googol / 2] # => "dlijhfafxmqxnusmhfpshmdmopvodxfnkfgivwvnejaapyxmynutdlmjhxxqrykiiuizzhi"
+#    collection.shuffle!
+#    collection[0]          # => "bipzqqzayczkgsmaseflwktpsotzclcjsqlnnjaciaawufpojywxflknuddhqkilhoedacn"
+#    collection[-1]         # => "etneuebyurxgrvrfsreesxuvjaiyoqwplofsptacjdbhuhafdiwbwujvniokltgkjbfkiuy"
+class HugeCollection < HugeEnumerable
+
+  # Create a new HugeCollection
+  #
+  # ==== Attributes
+  #
+  # * +enumerable+ - Any enumerable that responds to []
+  #
+  # ==== Options
+  #
+  # * +:max_array_size+ - The default size of arrays when #to_a is called.
+  # * +:rng+ - The random number generator to use.
+  def initialize(enumerable, max_array_size = nil, rng = nil)
+    @enum = enumerable
+    super(max_array_size, rng)
+  end
+
+  private
+
+  attr_accessor :enum
+
+  def collection_size
+    @collection_size ||= enum_size
+  end
+
+  def enum_size
+    @enum_size ||= enum.size
+  end
+
+  def fetch(index)
+    enum[index]
+  end
+
+end

data/lib/huge_enumerable/huge_combination.rb

@@ -1,118 +1,112 @@
-require 'huge_enumerable'
-# HugeCombination is a HugeEnumerable style combination. Comparable to Array#combination.
-# This class can be used to generate combinations of large arrays or anything else that responds to [].
-# It is not necessary for the enumerable to be completely mapped into memory.
-# It only has to be able to return the element mapped to the index given to [].
-# ==== Examples
-#
-# Using HugeCombination directly:
-#
-#    combination = HugeCombination.new(('a'..'z').to_a, 2)
-#    combination[0..4] # => [["a", "b"], ["a", "c"], ["a", "d"], ["a", "e"], ["a", "f"]]
-#    combination[23..27] # => [["a", "y"], ["a", "z"], ["b", "c"], ["b", "d"], ["b", "e"]]
-#
-#
-# Subclassing HugeCombination
-#
-#    class NumberArray < HugeCollection
-#
-#      def initialize(size)
-#        @collection_size = size
-#        super(nil)
-#      end
-#
-#      private
-#
-#      def fetch(index)
-#        index
-#      end
-#
-#    end
-#
-#    class NumberCombination < HugeCombination
-#
-#      def initialize(size)
-#        enumerable = size < 10 ? (0...size).to_a : NumberArray.new(size)
-#        super enumerable, 2, nil, nil
-#      end
-#
-#      private
-#
-#      def fetch(index)
-#        array = super
-#        sum = array.inject(0) { |sum, i| sum += i }
-#        "#{array.first} + #{array.last} = #{sum}"
-#      end
-#
-#    end
-#
-#    combination = NumberCombination.new(10**30)
-#    size = combination.size # => 499999999999999999999999999999500000000000000000000000000000
-#    combination[0]          # => "0 + 1 = 1"
-#    combination[-1]         # => "999999999999999999999999999998 + 999999999999999999999999999999 = 1999999999999999999999999999997"
-#    combination[size / 2]   # => "292893218813452475599155637895 + 296085173605458049080913472356 = 588978392418910524680069110251"
-class HugeCombination < HugeCollection
-
-  # Create a new HugeCombination
-  #
-  # ==== Attributes
-  #
-  # * +enumerable+ - Any enumerable that responds to []
-  # * +size+ - The number of elements per combination to use from enumerable. (Currently only size 2 is supported)
-  #
-  # ==== Options
-  #
-  # * +:max_array_size+ - The default size of arrays when #to_a is called.
-  # * +:rng+ - The random number generator to use.
-  def initialize(enumerable, size, max_array_size = nil, rng = nil)
-    raise NotImplementedError, "Not yet implemented for any size != 2" if size != 2 # TODO: Extend this class to handle length N
-    @combination_size = size
-    super(enumerable, max_array_size, rng)
-  end
-
-  private
-
-  def collection_size
-    sum(enum_size - 1)
-  end
-
-  def fetch(index)
-    cycle = locate_cycle(index)
-    first_index = cycle - 1
-    max_cycles = enum_size - 1
-    used = (cycle - 1) == 0 ? 0 : sum_from(max_cycles, max_cycles - (cycle - 2))
-    second_index = index - used + cycle
-    [enum[first_index], enum[second_index]]
-  end
-
-  def locate_cycle(index, min=0, max=enum_size-1)
-    cycle = min + (max - min) / 2
-
-    check_high = sum_at_cycle(cycle)
-    check_low = sum_at_cycle(cycle - 1)
-
-    if check_high > index && check_low <= index
-      cycle
-    elsif check_low > index
-      locate_cycle(index, min, cycle-1)
-    else
-      locate_cycle(index, cycle+1, max)
-    end
-  end
-
-  def sum(x)
-    x * (x + 1) / 2
-  end
-
-  def sum_from(m, n)
-    m, n = [n, m] if m > n
-    (n + 1 - m)*(n + m)/2
-  end
-
-  def sum_at_cycle(c)
-    ec = enum_size * c
-    (-c + 2*ec - c**2)/2
-  end
-
-end
-
+require 'huge_enumerable'
+# HugeCombination is a HugeEnumerable style combination. Comparable to Array#combination.
+# This class can be used to generate combinations of large arrays or anything else that responds to [].
+# It is not necessary for the enumerable to be completely mapped into memory.
+# It only has to be able to return the element mapped to the index given to [].
+# ==== Examples
+#
+# Using HugeCombination directly:
+#
+#    combination = HugeCombination.new(('a'..'z').to_a, 2)
+#    combination[0..4] # => [["a", "b"], ["a", "c"], ["a", "d"], ["a", "e"], ["a", "f"]]
+#    combination[23..27] # => [["a", "y"], ["a", "z"], ["b", "c"], ["b", "d"], ["b", "e"]]
+#
+#
+# Subclassing HugeCombination
+#
+#    class NumberArray < HugeCollection
+#
+#      def initialize(size)
+#        @collection_size = size
+#        super(nil)
+#      end
+#
+#      private
+#
+#      def fetch(index)
+#        index
+#      end
+#
+#    end
+#
+#    class NumberCombination < HugeCombination
+#
+#      def initialize(size)
+#        enumerable = size < 10 ? (0...size).to_a : NumberArray.new(size)
+#        super enumerable, 2, nil, nil
+#      end
+#
+#      private
+#
+#      def fetch(index)
+#        array = super
+#        sum = array.inject(0) { |sum, i| sum += i }
+#        "#{array.first} + #{array.last} = #{sum}"
+#      end
+#
+#    end
+#
+#    combination = NumberCombination.new(10**30)
+#    size = combination.size # => 499999999999999999999999999999500000000000000000000000000000
+#    combination[0]          # => "0 + 1 = 1"
+#    combination[-1]         # => "999999999999999999999999999998 + 999999999999999999999999999999 = 1999999999999999999999999999997"
+#    combination[size / 2]   # => "292893218813452475599155637895 + 296085173605458049080913472356 = 588978392418910524680069110251"
+class HugeCombination < HugeCollection
+
+  # Create a new HugeCombination
+  #
+  # ==== Attributes
+  #
+  # * +enumerable+ - Any enumerable that responds to []
+  # * +size+ - The number of elements per combination to use from enumerable.
+  #
+  # ==== Options
+  #
+  # * +:max_array_size+ - The default size of arrays when #to_a is called.
+  # * +:rng+ - The random number generator to use.
+  def initialize(enumerable, size, max_array_size = nil, rng = nil)
+    @combination_size = size
+    super(enumerable, max_array_size, rng)
+  end
+
+  private
+
+  attr_reader :combination_size
+
+  def collection_size
+    @collection_size ||= size_of_combination(enum_size, combination_size)
+  end
+
+  def fetch(index)
+    indexes_for(collection_size - index - 1).map { |i| enum[enum_size - i - 1] }
+  end
+
+  def size_of_combination(n, k)
+    k < 0 || n < k ? 0 : factorial(n)/(factorial(k) * factorial(n - k))
+  end
+
+  def indexes_for(position)
+    k = combination_size
+    indexes = []
+    while k > 0
+      n, size = next_n_and_size(position, k)
+      position -= size
+      k -= 1
+      indexes << n
+    end
+    indexes
+  end
+
+  def next_n_and_size(p, k)
+    n = k - 1
+    size = size_of_combination(n, k)
+    begin
+      rc = [n, size]
+      n += 1
+      size = size_of_combination(n, k)
+    end while size <= p
+    rc
+  end
+
+end
+

data/lib/huge_enumerable/huge_permutation.rb

@@ -1,67 +1,80 @@
-require 'huge_enumerable'
-# HugePermutation is a HugeEnumerable style permutation. Comparable to Array#permutation.
-# This class can be used to generate permutations of large arrays or anything else that responds to [].
-# It is not necessary for the enumerable to be completely mapped into memory.
-# It only has to be able to return the element mapped to the index given to [].
-# ==== Examples
-#
-# Using HugePermutation directly:
-#
-#    permutation = HugePermutation.new(('a'..'z').to_a, 2)
-#    permutation[0..4]   # => [["a", "b"], ["a", "c"], ["a", "d"], ["a", "e"], ["a", "f"]]
-#    permutation[23..27] # => [["a", "y"], ["a", "z"], ["b", "a"], ["b", "c"], ["b", "d"]]
-#
-#
-# Subclassing HugePermutation
-#
-#    class SouthernNames < HugePermutation
-#
-#      def initialize
-#        base_names = %w{Bill Joe Jo Bob Mary Lou Betty Sue Jimmy Ann Lee Ruby Jack Belle Daisy Dixie Lynn}
-#        super base_names, 2, nil, nil
-#      end
-#
-#      private
-#
-#      def fetch(index)
-#        "Your southern name is: #{super(index).join(' ')}"
-#      end
-#
-#    end
-#
-#    southern_name = SouthernNames.new
-#    southern_name[0]          # => "Your southern name is: Bill Joe"
-#    southern_name[-1]         # => "Your southern name is: Lynn Dixie"
-#    size = southern_name.size # => 272
-#    southern_name[size / 2]   # => "Your southern name is: Jimmy Ann"
-class HugePermutation < HugeCollection
-
-  # Create a new HugePermutation
-  #
-  # ==== Attributes
-  #
-  # * +enumerable+ - Any enumerable that responds to []
-  # * +size+ - The number of elements per permutation to use from enumerable. (Currently only size 2 is supported)
-  #
-  # ==== Options
-  #
-  # * +:max_array_size+ - The default size of arrays when #to_a is called.
-  # * +:rng+ - The random number generator to use.
-  def initialize(enumerable, length, max_array_size = nil, rng = nil)
-    raise NotImplementedError, "Not yet implemented for any length != 2" if length != 2 # TODO: Extend this class to handle length N
-    super(enumerable, max_array_size, rng)
-  end
-
-  private
-
-  def fetch(x)
-    first_index = x / (enum_size - 1)
-    second_index = ((x % enum_size) + (x / enum_size + 1)) % enum_size
-    [enum[first_index], enum[second_index]]
-  end
-
-  def collection_size
-    enum_size * (enum_size - 1)
-  end
-
-end
+require 'huge_enumerable'
+# HugePermutation is a HugeEnumerable style permutation. Comparable to Array#permutation.
+# This class can be used to generate permutations of large arrays or anything else that responds to [].
+# It is not necessary for the enumerable to be completely mapped into memory.
+# It only has to be able to return the element mapped to the index given to [].
+# ==== Examples
+#
+# Using HugePermutation directly:
+#
+#    permutation = HugePermutation.new(('a'..'z').to_a, 2)
+#    permutation[0..4]   # => [["a", "b"], ["a", "c"], ["a", "d"], ["a", "e"], ["a", "f"]]
+#    permutation[23..27] # => [["a", "y"], ["a", "z"], ["b", "a"], ["b", "c"], ["b", "d"]]
+#
+#
+# Subclassing HugePermutation
+#
+#    class SouthernNames < HugePermutation
+#
+#      def initialize
+#        base_names = %w{Bill Joe Jo Bob Mary Lou Betty Sue Jimmy Ann Lee Ruby Jack Belle Daisy Dixie Lynn}
+#        super base_names, 2, nil, nil
+#      end
+#
+#      private
+#
+#      def fetch(index)
+#        "Your southern name is: #{super(index).join(' ')}"
+#      end
+#
+#    end
+#
+#    southern_name = SouthernNames.new
+#    southern_name[0]          # => "Your southern name is: Bill Joe"
+#    southern_name[-1]         # => "Your southern name is: Lynn Dixie"
+#    size = southern_name.size # => 272
+#    southern_name[size / 2]   # => "Your southern name is: Jimmy Ann"
+class HugePermutation < HugeCollection
+
+  # Create a new HugePermutation
+  #
+  # ==== Attributes
+  #
+  # * +enumerable+ - Any enumerable that responds to []
+  # * +size+ - The number of elements per permutation to use from enumerable.
+  #
+  # ==== Options
+  #
+  # * +:max_array_size+ - The default size of arrays when #to_a is called.
+  # * +:rng+ - The random number generator to use.
+  def initialize(enumerable, size, max_array_size = nil, rng = nil)
+    @permutation_size = size
+    super(enumerable, max_array_size, rng)
+  end
+
+  private
+
+  attr_accessor :permutation_size
+
+  def fetch(x)
+    indexes_for(x).map { |i| enum[i] }
+  end
+
+  def collection_size
+    @collection_size ||= factorial(enum_size) / factorial(enum_size - permutation_size)
+  end
+
+  def indexes_for(position)
+    inversions = []
+    (enum_size-permutation_size+1..enum_size).each do |m|
+      inversions.unshift(position % m)
+      position /= m
+    end
+
+    indexes = []
+    positions = (0..enum_size-1).to_a
+    permutation_size.times { |i| indexes << positions.delete_at(inversions[i]) }
+    indexes
+  end
+
+end