ruby-numtheory 0.0.5 → 0.0.6

data/ext/numtheory/primes.h

@@ -0,0 +1,25 @@
+#ifndef NUMTHEORY_PRIMES_H
+#define NUMTHEORY_PRIMES_H
+
+unsigned long init_sieve(unsigned long max_n); // returns prime_pi(max_n)
+
+#define ULONG_SZ sizeof(unsigned long)
+
+extern unsigned long *numtheory_is_prime;
+extern unsigned long *numtheory_primes;
+
+static inline unsigned long
+is_set(unsigned long* ary, unsigned long n)
+{
+    long k = n >> 1;
+    return ary[k / ULONG_SZ] & (1 << (k & (ULONG_SZ - 1)));
+}
+   
+static inline void 
+unset_bit(unsigned long* ary, unsigned long n)
+{
+    long k = n >> 1;
+    ary[k / ULONG_SZ] &= ~(1 << (k & (ULONG_SZ - 1)));
+}
+
+#endif

data/ext/numtheory/queue.h

@@ -0,0 +1,63 @@
+#ifndef NUMTHEORY_QUEUE_H
+#define NUMTHEORY_QUEUE_H
+
+#include <stdlib.h>
+
+typedef struct Node Node;
+struct Node {
+    void* val;
+    Node* next;
+};
+
+typedef struct {
+    Node* first;
+    Node* last;
+} Queue;
+
+static inline Queue* queue_new()
+{
+    Queue* q;
+    q = malloc(sizeof(Queue));
+    q -> first = q -> last = NULL;
+    return q;
+}
+
+static inline void queue_push(Queue* q, void* elem)
+{
+    Node* new_node = malloc(sizeof(Node));
+    new_node -> val = elem;
+    new_node -> next = NULL;
+    if (q -> last)
+    {
+        q -> last -> next = new_node;
+    }
+    else
+    {
+        q -> first = new_node;
+    }
+    q -> last = new_node;
+}
+
+static inline void* queue_pop(Queue* q)
+{
+    if (q -> first == NULL)
+    {
+        return NULL;
+    }
+    Node* fst_node = q -> first;
+    void* elem = fst_node -> val;
+    q -> first = fst_node -> next;
+    if (q -> first == NULL)
+    {
+        q -> last = NULL;
+    }
+    free(fst_node);
+    return elem;
+}
+
+static inline int queue_empty(Queue* q)
+{
+    return q -> first == NULL;
+}
+
+#endif

data/ext/numtheory/reduce.c

@@ -0,0 +1,234 @@
+#include <string.h>
+#include "numtheory.h"
+
+#define MULADD(i, j) \
+    __asm__ volatile(                   \
+          "movl %6, %%eax \n\t"     \
+          "mull %7        \n\t"     \
+          "addl %%eax, %0 \n\t"     \
+          "adcl %%edx, %1 \n\t"     \
+          "adcl $0, %2    \n\t" :   \
+          "=m"(c0), "=m"(c1), "=m"(c2) :    \
+          "m"(c0), "m"(c1), "m"(c2), "m"(i), "m"(j) :     \
+          "%eax","%edx", "%cc");
+
+#define BITSPERDIG (SIZEOF_BDIGITS * CHAR_BIT)
+#define BIGRAD ((BDIGIT_DBL)1 << BITSPERDIG)
+#define BIGLO(x) ((BDIGIT)((x) & (BIGRAD - 1)))
+
+#define RBIGNUM_SET_LEN(b,l) \
+        ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \
+              (void)(RBASIC(b)->flags = \
+                        (RBASIC(b)->flags & ~RBIGNUM_EMBED_LEN_MASK) | \
+                        ((l) << RBIGNUM_EMBED_LEN_SHIFT)) : \
+              (void)(RBIGNUM(b)->as.heap.len = (l)))
+
+inline static VALUE rshift_digits_inplace(VALUE n, int k)
+{
+    if (FIXNUM_P(n)) {
+        return INT2FIX(0);
+    }
+
+    BDIGIT* ds = RBIGNUM_DIGITS(n);
+    int len = RBIGNUM_LEN(n);
+    int i;
+    if (len > k)
+    {
+        memmove(ds, ds + k, SIZEOF_BDIGITS * (len - k));
+        RBIGNUM_SET_LEN(n, len - k);
+        return n;
+    } 
+    else
+    {
+        RBIGNUM_SET_LEN(n, 0);
+        return n;
+    }
+}
+
+inline static VALUE power_of_two(int p)
+{
+    return rb_big_lshift(rb_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));
+    int yn = RBIGNUM_LEN(y);
+
+    int all = 0;
+    if (digits > xn + yn) 
+    {
+        digits = xn + yn;
+        all = 1;
+    }
+    VALUE z = rb_big_new(digits, 1);
+
+    BDIGIT* xds = RBIGNUM_DIGITS(x);
+    BDIGIT* yds = RBIGNUM_DIGITS(y);
+    BDIGIT* zds = RBIGNUM_DIGITS(z);
+
+    BDIGIT c0,c1,c2; // carry
+    int i, j, k, beg, end;
+    for (k = c0 = c1 = c2 = 0; k < digits; k++)
+    {
+        beg = k >= yn - 1 ? k - yn + 1 : 0; 
+        end = k >= xn     ? xn - 1     : k;
+        for (i = beg, j = k - beg; i <= end; ++i, --j)
+            MULADD(xds[i], yds[j]);
+        zds[k] = c0;
+        c0 = c1;
+        c1 = c2;
+        c2 = 0;
+    }
+    return rb_big_norm(z);
+}
+/*
+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));
+    int yn = RBIGNUM_LEN(y);
+    VALUE z = rb_big_new(digits, 1);
+    BDIGIT* xds = RBIGNUM_DIGITS(x);
+    BDIGIT* yds = RBIGNUM_DIGITS(y);
+    BDIGIT* zds = RBIGNUM_DIGITS(z);
+
+    int i, j, k;
+    for (i = 0; i < digits; zds[i++] = 0);
+    BDIGIT_DBL dd, carry;
+    for (i = 0; i < xn; ++i)
+    {
+        dd = xds[i];
+        carry = 0;
+        k = digits - i;
+        if (k > yn) k = yn;
+        for (j = 0; j < k; ++j)
+        {
+            carry += dd * yds[j] + zds[i + j];
+            zds[i + j] = BIGLO(carry);
+            carry >>= BITSPERDIG;
+        }
+        if (carry && (i + j) < digits)
+            zds[i + j] = carry;
+    }
+    return rb_big_norm(z);
+} */
+
+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));
+    int yn = RBIGNUM_LEN(y);
+
+
+    BDIGIT* xds = RBIGNUM_DIGITS(x);
+    BDIGIT* yds = RBIGNUM_DIGITS(y);
+
+    /* 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);
+    } else {
+        xds += x_right_shift;
+        xn -= x_right_shift;
+    }
+
+    int digits = xn + yn;
+    int i, j, k;
+    VALUE z = rb_big_new(digits, 1);
+    BDIGIT* zds = RBIGNUM_DIGITS(z);
+    for (i = 0; i < digits; zds[i++] = 0);
+
+    int beg, end;
+
+    BDIGIT c0, c1, c2;
+    for (k = dontcare, c0 = c1 = c2 = 0; k < digits; k++)
+    {
+        beg = k >= yn - 1 ? k - yn + 1 : 0; 
+        end = k >= xn     ? xn - 1     : k;
+        for (i = beg, j = k - beg; i <= end; ++i, --j)
+            MULADD(xds[i], yds[j]);
+        zds[k] = c0;
+        c0 = c1;
+        c1 = c2;
+        c2 = 0;
+    }
+    return z;
+}
+
+/*
+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));
+    int yn = RBIGNUM_LEN(y);
+    VALUE z = rb_big_new(xn + yn, 1);
+    BDIGIT* xds = RBIGNUM_DIGITS(x);
+    BDIGIT* yds = RBIGNUM_DIGITS(y);
+    BDIGIT* zds = RBIGNUM_DIGITS(z);
+
+    int i, j, k;
+    for (i = 0; i < xn + yn; zds[i++] = 0);
+    BDIGIT_DBL dd, carry;
+    for (i = 0; i < xn; ++i)
+    {
+        dd = xds[i];
+        carry = 0;
+        k = dontcare - i;
+        if (k < 0) k = 0;
+        for (j = k; j < yn; ++j)
+        {
+            carry += dd * yds[j] + zds[i + j];
+            zds[i + j] = BIGLO(carry);
+            carry >>= BITSPERDIG;
+        }
+        if (i+j >= dontcare)
+            zds[i+j] = carry;
+    }
+    return z;
+}*/
+
+
+VALUE rb_big_barrett_mu(VALUE m)
+{
+    long len = RBIGNUM_LEN(m);
+    return rb_big_div(power_of_two(2 * len * BITSPERDIG), m);
+}
+
+VALUE rb_big_barrett_reduce(VALUE x, VALUE m, VALUE mu, int inplace)
+{
+    if (!NEGATIVE_P(x) && MORE(m, x))
+    {
+        return x;
+    }
+    unsigned long len = RBIGNUM_LEN(m); /* >= 1 */
+    if (FIXNUM_P(x))
+    {
+        return FIX2LONG(x) >= 0 ? x : rb_big_plus(m, x);
+    }
+
+    VALUE   q = bigmul_high_digits(x, mu, len - 1, len - 1);
+    /* q is not normed */
+    q = rshift_digits_inplace(q, len + 1);
+    /* [x/m] - 3 <= q <= [x/m] */
+    q = bigmul_low_digits(q, m, len + 1);
+    /* q is normed */
+
+    VALUE a = inplace ? x : rb_big_clone(x);
+    if (RBIGNUM_LEN(a) > (long)len + 1)
+    {
+        RBIGNUM_SET_LEN(a, len + 1);
+    }
+
+    a = rb_big_minus(a, q);
+    if (NEGATIVE_P(a))
+        a = ADD(a, power_of_two((len + 1) * BITSPERDIG));
+    /* a = (x - q * m) mod (base ** (len + 1)) */
+
+    while (!MORE(m, a)) /* that is, m <= a */
+        a = SUB(a, m);
+    return rb_big_norm(a);
+}

data/ext/numtheory/reduce.h

@@ -0,0 +1,11 @@
+#ifndef NUMTHEORY_REDUCE_H
+#define NUMTHEORY_REDUCE_H
+
+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

@@ -0,0 +1,24 @@
+Gem::Specification.new do |gem|
+  gem.name = "ruby-numtheory"
+  gem.homepage = "http://github.com/lomereiter/ruby-numtheory"
+  gem.license = "MIT"
+  gem.summary = "Ruby number theory library"
+  gem.version = "0.0.6"
+  gem.platform = Gem::Platform::RUBY
+
+  gem.description = <<-EOF
+    The library is written as C extension and aims to provide
+    common number-theoretical functions such as powermod, jacobi symbol,
+    various multiplicative ones, etc.
+  EOF
+
+  gem.email = "lomereiter@gmail.com"
+  gem.authors = ["Artem Tarasov"]
+
+  gem.extensions = FileList["ext/numtheory/extconf.rb"]
+  gem.require_path = 'ext'
+  gem.files = `git ls-files`.split("\n")
+
+  gem.has_rdoc = true
+  gem.extra_rdoc_files = ["ext/numtheory/numtheory.c", "LICENSE.txt"]
+end

metadata

@@ -1,24 +1,19 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-numtheory
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 5
-  version: 0.0.5
+  prerelease: 
+  version: 0.0.6
 platform: ruby
 authors: 
-- lomereiter
+- Artem Tarasov
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-05-27 00:00:00 +04:00
-default_executable: 
+date: 2012-08-27 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"
+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: []
 
@@ -26,40 +21,52 @@ extensions:
 - ext/numtheory/extconf.rb
 extra_rdoc_files: 
 - ext/numtheory/numtheory.c
+- LICENSE.txt
 files: 
-- ext/numtheory/numtheory.c
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/numtheory/Makefile
+- ext/numtheory/constants.h
 - ext/numtheory/extconf.rb
-has_rdoc: true
-homepage: http://code.google.com/p/ruby-numtheory
-licenses: []
-
+- ext/numtheory/numtheory.c
+- ext/numtheory/numtheory.h
+- ext/numtheory/numtheory_macros.c
+- ext/numtheory/powermod.h
+- ext/numtheory/primes.c
+- ext/numtheory/primes.h
+- ext/numtheory/queue.h
+- ext/numtheory/reduce.c
+- ext/numtheory/reduce.h
+- ruby-numtheory.gemspec
+homepage: http://github.com/lomereiter/ruby-numtheory
+licenses: 
+- MIT
 post_install_message: 
 rdoc_options: []
 
 require_paths: 
-- lib
+- ext
 required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: -228771462311290448
       segments: 
-      - 1
-      - 9
       - 0
-      version: 1.9.0
+      version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Ruby number theory library