ruby-numtheory 0.0.6 → 0.0.7

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.3 

data/README.md

@@ -2,6 +2,8 @@
 
 The library is written as C extension and aims to provide fast implementations of common number-theoretical algorithms.
 
+[![Build Status](https://secure.travis-ci.org/lomereiter/ruby-numtheory.png)](http://travis-ci.org/lomereiter/ruby-numtheory)
+
 ## Currently implemented
 
 * powermod (uses sliding window exponentiation)

data/Rakefile

@@ -11,24 +11,24 @@ rescue Bundler::BundlerError => e
 end
 require 'rake'
 
-spec = Gem::Specification.load('ruby-numtheory.gemspec')
-  
 require 'rspec/core'
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList["spec/**/*_spec.rb"]
 end
 
-task :test => :spec
-task :default => :test
-
+spec = Gem::Specification.load('ruby-numtheory.gemspec')
+  
 require 'rubygems/package_task'
 Gem::PackageTask.new(spec) do |pkg|
 end
 
-task :build => :gem
-
 require 'rake/extensiontask'
 Rake::ExtensionTask.new('numtheory', spec) do |ext|
   ext.cross_compile = true
 end
+
+task :spec => :compile
+task :test => :spec
+task :default => :test
+task :build => :gem

data/ext/numtheory/extconf.rb

@@ -1,3 +1,3 @@
 require 'mkmf'
-$CFLAGS = "-g -O3 -funroll-all-loops -fPIC -pedantic -std=c99"
+$CFLAGS = "-g -O3 -funroll-all-loops -fPIC -pedantic -std=c99 -Wall -Wno-unused-but-set-variable"
 create_makefile 'numtheory'

data/ext/numtheory/numtheory.c

@@ -2,10 +2,16 @@
 
 #include "primes.h"
 #include "queue.h"
+#if RUBY_VERSION_MINOR != 8
 #include "reduce.h"
-#include "numtheory_macros.c"
+#endif
+#include "numtheory_macros.h"
 #include "constants.h"
 
+#ifdef DEBUG
+#include <stdio.h>
+#endif
+
 static VALUE mNumTheory;
 static ID primality_tests_ID;
 
@@ -45,6 +51,10 @@ Init_numtheory()
     id_lcm = rb_intern("lcm");
     id_pow = rb_intern("**");
     id_mul = rb_intern("*");
+#if RUBY_VERSION_MINOR == 8
+    id_cmp = rb_intern("<=>");
+    id_equal = rb_intern("==");
+#endif
 
     primality_tests_ID = rb_intern("PrimalityTests");
     /* PrimalityTests: the number of rounds in Miller-Rabin test for primality. */
@@ -122,7 +132,7 @@ Init_numtheory()
  *
  *    NumTheory.precompute_primes_upto(20000000)
  */
-static VALUE 
+VALUE 
 numtheory_precompute_primes_upto(VALUE obj, VALUE n)
 {
     if (FIXNUM_P(n))
@@ -166,7 +176,7 @@ numtheory_precompute_primes_upto(VALUE obj, VALUE n)
  *                       Matrix.identity(2))                
  *                              #=> Matrix[[10946, 6765], [6765, 4181]]
  */
-static VALUE
+VALUE
 numtheory_powermod(int argc, VALUE *argv)
 {
     VALUE base, pow, modulo, one;
@@ -175,7 +185,7 @@ numtheory_powermod(int argc, VALUE *argv)
     ID id_mul = rb_intern("*");
     ID id_mod = rb_intern("%");
 
-    VALUE result = NIL_P(one) ? rb_uint2big(1) : one;
+    VALUE result = NIL_P(one) ? INT2BIG(1) : one;
     FOR_BITS(pow, result = rb_funcall(result, id_mul, 1, result),
                   {},
                   result = rb_funcall(result, id_mul, 1, base),
@@ -187,7 +197,9 @@ numtheory_powermod(int argc, VALUE *argv)
 }
 
 static VALUE int_powermod_sliding_window(VALUE,VALUE,VALUE);
+#if RUBY_VERSION_MINOR != 8
 static VALUE int_powermod_sliding_window_br(VALUE,VALUE,VALUE);
+#endif
 
 /*
  *  call-seq:
@@ -198,7 +210,7 @@ static VALUE int_powermod_sliding_window_br(VALUE,VALUE,VALUE);
  *
  *    172.powermod(238, 239) #=> 1
  */
-static VALUE
+VALUE
 numtheory_int_powermod(VALUE b, VALUE p, VALUE m){
     if (!INTEGER_P(p))
     {
@@ -233,8 +245,10 @@ numtheory_int_powermod(VALUE b, VALUE p, VALUE m){
     if (!FIXNUM_P(m) && RBIGNUM_LEN(m) >= BARRETT_REDUCE_THRESHOLD)
         use_barrett = 1;
 
+#if RUBY_VERSION_MINOR != 8
     if (use_barrett)
         return int_powermod_sliding_window_br(b, p, m);
+#endif
 
     if (use_sliding_window)
         return int_powermod_sliding_window(b, p, m);
@@ -251,8 +265,8 @@ static int tail_zeros(VALUE n)
 {
     if (FIXNUM_P(n))
     {
-        int t = FIX2LONG(n);
-        int s = 0;
+        long t = FIX2LONG(n);
+        long s = 0;
         while (!(t & 1))
             t >>= 1, ++s;
         return s;
@@ -261,8 +275,9 @@ static int tail_zeros(VALUE n)
     {
         BDIGIT* digit = RBIGNUM_DIGITS(n);
         unsigned int L = RBIGNUM_LEN(n);
-        unsigned int i, j, s, z;
-        const unsigned long MAX = 1 << (SIZEOF_BDIGITS * 8 - 1);
+        unsigned int i, s, z;
+        unsigned LONG_LONG j;
+        const unsigned LONG_LONG MAX = 1ULL << (SIZEOF_BDIGITS * 8 - 1);
         for (i = s = 0, z = 1; i < L; ++i, ++digit)
         {
             for (j = 1; j <= MAX; j <<= 1)
@@ -289,7 +304,7 @@ static int tail_zeros(VALUE n)
  *  accordingly to Miller-Rabin test with <i>NumTheory::PrimalityTests</i>
  *  rounds. Otherwise returns <code>false</code>.
  */
-static VALUE 
+VALUE 
 numtheory_miller_rabin_pseudoprime_p(VALUE n)
 {
     long PRIMALITY_TESTS = FIX2LONG(rb_const_get(mNumTheory, primality_tests_ID));
@@ -329,7 +344,12 @@ numtheory_miller_rabin_pseudoprime_p(VALUE n)
     for (i = 0; i < PRIMALITY_TESTS; ++i)
     {
 
-        VALUE a = rb_funcall(rb_cRandom, 
+        VALUE a = rb_funcall(
+#if RUBY_VERSION_MINOR == 8
+                rb_mKernel,
+#else       
+                rb_cRandom, 
+#endif
                 id_rand,
                 1, 
                 num_minus_four);
@@ -362,12 +382,12 @@ numtheory_miller_rabin_pseudoprime_p(VALUE n)
 }
 
 inline static int
-prime_p(unsigned long t)
+prime_p(unsigned LONG_LONG t)
 {
     return (t & 1) ? t == 3 ? 1 : 
                        ((t % 6 == 1) || (t % 6 == 5)) ?
                            t < PRIMES_UPPER_LIMIT ? 
-                               is_set(numtheory_is_prime, t) ? 1 : 0 :
+                               is_set(numtheory_is_prime, (unsigned long)t) ? 1 : 0 :
                                numtheory_bpsw_pseudoprime_p(ULL2NUM(t)) :
                        0
                    : t == 2 ? 1 : 0;
@@ -382,16 +402,22 @@ prime_p(unsigned long t)
  *
  *    29.prime?      #=> true
  */
-static VALUE
+VALUE
 numtheory_prime_p(VALUE n) 
 {
     unsigned long t;
     if (FIXNUM_P(n) && (t = abs(FIX2LONG(n)), t < PRIMES_UPPER_LIMIT))
     {
+#ifdef DEBUG
+        fprintf(stderr, "[prime_p] looking up in the precomputed table...\n");
+#endif
         return prime_p(t) ? Qtrue : Qfalse;
     }
     else
     {
+#ifdef DEBUG
+        fprintf(stderr, "[prime_p] calling BPSW primality test...\n");
+#endif
         return numtheory_bpsw_pseudoprime_p(n);
     }
 }
@@ -404,7 +430,7 @@ numtheory_prime_p(VALUE n)
  *
  *    (10**28).nextprime #=> 10000000000000000000000000331
  */
-static VALUE
+VALUE
 numtheory_nextprime(VALUE n)
 {
     VALUE p = n;
@@ -437,7 +463,7 @@ nth_prime(long n)
  *    NumTheory.prime 1             #=> 2
  *    NumTheory.prime 1000          #=> 7919
  */
-static VALUE
+VALUE
 numtheory_prime(VALUE obj, VALUE i)
 {
     long t;
@@ -493,7 +519,7 @@ primepi(unsigned long t)
  *    NumTheory.primepi 10          #=> 4
  *    NumTheory.primepi -10         #=> 0
  */
-static VALUE
+VALUE
 numtheory_primepi(VALUE obj, VALUE n)
 {
     if (NEGATIVE_P(n))
@@ -520,7 +546,7 @@ numtheory_primepi(VALUE obj, VALUE n)
  *    NumTheory.fibonacci 10                    #=> 55
  *    NumTheory.fibonacci 10**30, 1234567890    #=> 862134135
  */
-static VALUE
+VALUE
 numtheory_fibonacci(int argc, VALUE* argv)
 {
     VALUE n, modulo;
@@ -540,13 +566,13 @@ numtheory_fibonacci(int argc, VALUE* argv)
         rb_raise(rb_eTypeError, "modulo must be integer");
     }
 
-    VALUE a, b, c, old_a, old_b, old_c, old_b_sq;
+    VALUE a, b, c, old_a, old_b_sq, old_c;
     a = c = one;
     b = zero;
 
     n = SUB(n, one);
 
-    FOR_BITS(n, { old_a = a; old_b = b; old_c = c;
+    FOR_BITS(n, { old_a = a; old_c = c;
                   old_b_sq = MUL(b, b);
                   
                   a = ADD(MUL(a, a), old_b_sq);
@@ -579,7 +605,7 @@ numtheory_fibonacci(int argc, VALUE* argv)
  *    NumTheory.sigma 1234567890, 0        #=> 48 
  *    NumTheory.sigma 1234567890, 1        #=> 3211610688
  */
-static VALUE
+VALUE
 numtheory_sigma(int argc, VALUE* argv)
 {
     VALUE n, pow;
@@ -632,7 +658,7 @@ numtheory_sigma(int argc, VALUE* argv)
  *
  *    NumTheory.eulerphi(1234567890)        #=> 329040288
  */
-static VALUE
+VALUE
 numtheory_eulerphi(VALUE obj, VALUE n)
 {
     if (!INTEGER_P(n))
@@ -665,7 +691,7 @@ numtheory_eulerphi(VALUE obj, VALUE n)
  *    (-987654321).prime_division 
  *          #=> [[-1, 1], [3, 2], [17, 2], [379721, 1]]
  */
-static VALUE
+VALUE
 numtheory_prime_division(VALUE n)
 {
     VALUE pd[2];
@@ -701,7 +727,7 @@ numtheory_prime_division(VALUE n)
  *    NumTheory.moebius(4)      #=> 0
  *    NumTheory.moebius(35)     #=> 1
  */
-static VALUE
+VALUE
 numtheory_moebius(VALUE obj, VALUE n)
 {
     if (!INTEGER_P(n))
@@ -796,10 +822,10 @@ primorial(unsigned long min, unsigned long max)
  *
  *    NumTheory.product([1,2,3,4,5,6])    #=> 720
  */
-static VALUE
+VALUE
 numtheory_product(VALUE obj, VALUE arr)
 {
-    if (!RB_TYPE_P(arr, T_ARRAY))
+    if (TYPE(arr) != T_ARRAY)
     {
         rb_raise(rb_eTypeError, "the argument must be an array");
     }
@@ -815,7 +841,7 @@ numtheory_product(VALUE obj, VALUE arr)
  *
  *    2.primes_upto(17).to_a   #=> [2, 3, 5, 7, 11, 13, 17]
  */
-static VALUE
+VALUE
 numtheory_primes_upto(VALUE min, VALUE _max)
 {
     VALUE max = _max;
@@ -924,7 +950,7 @@ rec_factorial(long n)
  *
  *    50.factorial.to_s(31)  #=> "283sp352ltrc9csg1398f0dt7dg067g15ikr4b6spf70"
  */
-static VALUE
+VALUE
 numtheory_factorial_primeswing(VALUE n)
 {
     long t;
@@ -951,7 +977,7 @@ numtheory_factorial_primeswing(VALUE n)
         q >>= 1;
         shift += q;
     }
-    return rb_big_lshift(rec_factorial(t), LONG2NUM(shift));
+    return rb_big_lshift(TO_BIGNUM(rec_factorial(t)), LONG2NUM(shift));
 }
 
 struct Egcd {
@@ -988,7 +1014,7 @@ extended_gcd(VALUE x, VALUE y)
  *    0.extended_gcd(0)           #=> [0, [0, 0]]
  *    239.extended_gcd(932)       #=> [1, [39, -10]]
  */
-static VALUE
+VALUE
 numtheory_extended_gcd(VALUE x, VALUE y)
 {
     if (!INTEGER_P(y))
@@ -1021,7 +1047,7 @@ numtheory_extended_gcd(VALUE x, VALUE y)
  *
  *    1234.inverse(12345)   #=> 9874
  */
-static VALUE
+VALUE
 numtheory_modular_inverse(VALUE x, VALUE y)
 {
     struct Egcd egcd = extended_gcd(x, y);
@@ -1046,7 +1072,7 @@ numtheory_modular_inverse(VALUE x, VALUE y)
  *
  *    20.znorder(11)  => 5
  */
-static VALUE
+VALUE
 numtheory_multiplicative_order(VALUE a, VALUE m)
 {
     if (rb_funcall(a, id_gcd, 1, m) != one)
@@ -1095,7 +1121,7 @@ static inline VALUE* triple_new(VALUE v1, VALUE v2, VALUE v3)
  *  Yields primitive pythagorean triples with perimeter less
  *  or equal to <i>max_perimeter</i>.
  */
-static VALUE 
+VALUE 
 numtheory_pythagorean_triples(VALUE obj, VALUE max_l)
 {
     RETURN_ENUMERATOR(obj, 1, &max_l);
@@ -1119,7 +1145,11 @@ numtheory_pythagorean_triples(VALUE obj, VALUE max_l)
         }
 
         a = triple[0]; b = triple[1]; c = triple[2];
+#if RUBY_VERSION_MINOR == 8
+        rb_yield_values(3, triple[0], triple[1], triple[2]);
+#else
         rb_yield_values2(3, triple);
+#endif
 
         // uses ternary pythagorean tree
         a2 = DOUBLED(a);
@@ -1152,7 +1182,7 @@ numtheory_pythagorean_triples(VALUE obj, VALUE max_l)
  *  
  *  Returns the number of set bits.
  */
-static VALUE
+VALUE
 numtheory_popcount(VALUE n)
 {
     if (NEGATIVE_P(n))
@@ -1165,15 +1195,23 @@ numtheory_popcount(VALUE n)
 }
 
 int
-int_bitlength(unsigned int v)
+long_bitlength(unsigned long v)
 {   
-    // taken from http://graphics.stanford.edu/~seander/bithacks.html
-    const unsigned int b[] = {0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000};
-    const unsigned int S[] = {1, 2, 4, 8, 16};
-    int i;
+    /* taken from http://graphics.stanford.edu/~seander/bithacks.html */
 
-    register unsigned int r = 0;
+#if SIZEOF_LONG == 8
+    const unsigned long b[] = {0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000, 0xFFFFFFFF00000000ULL};
+    const unsigned long S[] = {1, 2, 4, 8, 16, 32};
+    int i;
+    register unsigned long r = 0;
+    for (i = 5; i >= 0; --i)
+#else
+    const unsigned long b[] = {0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000 };
+    const unsigned long S[] = {1, 2, 4, 8, 16};
+    int i;
+    register unsigned long r = 0;
     for (i = 4; i >= 0; --i)
+#endif
     {
       if (v & b[i])
       {
@@ -1191,32 +1229,32 @@ int_bitlength(unsigned int v)
  *  Returns the length in bits. Defined for positive integers only.
  *  0 is assumed to have length 1.
  */
-static VALUE
+VALUE
 numtheory_bitlength(VALUE n)
 {
     if (NEGATIVE_P(n))
     {
         rb_raise(rb_eArgError, "n must be positive");
     }
-    long bit_len, half_k;
+    long bit_len;
     if (FIXNUM_P(n))
     {
-        return INT2FIX(int_bitlength(FIX2LONG(n)));
+        return INT2FIX(long_bitlength(FIX2LONG(n)));
     }
     else
     {
         long len = RBIGNUM_LEN(n);
         bit_len = (len - 1) * SIZEOF_BDIGITS * 8;
-        return INT2FIX(bit_len + int_bitlength(RBIGNUM_DIGITS(n)[len - 1]));
+        return INT2FIX(bit_len + long_bitlength(RBIGNUM_DIGITS(n)[len - 1]));
     }
 }
 
 static int
-ull_jacobi(long long a, unsigned long long n)
+ull_jacobi(LONG_LONG a, unsigned LONG_LONG n)
 {
     /* it's assumed that n is odd and > 0 */
     int t = 1;
-    long long tmp;
+    LONG_LONG tmp;
     while (a) {
         if (a < 0) {
             a = -a; if ((n & 3) == 3) t = -t;
@@ -1230,7 +1268,7 @@ ull_jacobi(long long a, unsigned long long n)
         tmp = a; a = n; n = tmp; 
         if ((a & 3) == 3 && (n & 3) == 3) t = -t;
         a %= n; 
-        if (a > (long long)(n >> 1)) a -= n;
+        if (a > (LONG_LONG)(n >> 1)) a -= n;
     }
     return n == 1 ? t : 0;
 }
@@ -1241,7 +1279,7 @@ ull_jacobi(long long a, unsigned long long n)
  *  
  *  Returns jacobi symbol (a|n) where n must be odd positive
  */
-static VALUE
+VALUE
 numtheory_jacobi(VALUE a, VALUE n)
 {
     if (EVEN_P(n) || NEGATIVE_P(n))
@@ -1262,7 +1300,7 @@ numtheory_jacobi(VALUE a, VALUE n)
         {
             return INT2FIX(t * ull_jacobi(FIX2LONG(a), FIX2LONG(n)));
         }
-        if (RBIGNUM_LEN(n) <= 2) // unsigned long long is used 
+        if (RBIGNUM_LEN(n) <= 2) // unsigned LONG_LONG is used 
         {
             return INT2FIX(t * ull_jacobi(FIXNUM_P(a) ? FIX2LONG(a) : rb_big2ll(a), 
                                           rb_big2ull(n)));
@@ -1312,7 +1350,7 @@ numtheory_jacobi(VALUE a, VALUE n)
  *  If (a|p) = 1 returns the square root of a in Z/pZ
  *  from the interval [0, p/2]. Otherwise returns +nil+.
  */
-static VALUE
+VALUE
 numtheory_sqrtmod(VALUE a, VALUE p)
 {
     if (!INTEGER_P(p))
@@ -1401,7 +1439,7 @@ numtheory_sqrtmod(VALUE a, VALUE p)
  *
  *  Returns the square root integer part.
  */
-static VALUE
+VALUE
 numtheory_isqrt(VALUE n)
 {
     if (NEGATIVE_P(n))
@@ -1438,7 +1476,7 @@ static int MOD_255(VALUE n)
     {
         return FIX2LONG(n) % 255;
     }
-    unsigned long long m = 0;
+    unsigned LONG_LONG m = 0;
     BDIGIT* digit = RBIGNUM_DIGITS(n);
     int i;
     for (i = 0; i < RBIGNUM_LEN(n); ++i, ++digit)
@@ -1457,7 +1495,7 @@ static int MOD_255(VALUE n)
  *
  *  Checks whether the integer is a perfect square or not.
  */
-static VALUE
+VALUE
 numtheory_perfect_square_p(VALUE n)
 {
     if (NEGATIVE_P(n))
@@ -1530,19 +1568,32 @@ static VALUE power_of_2_mod(VALUE p, VALUE m){
    
 static VALUE miller_rabin_base2_pseudoprime_p(VALUE n)
 {
-    // for internal use only
+    /* for internal use only */
+#ifdef DEBUG
+    fprintf(stderr, "[miller-rabin base 2] start test for %s...\n", TO_CSTRING(n));
+#endif
     VALUE num = rb_big_clone(TO_BIGNUM(n));
     VALUE num_minus_one = SUB(num, one);
     VALUE d = rb_big_clone(TO_BIGNUM(num_minus_one));
 
     int s = tail_zeros(d);
+#ifdef DEBUG
+    fprintf(stderr, "[miller-rabin base 2] p-1 =  %s...\n", TO_CSTRING(d));
+    fprintf(stderr, "[miller-rabin base 2] tail zeros: %d\n", s);
+#endif
     d = RIGHT_SHIFT(d, s); 
 
     VALUE x = power_of_2_mod(d, num);
+#ifdef DEBUG
+    fprintf(stderr, "[miller-rabin base 2] 2**d = %s modulo %s\n", TO_CSTRING(x), TO_CSTRING(num));
+#endif
     if (EQL(x, one) || EQL(x, num_minus_one)) return Qtrue;
 
     while (s--) {
         x = MOD(MUL(x, x), num);
+#ifdef DEBUG
+    fprintf(stderr, "[miller-rabin base 2] x = %s modulo %s\n", TO_CSTRING(x), TO_CSTRING(num));
+#endif
         if (EQL(x, one)) return Qfalse;
         if (EQL(x, num_minus_one)) break;
     }
@@ -1558,7 +1609,7 @@ static VALUE miller_rabin_base2_pseudoprime_p(VALUE n)
  *
  *  Standard BPSW primality test.
  */
-static VALUE
+VALUE
 numtheory_bpsw_pseudoprime_p(VALUE n)
 {
     VALUE num = ABS(n);
@@ -1570,12 +1621,18 @@ numtheory_bpsw_pseudoprime_p(VALUE n)
     if (LESS(num, two) || EVEN_P(num) || 
                           (numtheory_perfect_square_p(num) == Qtrue))
     {
+#ifdef DEBUG
+        fprintf(stderr, "[bpsw_pseudoprime_p] the number is less than 2, even or a perfect square\n");
+#endif
         return Qfalse;
     }
 
     // Miller-Rabin test with base 2
     if (miller_rabin_base2_pseudoprime_p(num) == Qfalse)
     {
+#ifdef DEBUG
+        fprintf(stderr, "[bpsw_pseudoprime_p] Miller-Rabin test with base 2 returned false\n");
+#endif
         return Qfalse;
     }
 
@@ -1595,7 +1652,10 @@ numtheory_bpsw_pseudoprime_p(VALUE n)
             break;
         }
     }
-    
+   
+#ifdef DEBUG
+    fprintf(stderr, "[bpsw_pseudoprime_p] calling Lucas primality test...\n");
+#endif
     return lucas_pseudoprime_p(num, one, RIGHT_SHIFT(SUB(one, INT2FIX(d)), 2));
 }
 
@@ -1603,6 +1663,8 @@ DEFINE_POWERMOD_SLIDING_WINDOW(int_powermod_sliding_window,
                                {}, 
                                MOD)
 
+#if RUBY_VERSION_MINOR != 8
 DEFINE_POWERMOD_SLIDING_WINDOW(int_powermod_sliding_window_br,
                                VALUE mu = rb_big_barrett_mu(m),
                                BARRETT_MOD)
+#endif

data/ext/numtheory/numtheory.h

@@ -2,52 +2,105 @@
 #define NUMTHEORY_H 
 
 #include <ruby.h>
-#include <stdio.h>
 #include <math.h>
 
+#ifndef HAVE_RUBY_VERSION_H
+#include <version.h>
+#else
+#include <ruby/version.h>
+#endif
+
+#if RUBY_VERSION_MINOR == 8
+#include <intern.h>
+#include <defines.h>
+#endif
+
+#ifdef DEBUG
+#include <stdio.h>
+inline static char* TO_CSTRING(VALUE x) {
+    VALUE v = rb_String(x);
+    return StringValueCStr(v);
+}
+#endif
+
 ID id_rand, id_mod, id_divmod, id_div,
    id_gcd, id_lcm, id_pow, id_mul;
 
 extern const VALUE zero,one,two,three,four,five,six,seven,eight;
 
-static VALUE numtheory_powermod(int argc, VALUE *argv);
-static VALUE numtheory_miller_rabin_pseudoprime_p(VALUE n);
-static VALUE numtheory_nextprime(VALUE n);
-static VALUE numtheory_precompute_primes_upto(VALUE obj, VALUE n);
-static VALUE numtheory_prime(VALUE obj, VALUE i);
-static VALUE numtheory_primepi(VALUE obj, VALUE n);
-static VALUE numtheory_fibonacci(int argc, VALUE *argv);
-static VALUE numtheory_sigma(int argc, VALUE *argv);
-static VALUE numtheory_eulerphi(VALUE obj, VALUE n);
-static VALUE numtheory_moebius(VALUE obj, VALUE n);
-static VALUE numtheory_prime_division(VALUE n);
-static VALUE numtheory_product(VALUE obj, VALUE arr);
-static VALUE numtheory_primes_upto(VALUE min, VALUE max);
-static VALUE numtheory_factorial_primeswing(VALUE n);
-static VALUE numtheory_extended_gcd(VALUE x, VALUE y);
-static VALUE numtheory_multiplicative_order(VALUE a, VALUE m);
-static VALUE numtheory_pythagorean_triples(VALUE obj, VALUE max_l);
-static VALUE numtheory_popcount(VALUE n);
-static VALUE numtheory_bitlength(VALUE n);
-static VALUE numtheory_sqrtmod(VALUE a, VALUE p);
-static VALUE numtheory_isqrt(VALUE n);
-static VALUE numtheory_perfect_square_p(VALUE n);
-static VALUE numtheory_bpsw_pseudoprime_p(VALUE n);
-
-static VALUE numtheory_int_powermod(VALUE b, VALUE p, VALUE m);
-
-static VALUE numtheory_prime_p(VALUE n);
-static VALUE numtheory_modular_inverse(VALUE x, VALUE y);
-static VALUE numtheory_jacobi(VALUE a, VALUE n);
+VALUE numtheory_powermod(int argc, VALUE *argv);
+VALUE numtheory_miller_rabin_pseudoprime_p(VALUE n);
+VALUE numtheory_nextprime(VALUE n);
+VALUE numtheory_precompute_primes_upto(VALUE obj, VALUE n);
+VALUE numtheory_prime(VALUE obj, VALUE i);
+VALUE numtheory_primepi(VALUE obj, VALUE n);
+VALUE numtheory_fibonacci(int argc, VALUE *argv);
+VALUE numtheory_sigma(int argc, VALUE *argv);
+VALUE numtheory_eulerphi(VALUE obj, VALUE n);
+VALUE numtheory_moebius(VALUE obj, VALUE n);
+VALUE numtheory_prime_division(VALUE n);
+VALUE numtheory_product(VALUE obj, VALUE arr);
+VALUE numtheory_primes_upto(VALUE min, VALUE max);
+VALUE numtheory_factorial_primeswing(VALUE n);
+VALUE numtheory_extended_gcd(VALUE x, VALUE y);
+VALUE numtheory_multiplicative_order(VALUE a, VALUE m);
+VALUE numtheory_pythagorean_triples(VALUE obj, VALUE max_l);
+VALUE numtheory_popcount(VALUE n);
+VALUE numtheory_bitlength(VALUE n);
+VALUE numtheory_sqrtmod(VALUE a, VALUE p);
+VALUE numtheory_isqrt(VALUE n);
+VALUE numtheory_perfect_square_p(VALUE n);
+VALUE numtheory_bpsw_pseudoprime_p(VALUE n);
+VALUE numtheory_int_powermod(VALUE b, VALUE p, VALUE m);
+
+VALUE numtheory_prime_p(VALUE n);
+VALUE numtheory_modular_inverse(VALUE x, VALUE y);
+VALUE numtheory_jacobi(VALUE a, VALUE n);
 
 #define BITSPERDIG  (SIZEOF_BDIGITS * CHAR_BIT)
 #define BIGRAD  ((BDIGIT_DBL)1 << BITSPERDIG)
 #define BIGLO(x) ((BDIGIT)((x) & (BIGRAD - 1)))
 
+inline static VALUE INT2BIG(long x) {
+    return rb_int2big(x);
+}
+
+inline static VALUE INTVALUE2BIG(VALUE x) {
+#ifdef DEBUG
+    fprintf(stderr, "[intvalue2big] initial value = %s\n", TO_CSTRING(x));
+    fprintf(stderr, "[intvalue2big] after conversion to long: %ld\n", FIX2LONG(x));
+    fprintf(stderr, "[intvalue2big] after conversion to BIGNUM: %s\n", TO_CSTRING(rb_int2big(FIX2LONG(x))));
+#endif
+    return rb_int2big(FIX2LONG(x));
+}
+
 inline static VALUE TO_BIGNUM(VALUE x) {
-    return FIXNUM_P(x) ? rb_int2big(FIX2LONG(x)) : x;
+    return FIXNUM_P(x) ? INTVALUE2BIG(x) : x;
 }
 
+#if RUBY_VERSION_MINOR == 8
+static ID id_cmp, id_equal;
+
+inline static VALUE rb_big_cmp(VALUE x, VALUE y) {
+    return rb_funcall(x, id_cmp, 1, y);
+}
+
+inline static int rb_bigzero_p(VALUE x) {
+    return rb_funcall(x, id_equal, 1, zero) == Qtrue;
+}
+
+inline static VALUE rb_big_eq(VALUE x, VALUE y) {
+    return rb_funcall(x, id_equal, 1, y);
+}
+
+inline static VALUE rb_big_div(VALUE x, VALUE y) {
+    return rb_funcall(x, id_div, 1, y);
+}
+#undef RBIGNUM_DIGITS
+#define RBIGNUM_DIGITS(obj) ((BDIGIT*)(RBIGNUM(obj)->digits))
+
+#endif
+
 inline static unsigned long TO_ULONG(VALUE x) {
     if (!FIXNUM_P(x))
     { 
@@ -80,7 +133,7 @@ inline static VALUE SUB(VALUE x, VALUE y) {
            rb_big_minus(TO_BIGNUM(x), y);
 }
 
-#define NEGATE(x) do { if (FIXNUM_P(x)) x = -x; \
+#define NEGATE(x) do { if (FIXNUM_P(x)) x = INT2FIX(-FIX2LONG(x)); \
                        else RBIGNUM_SET_SIGN(x, !RBIGNUM_SIGN(x)); } \
 while(0);
 
@@ -107,13 +160,13 @@ inline static VALUE MOD(VALUE x, VALUE y) {
 inline static int MOD_4(VALUE x) {
     return FIXNUM_P(x) ? FIX2LONG(x) & 3 :
         RBIGNUM_SIGN(x) ? RBIGNUM_DIGITS(x)[0] & 3 :
-                      4 - RBIGNUM_DIGITS(x)[0] & 3;
+                      4 - (RBIGNUM_DIGITS(x)[0] & 3);
 }
 
 inline static int MOD_8(VALUE x) {
     return FIXNUM_P(x) ? FIX2LONG(x) & 7 :
         RBIGNUM_SIGN(x) ? RBIGNUM_DIGITS(x)[0] & 7 :
-                      8 - RBIGNUM_DIGITS(x)[0] & 7;
+                      8 - (RBIGNUM_DIGITS(x)[0] & 7);
 }
 
 inline static int EQL(VALUE x, VALUE y) {
@@ -141,8 +194,14 @@ inline static int MORE_EQL(VALUE x, VALUE y) {
 }
 
 inline static VALUE ABS(VALUE x) {
-    if (FIXNUM_P(x))
-        return INT2FIX(abs(FIX2LONG(x)));
+    if (FIXNUM_P(x)) {
+#ifdef DEBUG
+        fprintf(stderr, "[abs] x = %s\n", TO_CSTRING(x));
+        fprintf(stderr, "[abs] FIX2LONG(x) = %ld\n", FIX2LONG(x));
+        fprintf(stderr, "[abs] result = %s\n", TO_CSTRING(LONG2FIX(labs(FIX2LONG(x)))));
+#endif
+        return LONG2FIX(labs(FIX2LONG(x)));
+    }
     VALUE v = rb_big_clone(x);
     RBIGNUM_SET_SIGN(v, 1);
     return v;
@@ -161,8 +220,8 @@ inline static int INTEGER_P(VALUE x) {
 }
 
 inline static VALUE DOUBLED(VALUE x) {
-    return FIXNUM_P(x) ? LONG2NUM(FIX2LONG(x) << 1) :
-            rb_big_lshift(x, one);
+    return FIXNUM_P(x) ? INT2FIX(FIX2LONG(x) << 1) :
+                         rb_big_lshift(x, one);
 }
 
 inline static VALUE HALF(VALUE x) {
@@ -180,4 +239,5 @@ inline static VALUE RIGHT_SHIFT(VALUE x, int s) {
 #endif
 inline static int min(int a, int b) { return a < b ? a : b; }
 
+
 #endif

data/ext/numtheory/{numtheory_macros.c → numtheory_macros.h}

@@ -1,7 +1,10 @@
+#ifndef NUMTHEORY_MACROS_H
+#define NUMTHEORY_MACROS_H 1
+
 #define FOR_PRIME_FACTORS(n, p, d, action) do { \
     int __d; \
-    unsigned long __i; \
-    unsigned long long __t; \
+    BDIGIT __i; \
+    unsigned LONG_LONG __t; \
     VALUE __num = (FIXNUM_P(n) ? n : rb_big_clone(n)); \
     if (!FIXNUM_P(__num)) \
     { \
@@ -11,7 +14,7 @@
       } \
       else \
       { \
-        rb_raise(rb_eNotImpError, "Not implemented for numbers >= 2**64"); \
+        rb_raise(rb_eNotImpError, "Factorization is not implemented for numbers >= 2**64"); \
       } \
     } \
     else \
@@ -19,7 +22,7 @@
       __t = FIX2LONG(__num); \
     } \
  \
-    unsigned long long __p; \
+    unsigned LONG_LONG __p; \
     VALUE p, d; \
     if (prime_p(__t)) \
     { \
@@ -93,7 +96,7 @@
     else { \
         BDIGIT* _digits = RBIGNUM_DIGITS(n); \
         long _digits_length = RBIGNUM_LEN(n); \
-        BDIGIT _j; \
+        unsigned LONG_LONG _j; \
         BDIGIT* _digit = _digits + _digits_length - 1; \
         BDIGIT _half_fst_digit = (*_digit) >> 1; \
         for (_j = 1; _j <= _half_fst_digit; _j <<= 1); \
@@ -104,7 +107,7 @@
                 else if_zero_action; \
                 final_action; \
             } \
-            _j = 1 << (SIZEOF_BDIGITS * 8 - 1); \
+            _j = 1ULL << (SIZEOF_BDIGITS * 8 - 1); \
         } \
     } \
 } while(0)
@@ -121,7 +124,7 @@ FUNC_NAME(VALUE b, VALUE p, VALUE m) {\
     int pow = 0; \
     \
     /* adjusting window size */ \
-    if (FIXNUM_P(p)) p = rb_int2big(FIX2LONG(p)); \
+    if (FIXNUM_P(p)) p = INTVALUE2BIG(p); \
     len = RBIGNUM_LEN(p); \
     if      (len  <  8) k = 4; \
     else if (len  < 20) k = 5; \
@@ -199,3 +202,5 @@ FUNC_NAME(VALUE b, VALUE p, VALUE m) {\
 }
 
 #define BARRETT_MOD(x, m) rb_big_barrett_reduce(x, m, mu, 1)
+
+#endif

data/ext/numtheory/primes.c

@@ -15,13 +15,12 @@ init_sieve(unsigned long max_n)
     unset_bit(numtheory_is_prime, 1);
     numtheory_primes = calloc((long)((double)max_n/(log((double)max_n)-4.0)+1), ULONG_SZ);
 
-    unsigned long long i;
     unsigned long j;
     unsigned long p = 0;
     numtheory_primes[p++] = 2;
     numtheory_primes[p++] = 3;
 
-    unsigned long long i1, i2, s;
+    unsigned LONG_LONG i1, i2, s;
     unsigned long max_n_sqrt = (unsigned long)(sqrt((double)max_n));
 
     for (i1 = 5, i2 = 7; ; i1 += 6, i2 += 6)

data/ext/numtheory/primes.h

@@ -1,6 +1,8 @@
 #ifndef NUMTHEORY_PRIMES_H
 #define NUMTHEORY_PRIMES_H
 
+#include <ruby.h>
+
 unsigned long init_sieve(unsigned long max_n); // returns prime_pi(max_n)
 
 #define ULONG_SZ sizeof(unsigned long)

data/ext/numtheory/reduce.c

@@ -1,6 +1,8 @@
 #include <string.h>
 #include "numtheory.h"
 
+#if RUBY_VERSION_MINOR != 8
+
 #define MULADD(i, j) \
     __asm__ volatile(                   \
           "movl %6, %%eax \n\t"     \
@@ -31,7 +33,6 @@ inline static VALUE rshift_digits_inplace(VALUE n, int k)
 
     BDIGIT* ds = RBIGNUM_DIGITS(n);
     int len = RBIGNUM_LEN(n);
-    int i;
     if (len > k)
     {
         memmove(ds, ds + k, SIZEOF_BDIGITS * (len - k));
@@ -47,21 +48,19 @@ inline static VALUE rshift_digits_inplace(VALUE n, int k)
 
 inline static VALUE power_of_two(int p)
 {
-    return rb_big_lshift(rb_int2big(1), INT2FIX(p));
+    return rb_big_lshift(INT2BIG(1), INT2FIX(p));
 }
 
 static VALUE 
 bigmul_low_digits(VALUE x, VALUE y, int digits)
 {
     int xn = RBIGNUM_LEN(x);
-    if (FIXNUM_P(y)) y = rb_int2big(FIX2LONG(y));
+    if (FIXNUM_P(y)) y = INTVALUE2BIG(y);
     int yn = RBIGNUM_LEN(y);
 
-    int all = 0;
     if (digits > xn + yn) 
     {
         digits = xn + yn;
-        all = 1;
     }
     VALUE z = rb_big_new(digits, 1);
 
@@ -88,7 +87,7 @@ bigmul_low_digits(VALUE x, VALUE y, int digits)
 VALUE bigmul_low_digits_old(VALUE x, VALUE y, int digits)
 {
     int xn = RBIGNUM_LEN(x);
-    if (FIXNUM_P(y)) y = rb_int2big(FIX2LONG(y));
+    if (FIXNUM_P(y)) y = INTVALUE2BIG(y);
     int yn = RBIGNUM_LEN(y);
     VALUE z = rb_big_new(digits, 1);
     BDIGIT* xds = RBIGNUM_DIGITS(x);
@@ -120,7 +119,7 @@ static VALUE
 bigmul_high_digits(VALUE x, VALUE y, int dontcare, int x_right_shift)
 {
     int xn = RBIGNUM_LEN(x);
-    if (FIXNUM_P(y)) y = rb_int2big(FIX2LONG(y));
+    if (FIXNUM_P(y)) y = INTVALUE2BIG(y);
     int yn = RBIGNUM_LEN(y);
 
 
@@ -130,7 +129,7 @@ bigmul_high_digits(VALUE x, VALUE y, int dontcare, int x_right_shift)
     /* in order to avoid rb_big_clone call,
        let's virtually "shift" x instead of actual shifting */
     if (x_right_shift >= xn) { 
-        return rb_int2big(0);
+        return INT2BIG(0);
     } else {
         xds += x_right_shift;
         xn -= x_right_shift;
@@ -163,7 +162,7 @@ bigmul_high_digits(VALUE x, VALUE y, int dontcare, int x_right_shift)
 VALUE bigmul_high_digits_old(VALUE x, VALUE y, int dontcare)
 {
     int xn = RBIGNUM_LEN(x);
-    if (FIXNUM_P(y)) y = rb_int2big(FIX2LONG(y));
+    if (FIXNUM_P(y)) y = INTVALUE2BIG(y);
     int yn = RBIGNUM_LEN(y);
     VALUE z = rb_big_new(xn + yn, 1);
     BDIGIT* xds = RBIGNUM_DIGITS(x);
@@ -232,3 +231,5 @@ VALUE rb_big_barrett_reduce(VALUE x, VALUE m, VALUE mu, int inplace)
         a = SUB(a, m);
     return rb_big_norm(a);
 }
+
+#endif

data/ext/numtheory/reduce.h

@@ -4,8 +4,4 @@
 VALUE rb_big_barrett_reduce(VALUE,VALUE,VALUE,int);
 VALUE rb_big_barrett_mu(VALUE);
 
-BDIGIT montgomery_setup(BDIGIT);
-VALUE rb_big_montgomery_reduce(VALUE,VALUE,VALUE,int);
-BDIGIT small_montgomery_reduce(BDIGIT_DBL, BDIGIT, BDIGIT);
-
 #endif

data/ruby-numtheory.gemspec

@@ -3,7 +3,7 @@ Gem::Specification.new do |gem|
   gem.homepage = "http://github.com/lomereiter/ruby-numtheory"
   gem.license = "MIT"
   gem.summary = "Ruby number theory library"
-  gem.version = "0.0.6"
+  gem.version = "0.0.7"
   gem.platform = Gem::Platform::RUBY
 
   gem.description = <<-EOF

data/spec/numtheory/arithmetic_functions_spec.rb

@@ -0,0 +1,31 @@
+require 'numtheory'
+
+describe "arithmetic function" do
+  include NumTheory
+
+  describe "primepi" do
+    it "should raise ArgumentError if there're not enough precomputed primes" do
+      expect { primepi(100_000_000_000) }.should raise_error
+    end
+
+    it "should return the number of primes less or equal than a given number" do
+      primepi(1).should == 0
+      primepi(2).should == 1
+      primepi(123512).should == 11607
+      primepi(498765).should == 41438
+      primepi(312361).should == 26983
+      primepi(-123513).should == 0
+    end
+  end
+
+  describe "eulerphi" do
+    it "should raise ArgumentError if the number is zero" do
+      expect { eulerphi(0) }.should raise_error
+    end
+
+    it "should return the number of positive integers less than 'n' and coprime with 'n'" do
+      eulerphi(12312361361).should == 11664342324
+      eulerphi(12361212371236123).should == 11713214239144000
+    end
+  end
+end

data/spec/numtheory/bit_function_spec.rb

@@ -0,0 +1,32 @@
+require 'numtheory'
+
+describe "bit functions" do
+  describe "popcount" do
+    it "should return the number of bits set in a non-negative number" do
+      12351231231235091328209183029825132908123295012351.popcount.should == 84
+      82362346211236.popcount.should == 23
+    end
+
+    it "should raise ArgumentError for negative numbers" do
+      expect { (-5).popcount }.should raise_error
+      expect { (-112351235123512351235).popcount }.should raise_error
+    end
+  end
+
+  describe "bitlength" do
+    it "should return the length of a positive number in bits" do
+      123512351235125312.bitlength.should == 57
+      12355312.bitlength.should == 24
+      9123616312361235523462346311236136123123136212361.bitlength.should == 163
+    end
+
+    it "should return 1 when argument is 0" do
+      0.bitlength.should == 1
+    end
+
+    it "should raise ArgumentError for negative numbers" do
+      expect { (-12351).bitlength }.should raise_error
+      expect { (-2039462306492384059132).bitlength }.should raise_error
+    end
+  end
+end

data/spec/numtheory/modular_arithmetic_spec.rb

@@ -0,0 +1,64 @@
+require 'numtheory'
+
+describe "Z/pZ" do
+
+  describe "modular inverse" do
+    it "should raise ArgumentError if the inverse doesn't exist" do
+      expect { 3.inverse(1236123) }.should raise_error
+      expect { 636356661312236113261221231.inverse(71324141236123712312361347131) }.should raise_error
+    end
+
+    it "should return the inverse modulo 'p' if it exists" do
+      170149610396103139612301.inverse(91023960139513512035130519351035).should == 47319168690720853552108144675271
+      10239613261.inverse(1713461351236).should == 1314959799745
+      61235.inverse(13271).should == 10552
+    end
+  end
+
+  describe "jacobi symbol (a|n)" do
+    it "should raise ArgumentError for negative 'n'" do
+      expect { 23.jacobi(-15) }.should raise_error
+    end
+
+    it "should raise ArgumentError for even 'n'" do
+      expect { 17.jacobi(24) }.should raise_error
+    end
+
+    it "should return 0 when 'a' and 'n' have common divisors" do
+      25.jacobi(35).should be_zero
+      -24.jacobi(9).should be_zero
+      33.jacobi(3).should be_zero
+      128367169183989283691832619381.jacobi(1829631238193612396183612312361231123).should be_zero
+    end
+
+    it "should return 1 when 'a' is a square residue modulo 'n'" do
+      26.jacobi(25).should == 1
+      261235125312351.jacobi(251235123123512351).should == 1
+      123412354123123512351235123512455123.jacobi(12351231236123112351235123523513411).should == 1
+    end
+
+    it "should return -1 in all the other cases" do
+      123412354123123512351235123512455123.jacobi(1235123123612311235123512352351341).should == -1
+      1386136123613661.jacobi(19381923138198391).should == -1
+      2.jacobi(5).should == -1
+      17.jacobi(23).should == -1
+    end
+  end
+
+  describe "square root" do
+
+    it "should raise ArgumentError if 'p' is not a prime number" do
+      expect { 7.sqrt_mod(9)}.should raise_error
+    end
+
+    it "should return nil if there is no square root" do
+      33.sqrt_mod(3).should be_nil
+      1231356123521351251.sqrt_mod(123061236013903516123121612316123612379).should be_nil
+    end
+
+    it "should otherwise return the square root from range [0 .. p/2]" do
+      1235112351311.sqrt_mod(123061936032513553).should == 20377270042474840
+      910836013912301293612035135.sqrt_mod(45734753461235122313131523613612412341612361691).should == 17194653522779996910096883279884862754880186510
+    end
+  end
+end

data/spec/numtheory/primality_tests_spec.rb

@@ -0,0 +1,44 @@
+require 'numtheory'
+
+describe "primality tests" do
+  
+  describe "prime? method" do
+    it "should return exact result for precomputed values" do
+      0.should_not be_prime
+      1.should_not be_prime
+      2.should be_prime
+      3.should be_prime
+      9.should_not be_prime
+      -1.should_not be_prime
+      -2.should be_prime
+      -13.should be_prime
+      -16.should_not be_prime
+    end
+
+    it "should apply BPSW test for larger values" do
+      12351236123627.should_not be_prime
+      12351236123659.should be_prime
+      12351236123627123612361235012532906135124234123512356123512342219.should_not be_prime
+      12351236123627123612361235012532906135124234123512356123512342221.should be_prime
+    end
+
+    it "should return true for BPSW pseudoprimes" do
+      # no one is found yet :-)
+    end
+  end
+
+  describe "miller-rabin test" do
+    it "should perform NumTheory::PrimalityTests rounds of Miller-Rabin test" do
+      NumTheory.module_eval { remove_const :PrimalityTests }
+      NumTheory::PrimalityTests = 1
+      srand(100) # MR test uses random base to start
+      671.should be_MR_pseudoprime
+      671.should_not be_BPSW_pseudoprime
+
+      NumTheory.module_eval { remove_const :PrimalityTests }
+      NumTheory::PrimalityTests = 10
+      srand(42)
+      671.should_not be_MR_pseudoprime
+    end
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: ruby-numtheory
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors: 
 - Artem Tarasov
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-27 00:00:00 Z
+date: 2012-08-28 00:00:00 Z
 dependencies: []
 
 description: "    The library is written as C extension and aims to provide\n    common number-theoretical functions such as powermod, jacobi symbol,\n    various multiplicative ones, etc.\n"
@@ -23,6 +23,7 @@ extra_rdoc_files:
 - ext/numtheory/numtheory.c
 - LICENSE.txt
 files: 
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -32,7 +33,7 @@ files:
 - ext/numtheory/extconf.rb
 - ext/numtheory/numtheory.c
 - ext/numtheory/numtheory.h
-- ext/numtheory/numtheory_macros.c
+- ext/numtheory/numtheory_macros.h
 - ext/numtheory/powermod.h
 - ext/numtheory/primes.c
 - ext/numtheory/primes.h
@@ -40,6 +41,10 @@ files:
 - ext/numtheory/reduce.c
 - ext/numtheory/reduce.h
 - ruby-numtheory.gemspec
+- spec/numtheory/arithmetic_functions_spec.rb
+- spec/numtheory/bit_function_spec.rb
+- spec/numtheory/modular_arithmetic_spec.rb
+- spec/numtheory/primality_tests_spec.rb
 homepage: http://github.com/lomereiter/ruby-numtheory
 licenses: 
 - MIT
@@ -53,7 +58,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -228771462311290448
+      hash: -4196605072839558477
       segments: 
       - 0
       version: "0"