# Prime numbers and factorization library.
# Copyright (c) 1998-2008 Keiju ISHITSUKA(SHL Japan Inc.)
# Copyright (c) 2008 Yuki Sonoda (Yugui) <yugui@yugui.jp>
# Re-composes a prime factorization and returns the product.
# See Prime#int_from_prime_division for more details.
def Integer.from_prime_division(pd)
Prime.int_from_prime_division(pd)
# Returns the factorization of +self+.
# See Prime#prime_division for more details.
def prime_division(generator = Prime::Generator23.new)
Prime.prime_division(self, generator)
# Returns true if +self+ is a prime number, else returns false.
# Iterates the given block over all prime numbers.
# See +Prime+#each for more details.
def Integer.each_prime(ubound, &block) # :yields: prime
Prime.each(ubound, &block)
# The set of all prime numbers.
# Prime.each(100) do |prime|
# p prime #=> 2, 3, 5, 7, 11, ...., 97
# 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+.
# Prime.instance.prime?(2) #=> true
# Prime.prime?(2) #=> true
# A "generator" provides an implementation of enumerating pseudo-prime
# numbers and it remembers the position of enumeration and upper bound.
# 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' sieve.
# [+Prime+::+TrialDivisionGenerator+]
# Uses the trial division method.
# [+Prime+::+Generator23+]
# 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 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? .
@the_instance = Prime.new
# obsolete. Use +Prime+::+instance+ or class methods of +Prime+.
@generator = EratosthenesGenerator.new
warn "Prime::new is obsolete. use Prime::instance or class methods of Prime."
# Returns the default instance of Prime.
def instance; @the_instance end
def method_added(method) # :nodoc:
(class<< self;self;end).def_delegator :instance, method
# Iterates the given block over all prime numbers.
# Optional. An arbitrary positive number.
# The upper bound of enumeration. The method enumerates
# prime numbers infinitely if +ubound+ is nil.
# Optional. An implementation of pseudo-prime generator.
# An evaluated value of the given block at the last time.
# Or an enumerator which is compatible to an +Enumerator+
# Calls +block+ once for each prime number, passing the prime as
# Upper bound of prime numbers. The iterator stops after it
# yields all prime numbers p <= +ubound+.
# +Prime+.+new+ returns an object extended by +Prime+::+OldCompatibility+
# in order to be compatible with Ruby 1.8, and +Prime+#each is overwritten
# by +Prime+::+OldCompatibility+#+each+.
# +Prime+.+new+ is now obsolete. Use +Prime+.+instance+.+each+ or simply
def each(ubound = nil, generator = EratosthenesGenerator.new, &block)
generator.upper_bound = ubound
# Returns true if +value+ is a prime number, else returns false.
# +value+:: an arbitrary integer to be checked.
# +generator+:: optional. A pseudo-prime generator.
def prime?(value, generator = Prime::Generator23.new)
return false if value < 2
# Re-composes a prime factorization and returns the product.
# +pd+:: Array of pairs of integers. The each internal
# pair consists of a prime number -- a prime factor --
# and a natural number -- an exponent.
# For <tt>[[p_1, e_1], [p_2, e_2], ...., [p_n, e_n]]</tt>, 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)|
# Returns the factorization of +value+.
# +value+:: An arbitrary integer.
# +generator+:: Optional. A pseudo-prime generator.
# +generator+.succ must return the next
# pseudo-prime number in the ascending
# order. It must generate all prime numbers,
# but may also generate non prime numbers too.
# +ZeroDivisionError+:: when +value+ is zero.
# 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
while (value1, mod = value.divmod(prime)
# An abstract class for enumerating pseudo-prime numbers.
# Concrete subclasses should override succ, next, rewind.
class PseudoPrimeGenerator
def initialize(ubound = nil)
# returns the next pseudo-prime number, and move the internal
# +PseudoPrimeGenerator+#succ raises +NotImplementedError+.
raise NotImplementedError, "need to define `succ'"
raise NotImplementedError, "need to define `next'"
# Rewinds the internal position for enumeration.
# See +Enumerator+#rewind.
raise NotImplementedError, "need to define `rewind'"
# Iterates the given block for each prime number.
return self.dup unless block_given?
break last_value if prime > @ubound
# see +Enumerator+#with_index.
alias with_index each_with_index
# see +Enumerator+#with_object.
return enum_for(:with_object) unless block_given?
# An implementation of +PseudoPrimeGenerator+.
# Uses +EratosthenesSieve+.
class EratosthenesGenerator < PseudoPrimeGenerator
EratosthenesSieve.instance.get_nth_prime(@last_prime_index)
# An implementation of +PseudoPrimeGenerator+ which uses
# a prime table generated by trial division.
class TrialDivisionGenerator<PseudoPrimeGenerator
TrialDivision.instance[@index += 1]
# 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 an integer by brute force
class Generator23<PseudoPrimeGenerator
when 3; @prime = 5; @step = 2
# Internal use. An implementation of prime table by trial division method.
# 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
# Returns the cached prime numbers.
alias primes_so_far cache
# Returns the +index+th prime number.
# +index+ is a 0-based 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_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
@primes.push @next_to_check if @primes[2..@ulticheck_index].find {|prime| @next_to_check % prime == 0 }.nil?
@primes.push @next_to_check if @primes[2..@ulticheck_index].find {|prime| @next_to_check % prime == 0 }.nil?
# Internal use. An implementation of eratosthenes' sieve
@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
compute_primes while @primes.size <= n
# 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
@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)
sieving_primes = @primes[1 .. -1].take_while { |prime| prime <= root }
offsets = Array.new(sieving_primes.size) do |i|
(-(segment_min + 1 + sieving_primes[i]) / 2) % sieving_primes[i]
segment = ((segment_min + 1) .. segment_max).step(2).to_a
sieving_primes.each_with_index do |prime, index|
composite_index = offsets[index]
while composite_index < segment.size do
segment[composite_index] = nil
@primes.push prime unless prime.nil?
@max_checked = segment_max
# Provides a +Prime+ object with compatibility to Ruby 1.8 when instantiated via +Prime+.+new+.
# Returns the next prime number and forwards internal pointer.
# Iterates the given block over all prime numbers. Note that enumeration
# starts from the current position of internal pointer, not rewound.
return @generator.dup unless block_given?
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
