ruby-numtheory 0.0.4-x86-mingw32 → 0.0.5-x86-mingw32

data/ext/numtheory/numtheory.c

@@ -217,6 +217,10 @@ 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; \
+                       else RBIGNUM_SET_SIGN(x, !RBIGNUM_SIGN(x)); } \
+while(0);
+
 inline static VALUE MUL(VALUE x, VALUE y) { 
     return rb_funcall(x, id_mul, 1, y);
 }
@@ -243,7 +247,19 @@ inline static VALUE DIVMOD(VALUE x, VALUE y) {
 inline static VALUE MOD(VALUE x, VALUE y) {
     return rb_funcall(x, id_mod, 1, 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;
+}
+
+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;
+}
+
 inline static int EQL(VALUE x, VALUE y) {
     return (FIXNUM_P(x) && FIXNUM_P(y)) ? 
                    x == y : 
@@ -345,6 +361,8 @@ numtheory_powermod(int argc, VALUE *argv)
     return result;
 }
 
+static VALUE int_powermod_sliding_window(VALUE,VALUE,VALUE);
+
 /*
  *  call-seq:
  *    integer.powermod(power, modulo)         -> integer
@@ -356,7 +374,6 @@ numtheory_powermod(int argc, VALUE *argv)
  */
 static VALUE
 numtheory_int_powermod(VALUE b, VALUE p, VALUE m){
-    VALUE result = one;
     if (!INTEGER_P(p))
     {
         rb_raise(rb_eArgError, "power must be integer");
@@ -365,16 +382,32 @@ numtheory_int_powermod(VALUE b, VALUE p, VALUE m){
     {
         rb_raise(rb_eTypeError, "modulo must be integer");
     }
+    if (ZERO_P(p))
+    {
+        return one;
+    }
     if (NEGATIVE_P(p))
     {
         b = numtheory_modular_inverse(b, m);
         p = ABS(p);
+    } 
+    else 
+    {
+        b = MOD(b, m);
+    }
+    if (FIXNUM_P(p) || RBIGNUM_LEN(p) < 4)
+    {
+        VALUE result = one;
+        FOR_BITS(p, result = MUL(result, result),
+                    {},
+                    result = MUL(result, b),
+                    result = MOD(result, m));
+        return result;
+    } 
+    else 
+    {
+        return int_powermod_sliding_window(b, p, m);
     }
-    FOR_BITS(p, result = MUL(result, result),
-                {},
-                result = MUL(result, b),
-                result = MOD(result, m));
-    return result;
 }
 
 static int tail_zeros(VALUE n)
@@ -1378,48 +1411,52 @@ numtheory_jacobi(VALUE a, VALUE n)
     {
         rb_raise(rb_eArgError, "n must be odd positive");
     }
-    int t = 1;
+    int t = 1, z;
     VALUE tmp;
+
+    a = MOD(a, n); 
+    if (MORE(a, HALF(n))) {
+        a = SUB(a, n);
+    }
+
     while (!ZERO_P(a))
     {
-        a = MOD(a, n);
-        if (MORE(a, HALF(n)))
+        if (FIXNUM_P(n) && FIXNUM_P(a)) 
         {
-            a = SUB(a, n);
-        }
-        if (FIXNUM_P(n)) 
-        {
-            return INT2FIX(ull_jacobi(FIX2LONG(a), FIX2LONG(n)));
+            return INT2FIX(t * ull_jacobi(FIX2LONG(a), FIX2LONG(n)));
         }
         if (RBIGNUM_LEN(n) <= 2) // unsigned long long is used 
         {
-            return INT2FIX(ull_jacobi(FIXNUM_P(a) ? FIX2LONG(a) : rb_big2ll(a), 
-                              rb_big2ull(n)));
+            return INT2FIX(t * ull_jacobi(FIXNUM_P(a) ? FIX2LONG(a) : rb_big2ll(a), 
+                                          rb_big2ull(n)));
         }
         if (NEGATIVE_P(a))
         {
-            a = SUB(zero, a);
-            if (MOD(n, four) == three)
+            NEGATE(a);
+            if (MOD_4(n) == 3)
                 t = -t;
         }
-        switch (FIX2LONG(MOD(n, eight)))
+        z = tail_zeros(a);
+        a = RIGHT_SHIFT(a, z);
+        if (z & 1)
         {
-            case 1:
-            case 7:
-                while (EVEN_P(a))
-                    a = HALF(a);
-                break;
-            case 3:
-            case 5:
-                while (EVEN_P(a))
-                    a = HALF(a), t = -t;
-                break;
+            switch (MOD_8(n))
+            {
+                case 3:
+                case 5:
+                    t = -t;
+                    break;
+            }
         }
         tmp = a;
         a = n;
-        n = tmp;
-        if (MOD(a, four) == three && MOD(n, four) == three)
+        n = tmp; /* n > 0 */
+        if (MOD_4(a) == 3 && MOD_4(n) == 3)
             t = -t;
+        a = MOD(a, n); 
+        if (MORE(a, HALF(n))) {
+            a = SUB(a, n);
+        }
     }
     if (n == one)
     {
@@ -1724,3 +1761,84 @@ numtheory_bpsw_pseudoprime_p(VALUE n)
     
     return lucas_pseudoprime_p(num, one, RIGHT_SHIFT(SUB(one, INT2FIX(d)), 2));
 }
+
+static VALUE
+int_powermod_sliding_window(VALUE b, VALUE p, VALUE m){
+    VALUE result = one;
+    /* used when p is bignum only */
+    enum { squaring, collecting } state;
+
+    state = collecting;
+    int len, k;
+    int zeros = 0;
+    int pow = 0;
+
+    /* adjusting window size */
+    len = RBIGNUM_LEN(p);
+    if      (len  <  8) k = 4;
+    else if (len  < 20) k = 5;
+    else if (len  < 48) k = 6;
+    else k = 7;
+
+    len = 0;
+    
+    VALUE b_squared = MOD(MUL(b, b), m);
+    VALUE *powers = ALLOCA_N(VALUE, 1<<(k-1));
+    powers[0] = b;
+    int i;
+    /* precomputation of odd powers;
+       powers[n] = (b ** (2n + 1)) % m        */
+    for (i = 1; i < (1<<(k-1)); ++i)
+        powers[i] = MOD(MUL(powers[i-1], b_squared), m);
+
+    FOR_BITS(p, {},
+                { /* if the bit is zero */
+                    if (state == collecting) {
+                        ++ len;
+                        ++ zeros;
+                        pow <<= 1;
+                        if (len == k) {
+                            pow >>= zeros;
+
+                            for (i = len; i > zeros; i--)
+                                result = MOD(MUL(result, result), m);
+                            result = MOD(MUL(result, powers[pow>>1]), m);     
+                            while (zeros--)
+                                result = MOD(MUL(result, result), m);
+
+                            state = squaring; pow = len = zeros = 0;
+                        }
+                    } else {
+                        result = MOD(MUL(result, result), m);
+                    }
+                }, 
+                { /* the bit is one */
+                    if (state == collecting) {
+                        ++ len;
+                        zeros = 0;
+                        pow = (pow << 1) + 1;
+                        if (len == k) {
+                            while (len--)
+                                result = MOD(MUL(result, result), m);
+                            result = MOD(MUL(result, powers[pow>>1]), m);     
+                            state = squaring;
+                            pow = len = 0;
+                        }
+                    } else {
+                        state = collecting;
+                        pow = 1;
+                        len = 1;
+                        zeros = 0;
+                    }
+                }, {});
+    if (len > 0) {
+        pow >>= zeros;
+
+        for (i = len; i > zeros; i--)
+            result = MOD(MUL(result, result), m);
+        result = MOD(MUL(result, powers[pow>>1]), m);     
+        while (zeros--)
+            result = MOD(MUL(result, result), m);
+    }
+    return result;
+}

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 5
+  version: 0.0.5
 platform: x86-mingw32
 authors: 
 - lomereiter
@@ -14,11 +14,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-16 00:00:00 +04:00
+date: 2011-05-27 00:00:00 +04:00
 default_executable: 
 dependencies: []
 
-description: fast implementations of common number-theoretical algorithms
+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"
 email: lomereiter@gmail.com
 executables: []