number-theory 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9284bb03268cfa67e75ffef537016a2a4d8d8533
+  data.tar.gz: 4b8ee777a7acd1c3dad895d76b8220c400231c30
+SHA512:
+  metadata.gz: fbde0ca1af6d1e0f089b04b7801aa8a5c7b28ff39ee3e7d18637b14327ea0dcadfad18e9b030c6c968b7504fa23b246367e33057c611ecdcb49ea272c7fde285
+  data.tar.gz: 0ce4ba32f0a9d869d818d9a228be60a36278bd027cdf9c0847755128efa141c1d1c25e5413e8673d678e5b3bc7bd63b9686319168daf981f47d864bad591dbab

data/lib/number-theory.rb

@@ -0,0 +1,15 @@
+module NumberTheory
+
+  begin
+    require 'narray'
+  rescue LoadError
+    raise LoadError, "You must have NArray installed"
+  end
+
+  # Load modules
+  require File.dirname(__FILE__) + '/number-theory/primes.rb'
+  require File.dirname(__FILE__) + '/number-theory/divisors.rb'
+  require File.dirname(__FILE__) + '/number-theory/utils.rb'
+  require File.dirname(__FILE__) + '/number-theory/congruences.rb'
+
+end

data/lib/number-theory/congruences.rb

@@ -0,0 +1,82 @@
+require_relative 'divisors'
+
+module NumberTheory
+
+  module Congruences
+    ##
+    # Returns all the incongruent solutions to ax ≡ c (mod m) in ascending order
+    #
+    # == Example
+    #  >> Congruences.congruences_solver(893, 266, 2432) # this solves 893x ≡ 266 (mod 2432)
+    #  => [82, 210, 338, 466, 594, 722, 850, 978, 1106, 1234, 1362, 1490, 1618, 1746, 1874, 2002, 2130, 2258, 2386]
+    #
+    def self.linear_congruences_solver(a, c, m)
+      return [] if a == 0 || m == 0
+      # Assuming both a and m are positive integers
+      # If negative values are passed, they will be treated as positive integers
+      a = 0 - a if a < 0
+      m = 0 - m if m < 0
+      arr = Divisors.extended_euclidean_algo(a, m)
+      gcd = arr[0]
+      if c % gcd != 0
+        [] # i.e no solution
+      else
+        first = (arr[1] * c / gcd) % m
+        sol = [first]
+        i = 1
+        while i < gcd do
+          x = first + i * m / gcd
+          x -= m if x >= m
+          sol << x
+          i+=1
+        end
+        sol.sort
+      end
+    end
+
+    ##
+    # Returns an integer d satifying the following simultaneous congruences
+    # x ≡ r1 (mod m1)
+    # x ≡ r2 (mod m2)
+    # x ≡ r3 (mod m3)
+    # and 0 <= d < m1*m2*m3
+    # == Example
+    #  >> Congruences.chinese_remainder_theorem([2, 3, 2], [3, 5, 7])
+    #  => 23
+    #  the above solves
+    #  # x ≡ 2 (mod 3)
+    #  # x ≡ 3 (mod 5)
+    #  # x ≡ 2 (mod 7)
+    def self.chinese_remainder_theorem(remainders, modulos)
+      m1 = modulos[0].abs
+      m2 = modulos[1].abs
+      m3 = modulos[2].abs
+      r1 = remainders[0]
+      r2 = remainders[1]
+      r3 = remainders[2]
+      arr = Divisors.extended_euclidean_algo(m1, m2)
+      g1 = arr[0]
+      g2 = Divisors.euclidean_algo(m2, m3)
+      g3 = Divisors.euclidean_algo(m3, m1)
+      if g1 != 1 || g2 != 1 || g3 != 1
+        false
+      else
+        # x ≡ r1 (mod m1) ...... (1)
+        # x ≡ r2 (mod m2) ...... (2)
+        # x ≡ r3 (mod m3) ...... (3)
+        # From (1) and (2), we have m1*q1 + r1 ≡ r2 (mod m2)
+        # which means m1*q1 - m2*q2 = r2 - r1
+        # So, we can solve this linear congruence equation for x0 which equals m1*q1 + r1
+        # Then, we can assume x0 + m1*m2*y ≡ r3 (mod m3)
+        # which means m1*m2*y - m3*q3 = r3 - x0
+        # So, we have the following solution
+        q1 = arr[1] * (r2 - r1)
+        x0 = m1 * q1 + r1
+        arr2 = Divisors.extended_euclidean_algo(m1*m2, m3)
+        x = (arr2[1] * (r3 - x0) * m1 * m2 + x0) % (m1*m2*m3) # Make sure 0 <= x < m1*m2*m3
+        x
+      end
+    end
+  end
+
+end

data/lib/number-theory/divisors.rb

@@ -0,0 +1,200 @@
+require_relative 'utils'
+require_relative 'primes'
+
+module NumberTheory
+
+  module Divisors
+
+    ##
+    # Returns the greatest integer k such that
+    # d^k divides n.
+    #
+    # == Example
+    #  >> Divisors.multiplicity(1000,5)
+    #  => 3
+    #
+    def self.multiplicity(n, d)
+      return 0 if n % d != 0
+      m, res = n, 0
+      while m % d == 0
+        m /= d
+        res += 1
+      end
+      res
+    end
+
+    ##
+    # Returns the ordered list of the divisors of n (1 and n included).
+    #
+    # == Example
+    #  >> Divisors.divisors(100)
+    #  => [1, 2, 4, 5, 10, 20, 25, 50, 100]
+    #
+    def self.divisors(n)
+      factors = Primes.factor(n)
+      ps = factors.keys.sort!
+      self._divisors(0, factors, ps).sort!.uniq
+    end
+
+    ## Helper function for divisors
+    def self._divisors(n = 0, factors, ps) # :nodoc:
+      give = []
+      if n == ps.size
+        give << 1
+      else
+        pows = [1]
+        factors[ps[n]].times {pows << pows[-1]*ps[n]}
+        for q in self._divisors(n+1, factors, ps)
+          for p in pows
+            give << p * q
+          end
+        end
+      end
+      give
+    end
+
+    ##
+    # Return sigma_0(n), i.e. the number of divisors of n.
+    #
+    # == Example
+    #  >> Divisors.divcount(100)
+    #  => 9
+    #
+    def self.divcount(n)
+      return nil if n < 0
+      return 1 if n == 1
+      divcount = 1
+      Primes.factor(n).values.each {|n| divcount *= (n+1)}
+      divcount
+    end
+
+    ##
+    # Returns sigma_k(n), i.e. the sum of the k-th powers of 
+    # the divisors of n.
+    #
+    # == Example
+    #  >> Divisors.divisor_sigma(10, 2)
+    #  => 130
+    #
+    def self.divisor_sigma(n, k)
+      return self.divcount(n) if k == 0
+      res = 0
+      for i in self.divisors(n)
+        res += i**k
+      end
+      res
+    end
+
+    ##
+    # Returns true if n is a perfect number, false otherwise.
+    #
+    # == Example
+    #  >> Divisors.perfect?(6)
+    #  => true
+    #
+    def self.perfect? (n)
+      self.divisor_sigma(n, 1) == 2*n
+    end
+
+
+    ##
+    # Returns the valuer of phi(n), the Euler phi function; i.e.
+    # the number of integers in [1..n] comprime to n. 
+    #
+    # == Example
+    #  >> Divisors.euler_phi(30)
+    #  => 8
+    #
+    #  >> Divisors.euler_phi(37)
+    #  => 36
+    #
+    # == Algorithm
+    # n is first factored, then the result is computed as
+    # n * prod_{p} (1 - 1/p)
+    # where the product spans over all the prime factors of n
+    #
+    def self.euler_phi(n)
+      return 0 if n < 1
+      res = n
+      Primes.factor(n).keys.each do |i|
+        res *= i - 1
+        res /= i
+      end
+      res
+    end 
+
+    ##
+    # Returns true if a positive integer is square free;
+    # returns false otherwise
+    #
+    # A positive integer 'n' is said to be square free
+    # if no prime factor appears more than once
+    # in the list of prime factors for 'n'
+    #
+    # == Example
+    #  >> Divisors.square_free?(10)
+    #  => true
+    #
+    # The integer 1 is a special case since it is 
+    # both a prefect square, and square free.
+    # 
+    def self.square_free?(n)
+      return false if n <= 0
+      (Primes.factor(n)).each_value { |value| return false if value >= 2 }
+      true
+    end
+
+    ##
+    # Returns the greatest common divisor of a and b
+    # == Example
+    #  >> Divisors.euclidean_algo(20, 15) = 5
+    def self.euclidean_algo(a, b)
+      a = 0 - a if a < 0
+      b = 0 - b if b < 0
+      if a == 0 || b == 0
+        0
+      else
+        r = a - (a/b)*b
+        while r!=0 do
+          a = b
+          b = r
+          r = a - (a/b)*b
+        end
+        b
+      end
+    end
+
+    ##
+    # Returns the greatest common divisor of a and b and the corresponding Bézout coefficients
+    # for ax + by = g where g is the greatest common divisor of a and b
+    # == Example
+    #  >> Divisors.extended_euclidean_algo(20, 15) = [5, 1, -1]
+    def self.extended_euclidean_algo(a, b)
+      a = 0 - a if a < 0
+      b = 0 - b if b < 0
+      if a == 0 || b == 0
+        [0, 0, 0]
+      else
+        r = a - (a/b)*b
+        s0 = 1;                 t0 = 0
+        s1 = 0;                 t1 = 1
+        s2 = s0 - (a/b)*s1;     t2 = t0 - (a/b)*t1
+        while r!=0 do
+          a = b
+          b = r
+          r = a - (a/b)*b
+          s0 = s1;              t0 = t1
+          s1 = s2;              t1 = t2
+          s2 = s0 - (a/b)*s1;   t2 = t0 - (a/b)*t1
+        end
+        ans = []
+        ans << b
+        ans << s1
+        ans << t1
+        ans
+      end
+    end
+    
+  end
+
+end

data/lib/number-theory/primes.rb

@@ -0,0 +1,400 @@
+module NumberTheory
+
+  module Primes
+
+    ## 
+    # Returns true if n is (probably) prime, false otherwise.
+    # For n < 10^15 the answer is accurate; greater n values
+    # reported as primes have a (very) small probability of
+    # actually being pseudoprimes.
+    #
+    # == Example
+    #  >> Primes.prime?(12)
+    #  => false
+    #
+    #  >> Primes.prime?(1882341361)
+    #  => true
+    #
+    # == Algorithm
+    # For n < 10^9 the function just test by trial division;
+    # for greater n values it performs a Miller-Rabin a
+    # pseudoprime test. 
+    #
+    # If n < 341550071728321 the test is deterministic, otherwise
+    # there's a probability smaller than 7 x 10^-31 that a composite
+    # number is reported as prime.
+    #
+    def self.prime?(n)
+      if n < 10**9 or n % 2 == 0
+        self._trial_division(n)
+      else
+        self._miller_rabin(n)
+      end
+    end
+
+    ## helper method for prime?
+    def self._trial_division(n) 
+      return false if n < 2 or n == 4
+      return true if n == 2 or n == 3 or n == 5
+
+      mods30 = [1, 7, 11, 13, 17, 19, 23, 29] 
+      return false if not mods30.include?(n % 30)
+
+      3.step(n**0.5, 2) { |x| return false if n % x == 0 }
+      true
+    end
+
+    ## helper method for prime?
+    def self._miller_rabin(n, runs = 50) # :nodoc:
+      if n < 341550071728321
+        for a in [2, 3, 5, 7, 11, 13, 17] do
+          return false if self._witness(a, n)
+        end
+        true
+      else
+        runs.times do
+          a = 1 + Random.rand(n)
+          return false if self._witness(a, n)
+        end
+        true
+      end
+    end
+
+    ## helper method for _miller_rabin
+    def self._witness(a, n) 
+      t = Divisors.multiplicity(n - 1, 2)
+      u = (n - 1) / (2**t)
+      x1 = Utils.mod_exp(a, u, n)
+      t.times do |i|
+        x0 = x1
+        x1 = (x0 * x0) % n
+        return true if x1 == 1 and x0 != 1 and x0 != n-1
+      end
+      return true if x1 != 1
+      false
+    end
+      
+    ##
+    # Memoized list of primes.
+    #
+    # primes_list returns a list of the prime numbers
+    # between low and high (extremes included). 
+    #
+    # The computation is memoized in @primes_bit_array,
+    # @upper_limit is the current highest prime in the list.
+      # Later requests are serverd either by using the memoized
+      # list, or extending it (if high > @upper_limit)
+    # 
+    # == Example
+    #  >> Primes.primes_list(30)
+    #  => [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+    #
+    # == Algorithm
+    # Primes are computed using a plain version of the Sieve 
+    # of Eratosthenes; the method uses the bit-array structure
+    # implemented in the NArray gem
+    #
+    @primes_bit_array = nil
+    @upper_limit = 0
+
+    def self.primes_list(low = 2, high)  
+      self._initialize_bit_array(high) if not @primes_bit_array
+      if high > @upper_limit
+        self._extend_bit_array(high)
+      end
+      primes = NArray.object(high + 1).indgen!
+      ret = primes[@primes_bit_array[0..high]].to_a
+      return ret[ret.index{ |i| i >= low}..-1 ]
+    end
+
+    ## extend the memoized bit array up to high
+    def self._extend_bit_array(high)
+      arr = NArray.byte(high + 1)
+      arr[0..@upper_limit] = @primes_bit_array[0..@upper_limit]
+      arr[@upper_limit+1..-1] = NArray.byte(high - @upper_limit).fill(1)[0..-1]
+      sq = (high**0.5).ceil
+      2.upto(sq) do |i|
+        if arr[i] == 1
+          j = i*i
+          j += i while j < @upper_limit
+          while j <= high
+            arr[j] = 0
+            j += i
+          end
+        end
+      end
+      @primes_bit_array = arr
+      @upper_limit = high
+    end
+
+    ## for the first computation of the bit array
+    def self._initialize_bit_array  (high)
+      arr = NArray.byte(high + 1).fill(1)
+      arr[0], arr[1] = 0, 0
+      sq = (high**0.5).ceil
+      2.upto(sq) do |i|
+        if arr[i] == 1
+          j = i**2
+          while j <= high
+            arr[j] = 0
+            j += i
+          end
+        end
+      end
+      @primes_bit_array = arr
+      @upper_limit = high
+    end
+
+    ##
+    # Returns the nth prime number.
+    #
+    # == Example
+    #  >> Primes.nthprime(10**4)
+    #  => 104729
+    #
+    # == Algorithm
+    # Since it can be proved that the nth prime number is 
+    # not greater than n * (log n + log log n)
+    # the method returns the nth element of 
+    # primes_list(n * (log n + log log n))
+    #
+    def self.nthprime(n)
+      return [2, 3, 5, 7, 11, 13][n - 1] if n < 7
+      lim = n * (Math.log(n) + Math.log(Math.log(n))).to_i
+      self.primes_list(lim + 1)[n - 1]
+    end
+
+    ##
+    # Returns the value of primepi(n), i.e. the number
+    # of primes smaller than n
+    #
+    # == Example
+    #  >> Primes.primepi(100000)
+    #  => 9592
+    #
+    def self.primepi(n)
+      return 0 if n < 2
+      self.primes_list(n).size
+    end
+
+
+    ##
+    # Factors n and returns an hash containing the prime
+    # factors of n as keys and their respective multiplicities
+    # as values. If limit is passed, no factors greater
+    # than limit are searched, and some of the keys could be
+    # composite.
+    #
+    # == Example
+    #  >> Primes.factor(1690)
+    #  => {2=>1, 5=>1, 13=>2}
+    #
+    #  >> Primes.factor(1690, 10)
+    #  => {2=>1, 5=>1, 169=>1}
+    #
+    #  >> Primes.factor(79103835773176077140539788299)
+    #  => {3267000013=>1, 4093082899=>1, 5915587277=>1}
+    #
+    # == Algorithm
+    # The procedure first searches for small factors of n
+    # in the primes list provided by the primes_list method.
+    # Then, if needed, the procedure switches between Pollard's Rho method
+    # and Pollard's p - 1 method until n is fully factored.
+    #
+    def self.factor(n, opts = {})
+      defaults = { limit: nil, use_rho: true, use_pm1: true}
+      options = defaults.merge!(opts)
+
+      limit = options[:limit]
+      use_rho = options[:use_rho]
+      use_pm1 = options[:use_pm1]
+
+      return nil if n < 1
+      return {1 => 1} if n == 1
+      return {n => 1} if self.prime?(n)
+
+      if limit 
+        factors, m = self._trial(n, limit)
+        return factors if m == 1
+        return factors.merge({m => 1})
+      else
+        factors, m = self._trial(n, 100000)
+        return factors if m == 1
+        return factors.merge({m => 1}) if self.prime?(m)
+
+        if not (use_pm1 or use_rho)
+          return factors.merge({m => 1})
+        end
+        
+        count = 1
+        while m > 1
+
+          ## pollard rho
+          if use_rho
+            rounds = [10**3, 10**count].max
+            div = self._pollard_rho(m, rounds)
+            if div
+              if self.prime?(div)
+                fac = {div => 1}
+              else
+                fac = self.factor(div)
+              end
+              factors.merge!(fac) { |_, v1, v2| v1 + v2 }
+              m /= div
+              return factors.merge({m => 1}) if self.prime?(m)
+            end
+          end
+
+          ## pollard p - 1
+          if use_pm1
+            bound = [10**3, 10**count].max
+            div = self._pollard_pm1(m, bound)
+            if div
+              if self.prime?(div)
+                fac = {div => 1}
+              else
+                fac = self.factor(div)
+              end
+              factors.merge!(fac) { |_, v1, v2| v1 + v2 }
+              m /= div
+              return factors.merge({m => 1}) if self.prime?(m)
+            end
+          end
+
+          count += 1
+        end
+        return factors
+      end
+    end
+
+    ## search for small factor of n (upto lim)
+    def self._trial(n, lim) 
+      factors = {}
+      for p in self.primes_list(lim)
+        if n % p == 0
+          t = Divisors.multiplicity(n, p)
+          factors[p] = t
+          n /= p**t
+        end
+      end
+      return factors, n
+    end
+
+    ## Pollard's rho method
+    def self._pollard_rho(n, max_rounds, retries = 5) 
+      v, a, i = 2, -1, 0
+      retries.times do
+        u, f = v, ->(x) { (x*x + a) % n }
+        max_rounds.times do
+          u, v = f.call(u), f.call(f.call(v))
+          g = n.gcd(u - v)
+          next if g == 1
+          break if g == n
+          return g
+        end
+        v, a = rand(n - 1), 1 + rand(n - 4) 
+      end
+      return nil
+    end
+
+    ## Pollard's p - 1 method
+    def self._pollard_pm1 (n, bound, max_rounds = 8)
+      primes = self.primes_list(bound)
+      max_rounds.times do
+        c = 2
+        primes.each do |p|
+          Math.log(bound, p).floor.times { c = Utils.mod_exp(c, p, n) }
+        end
+        g = n.gcd(c-1)
+        return g if g != 1 and g != n
+      end
+      return nil
+    end
+
+    ##
+    # Returns the smallest prime number greater than n.
+    #
+    # == Example
+    #  >> Primes.nextprime(1000)
+    #  => 1009
+    #
+    # == Algorithm
+    # Starting from n, tests primality for each successive number
+    # equals to 1 or 5 (mod 6). Return the first prime
+    # found.
+    #
+    def self.nextprime(n)
+      if n < 10007
+        return self.primes_list(10007).find { |x| x > n }
+      else
+        p = n + 1
+        p += 1 while p % 6 != 1 and p % 6 != 5
+        flip = (p % 6 == 1 ? 4 : 2)
+        while not self.prime?(p)
+          p += flip
+          flip = 6 - flip 
+        end
+        return p
+      end
+    end
+
+    ##
+    # Returns the greatest prime number smaller than +n+.
+    #
+    # == Example
+    #  >> Primes.prevprime(1000)
+    #  => 997
+    #
+    # == Algorithm
+    # Starting from n, tests primality for each previous number
+    # equals to 1 or 5 (mod 6). Return the first prime
+    # found.
+    def self.prevprime(n)
+      return nil if n < 3
+      p = n-1
+      p -= 1 while p % 6 != 1 and p % 6 != 5
+      flip = (p % 6 == 1 ? 2 : 4)
+      while not self.prime?(p)
+        p -= flip
+        flip = 6 - flip 
+      end
+      return p
+    end
+
+    ##
+    # Returns a random prime between low and high;
+    # and nil if there's not one.
+    #
+    # == Example
+    #  >> Primes.randprime(1000)
+    #  => 631
+    #
+    #  >> Primes.randprime(10000, 20000)
+    #  => 15569
+    #
+    def self.randprime(low = 1, high)
+      p = self.nextprime(low + rand(high - low + 1))
+      p = self.prevprime(p) if p > high
+      return nil if p < low
+      return p
+    end
+
+    ##
+    # Returns the primorial of n, i.e. the product
+    # of the first n prime numbers.
+    #
+    # == Example
+    #  >> Primes.primorial(10)
+    #  => 6469693230
+    #
+    def self.primorial(n)
+      return nil if n < 0
+      return [2, 6, 30, 210, 2310][n - 1] if n < 7
+      upp = n * (Math.log(n) + Math.log(Math.log(n)))
+      primes = self.primes_list(upp)[0..n-1]
+      primes.inject {|a, b| a * b}
+    end
+
+  end
+
+end

data/lib/number-theory/utils.rb

@@ -0,0 +1,68 @@
+module NumberTheory 
+
+  def self.time_once
+    start = Time.now
+    yield 
+    (Time.now - start).round(3)
+  end
+
+  module Utils
+
+    ## 
+    # Returns a^b (mod m). Negative exponents are allowed.
+    #
+    # == Example
+    #  >> Utils.mod_exp(12, 34, 107)
+    #  => 61
+    #
+    # == Algorithm
+    #
+    #
+    #
+    def self.mod_exp(a, b, m)
+      if b >= 0
+        res = 1
+        while b > 0
+          res = (res * a) % m if b & 1 != 0
+          b >>= 1
+          a = (a * a) % m
+        end
+        res
+      else
+        self.mod_exp(self.mod_inv(a, m), -b, m)
+      end
+    end
+
+    ##
+    # Returns the modular inverse of a, i.e. the number b
+    # such that a * b = 1 (mod m)
+    #
+    # == Example
+    #  >> Utils.mod_inv(121, 107)
+    #  => 23
+    #
+    # == Algorithm
+    #
+    #
+    #
+    #
+    def self.mod_inv(a, m)
+      return 0 if a % m == 0
+      g, a, y = self._eca(a, m) 
+      return g != 1 ? 0 : a % m
+    end
+
+    ## helper function for mod_inv
+    def self._eca(a, b)
+      return b, 0, 1 if a == 0
+      g, y, x = self._eca(b % a, a)
+      return g, x - y * (b / a).floor, y
+    end
+
+
+  end
+
+
+end
+
+

data/test/test_congruences.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'number-theory'))
+
+include NumberTheory
+
+class TestCongruences < Test::Unit::TestCase
+  def test_linear_congruences_solver
+    # test linear_congruences_solver(a, c, m) which solves ax ≡ c (mod m)
+    assert_equal [], Congruences.linear_congruences_solver(3, 5, 6)
+    assert_equal [], Congruences.linear_congruences_solver(0, 5, 6)
+    assert_equal [1], Congruences.linear_congruences_solver(3, -5, 8)
+    p Congruences.linear_congruences_solver(-3, -5, -8)
+    assert_equal [1], Congruences.linear_congruences_solver(-3, -5, -8) # treating both a and m are positive integers
+    assert_equal 1078, Congruences.linear_congruences_solver(316258250, 2156, 1160718174).size
+    assert_equal [82, 210, 338, 466, 594, 722, 850, 978, 1106, 1234, 1362, 1490, 1618, 1746, 1874, 2002, 2130, 2258, 2386], Congruences.linear_congruences_solver(893, 266, 2432)
+  end
+
+  def test_chinese_remainder_theorem
+    assert_equal 23, Congruences.chinese_remainder_theorem([2, 3, 2], [3, 5, 7])
+    assert_equal false, Congruences.chinese_remainder_theorem([2, 3, 2], [3, 6, 7]) # as gcd(3, 6) = 2 which is not 1
+    assert_equal 1000, Congruences.chinese_remainder_theorem([10, 4, 12], [11, 12, 13])
+    assert_equal 8083600090651983754, Congruences.chinese_remainder_theorem([10, 4, 12], [1160718174, 1160718175, 13])
+    assert_equal 6725167681631185062030019654, Congruences.chinese_remainder_theorem([10, 4, 12], [2160718174, 2160718175, 2160718177])
+  end
+end

data/test/test_divisors.rb

@@ -0,0 +1,80 @@
+require 'test/unit'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'number-theory'))
+
+include NumberTheory
+
+class TestDivisors < Test::Unit::TestCase
+
+  def test_divisors
+    assert_equal(Divisors.divisors(32), [1, 2, 4, 8, 16, 32])
+    assert_equal(Divisors.divisors(210), [1, 2, 3, 5, 6, 7, 10, 14, 15, 21, 30, 35, 42, 70, 105, 210])
+  end
+
+  def test_divcount
+    assert_equal(Divisors.divcount(210), 16)
+    assert_equal(Divisors.divcount(32000), 36)
+    assert_equal(Divisors.divcount(3861000), 256)
+    assert_equal(Divisors.divcount(4900265546530028103000), 12288)
+  end
+
+  def test_multiplicity
+    assert_equal(Divisors.multiplicity(18, 2), 1)
+    assert_equal(Divisors.multiplicity(34992, 3), 7)
+    assert_equal(Divisors.multiplicity(8152454278732958496, 19), 11)
+  end
+
+  def test_divisor_sigma
+    assert_equal(Divisors.divisor_sigma(16,1), 31)
+    assert_equal(Divisors.divisor_sigma(20,2), 546)
+    assert_equal(Divisors.divisor_sigma(28,5), 17766056)
+    assert_equal(Divisors.divisor_sigma(15,7), 170939688)
+  end
+
+  def test_euler_phi
+    assert_equal(Divisors.euler_phi(12), 4)
+    assert_equal(Divisors.euler_phi(19), 18)
+    assert_equal(Divisors.euler_phi(25555), 19296)
+    assert_equal(Divisors.euler_phi(87654), 25032)
+  end
+
+  def test_perfect?
+    assert(Divisors.perfect?(6))
+    assert(Divisors.perfect?(496))
+    assert(Divisors.perfect?(2305843008139952128))
+  end
+
+  def test_square_free?
+    assert(Divisors.square_free?(1))
+    assert(Divisors.square_free?(110))
+    assert(Divisors.square_free?(3226340895))
+    assert(Divisors.square_free?(3226340897))
+    assert(!Divisors.square_free?(3226340896))
+    assert(!Divisors.square_free?(18))
+    assert(!Divisors.square_free?(0))
+    assert(!Divisors.square_free?(-110))
+  end
+
+  def test_euclidean_algo
+    assert_equal 1, Divisors.euclidean_algo(1, 2) # Trivial case
+    assert_equal 5, Divisors.euclidean_algo(20, 15) # Trivial case
+    assert_equal 13, Divisors.euclidean_algo(13, 13) # a = b
+    assert_equal 100, Divisors.euclidean_algo(1000, 100) # one is a mulitple of the other
+    assert_equal 0, Divisors.euclidean_algo(1000, 0) # one number is zero
+    assert_equal 1, Divisors.euclidean_algo(-3, -7) # treat -ve numbers as +ve ones
+    assert_equal 1, Divisors.euclidean_algo(99991, 200) # with a prime number
+    assert_equal 1078, Divisors.euclidean_algo(1160718174, 316258250)
+  end
+
+  def test_extended_euclidean_algo
+    assert_equal [1, 1, 0], Divisors.extended_euclidean_algo(1, 2) # Trivial case
+    assert_equal [5, 1, -1], Divisors.extended_euclidean_algo(20, 15) # Trivial case
+    assert_equal [13, 0, 1], Divisors.extended_euclidean_algo(13, 13) # a = b
+    assert_equal [100, 0, 1], Divisors.extended_euclidean_algo(1000, 100) # one is a mulitple of the other
+    assert_equal [0, 0, 0], Divisors.extended_euclidean_algo(1000, 0) # one number is zero
+    assert_equal [1, -2, 1], Divisors.extended_euclidean_algo(-3, -7) # treat -ve numbers as +ve ones
+    assert_equal [1, -89, 44496], Divisors.extended_euclidean_algo(99991, 200) # with a prime number
+    assert_equal [1078, 144397, -529960], Divisors.extended_euclidean_algo(1160718174, 316258250)
+    assert_equal [1078, -529960, 144397], Divisors.extended_euclidean_algo(316258250, 1160718174)
+  end
+
+end

data/test/test_primes.rb

@@ -0,0 +1,84 @@
+require 'test/unit'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'number-theory'))
+
+include NumberTheory
+
+class TestPrimes < Test::Unit::TestCase
+
+  def test__trial_division
+    assert(!Primes._trial_division(1))
+    assert(Primes._trial_division(2))
+    assert(!Primes._trial_division(24680))
+    assert(Primes._trial_division(982451653))
+    assert(Primes._trial_division(1882341361))
+  end
+
+  def test__miller_rabin
+    assert(!Primes._miller_rabin(24680))
+    assert(Primes._miller_rabin(982451653))
+    assert(Primes._miller_rabin(1882341361))
+    assert(Primes._miller_rabin(9007199254740881))
+    assert(Primes._miller_rabin(9007199254740881))
+  end
+
+  def test_prime?
+    assert(!Primes.prime?(1))
+    assert(Primes.prime?(2))
+    assert(!Primes.prime?(24680))
+    assert(Primes.prime?(982451653))
+    assert(Primes.prime?(1882341361))
+    assert(Primes.prime?(9007199254740881))
+    assert(Primes.prime?(66405897020462343733))
+    assert(Primes.prime?(416064700201658306196320137931))
+    assert(Primes.prime?(6847944682037444681162770672798288913849))
+    assert(Primes.prime?(95647806479275528135733781266203904794419563064407))
+    assert(Primes.prime?(669483106578092405936560831017556154622901950048903016651289))
+    assert(Primes.prime?(2367495770217142995264827948666809233066409497699870112003149352380375124855230068487109373226251983))
+  end
+
+  def test_primes_list
+    assert_equal(Primes.primes_list(10), [2, 3, 5, 7])
+    assert_equal(Primes.primes_list(10, 30), [11, 13, 17, 19, 23, 29])
+    assert_equal(Primes.primes_list(10**3,10**4).size, 1229 - 168)
+    assert_equal(Primes.primes_list(10**5).size, 9592)
+  end
+
+  def test_primepi
+    assert_equal(Primes.primepi(10), 4)
+    assert_equal(Primes.primepi(10**3), 168)
+    assert_equal(Primes.primepi(10**6), 78498)
+  end
+
+  def test_factor
+    assert_equal(Primes.factor(10), {2=>1, 5=>1})
+    assert_equal(Primes.factor(10125000), {2=>3, 3=>4, 5=>6})
+    assert_equal(Primes.factor(10125001), {10125001=>1})
+    assert_equal(Primes.factor(79103835773176077140539788299), {3267000013=>1, 4093082899=>1, 5915587277=>1})
+    assert_equal(Primes.factor(323424426232167763068694468589), {5915587277=>1, 54673257461630679457=>1})
+    assert_equal(Primes.factor(12932983746293756928584532764589230), {2=>1, 5=>1, 73=>1, 383=>1, 63564265087747=>1, 727719592270351=>1})
+  end
+
+  def test_nextprime
+    assert_equal(Primes.nextprime(5), 7)
+    assert_equal(Primes.nextprime(98765432100), 98765432137)
+    assert_equal(Primes.nextprime(9876543210000000000), 9876543210000000029)
+  end
+
+  def test_prevprime
+    assert_equal(Primes.prevprime(1234567890), 1234567811)
+    assert_equal(Primes.prevprime(1234567890000000000), 1234567889999999953)
+  end
+
+  def test_nthprimes
+    assert_equal(Primes.nthprime(10), 29)
+    assert_equal(Primes.nthprime(1000), 7919)
+    assert_equal(Primes.nthprime(10000), 104729)
+  end
+
+  def test_primorial
+    assert_equal(Primes.primorial(5), 2310)
+    assert_equal(Primes.primorial(17), 1922760350154212639070)
+    assert_equal(Primes.primorial(25), 2305567963945518424753102147331756070)
+  end
+
+end

data/test/test_utils.rb

@@ -0,0 +1,24 @@
+require 'test/unit'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'number-theory'))
+
+include NumberTheory
+
+class TestUtils < Test::Unit::TestCase
+
+  def test_mod_exp
+    assert_equal(Utils.mod_exp(123, 0, 234), 1)
+    assert_equal(Utils.mod_exp(4, 13, 497), 445)
+    assert_equal(Utils.mod_exp(1777, 1885, 100000001), 2452785)
+    assert_equal(Utils.mod_exp(54321, 98765, 2147483647), 252276857)
+    assert_equal(Utils.mod_exp(4, -13, 497), 86)
+    assert_equal(Utils.mod_exp(1777, -1885, 100000001), 9159955)
+    assert_equal(Utils.mod_exp(54321, -98765, 2147483647), 1899303417)
+  end
+
+  def test_mod_inv
+    assert_equal(Utils.mod_inv(3, 17), 6)
+    assert_equal(Utils.mod_inv(116003, 1500450271), 287173581)
+    assert_equal(Utils.mod_inv(5915587277, 54673257461630679457), 50186303895605983691)
+  end
+
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: number-theory
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Alberto Donizetti
+- Danny Siu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.6'
+description: A number theory library written in pure Ruby. Provides methods for primality
+  test, factoring integers, and more.
+email: dannysiu392005@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/number-theory.rb
+- lib/number-theory/congruences.rb
+- lib/number-theory/divisors.rb
+- lib/number-theory/primes.rb
+- lib/number-theory/utils.rb
+- test/test_congruences.rb
+- test/test_divisors.rb
+- test/test_primes.rb
+- test/test_utils.rb
+homepage: https://github.com/dannysiu392005/ruby-number-theory
+licenses:
+- GNU GPL 3
+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.6.7
+signing_key: 
+specification_version: 4
+summary: A Ruby Number Theory Library
+test_files:
+- test/test_congruences.rb
+- test/test_divisors.rb
+- test/test_primes.rb
+- test/test_utils.rb
+has_rdoc: