msieve 0.1.0-x86-mingw32

data/README.markdown

@@ -0,0 +1,94 @@
+msieve Ruby gem
+===============
+
+This gem (library) provides Ruby bindings for the msieve library, "A Library for Factoring Large Integers" by Jason Papadopoulos.
+
+Usage
+-----
+
+It's entirely simple right now, and there is probably a lot to be desired. In any case, use it as follows:
+
+<pre><code>$irb -r lib/msieve --simple-prompt
+>> m = Msieve.new("1234567890")
+=> #&lt;Msieve:0x14418e0&gt;
+>> m.factor!
+=> [2, 3, 3, 5, 3607, 3803]
+>> n = Msieve.new("235711131719")
+=> #&lt;Msieve:0x14f28c0&gt;
+>> n.factor!
+=> [7, 4363, 7717859]
+>> p = Msieve.new("149162536496481")
+=> #&lt;Msieve:0x15b3140&gt;
+>> p.factor!
+=> [3, 7549, 48437, 135979]</code></pre>
+
+You can also include elementary functions as listed in msieve's readme. I quote:
+
+> Starting with v1.08, the inputs to msieve can be integer arithmetic 
+> expressions using any of the following operators:
+> 
+> * \+ -  plus, minus        (lowest priority)
+> * %    integer remainder
+> * \* /  multiply, integer divide
+> * ^    power
+> * ( )  grouping           (highest priority)
+
+Examples:
+
+<pre><code>$irb -r lib\msieve --simple-prompt
+>> m = Msieve.new("(10^17-1)/9")
+=> #&lt;Msieve:0x13ea4a0&gt;
+>> m.factor!
+=> [2071723, 5363222357]
+>> m = Msieve.new("(10^19-1)/9")
+=> #&lt;Msieve:0x1467b80&gt;
+>> m.factor!
+=> [1111111111111111111]</code></pre>
+
+Caveat
+------
+
+msieve has two headers that have the line
+
+<pre><code>#include &lt;util.h&gt;</code></pre>
+
+This is no good here, because mkmf always puts Ruby's include paths before the
+ones you request. So it ends up including ruby/util.h. No good! I had to hack
+my copy of msieve, the msieve.h and mp.h files, to change that line to
+
+<pre><code>#include "util.h"</code></pre>
+
+and boom! Everything works. No word on how to... autotically do this in the
+gem? I am wholly against toying with the global vars that mkmf sets up, in
+order to reorganize the include paths. Don't even suggest that. Yuck.
+
+
+Bugs
+----
+
+It has some bugs:
+
+<pre><code>$irb -r lib\msieve --simple-prompt
+
+>> m = Msieve.new(99999999)
+=> #&lt;Msieve:0x14e26c0&gt;
+>> m.input
+=> "99999999"
+>> m.factor!
+=> [3, 3, 11, 73, 101, 137]
+>> m.factor!
+=> [3, 3, 11, 73, 101, 137, 3, 3, 11, 73, 101, 137]</code></pre>
+
+Todo
+----
+
+* Fix weird crashing bug that occurs sporadically
+* Get all options working that msieve_obj_new() accepts
+* Internal logging???
+* Stop, Restart
+* Integrate with Ruby gmp gem if available (passing in GMP::Z, factors coming
+  out as GMP::Z, adding a GMP::Z.factor! method
+* Make Ruby bindings for GMP-ECM, then integrate those, haha.
+* Oh, verify that anything works on !windows.
+* Documentation
+* CHANGELOG, gemify, etc.

data/ext/extconf.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require 'mkmf'
+
+dir_config('gmp')
+dir_config('msieve')
+
+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_library('msieve', 'msieve_obj_new')
+  $stderr.puts "can't find -lmsieve, try --with-msieve-lib=<path>"
+  ok = false
+end
+
+unless have_header('msieve.h')
+  $stderr.puts "can't find msieve.h, try --with-msieve-include=<path>"
+  ok = false
+end
+
+$CFLAGS += ' -Wall -W -O6 -g'
+if ok
+  create_makefile('msieve')
+else
+  raise "Unable to build, correct above errors and rerun"
+end

data/ext/msieve.c

@@ -0,0 +1,327 @@
+#include <msieve.h>
+#include <ruby.h>
+
+#if !defined(RSTRING_LEN)
+#  define RSTRING_LEN(x) (RSTRING(x)->len)
+#  define RSTRING_PTR(x) (RSTRING(x)->ptr)
+#endif
+
+#define msieve_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, msieve_obj, c_var); }
+#define msieve_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cMsieve, msieve_obj, 0, 0, c_var); }
+#define BIGNUM_P(value) (TYPE(value) == T_BIGNUM)
+#define HASH_P(value) (TYPE(value) == T_HASH)
+#define NUMERIC_P(value) (FIXNUM_P(value) || BIGNUM_P(value))
+#define STRING_P(value) (TYPE(value) == T_STRING)
+#define MSIEVE_P(value) (rb_obj_is_instance_of(value, cMsieve) == Qtrue)
+#define rb_symbol(value) (rb_funcall(rb_str_new2(value), rb_intern("to_sym"), 0))
+
+#define DEFUN_0ARG_UINT32(fname)             \
+static VALUE r_msieve_##fname(VALUE self)    \
+{                                            \
+  msieve_obj *self_val;                      \
+  msieve_get_struct (self, self_val);        \
+                                             \
+  uint32 attr_val = self_val->fname;         \
+  return INT2FIX(attr_val);                  \
+}
+
+#define DEFUN_0ARG_UINT64(fname)             \
+static VALUE r_msieve_##fname(VALUE self)    \
+{                                            \
+  msieve_obj *self_val;                      \
+  msieve_get_struct (self, self_val);        \
+                                             \
+  uint64 attr_val = self_val->fname;         \
+  return INT2FIX(attr_val);                  \
+}
+
+#define DEFUN_0ARG_CHARSTAR(fname)           \
+static VALUE r_msieve_##fname(VALUE self)    \
+{                                            \
+  msieve_obj *self_val;                      \
+  msieve_get_struct (self, self_val);        \
+                                             \
+  char *attr_val = self_val->fname;          \
+  return rb_str_new2(attr_val);              \
+}
+
+VALUE cMsieve;
+VALUE cMsieve_Factor;
+
+void msieve_set_factors(VALUE obj);
+
+/*
+ * Swiped from msieve's demo for now. Will push to Ruby (and maybe GMP) later.
+ */
+void get_random_seeds(uint32 *seed1, uint32 *seed2) {
+
+	uint32 tmp_seed1, tmp_seed2;
+
+	/* In a multithreaded program, every msieve object
+	   should have two unique, non-correlated seeds
+	   chosen for it */
+
+#if !defined(WIN32) && !defined(_WIN64)
+
+	FILE *rand_device = fopen("/dev/urandom", "r");
+
+	if (rand_device != NULL) {
+
+		/* Yay! Cryptographic-quality nondeterministic randomness! */
+
+		fread(&tmp_seed1, sizeof(uint32), (size_t)1, rand_device);
+		fread(&tmp_seed2, sizeof(uint32), (size_t)1, rand_device);
+		fclose(rand_device);
+	}
+	else
+
+#endif
+	{
+		/* <Shrug> For everyone else, sample the current time,
+		   the high-res timer (hopefully not correlated to the
+		   current time), and the process ID. Multithreaded
+		   applications should fold in the thread ID too */
+
+		uint64 high_res_time = read_clock();
+		tmp_seed1 = ((uint32)(high_res_time >> 32) ^
+			     (uint32)time(NULL)) * 
+			    (uint32)getpid();
+		tmp_seed2 = (uint32)high_res_time;
+	}
+
+	/* The final seeds are the result of a multiplicative
+	   hash of the initial seeds */
+
+	(*seed1) = tmp_seed1 * ((uint32)40499 * 65543);
+	(*seed2) = tmp_seed2 * ((uint32)40499 * 65543);
+}
+
+void msieve_free(void *p) {
+  msieve_obj_free(p);
+}
+
+VALUE msieve_alloc(VALUE klass) {
+  msieve_obj *msieve_val;
+  VALUE obj;
+  
+  char *integer_val = "0";
+  uint32 default_flags = MSIEVE_FLAG_USE_LOGFILE;
+  char *savefile_name = NULL;
+  char *logfile_name = NULL;
+  char *nfs_fbfile_name = NULL;
+  uint32 seed1, seed2;
+  get_random_seeds(&seed1, &seed2);
+  uint32 max_relations = 0;
+  uint64 nfs_lower = 0;
+  uint64 nfs_upper = 0;
+  enum cpu_type cpu = get_cpu_type();
+  uint32 cache_size1;
+  uint32 cache_size2;
+  get_cache_sizes(&cache_size1, &cache_size2);
+  uint32 num_threads = 0;
+  uint32 mem_mb = 0;
+  uint32 which_gpu = 0;
+  
+  msieve_val = msieve_obj_new(integer_val, default_flags,
+      savefile_name, logfile_name, nfs_fbfile_name,
+      seed1, seed2, max_relations,
+      nfs_lower, nfs_upper, cpu,
+      cache_size1, cache_size2,
+      num_threads, mem_mb, which_gpu);
+  obj = Data_Wrap_Struct(klass, 0, msieve_free, msieve_val);
+  return obj;
+}
+
+// /*
+ // * call-seq:
+ // *   Msieve.new(hash)
+ // *
+ // * Creates a new Msieve object (state), with certain arguments and variables
+ // * set with <i>hash</i>.
+ // */
+// VALUE r_msievesg_new(int argc, VALUE *argv, VALUE klass)
+// {
+  // msieve_obj *res_val;
+  // VALUE res;
+  // (void)klass;
+
+  // if (argc > 2)
+    // rb_raise(rb_eArgError, "wrong # of arguments(%d for 0, 1, or 2)", argc);
+
+  // msieve_make_struct (res, res_val);
+  // rb_obj_call_init (res, argc, argv);
+
+  // return res;
+// }
+
+VALUE r_msieve_initialize(int argc, VALUE *argv, VALUE self)
+{
+  msieve_obj *self_val;
+  VALUE integer, hash, hash_value, str;
+  char *integer_val;
+
+  msieve_get_struct (self, self_val);
+  rb_scan_args (argc, argv, "11", &integer, &hash);
+  if (NUMERIC_P(integer)) {
+    VALUE integer_s = rb_funcall (integer, rb_intern("to_s"), 0);
+	str = StringValue (integer_s);
+  }
+  else if (STRING_P(integer)) {
+    str = StringValue (integer);
+  }
+  else {
+    rb_raise (rb_eArgError, "integer must be Numeric or String");
+  }
+  integer_val = RSTRING_PTR(str);
+  self_val->input = integer_val;
+  
+  if (NIL_P(hash)) { hash = rb_hash_new (); }
+  if (! HASH_P(hash)) {
+    rb_raise (rb_eArgError, "options must be a Hash");
+  }
+  
+  hash_value = rb_hash_aref(hash, rb_symbol("quiet"));
+  if (hash_value != Qnil) {
+    self_val->flags &= ~(MSIEVE_FLAG_USE_LOGFILE | MSIEVE_FLAG_LOG_TO_STDOUT);
+  }
+  
+  hash_value = rb_hash_aref(hash, rb_symbol("max_relations"));
+  if (hash_value != Qnil) {
+    self_val->max_relations = FIX2INT(hash_value);
+  }
+  
+  hash_value = rb_hash_aref(hash, rb_symbol("num_threads"));
+  if (hash_value != Qnil) {
+    self_val->num_threads = FIX2INT(hash_value);
+  }
+  
+  hash_value = rb_hash_aref(hash, rb_symbol("mem_mb"));
+  if (hash_value != Qnil) {
+    self_val->mem_mb = FIX2INT(hash_value);
+  }
+  
+  return Qnil;
+}
+
+VALUE r_msieve_factor_bang(VALUE self)
+{
+  msieve_obj *self_val;
+  msieve_get_struct (self, self_val);
+  
+  msieve_run(self_val);
+  
+  if (!(self_val->flags & MSIEVE_FLAG_FACTORIZATION_DONE)) {
+    rb_raise (rb_eRuntimeError, "current factorization was interrupted");
+  }
+  
+  msieve_set_factors(self);
+  
+  return rb_iv_get (self, "@factors");
+}
+
+void msieve_set_factors(VALUE obj) {
+  msieve_obj *obj_val;
+  msieve_get_struct (obj, obj_val);
+  VALUE factors_array = rb_ary_new ();
+  
+  //rb_iv_set (obj, "@factors", rb_ary_new);
+  
+  msieve_factor *factor = obj_val->factors;
+  while (factor != NULL) {
+    VALUE factor_type;
+
+    if (factor->factor_type == MSIEVE_PRIME)
+      factor_type = rb_symbol("prime");
+    else if (factor->factor_type == MSIEVE_COMPOSITE)
+      factor_type = rb_symbol("composite");
+    else
+      factor_type = rb_symbol("probably_prime");
+      
+    VALUE factor_obj = rb_funcall (cMsieve_Factor,
+                                   rb_intern("new"),
+                                   3,
+                                   factor_type,
+                                   rb_str_new2(factor->number),
+                                   INT2FIX((int32)strlen(factor->number)));
+    rb_ary_push(factors_array, factor_obj);
+
+    factor = factor->next;
+  }
+  rb_iv_set (obj, "@factors", factors_array);
+}
+
+VALUE r_msieve_seed1(VALUE self)
+{
+  msieve_obj *self_val;
+  msieve_get_struct (self, self_val);
+  
+  long seed1_val = self_val->seed1;
+  VALUE seed1 = LONG2FIX(seed1_val);
+  
+  return seed1;
+}
+
+DEFUN_0ARG_CHARSTAR(input)
+DEFUN_0ARG_UINT32(seed2)
+DEFUN_0ARG_UINT32(max_relations)
+DEFUN_0ARG_UINT64(nfs_lower)
+DEFUN_0ARG_UINT64(nfs_upper)
+DEFUN_0ARG_UINT32(cache_size1)
+DEFUN_0ARG_UINT32(cache_size2)
+DEFUN_0ARG_UINT32(num_threads)
+DEFUN_0ARG_UINT32(mem_mb)
+
+VALUE r_msieve_factor_initialize(int argc, VALUE *argv, VALUE self) {
+  VALUE factor_type, number, digits;
+  
+  rb_scan_args (argc, argv, "3", &factor_type, &number, &digits);
+  rb_iv_set (self, "@factor_type", factor_type);
+  rb_iv_set (self, "@number", number);
+  rb_iv_set (self, "@digits", digits);
+  
+  return Qnil;
+}
+
+VALUE r_msieve_factor_inspect(VALUE self) {
+  return rb_iv_get (self, "@number");
+}
+
+VALUE r_msieve_factor_to_i(VALUE self) {
+  return rb_funcall(rb_iv_get (self, "@number"), rb_intern("to_i"), 0);
+}
+
+VALUE r_msieve_factor_to_s(VALUE self) {
+  return rb_iv_get (self, "@number");
+}
+
+void Init_msieve() {
+  cMsieve = rb_define_class ("Msieve", rb_cObject);
+  char msieve_version_string[5];
+  sprintf (msieve_version_string, "%d.%02d", MSIEVE_MAJOR_VERSION, MSIEVE_MINOR_VERSION);
+  rb_define_const (cMsieve, "MSIEVE_VERSION", rb_str_new2 (msieve_version_string));
+  rb_define_const (cMsieve, "VERSION",        rb_str_new2 ("0.1.0"));
+  
+  rb_define_alloc_func (cMsieve, msieve_alloc);
+  rb_define_method (cMsieve, "initialize",    r_msieve_initialize, -1);
+  rb_define_method (cMsieve, "factor!",       r_msieve_factor_bang, 0);
+  rb_define_method (cMsieve, "input",         r_msieve_input, 0);
+  rb_define_method (cMsieve, "seed1",         r_msieve_seed1, 0);
+  rb_define_method (cMsieve, "seed2",         r_msieve_seed2, 0);
+  rb_define_method (cMsieve, "max_relations", r_msieve_max_relations, 0);
+  rb_define_method (cMsieve, "nfs_lower",     r_msieve_nfs_lower, 0);
+  rb_define_method (cMsieve, "nfs_upper",     r_msieve_nfs_upper, 0);
+  rb_define_method (cMsieve, "cache_size1",   r_msieve_cache_size1, 0);
+  rb_define_method (cMsieve, "cache_size2",   r_msieve_cache_size2, 0);
+  rb_define_method (cMsieve, "num_threads",   r_msieve_num_threads, 0);
+  rb_define_method (cMsieve, "mem_mb",        r_msieve_mem_mb, 0);
+  rb_define_attr (cMsieve, "factors", 1, 0);
+  
+  cMsieve_Factor = rb_define_class_under (cMsieve, "Factor", rb_cObject);
+  rb_define_method (cMsieve_Factor, "initialize", r_msieve_factor_initialize, -1);
+  rb_define_method (cMsieve_Factor, "inspect",    r_msieve_factor_inspect, 0);
+  rb_define_method (cMsieve_Factor, "to_i",       r_msieve_factor_to_i, 0);
+  rb_define_method (cMsieve_Factor, "to_s",       r_msieve_factor_to_s, 0);
+  rb_define_attr (cMsieve_Factor, "factor_type", 1, 0);
+  rb_define_attr (cMsieve_Factor, "number",      1, 0);
+  rb_define_attr (cMsieve_Factor, "digits",      1, 0);
+}

data/lib/msieve.rb

@@ -0,0 +1,18 @@
+# Thank you, Nokogiri
+
+require 'rbconfig'
+
+ENV['PATH'] = [File.expand_path(
+  File.join(File.dirname(__FILE__), "..", "ext")
+), ENV['PATH']].compact.join(';') if RbConfig::CONFIG['host_os'] =~ /(mswin|mingw|mingw32)/i
+
+require File.dirname(__FILE__) + '/../ext/msieve'
+
+class Msieve
+  def self.clear_log(log_name = "msieve.log")
+    if File.exist? log_name
+      File.delete log_name
+    end
+    puts "Cleared! (but not really)."
+  end
+end

data/test/tc_initiate.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+class TC_Initiate < Test::Unit::TestCase
+  def setup
+    @sample_fixnums = [  1,  2,  3,  4,  5,  8,  9, 15, 16, 17, 31, 32, 33,
+                       2**10-1,  2**10,    2*3*4*5*6*7,  10**6,  2**20]
+    @sample_strings = [    "1",  "2",  "3",  "4",  "5",  "8",  "9", "15",
+                          "16", "17", "31", "32", "33", "2**10-1",
+                       "2**10",    "2*3*4*5*6*7",         "10**6", "2**20"]
+  end
+
+  def test_initiate
+    (@sample_fixnums + @sample_strings).each do |i|
+      m = Msieve.new(i)
+      assert_equal(i.to_s, m.input, "Msieve.new(#{i.inspect}) should initiate ok.")
+    end
+  end
+end

data/test/tc_version.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+
+class TC_Version < Test::Unit::TestCase
+  def setup
+    
+  end
+
+  def test_version
+    assert_equal("0.1.0", Msieve::VERSION,  "msieve gem version should be correct")
+    assert_equal("1.44",  Msieve::MSIEVE_VERSION,  "msieve version should be correct")
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+require 'rbconfig'
+
+ENV['PATH'] = [File.expand_path(
+  File.join(File.dirname(__FILE__), "..", "ext")
+), ENV['PATH']].compact.join(';') if RbConfig::CONFIG['host_os'] =~ /(mswin|mingw|mingw32)/i
+
+require File.dirname(__FILE__) + '/../ext/msieve'

data/test/unit_tests.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'test_helper'
+
+require 'tc_version'
+require 'tc_initiate'

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: msieve
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: x86-mingw32
+authors: 
+- Sam Rawlins
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-04 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: msieve - providing Ruby bindings to the msieve library.
+email: 
+- sam.rawlins@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- ext/msieve.c
+- ext/extconf.rb
+- lib/msieve.rb
+- ext/libgmp-10.dll
+- ext/libmsieve.a
+- ext/msieve.so
+- test/tc_initiate.rb
+- test/tc_version.rb
+- test/test_helper.rb
+- test/unit_tests.rb
+- README.markdown
+has_rdoc: true
+homepage: http://github.com/srawlins/msieve
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- msieve compiled and working properly.
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Provides Ruby bindings to the msieve library.
+test_files: []
+