Prime

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 it yields all prime numbers p <= ubound.

 
               # File prime.rb, line 139
def each(ubound = nil, generator = EratosthenesGenerator.new, &block)
  generator.upper_bound = ubound
  generator.each(&block)
end
            

Returns true if obj is an Integer and is prime. Also returns true if obj is a Module that is an ancestor of Prime. Otherwise returns false.

 
               # File prime.rb, line 147
def include?(obj)
  case obj
  when Integer
    prime?(obj)
  when Module
    Module.instance_method(:include?).bind(Prime).call(obj)
  else
    false
  end
end
            

Re-composes a prime factorization and returns the product.

For the decomposition:

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

Parameters¶ ↑

pd

Array of pairs of integers. Each pair consists of a prime number – a prime factor – and a natural number – its exponent (multiplicity).

Example¶ ↑

Prime.int_from_prime_division([[3, 2], [5, 1]])  #=> 45
3**2 * 5                                         #=> 45

 
               # File prime.rb, line 194
def int_from_prime_division(pd)
  pd.inject(1){|value, (prime, index)|
    value * prime**index
  }
end
            

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.

 
               # File prime.rb, line 164
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
            

Returns the factorization of value.

For an arbitrary integer:

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

#prime_division returns an array of pairs of integers:

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

Each pair consists of a prime number – a prime factor – and a natural number – its exponent (multiplicity).

Parameters¶ ↑

value

An arbitrary integer.

generator

Optional. A pseudo-prime generator. generator.succ must return the next pseudo-prime number in ascending order. It must generate all prime numbers, but may also generate non-prime numbers, too.

Exceptions¶ ↑

ZeroDivisionError

when value is zero.

Example¶ ↑

Prime.prime_division(45)  #=> [[3, 2], [5, 1]]
3**2 * 5                  #=> 45

 
               # File prime.rb, line 229
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