gmp 0.4.0-x86-mingw32

data/benchmark/README

@@ -0,0 +1,75 @@
+GMPbench
+
+Copyright 2003, 2008 Free Software Foundation, Inc.
+
+This file is part of GMPbench.
+
+GMPbench 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 3 of the License, or (at your option)
+any later version.
+
+GMPbench 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 the GMPbench.  If not, see http://www.gnu.org/licenses/.
+
+
+For this version of GMPbench, there are just 6 parts:
+
+	[Multiply large numbers]
+	base.multiply (weight 1)
+
+	[Divide numbers of different sizes]
+	base.divide (weight 1)
+
+	[Compute the greatest common divisor]
+	base.gcd (weight 0.5)
+
+	[Compute the extended greatest common divisor]
+	base.gcdext (weight 0.5)
+
+	[Compute the square root]
+	base.sqrt (weight 0.5)
+
+	[Compute the nth root]
+	base.root (weight 0.5)
+
+	[Run the RSA encryption algorithm]
+	app.rsa (weight 1)
+
+	[Compute digits of Pi]
+	app.pi (weight 1)
+
+
+Result scores are computed as a weighted geometric mean.  Please use the included
+script runbench for running the benchmarks and computing benchmark scores.
+
+Guidelines:
+
+  1. If benchmark code is changed, results are invalid and should not be
+     reported as GMPbench results.  Compilation parameters may be changed,
+     as long as the same parameters are used for all GMP source files and
+     for all benchmark files.
+  2. If GMP source is changed, results should not be reported as GMPbench
+     results unless the following three conditions are met:
+     A. It is clearly stated that GMP was changed when reporting results.
+     B. The changes are generic and reasonable and not specifically targeted
+	towards improving some aspect specifically exercised by the benchmark
+	suite.
+     C. All rights to the changes are assigned to the Free Software
+	Foundation prior to publication of the benchmark results.
+  3. As long as these rules are followed, results may be freely used.
+     Please also report results to the GMP developer's mailing list
+     gmp-devel@swox.com.
+  4. When reporting results, this data should be included:
+     A. Machine type and model
+     B. CPU type and clock frequency
+     C. GMP version used
+     D. List of modifications as permitted above
+     E. Compiler and compiler version used
+     F. Compiler options used
+  5. The benchmark suite is believed to be compatible with GMP 4.1 or later.

data/benchmark/divide

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require '../ext/gmp'
+
+dividend = ARGV[0].to_i
+divisor = ARGV[1].to_i
+random_state = GMP::RandState.new
+
+x = random_state.urandomb(dividend)
+y = random_state.urandomb(divisor)
+
+t = GMP::time { z = x.tdiv y }
+iterations = (1 + (1e4 / t)).to_i
+
+print "Dividing an %i-bit number by an %i-bit number %i times..." % [dividend, divisor, iterations]
+STDOUT.flush
+
+t0 = GMP::cputime
+iterations.times do
+  z = x.tdiv 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/gcd

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require '../ext/gmp'
+
+m = ARGV[0].to_i
+n = ARGV[1].to_i
+random_state = GMP::RandState.new
+
+x = random_state.urandomb(m)
+y = random_state.urandomb(n)
+
+print "Calibrating CPU speed..."
+STDOUT.flush
+t = GMP::time { z = x.gcd(y) }
+puts "done"
+
+iterations = (1 + (1e4 / t)).to_i
+
+print "Calculating the gcd of a %i-bit number and a %i-bit number %i times..." % [m, n, iterations]
+STDOUT.flush
+
+t0 = GMP::cputime
+iterations.times do
+  z = x.gcd(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/gexpr.c

@@ -0,0 +1,359 @@
+/* Expression evaluation using plain floating-point arithmetic.
+   Copyright 1999, 2000, 2001, 2002, 2003, 2006 Free Software Foundation, Inc.
+
+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, 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; see the file COPYING.  If not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.  */
+
+#include <math.h>
+#include <ctype.h>
+#include <setjmp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+jmp_buf top;
+
+static char *bp, *expr_start_p, *expr_end_p;
+static int ch;
+static int previous_result_valid_flag;
+double previous_result;
+
+double term (void), expo (void), factor (void), number (void);
+
+#define next skip ()
+
+void
+skip (void)
+{
+  do
+    ch = *bp++;
+  while (ch == ' ' || ch == '\n');
+}
+
+void
+error (void)
+{
+  fprintf (stderr, "%s\n", expr_start_p);
+  fprintf (stderr, "%*s^ syntax error\n", (int) (bp - expr_start_p) - 1, "");
+  longjmp (top, 1);
+}
+
+double
+expr (void)
+{
+  double e;
+  if (ch == '+')
+    {
+      next;
+      e = term ();
+    }
+  else if (ch == '-')
+    {
+      next;
+      e = - term ();
+    }
+  else
+    e = term ();
+  while (ch == '+' || ch == '-')
+    { char op;
+      op = ch;
+      next;
+      if (op == '-')
+	e -= term ();
+      else
+	e += term ();
+    }
+  return e;
+}
+
+double
+term (void)
+{
+  double t;
+  t = expo ();
+  for (;;)
+    switch (ch)
+      {
+      case '*':
+	next;
+	t *= expo ();
+	break;
+      case '/':
+	next;
+	t /= expo ();
+	break;
+      case '%':
+	next;
+	t = fmod (t, expo ());
+	break;
+      default:
+	return t;
+      }
+}
+
+double
+expo (void)
+{
+  double e;
+  e = factor ();
+  if (ch == '^')
+    {
+      next;
+      e = pow (e, expo ());
+    }
+  return e;
+}
+
+struct functions
+{
+  char *spelling;
+  double (* evalfn) ();
+};
+
+double
+my_log2 (double x)
+{
+  return log (x) * 1.4426950408889634073599246810019;
+}
+
+struct functions fns[] =
+{
+  {"log2", my_log2},
+  {"log10", log10},
+  {"log", log},
+  {"exp", exp},
+  {"sqrt", sqrt},
+  {"floor", floor},
+  {"ceil", ceil},
+  {"sin", sin},
+  {"cos", cos},
+  {"tan", tan},
+  {"asin", asin},
+  {"acos", acos},
+  {"atan", atan},
+  {"sinh", sinh},
+  {"cosh", cosh},
+  {"tanh", tanh},
+  {"asinh", asinh},
+  {"acosh", acosh},
+  {"atanh", atanh},
+  {0, 0}
+};
+
+
+double
+factor (void)
+{
+  double f;
+  int i;
+
+  for (i = 0; fns[i].spelling != 0; i++)
+    {
+      char *spelling = fns[i].spelling;
+      int len = strlen (spelling);
+      if (strncmp (spelling, bp - 1, len) == 0 && ! isalnum (bp[-1 + len]))
+	{
+	  bp += len - 1;
+	  next;
+	  if (ch != '(')
+	    error ();
+	  next;
+	  f = expr ();
+	  if (ch != ')')
+	    error ();
+	  next;
+	  return (fns[i].evalfn) (f);
+	}
+    }
+
+  if (ch == '(')
+    {
+      next;
+      f = expr ();
+      if (ch == ')')
+	next;
+      else
+	error ();
+    }
+  else
+    f = number ();
+  if (ch == '!')
+    {
+      unsigned long n;
+      if (floor (f) != f)
+	error ();
+      for (n = f, f = 1; n > 1; n--)
+	f *= n;
+      next;
+    }
+  return f;
+}
+
+double
+number (void)
+{
+  double n;
+  char *endp;
+
+  if (strncmp ("pi", bp - 1, 2) == 0 && ! isalnum (bp[1]))
+    {
+      bp += 2 - 1;
+      next;
+      return 3.1415926535897932384626433832795;
+    }
+  if (ch == '$')
+    {
+      if (! previous_result_valid_flag)
+	error ();
+      next;
+      return previous_result;
+    }
+  if (ch != '.' && (ch < '0' || ch > '9'))
+    error ();
+  n = strtod (bp - 1, &endp);
+  if (endp == bp - 1)
+    error ();
+  bp = endp;
+  next;
+  return n;
+}
+
+int nl_flag = 1;
+int hhmm_flag = 0;
+int dhhmm_flag = 0;
+int round_flag = 0;
+int prec = 5;
+
+void
+output (double exp)
+{
+  int h, m;
+  if (hhmm_flag)
+    {
+      m = exp * 60;
+      h = m / 60;
+      m -= h * 60;
+      printf ("%02d:%02d", h, m);
+    }
+  else if (dhhmm_flag)
+    {
+      int d;
+      m = exp * (24 * 60);
+      d = m / (24 * 60);
+      m -= d * (24 * 60);
+      h = m / 60;
+      m -= h * 60;
+      printf ("%dd %02d:%02d", d, h, m);
+    }
+  else
+    printf ("%.*g", prec, exp);
+  if (nl_flag)
+    puts ("");
+  previous_result = exp;
+  previous_result_valid_flag = 1;
+}
+
+int
+main (int argc, char **argv)
+{
+  while (argc >= 2)
+    {
+      if (!strcmp (argv[1], "-n"))
+	{
+	  nl_flag = 0;
+	  argv++;
+	  argc--;
+	}
+      else if (!strcmp (argv[1], "-hhmm"))
+	{
+	  hhmm_flag = 1;
+	  argv++;
+	  argc--;
+	}
+      else if (!strcmp (argv[1], "-dhhmm"))
+	{
+	  dhhmm_flag = 1;
+	  argv++;
+	  argc--;
+	}
+      else if (!strcmp (argv[1], "-round"))
+	{
+	  round_flag = 1;
+	  argv++;
+	  argc--;
+	}
+      else if (!strcmp (argv[1], "-prec"))
+	{
+	  prec = atoi (argv[2]);
+	  argv += 2;
+	  argc -= 2;
+	}
+      else if (!strcmp (argv[1], "-help") || !strcmp (argv[1], "-h"))
+	{
+	  printf ("usage: %s [options] expr [expr ... ]\n", argv[0]);
+	  printf ("   options:    -n      -- suppress newline\n");
+	  printf ("               -prec n -- print n digits\n");
+	  printf ("               -round  -- round to nearest integer\n");
+	  printf ("               -hhmm   -- print in base 60 (time format)\n");
+	  printf ("               -dhhmm  -- print in base 24,60,60 (time format)\n");
+	  printf ("               -help   -- you've figured out that one\n");
+	  exit (0);
+	}
+      else
+	break;
+    }
+
+  if (argc >= 2)
+    {
+      int i;
+      double exp;
+
+      for (i = 1; i < argc; i++)
+	{
+	  expr_start_p = argv[i];
+	  expr_end_p = expr_end_p + strlen (expr_start_p);
+	  bp = expr_start_p;
+	  next;
+	  if (setjmp (top) == 0)
+	    {
+	      exp = expr ();
+	      if (round_flag)
+		exp = floor (exp + 0.5);
+	      output (exp);
+	    }
+	}
+    }
+  else
+    {
+#define BUFSIZE 1024
+      char buf[BUFSIZE];
+      double exp;
+
+      for (;;)
+	{
+	  fputs ("eval> ", stdout);
+	  bp = fgets (buf, BUFSIZE, stdin);
+	  if (bp == NULL)
+	    break;
+	  next;
+	  if (setjmp (top) == 0)
+	    {
+	      exp = expr ();
+	      if (round_flag)
+		exp = floor (exp + 0.5);
+	      output (exp);
+	    }
+	}
+    }
+
+  exit (0);
+}