ruby-numtheory 0.0.5 → 0.0.6

data/ext/numtheory/numtheory.h

@@ -0,0 +1,183 @@
+#ifndef NUMTHEORY_H
+#define NUMTHEORY_H 
+
+#include <ruby.h>
+#include <stdio.h>
+#include <math.h>
+
+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);
+
+#define BITSPERDIG  (SIZEOF_BDIGITS * CHAR_BIT)
+#define BIGRAD  ((BDIGIT_DBL)1 << BITSPERDIG)
+#define BIGLO(x) ((BDIGIT)((x) & (BIGRAD - 1)))
+
+inline static VALUE TO_BIGNUM(VALUE x) {
+    return FIXNUM_P(x) ? rb_int2big(FIX2LONG(x)) : x;
+}
+
+inline static unsigned long TO_ULONG(VALUE x) {
+    if (!FIXNUM_P(x))
+    { 
+      if (rb_big_cmp(x, ULONG2NUM(ULONG_MAX)) != one) 
+        return rb_big2ulong(x);
+      else 
+        rb_raise(rb_eNotImpError, "Not implemented for numbers >= 2**32");
+    } 
+    return FIX2ULONG(x);
+}
+
+inline static int EVEN_P(VALUE x) {
+    return FIXNUM_P(x) ? !(FIX2ULONG(x)&1) : !(RBIGNUM_DIGITS(x)[0]&1);
+}
+
+inline static int ZERO_P(VALUE x) {
+    return FIXNUM_P(x) ? FIX2LONG(x) == 0 : rb_bigzero_p(x); 
+}
+
+inline static VALUE ADD(VALUE x, VALUE y) {
+    return FIXNUM_P(x) ? FIXNUM_P(y) ? 
+                   LONG2NUM(FIX2LONG(x) + FIX2LONG(y)) : 
+                   rb_big_plus(y, x) : 
+           rb_big_plus(x, y);
+}
+
+inline static VALUE SUB(VALUE x, VALUE y) {
+    return (FIXNUM_P(x) && FIXNUM_P(y)) ? 
+                   LONG2NUM(FIX2LONG(x) - FIX2LONG(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);
+}
+
+inline static VALUE POW(VALUE b, VALUE p) {
+    return rb_funcall(b, id_pow, 1, p);
+}
+
+inline static VALUE DIV(VALUE x, VALUE y) {
+    return rb_funcall(x, id_div, 1, y);
+}
+
+inline static VALUE DIVMOD(VALUE x, VALUE y) {
+    return rb_funcall(x, id_divmod, 1, 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 : 
+           rb_big_eq(TO_BIGNUM(x), y) == Qtrue;
+}
+
+inline static int MORE(VALUE x, VALUE y) {
+    return (FIXNUM_P(x) && FIXNUM_P(y)) ?
+                   FIX2LONG(x) > FIX2LONG(y) :
+           rb_big_cmp(TO_BIGNUM(x), y) == one;
+}
+
+inline static int LESS(VALUE x, VALUE y) {
+    return (FIXNUM_P(x) && FIXNUM_P(y)) ?
+                   FIX2LONG(x) < FIX2LONG(y) :
+           rb_big_cmp(TO_BIGNUM(x), y) == INT2FIX(-1);
+}
+
+inline static int MORE_EQL(VALUE x, VALUE y) {
+    return (FIXNUM_P(x) && FIXNUM_P(y)) ?
+                   FIX2LONG(x) >= FIX2LONG(y) :
+           rb_big_cmp(TO_BIGNUM(x), y) != INT2FIX(-1);
+}
+
+inline static VALUE ABS(VALUE x) {
+    if (FIXNUM_P(x))
+        return INT2FIX(abs(FIX2LONG(x)));
+    VALUE v = rb_big_clone(x);
+    RBIGNUM_SET_SIGN(v, 1);
+    return v;
+}
+
+inline static int NEGATIVE_P(VALUE x) {
+    return FIXNUM_P(x) ? FIX2LONG(x) < 0 : RBIGNUM_NEGATIVE_P(x);
+}
+
+inline static VALUE CLONE(VALUE x) {
+    return FIXNUM_P(x) ? x : rb_big_clone(x);
+}
+
+inline static int INTEGER_P(VALUE x) {
+    return (TYPE(x) == T_FIXNUM) || (TYPE(x) == T_BIGNUM);
+}
+
+inline static VALUE DOUBLED(VALUE x) {
+    return FIXNUM_P(x) ? LONG2NUM(FIX2LONG(x) << 1) :
+            rb_big_lshift(x, one);
+}
+
+inline static VALUE HALF(VALUE x) {
+    return FIXNUM_P(x) ? INT2FIX(FIX2LONG(x) >> 1) :
+            rb_big_rshift(x, one);
+}
+
+inline static VALUE RIGHT_SHIFT(VALUE x, int s) {
+    return FIXNUM_P(x) ? INT2FIX(FIX2LONG(x) >> s) :
+            rb_big_rshift(x, INT2FIX(s));
+}
+
+#ifdef min
+#undef min
+#endif
+inline static int min(int a, int b) { return a < b ? a : b; }
+
+#endif

data/ext/numtheory/numtheory_macros.c

@@ -0,0 +1,201 @@
+#define FOR_PRIME_FACTORS(n, p, d, action) do { \
+    int __d; \
+    unsigned long __i; \
+    unsigned long long __t; \
+    VALUE __num = (FIXNUM_P(n) ? n : rb_big_clone(n)); \
+    if (!FIXNUM_P(__num)) \
+    { \
+      if (rb_big_cmp(__num, ULL2NUM(ULLONG_MAX)) != INT2FIX(1)) \
+      { \
+        __t = rb_big2ull(__num); \
+      } \
+      else \
+      { \
+        rb_raise(rb_eNotImpError, "Not implemented for numbers >= 2**64"); \
+      } \
+    } \
+    else \
+    { \
+      __t = FIX2LONG(__num); \
+    } \
+ \
+    unsigned long long __p; \
+    VALUE p, d; \
+    if (prime_p(__t)) \
+    { \
+      d = INT2FIX(1); \
+      p = ULL2NUM(__t); \
+      action; \
+      __t = 1; \
+      break; \
+    } \
+    for (__i = 0; (__i < NUM_OF_PRIMES) && (__t > 1); ++__i) \
+    { \
+      __p = numtheory_primes[__i]; \
+      if (__p * __p > __t) \
+      { \
+        d = INT2FIX(1); \
+        __p = __t; \
+        p = ULL2NUM(__p); \
+        action; \
+        __t = 1; \
+        break; \
+      } \
+      if (__t % __p == 0) \
+      { \
+        __d = 0; \
+        do { \
+            __t /= __p; \
+            ++__d; \
+        } while (!(__t % __p)); \
+        p = ULL2NUM(__p); \
+        d = INT2FIX(__d); \
+        action; \
+                \
+        if (prime_p(__t)) \
+        { \
+          d = INT2FIX(1); \
+          p = ULL2NUM(__t); \
+          action; \
+          __t = 1; \
+          break; \
+        } \
+      } \
+    } \
+    if (__t != 1) \
+    { \
+      p = ULL2NUM(__t); \
+      if (numtheory_prime_p(p) == Qtrue) \
+      { \
+          d = INT2FIX(1); \
+          action; \
+      } \
+      else \
+      { \
+          raise_not_enough_exception(); \
+      } \
+    } \
+} while(0)
+
+#define FOR_BITS(n, before_action, if_zero_action, if_one_action, final_action) do { \
+    if (FIXNUM_P(n)) { \
+        long _pow = FIX2LONG(n); \
+        long _half_p = _pow >> 1; \
+        long _j = 1; \
+        for( ; _j <= _half_p; _j <<= 1 ); \
+        for( ; _j ; _j >>= 1) { \
+            before_action; \
+            if (_pow & _j) do { if_one_action; } while(0); \
+            else if_zero_action; \
+            final_action; \
+        } \
+    } \
+    else { \
+        BDIGIT* _digits = RBIGNUM_DIGITS(n); \
+        long _digits_length = RBIGNUM_LEN(n); \
+        BDIGIT _j; \
+        BDIGIT* _digit = _digits + _digits_length - 1; \
+        BDIGIT _half_fst_digit = (*_digit) >> 1; \
+        for (_j = 1; _j <= _half_fst_digit; _j <<= 1); \
+        for (; _digit >= _digits; --_digit) { \
+            for (; _j > 0; _j >>= 1){ \
+                before_action; \
+                if (*_digit & _j) do { if_one_action; } while(0); \
+                else if_zero_action; \
+                final_action; \
+            } \
+            _j = 1 << (SIZEOF_BDIGITS * 8 - 1); \
+        } \
+    } \
+} while(0)
+
+#define DEFINE_POWERMOD_SLIDING_WINDOW(FUNC_NAME, REDUCE_PROLOGUE, REDUCE_METHOD) \
+static VALUE \
+FUNC_NAME(VALUE b, VALUE p, VALUE m) {\
+    VALUE result = one; \
+    enum { squaring, collecting } state; \
+    \
+    state = collecting; \
+    int len, k; \
+    int zeros = 0; \
+    int pow = 0; \
+    \
+    /* adjusting window size */ \
+    if (FIXNUM_P(p)) p = rb_int2big(FIX2LONG(p)); \
+    len = RBIGNUM_LEN(p); \
+    if      (len  <  8) k = 4; \
+    else if (len  < 20) k = 5; \
+    else if (len  < 48) k = 6; \
+    else if (len < 120) k = 7; \
+    else k = 8; \
+    \
+    len = 0; \
+    \
+    REDUCE_PROLOGUE; \
+    \
+    b = MOD(b, m); /* necessary because for Barrett reduction to work \
+                      b must be less than m^2 */    \
+    \
+    VALUE b_squared = REDUCE_METHOD(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] = REDUCE_METHOD(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 = REDUCE_METHOD(MUL(result, result), m); \
+                            result = REDUCE_METHOD(MUL(result, powers[pow>>1]), m); \
+                            while (zeros--) \
+                                result = REDUCE_METHOD(MUL(result, result), m); \
+    \
+                            state = squaring; pow = len = zeros = 0; \
+                        } \
+                    } else { \
+                        result = REDUCE_METHOD(MUL(result, result), m); \
+                    } \
+                }, \
+                { /* the bit is one */ \
+                    if (state == collecting) { \
+                        ++ len; \
+                        zeros = 0; \
+                        pow = (pow << 1) + 1; \
+                        if (len == k) { \
+                            while (len--) \
+                                result = REDUCE_METHOD(MUL(result, result), m); \
+                            result = REDUCE_METHOD(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 = REDUCE_METHOD(MUL(result, result), m); \
+        result = REDUCE_METHOD(MUL(result, powers[pow>>1]), m); \
+        while (zeros--) \
+            result = REDUCE_METHOD(MUL(result, result), m); \
+    } \
+    return result; \
+}
+
+#define BARRETT_MOD(x, m) rb_big_barrett_reduce(x, m, mu, 1)

data/ext/numtheory/powermod.h

@@ -0,0 +1,9 @@
+#ifndef NUMTHEORY_POWERMOD_H
+#define NUMTHEORY_POWERMOD_H
+
+BDIGIT int_powermod_montgomery_small(VALUE, VALUE, BDIGIT);
+VALUE int_powermod_sliding_window(VALUE, VALUE, VALUE);
+VALUE int_powermod_sliding_window_br(VALUE, VALUE, VALUE);
+VALUE int_powermod_sliding_window_mont(VALUE, VALUE, VALUE);
+
+#endif

data/ext/numtheory/primes.c

@@ -0,0 +1,57 @@
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include "primes.h"
+
+unsigned long *numtheory_is_prime; // n = 2k+1 -> k-th bit
+unsigned long *numtheory_primes; 
+
+unsigned long
+init_sieve(unsigned long max_n)
+{
+    size_t is_p_sz = max_n / (2 * ULONG_SZ) + 1;
+    numtheory_is_prime = malloc(is_p_sz * ULONG_SZ);
+    memset(numtheory_is_prime, 0xFFFFFFFF, is_p_sz * ULONG_SZ);
+    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 max_n_sqrt = (unsigned long)(sqrt((double)max_n));
+
+    for (i1 = 5, i2 = 7; ; i1 += 6, i2 += 6)
+    {
+        if (i1 > max_n_sqrt) break;
+        if (is_set(numtheory_is_prime, i1))
+        {
+            s = i1 << 1;
+            for (j = i1 * i1; j <= max_n; j += s)
+                unset_bit(numtheory_is_prime, j);
+            numtheory_primes[p++] = i1;
+        }
+        if (i2 > max_n_sqrt) break;
+        if (is_set(numtheory_is_prime, i2))
+        {
+            s = i2 << 1;
+            for (j = i2 * i2; j <= max_n; j += s)
+                unset_bit(numtheory_is_prime, j);
+            numtheory_primes[p++] = i2;
+        }
+    }
+    for ( ; ; i1 += 6, i2 += 6)
+    {
+        if (i1 > max_n) break;
+        if (is_set(numtheory_is_prime, i1))
+            numtheory_primes[p++] = i1;
+        if (i2 > max_n) break;
+        if (is_set(numtheory_is_prime, i2))
+            numtheory_primes[p++] = i2;
+    }
+    numtheory_primes = realloc(numtheory_primes, p * ULONG_SZ);
+    return p;
+}