backports 3.6.7 → 3.6.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b4d7b3bbc87415b5338da4e9769d0d039286aa5a
-  data.tar.gz: dd193ae2f5e07769687cc679325e78512f8a505d
+  metadata.gz: 4e7cf14929385f92c1246d5da12ac424b422338e
+  data.tar.gz: ddccf768a48e4cf4327cb2dd4244d14932b9d0bb
 SHA512:
-  metadata.gz: 51f3ece30f31a2927895bb7fe04350f8076f430b29471ddcaceab6bf74a17e3028c3f3a929dcc696df0953186fe752bb7112455df0589b2a198f057046d6edec
-  data.tar.gz: 1d4f8cc2c823dbb006bb56f7a420008d752a083525fbc84ff7dfc56e866c09cc7c34124625cdeb1e32fd2a3b48eec00f97480bb002062d6de526dc4eb4248297
+  metadata.gz: 62b66d725bbd40b4462ef16500c78d8d19a8382e09fbeb834ddbd2eab4a7df9bca45d22382604f91d557481b35873977fc304f266fe29be58c9602803f4db6ce
+  data.tar.gz: 551bddeb601f9eccbbb92469914ef3c7a7a1bd0777f30ec5be5f0763aa3a5b543dbf70fa4159a9ecdd4f7514a632379106af88b685caa03ead26038d88e7cf70

data/Gemfile.lock

@@ -7,7 +7,7 @@ GIT
 PATH
   remote: .
   specs:
-    backports (3.6.7)
+    backports (3.6.8)
 
 GEM
   remote: http://rubygems.org/

data/lib/backports/1.9.1/stdlib/prime.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: false
 #
 # = prime.rb
 #
@@ -29,9 +30,16 @@ class Integer
     Prime.prime_division(self, generator)
   end
 
-  # Returns true if +self+ is a prime number, false for a composite.
+  # Returns true if +self+ is a prime number, else returns false.
   def prime?
-    Prime.prime?(self)
+    return self >= 2 if self <= 3
+    return false if self % 2 == 0 or self % 3 == 0
+    (5..(self**0.5).floor).step(6).each do |i|
+      if self % i == 0 || self % (i + 2) == 0
+        return false
+      end
+    end
+    true
   end
 
   # Iterates the given block over all prime numbers.
@@ -46,57 +54,52 @@ end
 # The set of all prime numbers.
 #
 # == Example
-#  Prime.each(100) do |prime|
-#    p prime  #=> 2, 3, 5, 7, 11, ...., 97
-#  end
+#
+#   Prime.each(100) do |prime|
+#     p prime  #=> 2, 3, 5, 7, 11, ...., 97
+#   end
+#
+# Prime is Enumerable:
+#
+#   Prime.first 5 # => [2, 3, 5, 7, 11]
 #
 # == Retrieving the instance
-# +Prime+.new is obsolete. Now +Prime+ has the default instance and you can
-# access it as +Prime+.instance.
 #
 # For convenience, each instance method of +Prime+.instance can be accessed
 # as a class method of +Prime+.
 #
 # e.g.
-#  Prime.instance.prime?(2)  #=> true
-#  Prime.prime?(2)           #=> true
+#   Prime.instance.prime?(2)  #=> true
+#   Prime.prime?(2)           #=> true
 #
 # == Generators
+#
 # A "generator" provides an implementation of enumerating pseudo-prime
 # numbers and it remembers the position of enumeration and upper bound.
-# Futhermore, it is a external iterator of prime enumeration which is
-# compatible to an Enumerator.
+# Furthermore, it is an external iterator of prime enumeration which is
+# compatible with an Enumerator.
 #
 # +Prime+::+PseudoPrimeGenerator+ is the base class for generators.
 # There are few implementations of generator.
 #
 # [+Prime+::+EratosthenesGenerator+]
-#   Uses eratosthenes's sieve.
+#   Uses eratosthenes' sieve.
 # [+Prime+::+TrialDivisionGenerator+]
 #   Uses the trial division method.
 # [+Prime+::+Generator23+]
-#   Generates all positive integers which is not divided by 2 nor 3.
+#   Generates all positive integers which are not divisible by either 2 or 3.
 #   This sequence is very bad as a pseudo-prime sequence. But this
-#   is faster and uses much less memory than other generators. So,
+#   is faster and uses much less memory than the other generators. So,
 #   it is suitable for factorizing an integer which is not large but
 #   has many prime factors. e.g. for Prime#prime? .
+
 class Prime
-unless Prime.const_defined? :OldCompatibility
   include Enumerable
-  @the_instance = Prime.new
-
-  # obsolete. Use +Prime+::+instance+ or class methods of +Prime+.
-  def initialize
-    @generator = EratosthenesGenerator.new
-    extend OldCompatibility
-    warn "Prime::new is obsolete. use Prime::instance or class methods of Prime."
-  end
+  include Singleton
 
   class << self
     extend Forwardable
     include Enumerable
-    # Returns the default instance of Prime.
-    def instance; @the_instance end
 
     def method_added(method) # :nodoc:
       (class<< self;self;end).def_delegator :instance, method
@@ -106,6 +109,7 @@ unless Prime.const_defined? :OldCompatibility
   # Iterates the given block over all prime numbers.
   #
   # == Parameters
+  #
   # +ubound+::
   #   Optional. An arbitrary positive number.
   #   The upper bound of enumeration. The method enumerates
@@ -114,40 +118,37 @@ unless Prime.const_defined? :OldCompatibility
   #   Optional. An implementation of pseudo-prime generator.
   #
   # == Return value
+  #
   # An evaluated value of the given block at the last time.
   # Or an enumerator which is compatible to an +Enumerator+
   # if no block given.
   #
   # == Description
+  #
   # Calls +block+ once for each prime number, passing the prime as
   # a parameter.
   #
   # +ubound+::
-  #   Upper bound of prime numbers. The iterator stops after
+  #   Upper bound of prime numbers. The iterator stops after it
   #   yields all prime numbers p <= +ubound+.
   #
-  # == Note
-  # +Prime+.+new+ returns a object extended by +Prime+::+OldCompatibility+
-  # in order to compatibility to Ruby 1.8, and +Prime+#each is overwritten
-  # by +Prime+::+OldCompatibility+#+each+.
-  #
-  # +Prime+.+new+ is now obsolete. Use +Prime+.+instance+.+each+ or simply
-  # +Prime+.+each+.
   def each(ubound = nil, generator = EratosthenesGenerator.new, &block)
     generator.upper_bound = ubound
     generator.each(&block)
   end
 
 
-  # Returns true if +value+ is prime, false for a composite.
+  # Returns true if +value+ is a prime number, else returns false.
   #
   # == Parameters
+  #
   # +value+:: an arbitrary integer to be checked.
   # +generator+:: optional. A pseudo-prime generator.
   def prime?(value, generator = Prime::Generator23.new)
-    value = -value if value < 0
+    raise ArgumentError, "Expected a prime generator, got #{generator}" unless generator.respond_to? :each
+    raise ArgumentError, "Expected an integer, got #{value}" unless value.respond_to?(:integer?) && value.integer?
     return false if value < 2
-    for num in generator
+    generator.each do |num|
       q,r = value.divmod num
       return true if q < num
       return false if r == 0
@@ -162,13 +163,14 @@ unless Prime.const_defined? :OldCompatibility
   #        and a natural number -- an exponent.
   #
   # == Example
-  # For [[p_1, e_1], [p_2, e_2], ...., [p_n, e_n]], it returns
-  # p_1**e_1 * p_2**e_2 * .... * p_n**e_n.
+  # For <tt>[[p_1, e_1], [p_2, e_2], ...., [p_n, e_n]]</tt>, it returns:
   #
-  #  Prime.int_from_prime_division([[2,2], [3,1]])  #=> 12
+  #   p_1**e_1 * p_2**e_2 * .... * p_n**e_n.
+  #
+  #   Prime.int_from_prime_division([[2,2], [3,1]])  #=> 12
   def int_from_prime_division(pd)
     pd.inject(1){|value, (prime, index)|
-      value *= prime**index
+      value * prime**index
     }
   end
 
@@ -178,22 +180,25 @@ unless Prime.const_defined? :OldCompatibility
   # +value+:: An arbitrary integer.
   # +generator+:: Optional. A pseudo-prime generator.
   #               +generator+.succ must return the next
-  #               pseudo-prime number in the ascendent
+  #               pseudo-prime number in the ascending
   #               order. It must generate all prime numbers,
-  #               but may generate non prime numbers.
+  #               but may also generate non prime numbers too.
   #
   # === Exceptions
   # +ZeroDivisionError+:: when +value+ is zero.
   #
   # == Example
-  # For an arbitrary integer
-  # n = p_1**e_1 * p_2**e_2 * .... * p_n**e_n,
-  # prime_division(n) returns
-  # [[p_1, e_1], [p_2, e_2], ...., [p_n, e_n]].
+  # For an arbitrary integer:
+  #
+  #   n = p_1**e_1 * p_2**e_2 * .... * p_n**e_n,
+  #
+  # prime_division(n) returns:
   #
-  #  Prime.prime_division(12) #=> [[2,2], [3,1]]
+  #   [[p_1, e_1], [p_2, e_2], ...., [p_n, e_n]].
   #
-  def prime_division(value, generator= Prime::Generator23.new)
+  #   Prime.prime_division(12) #=> [[2,2], [3,1]]
+  #
+  def prime_division(value, generator = Prime::Generator23.new)
     raise ZeroDivisionError if value == 0
     if value < 0
       value = -value
@@ -201,22 +206,22 @@ unless Prime.const_defined? :OldCompatibility
     else
       pv = []
     end
-    for prime in generator
+    generator.each do |prime|
       count = 0
       while (value1, mod = value.divmod(prime)
-	     mod) == 0
-	value = value1
-	count += 1
+             mod) == 0
+        value = value1
+        count += 1
       end
       if count != 0
-	pv.push [prime, count]
+        pv.push [prime, count]
       end
       break if value1 <= prime
     end
     if value > 1
       pv.push [value, 1]
     end
-    return pv
+    pv
   end
 
   # An abstract class for enumerating pseudo-prime numbers.
@@ -256,33 +261,45 @@ unless Prime.const_defined? :OldCompatibility
       raise NotImplementedError, "need to define `rewind'"
     end
 
-    # Iterates the given block for each prime numbers.
-    def each(&block)
-      return self.dup unless block
+    # Iterates the given block for each prime number.
+    def each
+      return self.dup unless block_given?
       if @ubound
-	last_value = nil
-	loop do
-	  prime = succ
-	  break last_value if prime > @ubound
-	  last_value = block.call(prime)
-	end
+        last_value = nil
+        loop do
+          prime = succ
+          break last_value if prime > @ubound
+          last_value = yield prime
+        end
       else
-	loop do
-	  block.call(succ)
-	end
+        loop do
+          yield succ
+        end
       end
     end
 
     # see +Enumerator+#with_index.
-    alias with_index each_with_index
+    def with_index(offset = 0)
+      return enum_for(:with_index, offset) { Float::INFINITY } unless block_given?
+      return each_with_index(&proc) if offset == 0
+
+      each do |prime|
+        yield prime, offset
+        offset += 1
+      end
+    end
 
     # see +Enumerator+#with_object.
     def with_object(obj)
-      return enum_for(:with_object) unless block_given?
+      return enum_for(:with_object, obj) { Float::INFINITY } unless block_given?
       each do |prime|
-	yield prime, obj
+        yield prime, obj
       end
     end
+
+    def size
+      Float::INFINITY
+    end
   end
 
   # An implementation of +PseudoPrimeGenerator+.
@@ -290,12 +307,13 @@ unless Prime.const_defined? :OldCompatibility
   # Uses +EratosthenesSieve+.
   class EratosthenesGenerator < PseudoPrimeGenerator
     def initialize
-      @last_prime = nil
+      @last_prime_index = -1
       super
     end
 
     def succ
-      @last_prime = @last_prime ? EratosthenesSieve.instance.next_to(@last_prime) : 2
+      @last_prime_index += 1
+      EratosthenesSieve.instance.get_nth_prime(@last_prime_index)
     end
     def rewind
       initialize
@@ -320,11 +338,11 @@ unless Prime.const_defined? :OldCompatibility
     alias next succ
   end
 
-  # Generates all integer which are greater than 2 and
-  # are not divided by 2 nor 3.
+  # Generates all integers which are greater than 2 and
+  # are not divisible by either 2 or 3.
   #
   # This is a pseudo-prime generator, suitable on
-  # checking primality of a integer by brute force
+  # checking primality of an integer by brute force
   # method.
   class Generator23<PseudoPrimeGenerator
     def initialize
@@ -334,19 +352,17 @@ unless Prime.const_defined? :OldCompatibility
     end
 
     def succ
-      loop do
-	if (@step)
-	  @prime += @step
-	  @step = 6 - @step
-	else
-	  case @prime
-	  when 1; @prime = 2
-	  when 2; @prime = 3
-	  when 3; @prime = 5; @step = 2
-	  end
-	end
-	return @prime
+      if (@step)
+        @prime += @step
+        @step = 6 - @step
+      else
+        case @prime
+        when 1; @prime = 2
+        when 2; @prime = 3
+        when 3; @prime = 5; @step = 2
+        end
       end
+      @prime
     end
     alias next succ
     def rewind
@@ -354,9 +370,6 @@ unless Prime.const_defined? :OldCompatibility
     end
   end
 
-
-
-
   # Internal use. An implementation of prime table by trial division method.
   class TrialDivision
     include Singleton
@@ -376,7 +389,7 @@ unless Prime.const_defined? :OldCompatibility
 
     # Returns the cached prime numbers.
     def cache
-      return @primes
+      @primes
     end
     alias primes cache
     alias primes_so_far cache
@@ -386,112 +399,68 @@ unless Prime.const_defined? :OldCompatibility
     # +index+ is a 0-based index.
     def [](index)
       while index >= @primes.length
-	# Only check for prime factors up to the square root of the potential primes,
-	#   but without the performance hit of an actual square root calculation.
-	if @next_to_check + 4 > @ulticheck_next_squared
-	  @ulticheck_index += 1
-	  @ulticheck_next_squared = @primes.at(@ulticheck_index + 1) ** 2
-	end
-	# Only check numbers congruent to one and five, modulo six. All others
-
-	#   are divisible by two or three.  This also allows us to skip checking against
-	#   two and three.
-	@primes.push @next_to_check if @primes[2..@ulticheck_index].find {|prime| @next_to_check % prime == 0 }.nil?
-	@next_to_check += 4
-	@primes.push @next_to_check if @primes[2..@ulticheck_index].find {|prime| @next_to_check % prime == 0 }.nil?
-	@next_to_check += 2
+        # Only check for prime factors up to the square root of the potential primes,
+        #   but without the performance hit of an actual square root calculation.
+        if @next_to_check + 4 > @ulticheck_next_squared
+          @ulticheck_index += 1
+          @ulticheck_next_squared = @primes.at(@ulticheck_index + 1) ** 2
+        end
+        # Only check numbers congruent to one and five, modulo six. All others
+
+        #   are divisible by two or three.  This also allows us to skip checking against
+        #   two and three.
+        @primes.push @next_to_check if @primes[2..@ulticheck_index].find {|prime| @next_to_check % prime == 0 }.nil?
+        @next_to_check += 4
+        @primes.push @next_to_check if @primes[2..@ulticheck_index].find {|prime| @next_to_check % prime == 0 }.nil?
+        @next_to_check += 2
       end
-      return @primes[index]
+      @primes[index]
     end
   end
 
-  # Internal use. An implementation of eratosthenes's sieve
+  # Internal use. An implementation of eratosthenes' sieve
   class EratosthenesSieve
     include Singleton
 
-    BITS_PER_ENTRY = 16  # each entry is a set of 16-bits in a Fixnum
-    NUMS_PER_ENTRY = BITS_PER_ENTRY * 2 # twiced because even numbers are omitted
-    ENTRIES_PER_TABLE = 8
-    NUMS_PER_TABLE = NUMS_PER_ENTRY * ENTRIES_PER_TABLE
-    FILLED_ENTRY = (1 << NUMS_PER_ENTRY) - 1
-
-    def initialize # :nodoc:
-      # bitmap for odd prime numbers less than 256.
-      # For an arbitrary odd number n, @tables[i][j][k] is
-      # * 1 if n is prime,
-      # * 0 if n is composite,
-      # where i,j,k = indices(n)
-      @tables = [[0xcb6e, 0x64b4, 0x129a, 0x816d, 0x4c32, 0x864a, 0x820d, 0x2196].freeze]
+    def initialize
+      @primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101]
+      # @max_checked must be an even number
+      @max_checked = @primes.last + 1
     end
 
-    # returns the least odd prime number which is greater than +n+.
-    def next_to(n)
-      n = (n-1).div(2)*2+3 # the next odd number to given n
-      table_index, integer_index, bit_index = indices(n)
-      loop do
-	extend_table until @tables.length > table_index
-	for j in integer_index...ENTRIES_PER_TABLE
-	  if !@tables[table_index][j].zero?
-	    for k in bit_index...BITS_PER_ENTRY
-	      return NUMS_PER_TABLE*table_index + NUMS_PER_ENTRY*j + 2*k+1 if !@tables[table_index][j][k].zero?
-	    end
-	  end
-	  bit_index = 0
-	end
-	table_index += 1; integer_index = 0
-      end
+    def get_nth_prime(n)
+      compute_primes while @primes.size <= n
+      @primes[n]
     end
 
     private
-    # for an odd number +n+, returns (i, j, k) such that @tables[i][j][k] represents primarity of the number
-    def indices(n)
-      #   binary digits of n: |0|1|2|3|4|5|6|7|8|9|10|11|....
-      #   indices:            |-|    k  |  j  |     i
-      # because of NUMS_PER_ENTRY, NUMS_PER_TABLE
-
-      k = (n & 0b00011111) >> 1
-      j = (n & 0b11100000) >> 5
-      i = n >> 8
-      return i, j, k
-    end
-
-    def extend_table
-      lbound = NUMS_PER_TABLE * @tables.length
-      ubound = lbound + NUMS_PER_TABLE
-      new_table = [FILLED_ENTRY] * ENTRIES_PER_TABLE # which represents primarity in lbound...ubound
-      (3..Integer(Math.sqrt(ubound))).step(2) do |p|
-	i, j, k = indices(p)
-	next if @tables[i][j][k].zero?
-
-	start = (lbound.div(p)+1)*p  # least multiple of p which is >= lbound
-	start += p if start.even?
-	(start...ubound).step(2*p) do |n|
-	  _, j, k = indices(n)
-	  new_table[j] &= FILLED_ENTRY^(1<<k)
-	end
+    def compute_primes
+      # max_segment_size must be an even number
+      max_segment_size = 1e6.to_i
+      max_cached_prime = @primes.last
+      # do not double count primes if #compute_primes is interrupted
+      # by Timeout.timeout
+      @max_checked = max_cached_prime + 1 if max_cached_prime > @max_checked
+
+      segment_min = @max_checked
+      segment_max = [segment_min + max_segment_size, max_cached_prime * 2].min
+      root = Integer(Math.sqrt(segment_max).floor)
+
+      segment = ((segment_min + 1) .. segment_max).step(2).to_a
+
+      (1..Float::INFINITY).each do |sieving|
+        prime = @primes[sieving]
+        break if prime > root
+        composite_index = (-(segment_min + 1 + prime) / 2) % prime
+        while composite_index < segment.size do
+          segment[composite_index] = nil
+          composite_index += prime
+        end
       end
-      @tables << new_table.freeze
-    end
-  end
 
-  # Provides a +Prime+ object with compatibility to Ruby 1.8 when instantiated via +Prime+.+new+.
-  module OldCompatibility
-    # Returns the next prime number and forwards internal pointer.
-    def succ
-      @generator.succ
-    end
-    alias next succ
+      @primes.concat(segment.compact!)
 
-    # Overwrites Prime#each.
-    #
-    # Iterates the given block over all prime numbers. Note that enumeration starts from
-    # the current position of internal pointer, not rewound.
-    def each(&block)
-      return @generator.dup unless block_given?
-      loop do
-	yield succ
-      end
+      @max_checked = segment_max
     end
   end
 end
-end

data/lib/backports/version.rb

@@ -1,3 +1,3 @@
 module Backports
-  VERSION = "3.6.7" unless const_defined? :VERSION # the guard is against a redefinition warning that happens on Travis
+  VERSION = "3.6.8" unless const_defined? :VERSION # the guard is against a redefinition warning that happens on Travis
 end

data/test/_backport_guards_test.rb

@@ -35,14 +35,14 @@ class AAA_TestBackportGuards < Test::Unit::TestCase
   EXCLUDE.map!(&:to_sym) if instance_methods.first.is_a?(Symbol)
 
   # For some very strange reason, Hash[kvp.flatten] doesn't always work in 1.8.6??
-  def hash(key_value_pairs)
+  def to_hash(key_value_pairs)
     h = {}
     key_value_pairs.each{|k,v| h[k] = v}
     h
   end
 
   def class_signature(klass)
-    hash(
+    to_hash(
       (klass.instance_methods - EXCLUDE).map{|m| [m, klass.instance_method(m)] } +
       (klass.methods - EXCLUDE).map{|m| [".#{m}", klass.method(m) ]}
     )
@@ -62,7 +62,7 @@ class AAA_TestBackportGuards < Test::Unit::TestCase
   end
 
   def digest
-    hash(
+    to_hash(
       CLASSES.map { |klass| [klass, class_signature(klass)] }
     )
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: backports
 version: !ruby/object:Gem::Version
-  version: 3.6.7
+  version: 3.6.8
 platform: ruby
 authors:
 - Marc-André Lafortune
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-02 00:00:00.000000000 Z
+date: 2016-02-09 00:00:00.000000000 Z
 dependencies: []
 description: Essential backports that enable many of the nice features of Ruby 1.8.7
   up to 2.1.0 for earlier versions.