From ed5a2728fb1d3fe938d050746569d83db129bec7 Mon Sep 17 00:00:00 2001 From: ksss Date: Tue, 22 Mar 2022 18:14:08 +0900 Subject: [PATCH 1/2] Should define sig singleton and instance both --- stdlib/prime/0/prime.rbs | 119 +++++++++++++++++++++++++++++++++++++-- 1 file changed, 115 insertions(+), 4 deletions(-) diff --git a/stdlib/prime/0/prime.rbs b/stdlib/prime/0/prime.rbs index 1130870d1..a4038adae 100644 --- a/stdlib/prime/0/prime.rbs +++ b/stdlib/prime/0/prime.rbs @@ -76,9 +76,66 @@ class Prime # : Upper bound of prime numbers. The iterator stops after it yields all prime # numbers p <= `ubound`. # - def self?.each: (?Integer? ubound, ?PseudoPrimeGenerator generator) { (Integer) -> void } -> void + def self.each: (?Integer? ubound, ?PseudoPrimeGenerator generator) { (Integer) -> void } -> void | (?Integer? ubound, ?PseudoPrimeGenerator generator) -> PseudoPrimeGenerator + # + # 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`. + # + def each: (?Integer? ubound, ?PseudoPrimeGenerator generator) { (Integer) -> void } -> void + | (?Integer? ubound, ?PseudoPrimeGenerator generator) -> PseudoPrimeGenerator + + # + # 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 + # + def self.int_from_prime_division: (Array[[ Integer, Integer ]]) -> Integer + # + # Returns true if `value` is a prime number, else returns false. Integer#prime? + # is much more performant. + # + # ## Parameters + # + # `value` + # : an arbitrary integer to be checked. + # `generator` + # : optional. A pseudo-prime generator. + # + def prime?: (Integer value, ?PseudoPrimeGenerator generator) -> bool + + # + # 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 + # + def self.prime_division: (Integer, ?PseudoPrimeGenerator generator) -> Array[[ Integer, Integer ]] #