gmp 0.4.0-x86-mingw32

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/extconf.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require 'mkmf'
+
+dir_config('gmp')
+dir_config('mpfr')
+
+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
+
+if (have_header('mpfr.h') and
+    have_header('mpf2mpfr.h') and
+    have_library('mpfr', 'mpfr_init'))
+  $CFLAGS += ' -DMPFR'
+end
+
+$CFLAGS += ' -Wall -W -O6 -g'
+if ok
+  create_makefile('gmp')
+else
+  raise "Unable to build, correct above errors and rerun"
+end

data/ext/gmp.c

@@ -0,0 +1,197 @@
+/*
+ * gmp.c
+ *
+ * This file contains everything you would expect from a C extension.
+ */
+
+#include <ruby_gmp.h>
+
+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_gmprandstate_free(void *ptr) { gmp_randclear (ptr); free (ptr); }
+
+static void mpq_str_set(MP_RAT *ROP, char *str)
+{
+  int i=0;
+
+  while (str[i] && str[i] != '/')
+    i++;
+
+  if (str[i])
+  {
+    str[i] = 0; /* You didn't see that :) */
+    mpz_set_str (mpq_numref(ROP), str, 0);
+    str[i] = '/';
+    mpz_set_str (mpq_denref(ROP), str+i+1, 0);
+  } else {
+    mpz_set_str (mpq_numref(ROP), str, 0);
+    mpz_set_ui (mpq_denref(ROP), 1);
+  }
+  mpq_canonicalize (ROP);
+}
+
+static VALUE r_gmpq_initialize(int argc, VALUE *argv, VALUE self)
+{
+  MP_RAT *self_val, *arg_val;
+
+  if (argc != 0) {
+    mpq_get_struct(self, self_val);
+    if (argc == 1 && GMPQ_P(argv[0])) {
+      mpq_get_struct(argv[0], arg_val);
+      mpq_set (self_val, arg_val);
+    } else if (argc == 1 && STRING_P(argv[0])) {
+      mpq_str_set (self_val, STR2CSTR(argv[0]));
+    } else {
+      mpz_set_value (mpq_numref(self_val), argv[0]);
+      if (argc == 2) {
+        mpz_set_value (mpq_denref(self_val), argv[1]);
+        mpq_canonicalize(self_val);
+      }
+    }
+  }
+  return Qnil;
+}
+
+/* don't pass GMP::F here, it should be handled separately */
+void mpf_set_value(MP_FLOAT *self_val, VALUE arg)
+{
+  MP_RAT *arg_val_q;
+  MP_INT *arg_val_z;
+
+  if (GMPQ_P(arg)) {
+    mpq_get_struct(arg, arg_val_q);
+    mpf_set_q(self_val, arg_val_q);
+  } else if (GMPZ_P(arg)) {
+    mpz_get_struct(arg, arg_val_z);
+    mpf_set_z(self_val, arg_val_z);
+  } else if (FLOAT_P(arg)) {
+    mpf_set_d(self_val, NUM2DBL(arg));
+  } else if (FIXNUM_P(arg)) {
+    mpf_set_si(self_val, FIX2INT(arg));
+  } else if (STRING_P(arg)) {
+    if (mpf_set_str(self_val, STR2CSTR(arg), 10) == -1) {
+      rb_raise(rb_eRuntimeError, "Badly formatted string");
+    }
+  } else if (BIGNUM_P(arg)) {
+#if 1 /* GMP3 code */
+    mpz_temp_from_bignum(arg_val_z, arg);
+    mpf_set_z(self_val, arg_val_z);
+    mpz_temp_free(arg_val_z);
+#endif
+  } else {
+    rb_raise(rb_eTypeError, "Don't know how to convert %s into GMP::F", rb_class2name(rb_class_of(arg)));
+  }
+}
+
+static VALUE r_gmpz_coerce(VALUE self, VALUE arg)
+{
+  return rb_assoc_new(r_gmpzsg_new(1, &arg, cGMP_Z), self);
+}
+
+static VALUE r_gmpq_coerce(VALUE self, VALUE arg)
+{
+  return rb_assoc_new(r_gmpqsg_new(1, &arg, cGMP_Q), self);
+}
+
+static VALUE r_gmpf_coerce(VALUE self, VALUE arg)
+{
+  return rb_assoc_new(r_gmpfsg_new(1, &arg, cGMP_F), self);
+}
+
+static VALUE r_gmpfsg_get_default_prec(VALUE klass)
+{
+  (void)klass;
+  return INT2NUM(mpf_get_default_prec());
+}
+
+static VALUE r_gmpfsg_set_default_prec(VALUE klass, VALUE arg)
+{
+  (void)klass;
+  if (FIXNUM_P(arg)) {
+    if (FIX2INT(arg) <= 0) {
+      rb_raise(rb_eRangeError, "prec must be positive");
+    }
+    mpf_set_default_prec (FIX2INT(arg));
+  } else {
+    rb_raise(rb_eTypeError, "prec must be FixNum");
+  }
+  return Qnil;
+}
+
+#include "gmpf.h"
+#include "gmpq.h"
+/* #include "gmpz.h" */
+#include "takeover.h"
+
+#define REGISTER_TAKEOVER(fname, ruby_fname, old_fname) \
+  rb_define_alias(rb_cFixnum, old_fname, ruby_fname); \
+  rb_define_method(rb_cFixnum, ruby_fname, takeover_fixnum_##fname, -1); \
+  rb_define_alias(rb_cBignum, old_fname, ruby_fname); \
+  rb_define_method(rb_cBignum, ruby_fname, takeover_bignum_##fname, -1);
+
+void Init_gmp() {
+  mGMP = rb_define_module("GMP");
+  rb_define_const(mGMP, "GMP_VERSION", rb_str_new2(gmp_version));
+
+  cGMP_Z = rb_define_class_under(mGMP, "Z", rb_cInteger);
+  init_gmpz();
+  rb_define_method(cGMP_Z, "coerce", r_gmpz_coerce, 1);
+
+  cGMP_Q = rb_define_class_under (mGMP, "Q", rb_cNumeric);
+  init_gmpq();
+  rb_define_method(cGMP_Q, "initialize", r_gmpq_initialize, -1);
+  rb_define_method(cGMP_Q, "coerce", r_gmpq_coerce, 1);
+  rb_define_method(cGMP_Q, "num", r_gmpq_num, 0);
+  rb_define_method(cGMP_Q, "den", r_gmpq_den, 0);
+
+  cGMP_F = rb_define_class_under (mGMP, "F", rb_cNumeric);
+  init_gmpf();
+  rb_define_singleton_method(cGMP_F, "default_prec", r_gmpfsg_get_default_prec, 0);
+  rb_define_singleton_method(cGMP_F, "default_prec=", r_gmpfsg_set_default_prec, 1);
+  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);
+  rb_define_method(cGMP_F, "log", r_gmpfr_log, 0);
+  rb_define_method(cGMP_F, "sqrt", r_gmpfr_sqrt, 0);
+  rb_define_method(cGMP_F, "cos", r_gmpfr_cos, 0);
+  rb_define_method(cGMP_F, "sin", r_gmpfr_sin, 0);
+  rb_define_method(cGMP_F, "tan", r_gmpfr_tan, 0);
+  rb_define_method(cGMP_F, "acos", r_gmpfr_acos, 0);
+  rb_define_method(cGMP_F, "asin", r_gmpfr_asin, 0);
+  rb_define_method(cGMP_F, "atan", r_gmpfr_atan, 0);
+  rb_define_method(cGMP_F, "cosh", r_gmpfr_cosh, 0);
+  rb_define_method(cGMP_F, "sinh", r_gmpfr_sinh, 0);
+  rb_define_method(cGMP_F, "tanh", r_gmpfr_tanh, 0);
+  rb_define_method(cGMP_F, "acosh", r_gmpfr_acosh, 0);
+  rb_define_method(cGMP_F, "asinh", r_gmpfr_asinh, 0);
+  rb_define_method(cGMP_F, "atanh", r_gmpfr_atanh, 0);
+  rb_define_method(cGMP_F, "log1p", r_gmpfr_log1p, 0);
+  rb_define_method(cGMP_F, "expm1", r_gmpfr_expm1, 0);
+  rb_define_method(cGMP_F, "log2", r_gmpfr_log2, 0);
+  rb_define_method(cGMP_F, "log10", r_gmpfr_log10, 0);
+
+  rb_define_method(cGMP_F, "nan?", r_gmpfr_nan_p, 0);
+  rb_define_method(cGMP_F, "infinite?", r_gmpfr_inf_p, 0);
+  rb_define_method(cGMP_F, "finite?", r_gmpfr_fin_p, 0);
+  rb_define_method(cGMP_F, "number?", r_gmpfr_number_p, 0);
+
+  rb_define_method(cGMP_F, "**", r_gmpfr_pow, 1);
+#endif /* MPFR */
+  // more
+
+  REGISTER_TAKEOVER(and, "&", "old_and")
+  REGISTER_TAKEOVER(or, "|", "old_or")
+  REGISTER_TAKEOVER(xor, "^", "old_xor")
+  /* takeover cmpabs ? */
+}