faster_prime 1.0.0

data/lib/faster_prime/sieve.rb

@@ -0,0 +1,174 @@
+# Sieve of Atkin
+# http://cr.yp.to/papers/primesieves.pdf
+
+require "faster_prime/utils"
+
+module FasterPrime
+  module Sieve
+    module_function
+
+    TBL = []
+    [
+      [:mark_type_1, ->(f, g) { 4*f*f + g*g }, 15, 30,  1,  4],
+      [:mark_type_2, ->(f, g) { 3*f*f + g*g }, 10, 30,  7, 12],
+      [:mark_type_3, ->(f, g) { 3*f*f - g*g }, 10, 30, 11, 12],
+    ].each do |type, expr, fmax, gmax, n, mod|
+      gmax.times do |g|
+        fmax.times do |f|
+          d = expr[f, g] % 60
+          TBL << [type, f, g, d] if d % mod == n && d.gcd(60) == 1
+        end
+      end
+    end
+
+    MODULO60 = [1, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 49, 53, 59]
+
+    def each(ubound = nil, &blk)
+      if ubound && SMALL_PRIMES.last >= ubound
+        SMALL_PRIMES.each(&blk)
+        return
+      end
+
+      u = SMALL_PRIMES.last / 60 * 60
+      SMALL_PRIMES.pop until SMALL_PRIMES.last < u
+      SMALL_PRIMES.each(&blk)
+
+      b = Utils.integer_square_root(ubound * 3000) if ubound
+      b = 100000 if !b || b > 100000
+      l = u / 60
+
+      # Algorithm 3.1, 3.2, 3.3
+      flags = [0] * b
+      while true
+        # step
+        flags.fill(0)
+
+        # sieve
+        TBL.each do |name, f, g, d|
+          send(name, flags, f, g, d, l, b)
+        end
+
+        # squarefree
+        squarefree(flags, l, b)
+
+        # enumerate primes
+        if ubound && ubound < 60 * (l + b)
+          enumerate(flags, l, b) do |p|
+            return if p >= ubound
+            yield p
+          end
+        else
+          enumerate(flags, l, b, &blk)
+        end
+
+        l += b
+      end
+    end
+
+    def enumerate(flags, l, b)
+      b.times do |x|
+        base = 60 * (l + x)
+        flag = flags[x]
+        MODULO60.each do |d|
+          next if flag[d] == 0
+          p = base + d
+          SMALL_PRIMES << p
+          yield p
+        end
+      end
+    end
+
+    def squarefree(flags, l, b)
+      SMALL_PRIMES.each do |q|
+        q2 = q * q
+        break if q2 > 60 * (l + b)
+        next if q < 7
+        minus_inv_60 = -Utils.mod_inv(60, q2)
+        MODULO60.each do |d|
+          # 60(l+x)+d == 0 (mod q2)
+          # x = -d * 60^{-1} - l (mod q2)
+          x = (d * minus_inv_60 - l) % q2
+          m = ~(1 << d)
+          while x < b
+            flags[x] &= m
+            x += q2
+          end
+        end
+      end
+    end
+
+    # Algorithm 4.1
+    def mark_type_1(flags, f, g, d, l, b)
+      x, y0 = f, g
+      k0 = (4 * f * f + g * g - d) / 60 - l
+      m = 1 << d
+      while k0 < l + b
+        k0 += 2*x + 15
+        x += 15
+      end
+      while true
+        x -= 15
+        k0 -= 2*x + 15
+        return if x <= 0
+        while k0 < 0
+          k0 += y0 + 15
+          y0 += 30
+        end
+        k, y = k0, y0
+        while k < b
+          flags[k] ^= m # mark
+          k += y + 15
+          y += 30
+        end
+      end
+    end
+
+    # Algorithm 4.2
+    def mark_type_2(flags, f, g, d, l, b)
+      x, y0 = f, g
+      k0 = (3 * f * f + g * g - d) / 60 - l
+      m = 1 << d
+      while k0 < b
+        k0 += x + 5
+        x += 10
+      end
+      while true
+        x -= 10
+        k0 -= x + 5
+        return if x <= 0
+        while k0 < 0
+          k0 += y0 + 15
+          y0 += 30
+        end
+        k, y = k0, y0
+        while k < b
+          flags[k] ^= m # mark
+          k += y + 15
+          y += 30
+        end
+      end
+    end
+
+    # Algorithm 4.3
+    def mark_type_3(flags, f, g, d, l, b)
+      x, y0 = f, g
+      k0 = (3 * f * f - g * g - d) / 60 - l
+      m = 1 << d
+      while true
+        while k0 >= b
+          return if x <= y0
+          k0 -= y0 + 15
+          y0 += 30
+        end
+        k, y = k0, y0
+        while k >= 0 && y < x
+          flags[k] ^= m # mark
+          k -= y + 15
+          y += 30
+        end
+        k0 += x + 5
+        x += 10
+      end
+    end
+  end
+end

data/lib/faster_prime/utils.rb

@@ -0,0 +1,225 @@
+module FasterPrime
+  SMALL_PRIMES = []
+  SMALL_PRIME_TABLE = []
+
+  def self.setup_table(n)
+    n = (n + 59) / 60 * 60
+    SMALL_PRIMES.clear << 2
+    n /= 2
+    SMALL_PRIME_TABLE.replace([true] * n)
+    i = 1
+    while i < n
+      if SMALL_PRIME_TABLE[i]
+        SMALL_PRIMES << j = i * 2 + 1
+        k = i + j
+        while k < n
+          SMALL_PRIME_TABLE[k] = false
+          k += j
+        end
+      end
+      i += 1
+    end
+  end
+  setup_table(100000)
+
+  module Utils
+    module_function
+
+    FLOAT_BIGNUM = Float::RADIX ** (Float::MANT_DIG - 1)
+    # Find the largest integer m such that m <= sqrt(n)
+    def integer_square_root(n)
+      if n < FLOAT_BIGNUM
+        Math.sqrt(n).floor
+      else
+        # newton method
+        a, b = n, 1
+        a, b = a / 2, b * 2 until a <= b
+        a = b + 1
+        a, b = b, (b + n / b) / 2 until a <= b
+        a
+      end
+    end
+
+    # Find b such that a * b = 1 (mod n)
+    def mod_inv(a, n)
+      raise ArgumentError, "not coprime for mod_inv" if a == 0 || a.gcd(n) != 1
+
+      # Extended GCD Algorithm:
+      # Find $$(x, y)$$ such that $$ax + by = gcd(a, b), x > 0 and y > 0$$
+      x0, x1 = 1, 0
+      y0, y1 = 0, 1
+      b = n
+      while b != 0
+        q = a / b
+        a, b = b, a % b
+        x0, x1 = x1, x0 - x1 * q
+        y0, y1 = y1, y0 - y1 * q
+      end
+
+      x0 % n
+    end
+
+    # Calculate a^b mod n
+    def mod_pow(a, b, n)
+      r = 1
+      return 1 if b == 0
+      len = b.bit_length
+      len.times do |i|
+        if b[i] == 1
+          r = (a * r) % n
+          return r if i == len - 1
+        end
+        a = (a * a) % n
+      end
+
+      raise "assert not reached"
+    end
+
+    # Find x such that x^2 = a (mod prime)
+    # See ``Complexity of finding square roots'' section of wikipedia:
+    # http://en.wikipedia.org/wiki/Quadratic_residue
+    def mod_sqrt(a, prime)
+      return 0 if a == 0
+
+      case
+      when prime == 2
+        a.odd? ? 1 : 0
+
+      when prime % 4 == 3
+        mod_pow(a, (prime + 1) / 4, prime)
+
+      when prime % 8 == 5
+        # Let v = (2a)^((prime-5)/8) and r = (2av^2 - 1)av.
+        #
+        # 2^((prime-1)/2) = -1 because (2|prime) = -1.
+        # a^((prime-1)/2) =  1 because (a|prime) =  1.
+        # So, (2a)^((prime-1)/2) = -1.
+        #
+        # r = ((2a)^((prime-1)/4) - 1) * a * (2a)^((prime-5)/8)
+        # r^2 = ((2a)^((prime-1)/2) - 2(2a)^((prime-1)/4) + 1)
+        #        * a^2 * (2a)^((prime-5)/4)
+        #     = -2(2a)^((prime-1)/4) * a^2 * (2a)^((prime-5)/4)
+        #     = -a * (2a)^((prime-1)/2)
+        #     = a
+        #
+        # So r is the solution of x^2 = a (mod prime).
+        v = mod_pow(a * 2, (prime - 5) / 8, prime)
+        (2 * a * v * v - 1) * a * v % prime
+
+      else # prime % 8 == 1
+        # Use Tonelli–Shanks algorithm, see:
+        # http://en.wikipedia.org/wiki/Tonelli%E2%80%93Shanks_algorithm
+
+        # Calculate (q, s) such that prime - 1 = 2^s * q and q is odd
+        s, q = 3, prime - 1
+        s += 1 until q[s] == 1
+        q >>= s
+
+        # Find quadratic nonresidue z.
+        z = (2...prime).find {|z_| kronecker(z_, prime) != 1 }
+
+        # The main part of the algorithm
+        c = mod_pow(z, q, prime)
+        x = mod_pow(a, (q - 1) / 2, prime)
+        r = a * x % prime  # a^((q+1)/2)
+        t = r * x % prime  # a^q
+        until t == 1
+          i, d = 0, t
+          i, d = i + 1, d * d % prime while d != 1
+          b = mod_pow(c, 1 << (s - i - 1), prime)
+          c = b * b % prime
+          r = r * b % prime
+          t = t * c % prime
+          s = i
+        end
+        r
+      end
+    end
+
+    # p-adic valuation: Find the highest exponent v such that p^v divides n
+    def valuation(n, p)
+      e = 0
+      while n % p == 0
+        n /= p
+        e += 1
+      end
+      e
+    end
+
+    # Enumerate divisors of n, including n itself
+    def each_divisor(n)
+      return enum_for(:each_divisor, n) unless block_given?
+      t = 1
+      while t * t < n
+        yield t if n % t == 0
+        t += 1
+      end
+      yield t if n == t * t
+      while t > 1
+        t -= 1
+        yield n / t if n % t == 0
+      end
+    end
+
+    # Calculate the number of positive integers less than or equal to n that
+    # are coprime to n
+    def totient(n)
+      n = n.abs
+      raise "n must not be zero" if n == 0
+      r = n
+      PrimeFactorization.prime_factorization(n) do |prime, exp|
+        r = r * (prime - 1) / prime
+      end
+      r
+    end
+
+    # Finds the least primitive root modulo n.
+    # Algorithm 1.4.4 (Primitive Root).
+    def primitive_root(n)
+      t = Utils.totient(n)
+      ps = PrimeFactorization.prime_factorization(t).to_a
+      2.upto(t) do |a|
+        found = true
+        ps.each do |q,|
+          if mod_pow(a, t / q, n) == 1
+            found = false
+            break
+          end
+        end
+        return a if found
+      end
+      nil
+    end
+
+    # Calculate Kronecker symbol (a|b) in O((log a)(log b)), see pp. 29--30,
+    # Cohen, Henri (1993), A Course in Computational Algebraic Number Theory
+    def kronecker(a, b)
+      return a.abs != 1 ? 0 : 1 if b == 0
+      return 0 if a.even? && b.even?
+
+      k = 1
+
+      case a & 7
+      when 1, 7 then b    = b / 2     while b.even?
+      when 3, 5 then b, k = b / 2, -k while b.even?
+      end
+      if b < 0
+        b = -b
+        k = -k if a < 0
+      end
+
+      while a != 0
+        case b & 7
+        when 1, 7 then a    = a / 2     while a.even?
+        when 3, 5 then a, k = a / 2, -k while a.even?
+        end
+        k = -k if 2 & a & b == 2
+        a = a.abs
+        a, b = b % a, a
+        a -= b if a > b / 2
+      end
+
+      return b > 1 ? 0 : k
+    end
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: faster_prime
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yusuke Endoh
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: This provides `Integer#prime?`, `Integer#prime_division`, and `Prime#each`
+  that are almost compatible to and faster than `lib/prime.rb`.
+email:
+- mame@ruby-lang.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- faster_prime.gemspec
+- lib/faster_prime.rb
+- lib/faster_prime/core_ext.rb
+- lib/faster_prime/primality_test.rb
+- lib/faster_prime/prime_factorization.rb
+- lib/faster_prime/sieve.rb
+- lib/faster_prime/utils.rb
+homepage: https://github.com/mame/faster_prime
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: A faster substitute for `lib/prime.rb`.
+test_files: []