gmp_ecm 0.3.0

data/COPYING.md

@@ -0,0 +1,13 @@
+Copyright 2012 Sam Rawlins
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+
+gem 'gmp'
+
+group :test do
+  gem 'rspec'
+end
+
+group :development do
+  gem 'guard'
+  gem 'guard-rspec'
+  gem 'guard-shell'
+  gem 'yard'
+  gem 'redcarpet'
+end

data/Guardfile

@@ -0,0 +1,18 @@
+require 'fileutils'
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+
+guard 'shell' do
+  watch(/ext\/(.*)\.[c|h]$/) do |m|
+    system("cd ext && make; cd ..")
+    FileUtils.touch Dir.glob(File.join('spec', 'spec_helper.rb')).first # force the rspec guard to fire
+  end
+
+#  watch("manual.md") do |m|
+#    system("make")
+#  end
+end

data/README.md

@@ -0,0 +1,18 @@
+GMP-ECM
+=======
+
+GMP-ECM is a C implementation of the [Elliptic Curve Method](http://en.wikipedia.org/wiki/Elliptic_curve_method) for factorizing integers. This library, gmp_ecm, provides Ruby bindings to this library.
+
+The only prerequisite to using gmp_ecm is the [gmp](https://github.com/srawlins/gmp) gem, which provides Ruby bindings to GMP, a prerequisite to using the GMP-ECM library. The gmp gem is required because most numbers (input integer, resultant factors, and various parameters) are passed around as `GMP::Z` numbers.
+
+Usage
+=====
+
+The function of the gmp_ecm library is contained almost entirely in the `GMP::Z#ecm_factor` method (binding to GMP-ECM's `ecm_params` C function). So in order to start factorizing an integer, one must first initialize a `GMP::Z` number, and then call `#ecm_factor` against it. Just as in the C library, this method requires the `B1` parameter to be passed in. Optionally, the user can pass in a second parameter, a Hash, or an ECMParams object. This will be passed to `ecm_factor` as an `ecm_params` struct.
+
+Just now, not all of the fields in `ecm_params` is available. The current list of supported parameters is in the docs.
+
+License
+=======
+
+gmp_ecm is licensed under the Apache License, Version 2.0

data/ext/ecm.c

@@ -0,0 +1,200 @@
+/*
+ * ecm.c
+ *
+ * This file contains everything you would expect from a C extension.
+ */
+
+#include <ruby_ecm.h>
+
+/*********************************************************************
+ *    Initialization Functions                                       *
+ *********************************************************************/
+
+VALUE cECM_PARAMS;
+ID ecmp_method_id;
+ID ecmp_ecm_ecm_id;
+ID ecmp_ecm_pm1_id;
+ID ecmp_ecm_pp1_id;
+ID ecmp_x_id;
+ID ecmp_sigma_id;
+ID ecmp_sigma_is_A_id;
+ID ecmp_go_id;
+ID ecmp_B1done_id;
+ID ecmp_B2min_id;
+ID ecmp_B2_id;
+//void r_ecm_params_free(void *ptr) { ecm_clear (ptr); free (ptr); }
+void r_ecm_params_free(void *ptr) { ecm_clear (ptr); }
+
+/*
+ * So far, we accept the following:
+ *
+ * :method is supposed to be one of these constants: ECM_ECM, ECM_PM1, ECM_PP1.
+ * I am accepting :ecm_ecm, :ecm_pm1, :ecm_pp1.
+ *
+ * :x is supposed to be an mpz_t. I am accepting GMP::Z.
+ *
+ * :sigma is supposed to be an mpz_t. I am accepting Fixnum, Bignum, GMP::Z.
+ *
+ * :sigma_is_A is supposed to be 1, 0, or -1. I am accepting Fixnum.
+ */
+int add_item_to_ecm_params (VALUE key, VALUE value, VALUE params_value) {
+  ECM_PARAMS *params;
+  ecm_params_get_struct (params_value, params);
+  MP_INT *params_x, *params_sigma, *params_go, *params_B2min, *params_B2;
+  if (rb_to_id (key) == ecmp_method_id) {
+    if      ( rb_to_id (value) == ecmp_ecm_ecm_id) { params->method = ECM_ECM; }
+    else if ( rb_to_id (value) == ecmp_ecm_pm1_id) { params->method = ECM_PM1; }
+    else if ( rb_to_id (value) == ecmp_ecm_pp1_id) { params->method = ECM_PP1; }
+  } else if (rb_to_id (key) == ecmp_x_id) {
+    mpz_get_struct (value, params_x);
+    mpz_init_set (params->x, params_x);
+  } else if (rb_to_id (key) == ecmp_sigma_id) {
+    if (FIXNUM_P (value) || BIGNUM_P (value)) {
+      mpz_init_set_si (params->sigma, NUM2INT(value));
+    } else if (GMPZ_P (value)) {
+      mpz_get_struct (value, params_sigma);
+      mpz_init_set (params->sigma, params_sigma);
+    }
+  } else if (rb_to_id (key) == ecmp_sigma_is_A_id) {
+    params->sigma_is_A = NUM2INT(value);
+  } else if (rb_to_id (key) == ecmp_go_id) {
+    if (FIXNUM_P (value) || BIGNUM_P (value)) {
+      mpz_init_set_si (params->go, NUM2INT(value));
+    } else if (GMPZ_P (value)) {
+      mpz_get_struct (value, params_go);
+      mpz_init_set (params->go, params_go);
+    }
+  } else if (rb_to_id (key) == ecmp_B1done_id) {
+    if (FIXNUM_P (value)) {
+      params->B1done = (double) NUM2INT (value);
+    } else if (FLOAT_P (value)) {
+      params->B1done = NUM2DBL (value);
+    }
+  } else if (rb_to_id (key) == ecmp_B2min_id) {
+    if (FIXNUM_P (value) || BIGNUM_P (value)) {
+      mpz_init_set_si (params->B2min, NUM2INT(value));
+    } else if (GMPZ_P (value)) {
+      mpz_get_struct (value, params_B2min);
+      mpz_init_set (params->B2min, params_B2min);
+    }
+  } else if (rb_to_id (key) == ecmp_B2_id) {
+    if (FIXNUM_P (value) || BIGNUM_P (value)) {
+      mpz_init_set_si (params->B2, NUM2INT(value));
+    } else if (GMPZ_P (value)) {
+      mpz_get_struct (value, params_B2);
+      mpz_init_set (params->B2, params_B2);
+    }
+  }
+  return 1;
+}
+
+/*
+ * params should already be initialized
+ */
+VALUE build_ecm_params_from_hash (VALUE params_hash) {
+  VALUE params_value;
+  ECM_PARAMS *params;
+  ecm_params_make_struct_init (params_value, params);
+  rb_hash_foreach (params_hash, add_item_to_ecm_params, params_value);
+  return params_value;
+}
+
+VALUE r_ecmsg_new(int argc, VALUE *argv, VALUE klass)
+{
+  ECM_PARAMS *res;
+  VALUE res_value;
+  (void)klass;
+
+  if (argc > 1)
+    rb_raise (rb_eArgError, "wrong # of arguments (%d for 0 or 1)", argc);
+
+//  ecm_params_make_struct (res, res_val);
+  ecm_params_make_struct_init (res_value, res);
+  rb_obj_call_init (res_value, argc, argv);
+
+  return res_value;
+}
+
+  /*
+   * Document-method: GMP::Z#ecm_method
+   *
+   * @overload ecm_factor(b1, ecm_params)
+   *
+   * Search for a factor of `z`, using GMP-ECM's `ecm_factor()` method.
+   *
+   * @param [Fixnum, GMP::Z] b1 the stage 1 bound
+   * @param [Hash] ecm_params auxiliary parameters; must be a Hash for now.
+   *
+   * * option ecm_params [Symbol] :method the factorization method (ECM_ECM for ECM, ECM_PM1 for P-1, ECM_PP1 for P+1). Default is ECM_ECM.
+   * * option ecm_params [Fixnum, GMP::Z] :x (if non zero) is the starting point (ECM, P-1, P+1). For ECM, we take as starting point (x0 : y0) where x0=x, y0=1; for P-1, we take x0; for P+1, we take x0 as starting point of the Lucas sequence. When ecm_factor() returns, p->x is the point obtained after stage 1.
+   * * option ecm_params [?] :sigma (ECM only) is the "sigma" parameter. The elliptic curve chosen is b*y^2 = x^3 + a*x^2 + x where a = (v-u)^3*(3*u+v)/(4*u^3*v)-2, u = sigma^2-5, v = 4*sigma (Suyama's parametrization). The initial point (if p->x is zero) is taken as x0=u^3/v^3, y0=1 (thus b is taken as x0^3 + a*x0^2 + x0).
+   * * option ecm_params [-1, 0, 1] :sigma_is_A (ECM only) indicates that p->sigma is the 'a' parameter from the elliptic curve.
+   * * option ecm_params [?] :go the initial group order to preload (default is 1).
+   * * option ecm_params [?] :B1done tells that step 1 was already done up to B1done. This means that all prime powers <= B1done were dealt with. If for example B1done=100 and B1=200, prime 2 was dealt with up to power 6, thus it remains to "multiply" once by 2 to go up to power 7. Of course, all primes p such that B1done < p <= B1 will be considered with power 1.
+   * * option ecm_params [Fixnum, GMP::Z] :B2min the lower bound for stage 2, which will treat all primes p such that B2min <= p <= B2. If negative, B2min will be set to B1.
+   * * option ecm_params [Fixnum, GMP::Z] :B2 the upper bound for stage 2 (default is automatically computed from B1, to optimize the efficiency of the method).
+   * * option ecm_params [?] :k the number of blocks used in stage 2 (default is ECM_DEFAULT_K).
+   */
+VALUE r_ecm_factor (int argc, VALUE *argv, VALUE self_value) {
+  MP_INT *self, *res;
+  VALUE res_value, b1_value, params_arg, params_value;
+  ECM_PARAMS *params;
+  double b1;
+  int found;
+  (void)self;
+
+  mpz_get_struct (self_value, self);
+  mpz_make_struct (res_value, res);
+  mpz_init (res);
+
+  rb_scan_args (argc, argv, "02", &b1_value, &params_arg);
+  if (params_arg == Qnil) {
+    params = NULL;
+  } else if (ECM_PARAMS_P (params_arg)) {
+    ecm_params_get_struct (params_arg, params);
+  } else if (TYPE (params_arg) == T_HASH) {
+    params_value = build_ecm_params_from_hash (params_arg);
+    ecm_params_get_struct (params_value, params);
+  } else {
+    rb_raise (rb_eArgError, "Second argument must be an ECMParams");
+  }
+  if (b1_value == Qnil) {
+    b1 = 1000000;
+  } else if (FIXNUM_P (b1_value)) {
+    b1 = (double) NUM2INT (b1_value);
+  } else if (FLOAT_P (b1_value)) {
+    b1 = NUM2DBL (b1_value);
+  } else {
+    rb_raise (rb_eArgError, "b1 argument must be a Fixnum");
+  }
+
+  found = ecm_factor (res, self, b1, params);
+
+  return res_value;
+}
+
+void Init_ecm() {
+  ecmp_method_id     = rb_intern("method");
+  ecmp_ecm_ecm_id    = rb_intern("ecm_ecm");
+  ecmp_ecm_pm1_id    = rb_intern("ecm_pm1");
+  ecmp_ecm_pp1_id    = rb_intern("ecm_pp1");
+  ecmp_x_id          = rb_intern("x");
+  ecmp_sigma_id      = rb_intern("sigma");
+  ecmp_sigma_is_A_id = rb_intern("sigma_is_A");
+  ecmp_sigma_is_A_id = rb_intern("go");
+  ecmp_B1done_id     = rb_intern("B1done");
+  ecmp_B2min_id      = rb_intern("B2min");
+  ecmp_B2_id         = rb_intern("B2");
+  cECM_PARAMS = rb_define_class ("ECMParams", rb_cObject);
+
+  // Initialization Functions and Assignment Functions
+
+  rb_define_singleton_method (cECM_PARAMS, "new", r_ecmsg_new, -1);
+  //rb_define_method (cECM_PARAMS, "initialize", r_ecm_initialize, -1);
+
+  if (0) {
+    mGMP = rb_define_module("GMP");
+    cGMP_Z = rb_define_class_under(mGMP, "Z", rb_cInteger);
+  }
+  rb_define_method(cGMP_Z, "ecm_factor", r_ecm_factor, -1);
+}

data/ext/extconf.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require 'mkmf'
+dir_config('ecm')
+ok = true
+
+unless have_header('gmp.h')
+  $stderr.puts "can't find gmp.h, try --with-gmp-include=<path>"
+  ok = false
+end
+
+unless have_library('gmp', '__gmpz_init')
+  $stderr.puts "can't find -lgmp, try --with-gmp-lib=<path>"
+  ok = false
+end
+
+unless have_header('ecm.h')
+  $stderr.puts "can't find ecm.h, try --with-ecm-include=<path>"
+  ok = false
+end
+
+unless have_library('ecm', 'ecm_init')
+  $stderr.puts "can't find -lecm, try --with-ecm-lib=<path>"
+  ok = false
+end
+
+$CFLAGS += ' -Wall -W -O6 -g'
+
+if not ok
+  raise "Unable to build, correct above errors and rerun"
+end
+
+create_makefile('ecm')

data/ext/ruby_ecm.h

@@ -0,0 +1,31 @@
+#ifndef _RUBY_ECM_H_
+#define _RUBY_ECM_H_
+
+#include <stdio.h>
+#include <ruby.h>
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <ruby_gmp.h>
+#include <ecm.h>
+
+#include <stdlib.h>
+
+/*
+ * (a comment borrowed from the Ruby GMP bindings:)
+ * MP_???* is used because they don't have side-effects of single-element arrays ecm_params
+ */
+typedef __ecm_param_struct ECM_PARAMS;
+
+#define ecm_params_get_struct(ruby_var,c_var)       { Data_Get_Struct(ruby_var, ECM_PARAMS, c_var); }
+#define ecm_params_make_struct(ruby_var,c_var)      { ruby_var = Data_Make_Struct(cECM_PARAMS, ECM_PARAMS, 0, r_ecm_params_free, c_var); }
+#define ecm_params_make_struct_init(ruby_var,c_var) { ecm_params_make_struct(ruby_var,c_var); ecm_init (c_var); }
+#define ECM_PARAMS_P(value) (rb_obj_is_instance_of(value,cECM_PARAMS) == Qtrue)
+
+extern VALUE cECM_PARAMS;
+
+extern void ecm_params_set_value(ECM_PARAMS *target, VALUE source);
+
+extern void r_ecm_params_free(void *ptr);
+
+#endif /* _RUBY_ECM_H_ */

data/ext/ruby_gmp.h

@@ -0,0 +1,343 @@
+#ifndef _RUBY_GMP_H_
+#define _RUBY_GMP_H_
+
+#include <stdio.h>
+#include <ruby.h>
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <gmp.h>
+#include <mpfr.h>
+#include <mpf2mpfr.h>
+
+#include <stdlib.h>
+
+/*
+  MP_INT*, MP_RAT* and MP_FLOAT* are used because they don't have side-effects
+  of single-element arrays mp*_t
+
+  MP_FLOAT is defined here, as it's commented out in gmp.h
+*/
+typedef __mpfr_struct MP_FLOAT;
+
+#if __GNU_MP_VERSION < 5
+typedef unsigned long int mp_bitcnt_t;
+#endif
+
+/*
+  I don't like this solution, because in gmp.h, all of these typedefs are
+  marked with "gmp 1 source compatibility". :(.
+*/
+typedef __gmp_randstate_struct MP_RANDSTATE;
+
+#define mpz_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_INT, c_var); }
+#define mpq_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_RAT, c_var); }
+#define mpf_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_FLOAT, c_var); }
+#define mprandstate_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_RANDSTATE, c_var); }
+#define mpz_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_Z, MP_INT, 0, r_gmpz_free, c_var); }
+#define mpq_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_Q, MP_RAT, 0, r_gmpq_free, c_var); }
+#define mpf_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_F, MP_FLOAT, 0, r_gmpf_free, c_var); }
+#define mprandstate_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_RandState, MP_RANDSTATE, 0, r_gmprandstate_free, c_var); }
+#define mpz_make_struct_init(ruby_var,c_var) { mpz_make_struct(ruby_var,c_var); mpz_init (c_var); }
+#define mpq_make_struct_init(ruby_var,c_var) { mpq_make_struct(ruby_var,c_var); mpq_init (c_var); }
+#define BIGNUM_P(value) (TYPE(value) == T_BIGNUM)
+#define FLOAT_P(value)  (TYPE(value) == T_FLOAT)
+#define STRING_P(value) (TYPE(value) == T_STRING)
+#define ARRAY_P(value)  (TYPE(value) == T_ARRAY)
+#define GMPZ_P(value)   (rb_obj_is_instance_of(value, cGMP_Z) == Qtrue)
+#define GMPQ_P(value)   (rb_obj_is_instance_of(value, cGMP_Q) == Qtrue)
+#define GMPF_P(value)   (rb_obj_is_instance_of(value, cGMP_F) == Qtrue)
+#define mpz_set_bignum(var_mpz,var_bignum) {                   \
+  VALUE tmp = rb_funcall (rb_funcall (var_bignum, rb_intern ("to_s"), 1, INT2FIX(32)), rb_intern("upcase"), 0);  \
+  mpz_set_str (var_mpz, StringValuePtr (tmp), 32);              \
+}
+  /*VALUE tmp = rb_funcall (var_bignum, rb_intern ("to_s"), 1, INT2FIX(32));  \*/
+/*#define mpz_set_bignum(var_mpz,var_bignum) {                   \
+  VALUE tmp = rb_funcall (var_bignum, rb_intern ("to_s"), 0);  \
+  mpz_set_str (var_mpz, StringValuePtr (tmp), 10);              \
+}*/
+#define mpz_temp_alloc(var) { var=malloc(sizeof(MP_INT)); }
+#define mpz_temp_init(var) { mpz_temp_alloc(var); mpz_init(var); }
+#define mpz_temp_from_bignum(var,var_bignum) {                 \
+  mpz_temp_alloc(var);                                         \
+  VALUE tmp = rb_funcall (var_bignum, rb_intern ("to_s"), 1, INT2FIX(32));  \
+  mpz_init_set_str (var, StringValuePtr (tmp), 32);             \
+}
+#define mpz_temp_free(var) { mpz_clear(var); free(var); }
+#define mpf_temp_alloc(var) { var=malloc(sizeof(MP_FLOAT)); }
+#if defined(MPFR) && defined(HAVE_MPFR_H)
+#define prec_max(prec,var) {if(mpfr_get_prec(var) > prec) prec = mpfr_get_prec(var); }
+#else
+#define prec_max(prec,var) {if(mpf_get_prec(var) > prec) prec = mpf_get_prec(var); }
+#endif
+
+#define mpf_get_struct_prec(ruby_var,c_var,prec) { mpf_get_struct(ruby_var,c_var); prec = mpfr_get_prec(c_var); }
+#define mpf_make_struct_init(ruby_var,c_var,prec) { mpf_make_struct(ruby_var,c_var); mpfr_init2 (c_var,prec); }
+#define mpf_temp_init(var,prec) { mpf_temp_alloc(var); mpfr_init2(var,prec); }
+#define mpf_temp_free(var) { mpfr_clear(var); free(var); }
+#define r_mpf_init(var1) (mpfr_init(var1))
+#define r_mpf_init2(var1, var2) (mpfr_init2(var1, var2))
+#define r_mpf_set_z(var1, var2) (mpfr_set_z(var1, var2, __gmp_default_rounding_mode))
+#define r_mpf_set_q(var1, var2) (mpfr_set_q(var1, var2, __gmp_default_rounding_mode))
+#define r_mpf_set_d(var1, var2) (mpfr_set_d(var1, var2, __gmp_default_rounding_mode))
+#define r_mpf_set_str(var1, var2, var3) (mpfr_set_str(var1, var2, var3, __gmp_default_rounding_mode))
+#define r_mpf_cmp(var1, var2) (mpfr_cmp(var1, var2))
+
+#ifdef FIXNUM_WIDTH       /* RBX check */
+#if (((8*SIZEOF_INTPTR_T) - TAG_FIXNUM_SHIFT -1) == 63) /* 64-bit */
+#define FIX2NUM(x) FIX2LONG(x)
+#else                        /* 32-bit */
+#define FIX2NUM(x) FIX2INT(x)
+#endif
+#else                     /* RBX check */
+#if SIZEOF_INT < SIZEOF_LONG /* 64-bit */
+#define FIX2NUM(x) FIX2LONG(x)
+#else                        /* 32-bit */
+#define FIX2NUM(x) FIX2INT(x)
+#endif         /* MRI's 32-vs-64 check */
+#endif                    /* RBX check */
+
+#define EXPECTED_ZQFXBD "Expected GMP::Z, GMP::Q, GMP::F, Fixnum, Bignum or Float"
+#define EXPECTED_ZQFXB "Expected GMP::Z, GMP::Q, GMP::F, Fixnum or Bignum"
+#define EXPECTED_ZFXBD "Expected GMP::Z, GMP::F, Fixnum, Bignum or Float"
+#define EXPECTED_ZXB "Expected GMP::Z, Fixnum or Bignum"
+#define EXPECTED_ZX "Expected GMP::Z or Fixnum"
+#define EXPECTED_X "Expected Fixnum"
+#define EXPECTED_Z "Expected GMP::Z"
+#define EXPECTED_FD "Expected GMP::F or Float"
+#define typeerror(expected) rb_raise(rb_eTypeError, EXPECTED_##expected)
+#define typeerror_as(expected, argname) rb_raise(rb_eTypeError, EXPECTED_##expected " as " argname)
+
+//should change exception type
+#define not_yet rb_raise(rb_eTypeError,"Not implemented yet")
+
+#define mprnd_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, int, c_var); }
+#define mprnd_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_Rnd, int, 0, 0, c_var); }
+#define GMPRND_P(value)   (rb_obj_is_instance_of(value, cGMP_Rnd) == Qtrue)
+
+extern VALUE mGMP, cGMP_Z, cGMP_Q, cGMP_F, cGMP_RandState;
+extern VALUE cGMP_Rnd;
+
+extern void r_gmpz_free(void *ptr);
+extern void r_gmpq_free(void *ptr);
+extern void r_gmpf_free(void *ptr);
+extern void r_gmprandstate_free(void *ptr);
+
+
+/* from gmpz.h */
+
+// Initializing, Assigning Integers
+extern VALUE r_gmpzsg_new(int argc, VALUE *argv, VALUE klass);
+extern VALUE r_gmpz_initialize(int argc, VALUE *argv, VALUE self);
+extern void mpz_set_value(MP_INT *target, VALUE source);
+extern VALUE r_gmpmod_z(int argc, VALUE *argv, VALUE module);
+extern VALUE r_gmpz_swap(VALUE self, VALUE arg);
+
+// Converting Integers
+extern VALUE r_gmpz_to_i(VALUE self);
+extern VALUE r_gmpz_to_d(VALUE self);
+extern VALUE r_gmpz_to_s(int argc, VALUE *argv, VALUE self);
+
+// Integer Arithmetic
+extern VALUE r_gmpz_add(VALUE self, VALUE arg);
+extern VALUE r_gmpz_add_self(VALUE self, VALUE arg);
+extern VALUE r_gmpz_sub(VALUE self, VALUE arg);
+extern VALUE r_gmpz_sub_self(VALUE self, VALUE arg);
+extern VALUE r_gmpz_mul(VALUE self, VALUE arg);
+extern VALUE r_gmpz_div(VALUE self, VALUE arg);
+
+// Integer Division
+extern VALUE r_gmpz_mod(VALUE self, VALUE arg);
+
+// Integer Exponentiation
+extern VALUE r_gmpzsg_pow(VALUE klass, VALUE base, VALUE exp);
+extern VALUE r_gmpz_powm(VALUE self, VALUE exp, VALUE mod);
+
+// Integer Roots
+
+// Number Theoretic Functions
+extern VALUE r_gmpz_is_probab_prime(int argc, VALUE* argv, VALUE self);
+extern VALUE r_gmpz_gcd(VALUE self, VALUE arg);
+extern VALUE r_gmpz_invert(VALUE self, VALUE arg);
+extern VALUE r_gmpz_jacobi(VALUE self, VALUE b);
+extern VALUE r_gmpzsg_jacobi(VALUE klass, VALUE a, VALUE b);
+extern VALUE r_gmpz_legendre(VALUE self, VALUE p);
+extern VALUE r_gmpz_remove(VALUE self, VALUE arg);
+
+// Integer Comparisons
+extern VALUE r_gmpz_eq(VALUE self, VALUE arg);
+extern VALUE r_gmpz_cmp(VALUE self, VALUE arg);
+extern VALUE r_gmpz_cmpabs(VALUE self, VALUE arg);
+extern VALUE r_gmpz_sgn(VALUE self);
+extern int mpz_cmp_value(MP_INT *OP, VALUE arg);
+
+// Integer Logic and Bit Fiddling
+extern VALUE r_gmpz_popcount(VALUE self);
+extern VALUE r_gmpz_scan0(VALUE self, VALUE bitnr);
+extern VALUE r_gmpz_scan1(VALUE self, VALUE bitnr);
+extern VALUE r_gmpz_setbit(VALUE self, VALUE bitnr, VALUE set_to);
+extern VALUE r_gmpz_getbit(VALUE self, VALUE bitnr);
+
+// Miscelaneous Integer Functions
+extern VALUE r_gmpz_sizeinbase(VALUE self, VALUE base);
+extern VALUE r_gmpz_size_in_bin(VALUE self);
+
+
+/* from gmpq.h */
+
+// Initializing Rationals
+extern VALUE r_gmpqsg_new(int argc, VALUE *argv, VALUE klass);
+extern VALUE r_gmpq_initialize(int argc, VALUE *argv, VALUE self);
+extern VALUE r_gmpmod_q(int argc, VALUE *argv, VALUE module);
+extern VALUE r_gmpq_swap(VALUE self, VALUE arg);
+
+// Rational Conversions
+extern VALUE r_gmpq_to_d(VALUE self);
+extern VALUE r_gmpq_to_s(VALUE self);
+
+// Rational Arithmetic
+extern VALUE r_gmpq_add(VALUE self, VALUE arg);
+extern VALUE r_gmpq_sub(VALUE self, VALUE arg);
+extern VALUE r_gmpq_mul(VALUE self, VALUE arg);
+extern VALUE r_gmpq_div(VALUE self, VALUE arg);
+extern VALUE r_gmpq_inv(VALUE self);
+extern VALUE r_gmpq_inv_self(VALUE self);
+
+// Comparing Rationals
+extern VALUE r_gmpq_eq(VALUE self, VALUE arg);
+extern VALUE r_gmpq_cmp(VALUE self, VALUE arg);
+extern int mpq_cmp_value(MP_RAT *OP, VALUE arg);
+extern VALUE r_gmpq_sgn(VALUE self);
+
+// Applying Integer Functions
+extern VALUE r_gmpq_num(VALUE self);
+extern VALUE r_gmpq_den(VALUE self);
+
+// _unsorted_
+
+
+/* from gmpf.h */
+
+// Initializing, Assigning Floats
+extern VALUE r_gmpfsg_new(int argc, VALUE *argv, VALUE klass);
+extern VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self);
+extern void mpf_set_value(MP_FLOAT *self_val, VALUE arg);
+extern VALUE r_gmpmod_f(int argc, VALUE *argv, VALUE module);
+extern VALUE r_gmpf_get_prec(VALUE self);
+extern VALUE r_gmpf_set_prec(VALUE self, VALUE arg);
+extern VALUE r_gmpf_set_prec_raw(VALUE self, VALUE arg);
+
+// Converting Floats
+extern VALUE r_gmpf_to_d(VALUE self);
+extern VALUE r_gmpf_to_s(VALUE self);
+
+// Float Arithmetic
+extern VALUE r_gmpf_add(VALUE self, VALUE arg);
+extern VALUE r_gmpf_mul(VALUE self, VALUE arg);
+extern VALUE r_gmpf_sub(VALUE self, VALUE arg);
+extern VALUE r_gmpf_div(VALUE self, VALUE arg);
+
+// Float Comparison
+extern VALUE r_gmpf_eq(VALUE self, VALUE arg);
+extern VALUE r_gmpf_cmp(VALUE self, VALUE arg);
+extern int mpf_cmp_value(MP_FLOAT *OP, VALUE arg);
+
+// MPFR
+  extern void mpf_set_value2(MP_FLOAT *self_val, VALUE arg, int base);
+
+  extern VALUE r_gmpfr_sqrt(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_rec_sqrt(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_cbrt(int argc, VALUE *argv, VALUE self);
+
+  extern VALUE r_gmpfr_log(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_log2(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_log10(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_exp(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_exp2(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_exp10(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_cos(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_sin(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_tan(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_sec(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_csc(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_cot(int argc, VALUE *argv, VALUE self);
+
+  extern VALUE r_gmpfr_acos(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_asin(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_atan(int argc, VALUE *argv, VALUE self);
+
+  extern VALUE r_gmpfr_cosh(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_sinh(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_tanh(int argc, VALUE *argv, VALUE self);
+
+  extern VALUE r_gmpfr_sech(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_csch(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_coth(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_acosh(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_asinh(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_atanh(int argc, VALUE *argv, VALUE self);
+
+  extern VALUE r_gmpfr_log1p(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_expm1(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_eint(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_li2(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_gamma(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_lngamma(int argc, VALUE *argv, VALUE self);
+  /*extern VALUE r_gmpfr_lgamma(int argc, VALUE *argv, VALUE self);*/
+#if MPFR_VERSION_MAJOR > 2
+  extern VALUE r_gmpfr_digamma(int argc, VALUE *argv, VALUE self);
+#endif
+  extern VALUE r_gmpfr_zeta(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_erf(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_erfc(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_j0(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_j1(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_jn(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_y0(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_y1(int argc, VALUE *argv, VALUE self);
+
+  extern VALUE r_gmpfrsg_const_log2();
+  extern VALUE r_gmpfrsg_const_pi();
+  extern VALUE r_gmpfrsg_const_euler();
+  extern VALUE r_gmpfrsg_const_catalan();
+
+  extern mp_rnd_t r_get_rounding_mode(VALUE rnd);
+
+// _unsorted_
+extern VALUE r_gmpf_sgn(VALUE self);
+
+
+/* from gmprandstate.h */
+
+// Random State Initialization
+extern VALUE r_gmprandstatesg_new(int argc, VALUE *argv, VALUE klass);
+extern VALUE r_gmprandstate_initialize(int argc, VALUE *argv, VALUE self);
+extern VALUE r_gmpmod_randstate(int argc, VALUE *argv, VALUE module);
+
+// Random State Seeding
+extern VALUE r_gmprandstate_seed(VALUE self, VALUE arg);
+
+// Integer Random Numbers
+extern VALUE r_gmprandstate_urandomb(VALUE self, VALUE arg);
+extern VALUE r_gmprandstate_urandomm(VALUE self, VALUE arg);
+
+// Float Random Numbers
+extern VALUE r_gmprandstate_mpfr_urandomb(int argc, VALUE *argv, VALUE self);
+
+
+/* from gmpbench_timing.c */
+
+// GMPbench Timing
+extern VALUE r_gmpmod_cputime(VALUE self);
+extern VALUE r_gmpmod_time(VALUE self);
+
+
+
+extern void init_gmpz();
+extern void init_gmpq();
+extern void init_gmpf();
+extern void init_gmprandstate();
+extern void init_gmpbench_timing();
+extern void init_gmprnd();
+
+#endif

data/lib/ecm.rb

@@ -0,0 +1,3 @@
+require 'gmp'
+
+require File.join(File.dirname(__FILE__), '..', 'ext', 'ecm')

data/spec/sanity_spec.rb

@@ -0,0 +1,43 @@
+# I'm having trouble coming up with decent unit tests, so for now... sanity tests!
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe ECMParams, "new" do
+  before do
+    @z = GMP::Z(2)**255 - 1
+    @z2 = GMP::Z("2050449353925555290706354283")
+    @z3 = GMP::Z("212252637915375215854013140804296246361")
+  end
+
+  it "should allow a missing ECMParams" do
+    @z.ecm_factor(1_000_000)
+  end
+
+  it "should allow a simple hash with :method" do
+    @z.ecm_factor(1_000_000, :method => :ECM_ECM)
+    @z.ecm_factor(1_000_000, :method => :ECM_PM1)
+    @z.ecm_factor(1_000_000, :method => :ECM_PP1)
+  end
+
+  it "should allow a simple hash with :x" do
+    @z.ecm_factor(1_000_000, :z => GMP::Z(1_000))
+  end
+
+  it "should allow a simple hash with :sigma" do
+    @z2.ecm_factor 1_000_000, :sigma => 7
+    @z2.ecm_factor 1_000_000, :sigma => GMP::Z(7)
+  end
+
+  it "should allow a simple hash with :sigma_is_A" do
+    @z2.ecm_factor 1_000_000, :sigma_is_A =>  1
+    @z2.ecm_factor 1_000_000, :sigma_is_A =>  0
+    @z2.ecm_factor 1_000_000, :sigma_is_A => -1
+  end
+
+  it "should allow a simple hash with :go" do
+    @z3.ecm_factor 1_000_000, :sigma =>  GMP::Z(781683988), :go => GMP::Z(550232165123)
+  end
+
+  it "should allow a simple hash with :B1done" do
+    @z3.ecm_factor 1_000_000, :sigma =>  GMP::Z(781683988), :go => GMP::Z(550232165123), :B1done => 1000.0
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'ecm')

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: gmp_ecm
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
+platform: ruby
+authors:
+- srawlins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gmp
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: gmp_ecm - Elliptic Curve Method Factorization on GMP::Z integers
+email:
+- sam.rawlins@gmail.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/ecm.c
+- ext/ruby_ecm.h
+- ext/ruby_gmp.h
+- ext/extconf.rb
+- lib/ecm.rb
+- spec/sanity_spec.rb
+- spec/spec_helper.rb
+- README.md
+- COPYING.md
+- Gemfile
+- Guardfile
+homepage: http://github.com/srawlins/gmp-ecm
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- GMP-ECM compiled and working properly.
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Provides Ruby bindings to the GMP-ECM library.
+test_files: []
+has_rdoc: yard