diff options
Diffstat (limited to 'lib/prime.rb')
-rw-r--r-- | lib/prime.rb | 668 |
1 files changed, 334 insertions, 334 deletions
diff --git a/lib/prime.rb b/lib/prime.rb index 8d8598b9e1..d1164dbd05 100644 --- a/lib/prime.rb +++ b/lib/prime.rb @@ -99,397 +99,397 @@ class Prime def method_added(method) # :nodoc: (class<< self;self;end).def_delegator :instance, method + end end -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 + # 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 + # 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 end -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 = [] + # 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 - for prime in generator - count = 0 - while (value1, mod = value.divmod(prime) - mod) == 0 - value = value1 - count += 1 + + # 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 = [] + end + for prime in generator + count = 0 + while (value1, mod = value.divmod(prime) + mod) == 0 + value = value1 + count += 1 + end + if count != 0 + pv.push [prime, count] + end + break if value1 <= prime end - if count != 0 - pv.push [prime, count] + if value > 1 + pv.push [value, 1] end - break if value1 <= prime + return pv end - 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 + # 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 initialize(ubound = nil) + @ubound = ubound + end - def upper_bound=(ubound) - @ubound = ubound - end - def upper_bound - @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 + # 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 + # 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 + # 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) + # 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 end end - end - # see +Enumerator+#with_index. - alias with_index each_with_index + # 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 + # see +Enumerator+#with_object. + def with_object(obj) + return enum_for(:with_object) unless block_given? + each do |prime| + yield prime, obj + end end end -end -# An implementation of +PseudoPrimeGenerator+. -# -# Uses +EratosthenesSieve+. -class EratosthenesGenerator < PseudoPrimeGenerator - def initialize - @last_prime = nil - super - 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 + def succ + @last_prime = @last_prime ? EratosthenesSieve.instance.next_to(@last_prime) : 2 + end + def rewind + initialize + end + alias next succ end - 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 + # 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 + def succ + TrialDivision.instance[@index += 1] + end + def rewind + initialize + end + alias next succ end - 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 + # 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 + 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 end - return @prime + end + alias next succ + def rewind + initialize end end - 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. + # Internal use. An implementation of prime table by trial division method. + class TrialDivision + include Singleton - # 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 + 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. - # Returns the cached prime numbers. - def cache - return @primes - end - alias primes cache - alias primes_so_far cache + # 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 +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 + # 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 + 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 - # 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 - return @primes[index] end -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 + # Internal use. An implementation of eratosthenes's sieve + class EratosthenesSieve + include Singleton - # 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? + 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? + end end + bit_index = 0 end - bit_index = 0 + table_index += 1; integer_index = 0 end - table_index += 1; integer_index = 0 end - 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 + 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) + 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 end + @tables << new_table.freeze 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 - # 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 + # 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 end end end -end |