rsa 0.1.2 → 0.1.3

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.1.3

data/lib/rsa.rb

@@ -1,4 +1,5 @@
-require 'stringio' unless defined?(StringIO)
+require 'bigdecimal' unless defined?(BigDecimal)
+require 'stringio'   unless defined?(StringIO)
 
 if RUBY_VERSION < '1.9.1'
   # @see http://rubygems.org/gems/backports

data/lib/rsa/math.rb

@@ -6,6 +6,62 @@ module RSA
 
     class ArithmeticError < ArgumentError; end
 
+    ##
+    # Yields an infinite pseudo-prime number sequence.
+    #
+    # This is a pseudo-prime generator that simply yields the initial values
+    # 2 and 3, followed by all positive integers that are not divisible by 2
+    # or 3.
+    #
+    # It works identically to `Prime::Generator23`, the Ruby 1.9 standard
+    # library's default pseudo-prime generator implementation.
+    #
+    # @example
+    #   RSA::Math.primes.take(5)                       #=> [2, 3, 5, 7, 11]
+    #
+    # @yield  [p] each pseudo-prime number
+    # @yieldparam [Integer] p a pseudo-prime number
+    # @return [Enumerator] yielding pseudo-primes
+    # @see    http://ruby-doc.org/core-1.9/classes/Prime.html
+    def self.primes(&block)
+      if block_given?
+        yield 2; yield 3; yield 5
+        prime, step = 5, 4
+        loop { yield prime += (step = 6 - step) }
+      end
+      enum_for(:primes)
+    end
+
+    ##
+    # Yields the prime factorization of the nonzero integer `n`.
+    #
+    # @example
+    #   RSA::Math.factorize(12).to_a                   #=> [[2, 2], [3, 1]]
+    #
+    # @param  [Integer] n a nonzero integer
+    # @yield  [p, e] each prime factor
+    # @yieldparam [Integer] p the prime factor base
+    # @yieldparam [Integer] e the prime factor exponent
+    # @return [Enumerator]
+    # @raise  [ZeroDivisionError] if `n` is zero
+    # @see    http://ruby-doc.org/core-1.9/classes/Prime.html
+    def self.factorize(n, &block)
+      raise ZeroDivisionError if n.zero?
+      if block_given?
+        n = n.abs if n < 0
+        primes.find do |p|
+          e = 0
+          while (q, r = n.divmod(p); r.zero?)
+            n, e = q, e + 1
+          end
+          yield p, e unless e.zero?
+          n <= p
+        end
+        yield n, 1 if n > 1
+      end
+      enum_for(:factorize, n)
+    end
+
     ##
     # Performs a primality test on the integer `n`, returning `true` if it
     # is a prime.
@@ -13,16 +69,19 @@ module RSA
     # @example
     #   1.upto(10).select { |n| RSA::Math.prime?(n) }  #=> [2, 3, 5, 7]
     #
-    # @param  [Integer] n
+    # @param  [Integer] n an integer
     # @return [Boolean] `true` if `n` is a prime number, `false` otherwise
     # @see    http://en.wikipedia.org/wiki/Primality_test
     # @see    http://ruby-doc.org/core-1.9/classes/Prime.html
     def self.prime?(n)
-      if n.respond_to?(:prime?)
-        n.prime?
-      else
-        require 'prime' unless defined?(Prime) # Ruby 1.9+ only
-        Prime.prime?(n)
+      case
+        when n < 0 then prime?(n.abs)
+        when n < 2 then false
+        else primes do |p|
+          q, r = n.divmod(p)
+          return true  if q < p
+          return false if r.zero?
+        end
       end
     end
 
@@ -130,10 +189,10 @@ module RSA
     #   RSA::Math.modpow(5, 3, 13)                     #=> 8
     #   RSA::Math.modpow(4, 13, 497)                   #=> 445
     #
-    # @param  [Integer] base
-    # @param  [Integer] exponent
-    # @param  [Integer] modulus
-    # @return [Integer]
+    # @param  [Integer] base the base
+    # @param  [Integer] exponent the exponent
+    # @param  [Integer] modulus the modulus
+    # @return [Integer] the result
     # @see    http://en.wikipedia.org/wiki/Modular_exponentiation
     def self.modpow(base, exponent, modulus)
       result = 1
@@ -145,28 +204,38 @@ module RSA
       result
     end
 
+    ONE = BigDecimal('1')
+
     ##
     # Returns the Euler totient for the positive integer `n`.
     #
-    # This is presently a very naive implementation. Don't rely on it for
-    # anything but very small values of `n`.
-    #
     # @example
     #   (1..5).map { |n| RSA::Math.phi(n) }            #=> [1, 1, 2, 2, 4]
     #
-    # @param  [Integer] n
-    # @return [Integer]
+    # @param  [Integer] n a positive integer, or zero
+    # @return [Integer] the Euler totient of `n`
+    # @raise  [ArgumentError] if `n` < 0
     # @see    http://en.wikipedia.org/wiki/Euler's_totient_function
     # @see    http://mathworld.wolfram.com/TotientFunction.html
     def self.phi(n)
-      1 + (2...n).count { |i| coprime?(n, i) }
+      case
+        when n < 0     then raise ArgumentError, "expected a positive integer, but got #{n}"
+        when n < 2     then 1 # by convention
+        when prime?(n) then n - 1
+        else factorize(n).inject(n) { |product, (p, e)| product * (ONE - (ONE / BigDecimal(p.to_s))) }.round.to_i
+      end
     end
 
     ##
     # Returns the binary logarithm of `n`.
     #
-    # @param  [Integer] n
-    # @return [Float]
+    # @example
+    #   RSA::Math.log2(16)                             #=> 4.0
+    #   RSA::Math.log2(1024)                           #=> 10.0
+    #
+    # @param  [Integer] n a positive integer
+    # @return [Float] the logarithm
+    # @raise  [Errno::EDOM] if `n` < 1
     # @see    http://en.wikipedia.org/wiki/Binary_logarithm
     def self.log2(n)
       ::Math.log2(n)
@@ -175,8 +244,13 @@ module RSA
     ##
     # Returns the base-256 logarithm of `n`.
     #
-    # @param  [Integer] n
-    # @return [Float]
+    # @example
+    #   RSA::Math.log256(16)                           #=> 0.5
+    #   RSA::Math.log256(1024)                         #=> 1.25
+    #
+    # @param  [Integer] n a positive integer
+    # @return [Float] the logarithm
+    # @raise  [Errno::EDOM] if `n` < 1
     # @see    http://en.wikipedia.org/wiki/Logarithm
     def self.log256(n)
       ::Math.log(n, 256)
@@ -186,9 +260,14 @@ module RSA
     # Returns the natural logarithm of `n`. If the optional argument `b` is
     # given, it will be used as the base of the logarithm.
     #
-    # @param  [Integer] n
-    # @param  [Integer] b
-    # @return [Float]
+    # @example
+    #   RSA::Math.log(16, 2)                           #=> 4.0
+    #   RSA::Math.log(16, 256)                         #=> 0.5
+    #
+    # @param  [Integer] n a positive integer
+    # @param  [Integer] b a positive integer >= 2, or `nil`
+    # @return [Float] the logarithm
+    # @raise  [Errno::EDOM] if `n` < 1, or if `b` < 2
     # @see    http://en.wikipedia.org/wiki/Natural_logarithm
     def self.log(n, b = nil)
       b ? ::Math.log(n, b) : ::Math.log(n)

data/lib/rsa/version.rb

@@ -2,7 +2,7 @@ module RSA
   module VERSION
     MAJOR = 0
     MINOR = 1
-    TINY  = 2
+    TINY  = 3
     EXTRA = nil
 
     STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 2
-  version: 0.1.2
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - Arto Bendiken
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-07 00:00:00 +02:00
+date: 2010-09-10 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency