gmp 0.2.2 → 0.4.0

data/benchmark/multiply

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require '../ext/gmp'
+
+multiplicands = ARGV
+random_state = GMP::RandState.new
+
+if multiplicands.size > 1
+  m, n = multiplicands[0].to_i, multiplicands[1].to_i
+  x = random_state.urandomb(m)
+  y = random_state.urandomb(n)
+else
+  m = multiplicands[0].to_i
+  x = random_state.urandomb(m)
+  y = x
+end
+
+t = GMP::time { z = x * y }
+iterations = (1 + (1e4 / t)).to_i
+
+if multiplicands.size > 1
+  print "Multiplying %i-bit number with %i-bit number %i times..." % [m, n, iterations]
+else
+  print "Squaring a %i-bit number %i times..." % [m, iterations]
+end
+STDOUT.flush
+
+t0 = GMP::cputime
+iterations.times do
+  z = x * y
+end
+ti = GMP::cputime - t0
+  
+puts "done!"
+ops_per_sec = 1000.0 * iterations / ti
+f = 100.0
+decimals = 0
+while true
+  decimals += 1
+  break if ops_per_sec > f
+  f = f * 0.1
+end
+
+puts "RESULT: %#{decimals}f operations per second\n" % ops_per_sec

data/benchmark/rsa

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+
+require '../ext/gmp'
+
+RSA_EXP = 0x10001
+
+def rsa_sign(msg, p, q, pq, p_i_q, dp, dq)
+  pr = msg.powmod(dp, p)
+  qr = msg.powmod(dq, q)
+  
+  qr_m_pr = qr - pr
+  
+  t = qr_m_pr * p_i_q
+  o = t % q
+  
+  t = o * p
+  smsg = pr + t
+  smsg % pq
+end
+
+n = ARGV[0].to_i
+random_state = GMP::RandState.new
+
+print "Generating p, q, d..."
+STDOUT.flush
+
+pq = GMP::Z()
+while pq != 1
+  p = random_state.urandomb(n/2)
+  p[n/2 - 1] = true
+  p[n/2 - 2] = true
+  p[0]       = true
+  
+  q = random_state.urandomb(n/2)
+  q[n/2 - 1] = true
+  q[n/2 - 2] = true
+  q[0]       = true
+  
+  pq = p.gcd(q)
+end
+
+pq = p * q
+
+e = GMP::Z(RSA_EXP)
+
+pm1 = p - 1
+qm1 = q - 1
+phi = pm1 * qm1
+d = e.invert(phi)
+
+puts "done; pq is %i bits" % pq.sizeinbase(2)
+puts "Precomputing CRT constants"
+
+p_i_q = p.invert(q)
+
+dp = d % pm1
+dq = d % qm1
+
+puts "Generating random messages"
+
+msg = []
+(0...1024).each do |i|
+  msg << random_state.urandomb(n)
+end
+
+print "Calibrating CPU speed..."
+STDOUT.flush
+t = GMP::time { smsg = rsa_sign(msg[0], p, q, pq, p_i_q, dp, dq) }
+puts "done"
+
+iterations = (1e4 / t).to_i
+iterations = 1 if iterations == 0
+
+print "Signing random messages %i times..." % iterations
+STDOUT.flush
+
+t0 = GMP::cputime
+(1..iterations).to_a.reverse.each do |i|
+  smsg = rsa_sign(msg[i % 1024], p, q, pq, p_i_q, dp, dq)
+end
+ti = GMP::cputime - t0
+  
+puts "done!"
+ops_per_sec = 1000.0 * iterations / ti
+f = 100.0
+decimals = 0
+while true
+  decimals += 1
+  break if ops_per_sec > f
+  f = f * 0.1
+end
+
+puts "RESULT: %#{decimals}f operations per second\n" % ops_per_sec

data/benchmark/runbench

@@ -0,0 +1,147 @@
+#! /bin/sh
+
+# Copyright 2003 Free Software Foundation, Inc.
+
+# This file is part of the GNU GMPbench.
+
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+# Place - Suite 330, Boston, MA 02111-1307, USA.
+
+
+echo "***** GMPbench version `cat version` *****"
+
+
+default=false
+
+if [ "$1" = -n ]
+  then
+    echo "Suppressing compilation"
+  else
+    if [ -z "$CFLAGS" ]
+      then
+	CFLAGS="-O3 -fomit-frame-pointer"
+	echo "Using default CFLAGS = \"$CFLAGS\""
+	default=true
+      else
+	echo "Using CFLAGS = \"$CFLAGS\" from your environment"
+      fi
+    if [ -z "$CC" ]
+      then
+	CC="gcc"
+	echo "Using default CC = \"$CC\""
+	default=true
+      else
+	echo "Using CC = \"$CC\" from your environment"
+      fi
+    if [ -z "$LIBS" ]
+      then
+	LIBS="-static -lgmp"
+	echo "Using default LIBS = \"$LIBS\""
+	default=true
+      else
+	echo "Using LIBS = \"$LIBS\" from your environment"
+      fi
+
+    echo "Using compilation command: $CC $CFLAGS foo.c -o foo $LIBS"
+
+    if $default
+      then
+	echo "You may want to override CC, CFLAGS, and LIBS"
+      fi
+
+    $CC $CFLAGS gmpver.c $LIBS
+    `mv a.exe a.out`
+    echo "Using `./a.out`"
+
+    echo "Compiling benchmarks"
+    $CC $CFLAGS gcd.c -o gcd $LIBS
+    $CC $CFLAGS gcdext.c -o gcdext $LIBS
+    $CC $CFLAGS multiply.c -o multiply $LIBS
+    $CC $CFLAGS divide.c -o divide $LIBS
+    $CC $CFLAGS rsa.c -o rsa $LIBS
+    $CC $CFLAGS pi.c -o pi $LIBS -lm
+  fi
+
+multiply_args="128 512 8192 131072 2097152 128,128 512,512 8192,8192 131072,131072 2097152,2097152 15000,10000 20000,10000 30000,10000 16777216,512 16777216,262144"
+multiply_weight=1
+
+divide_args="8192,32 8192,64 8192,128 8192,4096 131072,65536 8388608,4194304 8192,8064 16777216,262144"
+divide_weight=1
+
+gcd_args="128,128 512,512 8192,8192 131072,131072 1048576,1048576"
+gcd_weight=0.5
+
+gcdext_args="128,128 512,512 8192,8192 131072,131072 1048576,1048576"
+gcdext_weight=0.5
+
+rsa_args="512 1024 2048"
+rsa_weight=1
+
+pi_args="10000 100000 1000000"
+pi_weight=1
+
+# base_tests="multiply divide gcd gcdext"
+base_tests="multiply divide gcd"
+# app_tests="rsa pi"
+app_tests="rsa"
+
+tests="base app"
+
+echo "Running benchmarks (propagated score accuracy exceeds printed intermediates)"
+
+acc2=1
+n2=0
+for cat in $tests
+  do
+    echo "  Category $cat"
+    eval tests=\$${cat}_tests
+
+    acc1=1
+    n1=0
+    for t in $tests
+      do
+	eval weight=\$${t}_weight
+	echo "    Program $t (weight=$weight)"
+	eval args=\$${t}_args
+
+	acc=1
+	n=0
+	for a in $args
+	  do
+	    ta=`echo $a | sed 's;,; ;g'`
+	    printf '      %-48s' "GMPbench.$cat.$t($a)"
+	    ./$t $ta >RES-$t-$a
+	    res=`grep "^RESULT" RES-$t-$a | sed 's;^RESULT: \([0-9.]*\).*$;\1;'`
+	    printf '%12s\n' `gexpr -prec 4 "$res"`
+	    acc=`gexpr -prec 10 "$acc * $res"`
+	    n=`gexpr $n+1`
+	  done
+
+	out=`gexpr -prec 10 "$acc^(1/$n)"`
+	printf '    %-40s%12s\n' "GMPbench.$cat.$t" `gexpr -prec 5 "$out"`
+	acc1=`gexpr -prec 10 "$acc1 * $out^$weight"`
+	n1=`gexpr $n1+$weight`
+      done
+
+    out=`gexpr -prec 10 "$acc1^(1/$n1)"`
+    printf '  %-32s%12s\n' "GMPbench.$cat" `gexpr -prec 5 "$out"`
+    acc2=`gexpr -prec 10 "$acc2 * $out"`
+    n2=`gexpr $n2+1`
+  done
+
+
+out=`gexpr "$acc2^(1/$n2)"`
+echo "GMPbench:         $out"
+
+exit 0

data/benchmark/version

@@ -0,0 +1 @@
+0.2

data/ext/gmp.c

@@ -6,11 +6,12 @@
 
 #include <ruby_gmp.h>
 
-VALUE mGMP, cGMP_Z, cGMP_Q, cGMP_F;
+VALUE mGMP, cGMP_Z, cGMP_Q, cGMP_F, cGMP_RandState;
 
-void r_gmpz_free(void *ptr) { mpz_clear (ptr); free (ptr); }
-void r_gmpq_free(void *ptr) { mpq_clear (ptr); free (ptr); }
-void r_gmpf_free(void *ptr) { mpf_clear (ptr); free (ptr); }
+void r_gmpz_free(void *ptr)         { mpz_clear (ptr);     free (ptr); }
+void r_gmpq_free(void *ptr)         { mpq_clear (ptr);     free (ptr); }
+void r_gmpf_free(void *ptr)         { mpf_clear (ptr);     free (ptr); }
+void r_gmprandstate_free(void *ptr) { gmp_randclear (ptr); free (ptr); }
 
 static void mpq_str_set(MP_RAT *ROP, char *str)
 {
@@ -138,10 +139,6 @@ void Init_gmp() {
   cGMP_Z = rb_define_class_under(mGMP, "Z", rb_cInteger);
   init_gmpz();
   rb_define_method(cGMP_Z, "coerce", r_gmpz_coerce, 1);
-/*
-  rb_define_method(cGMP_Z, "gcd",  r_gmpz_gcd, 1);
-  rb_define_method(cGMP_Z, "lcm",  r_gmpz_lcm, 1);
-*/
 
   cGMP_Q = rb_define_class_under (mGMP, "Q", rb_cNumeric);
   init_gmpq();
@@ -157,6 +154,11 @@ void Init_gmp() {
   rb_define_method(cGMP_F, "coerce", r_gmpf_coerce, 1); // new method - testing
 
 /*  rb_define_method(cGMP_F, "cmpabs",  r_gmpf_cmpabs, 1);*/
+  
+  cGMP_RandState = rb_define_class_under (mGMP, "RandState", rb_cObject);
+  init_gmprandstate();
+  
+  init_gmpbench_timing();
 
 #ifdef MPFR
   rb_define_method(cGMP_F, "exp", r_gmpfr_exp, 0);

data/ext/gmpbench_timing.c

@@ -0,0 +1,80 @@
+#include <ruby_gmp.h>
+
+/*
+ * Taken directly from GMPbench.
+ */
+
+#define TIME(t,func)                                       \
+  do {                                                     \
+    long int __t0, __times, __t, __tmp;                    \
+    __times = 1;                                           \
+    {func;}                                                \
+    do {                                                   \
+	  __times <<= 1;                                       \
+	  __t0 = FIX2INT(r_gmpmod_cputime ());                 \
+	  for (__t = 0; __t < __times; __t++)                  \
+	    {func;}                                            \
+	  __tmp = FIX2INT(r_gmpmod_cputime ()) - __t0;         \
+    } while (__tmp < 250);                                 \
+    (t) = (double) __tmp / __times;                        \
+  } while (0)
+
+/* Return user CPU time measured in milliseconds.  */
+#if !defined (__sun) \
+    && (defined (USG) || defined (__SVR4) || defined (_UNICOS) \
+	|| defined (__hpux) || defined (_WIN32))
+#include <time.h>
+
+int
+cputime ()
+{
+  return (int) ((double) clock () * 1000 / CLOCKS_PER_SEC);
+}
+#else
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+
+int
+cputime ()
+{
+  struct rusage rus;
+
+  getrusage (0, &rus);
+  return rus.ru_utime.tv_sec * 1000 + rus.ru_utime.tv_usec / 1000;
+}
+#endif
+
+VALUE
+r_gmpmod_cputime (VALUE self)
+{
+  (void)self;
+  return INT2FIX (cputime ());
+}
+
+VALUE
+r_gmpmod_time (VALUE self)
+{
+  (void)self;
+  long int __t0, __times, __t, __tmp;
+  __times = 1;
+  
+  rb_need_block();
+  
+  rb_yield (Qnil);
+  do {
+    __times <<= 1;
+    __t0 = cputime ();
+    for (__t = 0; __t < __times; __t++)
+      {rb_yield (Qnil);}
+    __tmp = cputime () - __t0;
+  } while (__tmp < 250);
+  return rb_float_new ((double) __tmp / __times);
+}
+
+void init_gmpbench_timing()
+{
+  mGMP = rb_define_module("GMP");
+  rb_define_module_function(mGMP, "cputime", r_gmpmod_cputime, 0);
+  rb_define_module_function(mGMP, "time", r_gmpmod_time, 0);
+}

data/ext/gmprandstate.c

@@ -0,0 +1,224 @@
+#include <gmpz.h>
+#include <gmpq.h>
+#include <gmpf.h>
+
+/*
+ * Document-class: GMP::Z
+ *
+ * GMP Multiple Precision Integer.
+ *
+ * Instances of this class can store variables of the type gmp_randstate_t.
+ * This class also contains many methods that act as the functions for
+ * gmp_randstate_t variables, as well as a few methods that attempt to make
+ * this library more Ruby-ish.
+ *
+ * The following list is just a simple checklist for me, really. A better
+ * reference should be found in the rdocs.
+ *
+ *   Ruby method    C Extension function     GMP function
+ *   new            r_gmprandstatesg_new     gmp_randinit_default
+ *   seed           r_gmprandstate_seed      gmp_randseed
+ *   \---           \------------------      gmp_randseed_ui
+ *   urandomb       r_gmprandstate_urandomb  mpz_urandomb
+ */
+
+/**********************************************************************
+ *    Random State Initialization                                     *
+ **********************************************************************/
+
+/*
+ * call-seq:
+ *   GMP::RandState.new()
+ *   GMP::RandState.new(:mt) #=> uses gmp_randinit_mt
+ *   GMP::RandState.new(:lc_2exp, a, c, m2exp) #=> uses gmp_randinit_lc_2exp
+ *   GMP::RandState.new(:lc_2exp_size, size) #=> uses gmp_randinit_lc_2exp_size
+ *
+ * Initializes a new Random State object. Multiple GMP::RandState objects can
+ * be instantiated. They may use different generators and the states
+ * are kept separate.
+ */
+VALUE r_gmprandstatesg_new(int argc, VALUE *argv, VALUE klass)
+{
+  MP_RANDSTATE *rs_val;
+  VALUE rs;
+  VALUE algorithm, arg2, arg3, arg4;
+  ID algorithm_id = rb_intern("default");
+  MP_INT *a_val;
+  unsigned long c_val, m2exp_val;
+  unsigned long size_val;
+  int free_a_val = 0;
+  
+  ID default_algorithm      = rb_intern("default");
+  ID mt_algorithm           = rb_intern("mt");
+  ID lc_2exp_algorithm      = rb_intern("lc_2exp");
+  ID lc_2exp_size_algorithm = rb_intern("lc_2exp_size");
+  
+  (void)klass;
+  
+  mprandstate_make_struct(rs, rs_val);
+  rb_scan_args(argc, argv, "04", &algorithm, &arg2, &arg3, &arg4);
+  if (NIL_P(algorithm))    { algorithm_id = rb_intern("default"); }  /* default value */
+  if (SYMBOL_P(algorithm)) { algorithm_id = rb_to_id(algorithm); }
+  if (algorithm_id == default_algorithm ||
+      algorithm_id == mt_algorithm) {
+    if (argc > 1)
+      rb_raise(rb_eArgError, "wrong # of arguments (%d for 0 or 1)", argc);
+    gmp_randinit_default(rs_val);
+  } else if (algorithm_id == lc_2exp_algorithm) {
+    if (argc != 4)
+      rb_raise(rb_eArgError, "wrong # of arguments (%d for 4)", argc);
+    if (GMPZ_P(arg2)) {
+      mpz_get_struct(arg2, a_val);
+    } else if (FIXNUM_P(arg2)) {
+      mpz_temp_alloc(a_val);
+      mpz_init_set_ui(a_val, FIX2INT(arg2));
+      free_a_val = 1;
+    } else if (BIGNUM_P(arg2)) {
+      mpz_temp_from_bignum(a_val, arg2);
+      free_a_val = 1;
+    } else {
+      typeerror_as(ZXB, "b");
+    }
+    c_val     = NUM2LONG(arg3);
+    m2exp_val = NUM2LONG(arg4);
+    gmp_randinit_lc_2exp(rs_val, a_val, c_val, m2exp_val);
+  } else if (algorithm_id == lc_2exp_size_algorithm) {
+    if (argc != 2)
+      rb_raise(rb_eArgError, "wrong # of arguments (%d for 2)", argc);
+    size_val = NUM2LONG(arg2);
+    if (size_val > 128)
+      rb_raise(rb_eArgError, "size must be within [0..128]");
+    int rv = gmp_randinit_lc_2exp_size(rs_val, size_val);
+    if (rv == 0)
+      rb_raise(rb_eArgError, "could not gmp_randinit_lc_2exp_size with %d", size_val);
+  }
+  
+  if (free_a_val) { mpz_temp_free(a_val); }
+  rb_obj_call_init(rs, argc, argv);
+  
+  return rs;
+}
+
+VALUE r_gmprandstate_initialize(int argc, VALUE *argv, VALUE self)
+{
+  MP_RANDSTATE *self_val;
+  (void)argv;
+
+  if (argc != 0) {
+    mprandstate_get_struct(self,self_val);
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   GMP::RandState(arg)
+ *
+ * A convenience method for +GMP::RandState.new(arg)+.
+ */
+VALUE r_gmpmod_randstate(int argc, VALUE *argv, VALUE module)
+{
+  (void)module;
+  return r_gmprandstatesg_new(argc, argv, cGMP_RandState);
+}
+
+
+/**********************************************************************
+ *    Random State Initialization                                     *
+ **********************************************************************/
+
+/*
+ * call-seq:
+ *   rand_state.seed(integer)
+ *
+ * From the GMP Manual:
+ *
+ * Set an initial seed value into state.
+ *
+ * The size of a seed determines how many different sequences of random numbers
+ * that it's possible to generate. The �quality� of the seed is the randomness
+ * of a given seed compared to the previous seed used, and this affects the
+ * randomness of separate number sequences. The method for choosing a seed is
+ * critical if the generated numbers are to be used for important applications,
+ * such as generating cryptographic keys.
+ *
+ * Traditionally the system time has been used to seed, but care needs to be
+ * taken with this. If an application seeds often and the resolution of the
+ * system clock is low, then the same sequence of numbers might be repeated.
+ * Also, the system time is quite easy to guess, so if unpredictability is
+ * required then it should definitely not be the only source for the seed
+ * value. On some systems there's a special device /dev/random which provides
+ * random data better suited for use as a seed.
+ */
+VALUE r_gmprandstate_seed(VALUE self, VALUE arg)
+{
+  MP_RANDSTATE *self_val;
+  MP_INT *arg_val;
+
+  mprandstate_get_struct(self,self_val);
+  
+  if (GMPZ_P(arg)) {
+    mpz_get_struct(arg,arg_val);
+    gmp_randseed(self_val, arg_val);
+  } else if (FIXNUM_P(arg)) {
+    gmp_randseed_ui(self_val, FIX2INT(arg));
+  } else if (BIGNUM_P(arg)) {
+    mpz_temp_from_bignum(arg_val, arg);
+    gmp_randseed(self_val, arg_val);
+  } else {
+    typeerror(ZXB);
+  }
+  return arg;
+}
+
+
+/**********************************************************************
+ *    Integer Random Numbers                                          *
+ **********************************************************************/
+
+/*
+ * call-seq:
+ *   rand_state.urandomb(fixnum)
+ *
+ * From the GMP Manual:
+ *
+ * Generate a uniformly distributed random integer in the range 0 to
+ * 2^fixnum-1, inclusive. 
+ */
+VALUE r_gmprandstate_urandomb(VALUE self, VALUE arg)
+{
+  MP_RANDSTATE *self_val;
+  MP_INT *res_val;
+  VALUE res;
+
+  mprandstate_get_struct(self,self_val);
+  
+   if (FIXNUM_P(arg)) {
+    mpz_make_struct_init(res, res_val);
+    mpz_urandomb(res_val, self_val, FIX2INT(arg));
+  } else {
+    typeerror(X);
+  }
+  
+  return res;
+}
+
+
+void init_gmprandstate()
+{
+  mGMP = rb_define_module("GMP");
+  rb_define_module_function(mGMP, "RandState", r_gmpmod_randstate, -1);
+
+  cGMP_RandState = rb_define_class_under(mGMP, "RandState", rb_cObject);
+
+  // Random State Initialization
+  rb_define_singleton_method(cGMP_RandState, "new", r_gmprandstatesg_new, -1);
+  rb_define_method(cGMP_RandState, "initialize", r_gmprandstate_initialize, -1);
+  
+  // Random State Seeding
+  rb_define_method(cGMP_RandState, "seed", r_gmprandstate_seed, 1);
+  
+  // Integer Random Numbers
+  rb_define_method(cGMP_RandState, "urandomb", r_gmprandstate_urandomb, 1);
+  
+}