gmp 0.6.17 → 0.6.19

data/CHANGELOG

@@ -1,3 +1,10 @@
+0.6.19:
+  * Added GMP::Z#congruent? and tests
+  * Added GMP::Z#export and GMP::Z.import and _minimal_ tests
+
+0.6.17:
+  * Added GMP::Z#out_raw, GMP::Z.inp_raw
+
 0.6.13:
   * Added three new GMP::Z methods for GMP 5.1.x: GMP::Z#2fac
     (GMP::Z#double_fac), GMP::Z#mfac, and GMP::Z#primorial

data/README.markdown

@@ -250,6 +250,7 @@ Methods
       tmod,fmod,cmod           truncate, floor and ceil modulus
       >>                       shift right, floor
       divisible?(b)            true if divisible by b
+      congruent?(c,d)          true if congruent to c modulus d
       **                       power
       powmod                   power modulo
       \[\],\[\]=                   testing and setting bits (as booleans)
@@ -286,6 +287,8 @@ Methods
       hamdist                  the hamming distance between two integers
       out_raw                  output to IO object
       inp_raw                  input from IO object
+      export                   export to a byte array (String)
+      import                   import from a byte array (String)
       sizeinbase(b)            digits in base b
       size_in_bin              digits in binary
       size                     number of limbs
@@ -406,7 +409,7 @@ Documentation
 -------------
 
 * [This README](https://github.com/srawlins/gmp)
-* Loren Segal and the guys at RubyGems.org are badasses: [YARDoc](http://rubydoc.info/gems/gmp/frames).
+* Loren Segal and the guys at RubyGems.org are awesome: [YARDoc](http://rubydoc.info/gems/gmp/frames).
 * There should be a manual.pdf [here](https://github.com/srawlins/gmp/blob/master/manual.pdf). I spend waaay too much time working on this, but it looks very pretty.
 * [CHANGELOG](https://github.com/srawlins/gmp/blob/master/CHANGELOG)
 
@@ -452,7 +455,7 @@ Please see [performance](performance.md)
 Todo
 ----
 
-* `GMP::Z#to_d_2exp`, `#congruent?`, `#rootrem`, `#kronecker`, `#bin`, `#fib2`, `#lucnum`, `#lucnum2`, `#combit`, `#fits_x?`
+* `GMP::Z#to_d_2exp`, `#rootrem`, `#kronecker`, `#bin`, `#fib2`, `#lucnum`, `#lucnum2`, `#combit`, `#fits_x?`
 * `GMP::Q#to_s(base)`, `GMP::F#to_s(base)` (test it!)
 * benchmark pi
 * a butt-load of functional mappings. 47-ish sets.

data/ext/gmpz.c

@@ -1502,7 +1502,7 @@ static VALUE r_gmpz_divisible(VALUE self, VALUE arg)
   MP_INT *self_val, *arg_val;
   int res;
   mpz_get_struct (self, self_val);
-  
+
   if (FIXNUM_P (arg) && FIX2NUM (arg) > 0) {
     mpz_temp_alloc(arg_val);
     mpz_init_set_ui(arg_val, FIX2NUM(arg));
@@ -1527,6 +1527,60 @@ static VALUE r_gmpz_divisible(VALUE self, VALUE arg)
   return (res != 0) ? Qtrue : Qfalse;
 }
 
+/*
+ * call-seq:
+ *   n.congruent?(c, d)
+ *
+ * @since 0.6.19
+ *
+ * Returns true if _n_ is congruent to _c_ modulo _d_. _c_ and _d_ can be an instance any of the following:
+ * * GMP::Z
+ * * Fixnum
+ * * Bignum
+ */
+static VALUE r_gmpz_congruent(VALUE self_val, VALUE c_val, VALUE d_val)
+{
+  MP_INT *self, *c, *d;
+  int res, free_c, free_d;
+  mpz_get_struct (self_val, self);
+  free_c = free_d = 0;
+
+  if (FIXNUM_P (c_val) && FIX2NUM (c_val) > 0 &&
+      FIXNUM_P (d_val) && FIX2NUM (d_val) > 0) {
+    res = mpz_congruent_ui_p (self, FIX2NUM (c_val), FIX2NUM (d_val));
+  } else {
+    if (FIXNUM_P (c_val)) {
+      mpz_make_struct_init (c_val, c);
+      mpz_init_set_si (c, FIX2NUM (c_val));
+    } else if (BIGNUM_P (c_val)) {
+      mpz_temp_from_bignum (c, c_val);
+      free_c = 1;
+    } else if (GMPZ_P (c_val)) {
+      mpz_get_struct (c_val, c);
+    } else {
+      typeerror_as (ZXB, "c");
+    }
+
+    if (FIXNUM_P (d_val)) {
+      mpz_make_struct_init (d_val, d);
+      mpz_init_set_si (d, FIX2NUM (d_val));
+    } else if (BIGNUM_P (d_val)) {
+      mpz_temp_from_bignum (d, d_val);
+      free_d = 1;
+    } else if (GMPZ_P (d_val)) {
+      mpz_get_struct (d_val, d);
+    } else {
+      if (free_c) { mpz_temp_free (c); }
+      typeerror_as (ZXB, "d");
+    }
+
+    res = mpz_congruent_p (self, c, d);
+    if (free_c) { mpz_temp_free (c); }
+    if (free_d) { mpz_temp_free (d); }
+  }
+  return (res != 0) ? Qtrue : Qfalse;
+}
+
 
 /**********************************************************************
  *    Integer Exponentiation                                          *
@@ -2731,6 +2785,94 @@ VALUE r_gmpzsg_inp_raw(VALUE klass, VALUE a_val, VALUE stream_val)
 }
 
 
+/**********************************************************************
+ *    Integer Import and Export                                       *
+ **********************************************************************/
+
+/*
+ * call-seq:
+ *   GMP::Z.import(str, order = -1) #=> GMP::Z
+ *
+ * Return a GMP::Z from a String, `str`.
+ *
+ * `order` can be 1 for most significant word first or -1 for least significant first.
+ *
+ * There is no sign taken from the data, the result will simply be a positive integer. An application can handle any sign itself, and apply it for instance with `GMP::Z#neg`.
+ */
+VALUE r_gmpzsg_import(int argc, VALUE *argv, VALUE klass)
+{
+  MP_INT *res;
+  VALUE string_val, order_val, res_val;
+  char *string;
+  int order, endian;
+  size_t nails;
+  (void)klass;
+
+  endian = 0;
+  nails = 0;
+
+  rb_scan_args (argc, argv, "11", &string_val, &order_val);
+
+  if (NIL_P (order_val))
+    order = -1;
+  else if (! FIXNUM_P (order_val))
+    typeerror_as (X, "order");
+  else
+    order = FIX2INT (order_val);
+
+  mpz_make_struct(res_val, res);
+  mpz_init(res);
+
+  string = StringValuePtr (string_val);
+
+  mpz_import (res, RSTRING_LEN(string_val), order, sizeof(char), endian, nails, string);
+  return res_val;
+}
+
+/*
+ * call-seq:
+ *   a.export(order = -1) #=> String
+ *
+ * Return a String with word data from _a_.
+ *
+ * `order` can be 1 for most significant word first or -1 for least significant
+ * first.
+ *
+ * If `a` is non-zero then the most significant word produced will be non-zero.
+ * `GMP::Z(0).export` returns `""`.
+ *
+ * The sign of _a_ is ignored, just the absolute value is exported. An
+ * application can use `GMP::Z#sgn` to get the sign and handle it as desired.
+ */
+VALUE r_gmpz_export(int argc, VALUE *argv, VALUE self_val)
+{
+  MP_INT *self;
+  VALUE order_val, res;
+  int order, endian;
+  size_t countp, nails;
+  char *string;
+
+  endian = 0;
+  nails = 0;
+  mpz_get_struct(self_val, self);
+
+  rb_scan_args (argc, argv, "01", &order_val);
+
+  if (NIL_P (order_val))
+    order = -1;
+  else if (! FIXNUM_P (order_val))
+    typeerror_as (X, "order");
+  else
+    order = FIX2INT (order_val);
+
+  string = mpz_export (NULL, &countp, order, sizeof(char), endian, nails, self);
+  res = rb_str_new (string, countp);
+  free (string);
+
+  return res;
+}
+
+
 /**********************************************************************
  *    Miscellaneous Integer Functions                                 *
  **********************************************************************/
@@ -2877,6 +3019,7 @@ void init_gmpz()
   rb_define_method(cGMP_Z, "cmod",         r_gmpz_cmod, 1);
   rb_define_method(cGMP_Z, "%",            r_gmpz_mod, 1);
   rb_define_method(cGMP_Z, "divisible?",   r_gmpz_divisible, 1);
+  rb_define_method(cGMP_Z, "congruent?",   r_gmpz_congruent, 2);
   // Functional Mappings
   rb_define_singleton_method(cGMP_Z, "divexact",    r_gmpzsg_divexact, 3);
   rb_define_singleton_method(cGMP_Z, "cdiv_q_2exp", r_gmpzsg_cdiv_q_2exp, 3);
@@ -2964,6 +3107,10 @@ void init_gmpz()
   // Functional Mapping
   rb_define_singleton_method(cGMP_Z, "inp_raw", r_gmpzsg_inp_raw, 2);
 
+  // Integer Import and Export
+  rb_define_singleton_method(cGMP_Z, "import", r_gmpzsg_import, -1);
+  rb_define_method(cGMP_Z, "export", r_gmpz_export, -1);
+
   // Miscellaneous Integer Functions
   rb_define_method(cGMP_Z, "even?", r_gmpz_is_even, 0);
   rb_define_method(cGMP_Z, "odd?", r_gmpz_is_odd, 0);

data/test/gmp_tcong.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class GMP_TCong < Test::Unit::TestCase
+  Data = [
+    # strict equality mod 0
+    [ "0",  "0", "0", true],
+    ["11", "11", "0", true],
+    [ "3", "11", "0", false],
+
+    # anything congruent mod 1
+    [                   "0",                    "0", "1", true ],
+    [                   "1",                    "0", "1", true ],
+    [                   "0",                    "1", "1", true ],
+    [                 "123",                  "456", "1", true ],
+    ["0x123456789123456789", "0x987654321987654321", "1", true ],
+
+    # csize==1, dsize==2 changing to 1 after stripping 2s
+    [                "0x3333333333333333",         "0x33333333",         "0x180000000", true],
+    ["0x33333333333333333333333333333333", "0x3333333333333333", "0x18000000000000000", true],
+
+    # another dsize==2 becoming 1, with opposite signs this time */
+    [        "0x444444441",         "-0x22222221F",         "0x333333330", true],
+    ["0x44444444444444441", "-0x2222222222222221F", "0x33333333333333330", true]
+  ]
+  RS = GMP::RandState.new(11213)
+  Reps = 2_000  # The original was 10_000 but that took like 5 seconds
+
+  def test_congruent()
+    Data.each do |a, c, d, want|
+      got = GMP::Z(a).congruent?(GMP::Z(c), GMP::Z(d))
+      assert_equal(want, got, "congruent? should produce the correct result for #{a}, #{c}, #{d}")
+    end
+
+    Reps.times do
+      size = RS.urandomb(32)
+      size = RS.urandomb((size % 16 + 1).to_i)
+      a = RS.rrandomb(size.to_i)
+
+      size = RS.urandomb(32)
+      size = RS.urandomb((size % 16 + 1).to_i)
+      c = RS.rrandomb(size.to_i)
+
+      d = 0
+      until d != 0
+        size = RS.urandomb(32)
+        size = RS.urandomb((size % 16 + 1).to_i)
+        d = RS.rrandomb(size.to_i)
+      end
+
+      a = negrandom(a)
+      c = negrandom(c)
+      d = negrandom(d)
+
+      ra = a.fmod d
+      rc = c.fmod d
+      want = (ra <=> rc) == 0
+
+      got = GMP::Z(a).congruent?(GMP::Z(c), GMP::Z(d))
+      assert_equal(want, got, "congruent? should produce the correct result for #{a}, #{c}, #{d}")
+
+      ra = ra - rc
+      a  =  a - ra
+
+      got = GMP::Z(a).congruent?(GMP::Z(c), GMP::Z(d))
+      assert_equal(true, got, "congruent? should produce the correct result for #{a}, #{c}, #{d}")
+    end
+  end
+
+  def negrandom(z)
+    return (RS.urandomb(1) != 0) ? z.neg : z
+  end
+end

data/test/tc_z_export_import.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class TC_Z_ExportImport < Test::Unit::TestCase
+  def setup
+    @a = GMP::Z.new(3)**40
+  end
+
+  def test_export_import_identity
+    assert_equal(@a, GMP::Z.import(@a.export),         "An integer should export and then import to itself")
+    assert_equal(@a, GMP::Z.import(@a.export(-1)),     "An integer should export and then import to itself")
+    assert_equal(@a, GMP::Z.import(@a.export, -1),     "An integer should export and then import to itself")
+    assert_equal(@a, GMP::Z.import(@a.export(-1), -1), "An integer should export and then import to itself")
+  end
+
+  def test_export_import_order
+    assert_equal(@a, GMP::Z.import(@a.export(1), 1), "An integer should export and then import to itself")
+
+    assert_false(@a == GMP::Z.import(@a.export( 1), -1), "An integer exported one way and then imported should not be equal")
+    assert_false(@a == GMP::Z.import(@a.export(-1),  1), "An integer exported one way and then imported should not be equal")
+  end
+end

data/test/unit_tests.rb

@@ -13,6 +13,7 @@ require './tc_z_addmul'
 require './tc_z_submul'
 require './tc_z_logic'
 require './tc_z_exponentiation'
+require './tc_z_export_import'
 require './tc_z_hamdist'
 require './tc_z_io'
 require './tc_z_to_dis'
@@ -32,7 +33,9 @@ require './tc_random'
 require './tc_hashes'
 require './tc_z_functional_mappings'
 
+require './gmp_tcong'
 require './gmp_tgcd'
+require './gmp_tlcm'
 require './gmp_tprintf'
 
 begin

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gmp
 version: !ruby/object:Gem::Version
-  version: 0.6.17
+  version: 0.6.19
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-13 00:00:00.000000000 Z
+date: 2012-12-31 00:00:00.000000000 Z
 dependencies: []
 description: gmp - providing Ruby bindings to the GMP library.
 email:
@@ -36,6 +36,7 @@ files:
 - ext/takeover.h
 - ext/extconf.rb
 - lib/gmp.rb
+- test/gmp_tcong.rb
 - test/gmp_tgcd.rb
 - test/gmp_tlcm.rb
 - test/gmp_tprintf.rb
@@ -68,6 +69,7 @@ files:
 - test/tc_z_addmul.rb
 - test/tc_z_basic.rb
 - test/tc_z_exponentiation.rb
+- test/tc_z_export_import.rb
 - test/tc_z_functional_mappings.rb
 - test/tc_z_gcd_lcm_invert.rb
 - test/tc_z_hamdist.rb