-end

-# Iterates the given block over all prime numbers.

-#

-# == Parameters

-# +ubound+::

-# Optional. An arbitrary positive number.

-# The upper bound of enumeration. The method enumerates

-# prime numbers infinitely if +ubound+ is nil.

-# +generator+::

-# 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

-# 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.

-#

-# == 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

- return false if value < 2

- for num in generator

- q,r = value.divmod num

- return true if q < num

- return false if r == 0

-end

-

-# Re-composes a prime factorization and returns the product.

-#

-# == Parameters

-# +pd+:: Array of pairs of integers. The each internal

-# pair consists of a prime number -- a prime factor --

-# 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.

-#

-# 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

- }

-end

-# Returns the factorization of +value+.

-#

-# == Parameters

-# +value+:: An arbitrary integer.

-# +generator+:: Optional. A pseudo-prime generator.

-# +generator+.succ must return the next

-# pseudo-prime number in the ascendent

-# order. It must generate all prime numbers,

-# but may generate non prime numbers.

-#

-# === 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]].

-#

-# 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

- pv = [[-1, 1]]

- else

- pv = []

- for prime in generator

- count = 0

- while (value1, mod = value.divmod(prime)

- mod) == 0

- value = value1

- count += 1

- if count != 0

- pv.push [prime, count]

- break if value1 <= prime

- if value > 1

- pv.push [value, 1]

- end

- return pv

-end

-# An abstract class for enumerating pseudo-prime numbers.

-#

-# Concrete subclasses should override succ, next, rewind.

-class PseudoPrimeGenerator

- include Enumerable

- def initialize(ubound = nil)

- @ubound = ubound

- end

- def upper_bound=(ubound)

- @ubound = ubound

- end

- def upper_bound

- @ubound

- end

- # returns the next pseudo-prime number, and move the internal

- # position forward.

- #

- # +PseudoPrimeGenerator+#succ raises +NotImplementedError+.

- def succ

- raise NotImplementedError, "need to define `succ'"

- end

- # alias of +succ+.

- def next

- raise NotImplementedError, "need to define `next'"

- end

- # Rewinds the internal position for enumeration.

- #

- # See +Enumerator+#rewind.

- def rewind

- raise NotImplementedError, "need to define `rewind'"

- end

- # Iterates the given block for each prime numbers.

- def each(&block)

- return self.dup unless block

- if @ubound

- last_value = nil

- loop do

- prime = succ

- break last_value if prime > @ubound

- last_value = block.call(prime)

- end

- else

- loop do

- block.call(succ)

- end

- # see +Enumerator+#with_index.

- alias with_index each_with_index

- # see +Enumerator+#with_object.

- def with_object(obj)

- return enum_for(:with_object) unless block_given?

- each do |prime|

- yield prime, obj

-end

-# An implementation of +PseudoPrimeGenerator+.

-#

-# Uses +EratosthenesSieve+.

-class EratosthenesGenerator < PseudoPrimeGenerator

- def initialize

- @last_prime = nil

- super

- end

- def succ

- @last_prime = @last_prime ? EratosthenesSieve.instance.next_to(@last_prime) : 2

- end

- def rewind

- initialize

- alias next succ

-end

-# An implementation of +PseudoPrimeGenerator+ which uses

-# a prime table generated by trial division.

-class TrialDivisionGenerator<PseudoPrimeGenerator

- def initialize

- @index = -1

- super

- end

- def succ

- TrialDivision.instance[@index += 1]

- end

- def rewind

- initialize

- alias next succ

-end

-# Generates all integer which are greater than 2 and

-# are not divided by 2 nor 3.

-#

-# This is a pseudo-prime generator, suitable on

-# checking primality of a integer by brute force

-# method.

-class Generator23<PseudoPrimeGenerator

- def initialize

- @prime = 1

- @step = nil

- super

- 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

- return @prime

- alias next succ

- def rewind

- initialize

- end

-end

-

-# Internal use. An implementation of prime table by trial division method.

-class TrialDivision

- include Singleton

- def initialize # :nodoc:

- # These are included as class variables to cache them for later uses. If memory

- # usage is a problem, they can be put in Prime#initialize as instance variables.

- # There must be no primes between @primes[-1] and @next_to_check.

- @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]

- # @next_to_check % 6 must be 1.

- @next_to_check = 103 # @primes[-1] - @primes[-1] % 6 + 7

- @ulticheck_index = 3 # @primes.index(@primes.reverse.find {|n|

- # n < Math.sqrt(@@next_to_check) })

- @ulticheck_next_squared = 121 # @primes[@ulticheck_index + 1] ** 2

- end

- # Returns the cached prime numbers.

- def cache

- return @primes

- end

- alias primes cache

- alias primes_so_far cache

- # Returns the +index+th prime number.

- #

- # +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

- # 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

- return @primes[index]

-end

-# Internal use. An implementation of eratosthenes's 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]

- 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?

- bit_index = 0

- table_index += 1; integer_index = 0

- 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)

- @tables << new_table.freeze

-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

- # 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