class Prime

def each(ubound = nil, generator = EratosthenesGenerator.new, &block)


yields all prime numbers p <= +ubound+.
Upper bound of prime numbers. The iterator stops after it
+ubound+::

a parameter.
Calls +block+ once for each prime number, passing the prime as

== Description

if no block given.
Or an enumerator which is compatible to an +Enumerator+
An evaluated value of the given block at the last time.

== Return value

Optional. An implementation of pseudo-prime generator.
+generator+::
prime numbers infinitely if +ubound+ is nil.
The upper bound of enumeration. The method enumerates
Optional. An arbitrary positive number.
+ubound+::

== Parameters

Iterates the given block over all prime numbers. 
def each(ubound = nil, generator = EratosthenesGenerator.new, &block)
  generator.upper_bound = ubound
  generator.each(&block)
end

def int_from_prime_division(pd)

Prime.int_from_prime_division([[2,2], [3,1]]) #=> 12

p_1**e_1 * p_2**e_2 * .... * p_n**e_n.

For [[p_1, e_1], [p_2, e_2], ...., [p_n, e_n]], it returns:
== Example

and a natural number -- an exponent.
pair consists of a prime number -- a prime factor --
+pd+:: Array of pairs of integers. The each internal
== Parameters

Re-composes a prime factorization and returns the product. 
def int_from_prime_division(pd)
  pd.inject(1){|value, (prime, index)|
    value * prime**index
  }
end

def method_added(method) # :nodoc:

:nodoc: 
def method_added(method) # :nodoc:
  (class<< self;self;end).def_delegator :instance, method
end

def prime?(value, generator = Prime::Generator23.new)

+generator+:: optional. A pseudo-prime generator.
+value+:: an arbitrary integer to be checked.

== Parameters

Returns true if +value+ is a prime number, else returns false. 
def prime?(value, generator = Prime::Generator23.new)
  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
  generator.each do |num|
    q,r = value.divmod num
    return true if q < num
    return false if r == 0
  end
end

def prime_division(value, generator = Prime::Generator23.new)


Prime.prime_division(12) #=> [[2,2], [3,1]]

[[p_1, e_1], [p_2, e_2], ...., [p_n, e_n]].

prime_division(n) returns:

n = p_1**e_1 * p_2**e_2 * .... * p_n**e_n,

For an arbitrary integer:
== Example

+ZeroDivisionError+:: when +value+ is zero.
=== Exceptions

but may also generate non prime numbers too.
order. It must generate all prime numbers,
pseudo-prime number in the ascending
+generator+.succ must return the next
+generator+:: Optional. A pseudo-prime generator.
+value+:: An arbitrary integer.
== Parameters

Returns the factorization of +value+. 
def prime_division(value, generator = Prime::Generator23.new)
  raise ZeroDivisionError if value == 0
  if value < 0
    value = -value
    pv = [[-1, 1]]
  else
    pv = []
  end
  generator.each do |prime|
    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 value > 1
    pv.push [value, 1]
  end
  pv
end