gmp 0.1.7

data/CHANGELOG

@@ -0,0 +1,47 @@
+0.1.6.2:
+  * Added optional argument to GMP::Z.to_s. Supply base as either a Fixnum or
+    a Symbol like :hex to get the string in a different base.
+
+0.1.6:
+  * Tested on OS X 10.5.8 with Ruby 1.9.1. It's a go!
+  * Tested on LinuxMint 7 with Ruby 1.8.7. It's a go! Ping me if you have Linux
+    problems.
+  * Added documentation.
+  * Cleaned up source.
+  * Added tests: tc_swap, tc_floor_ceil_truncate, tc_to_i_to_d
+
+0.1.5:
+ * Merged in reorg changes: Files like gmpz.c allow for documenting the C
+   extension methods.
+ * A good portion of the documentation has been written, may not be included
+   yet, but can be generated with
+   rdoc README.rdoc ext/*.c ext/*.h
+
+0.1.4:
+ * Fixed a lot of gemspec problems
+ * Many more tests
+ * Tested on OS X 10.5.8
+
+0.1.1:
+* Attempting to revitalize through GitHub
+* no changes to code yet
+* modernizing files, eg with new ruby standards, towards a gem
+
+1.0:
+* MPFR support
+* better string conversion
+* Debian package
+
+alpha9:
+* more GMP::F code
+* GMP::Z division
+
+alpha8:
+* various minor changes
+
+alpha7:
+* more GMP::F code
+
+alpha6:
+* basic support for GMP::F
+* various minor changes

data/INSTALL

@@ -0,0 +1,4 @@
+To compile:
+$ ./extconf.rb
+$ make
+$ make install

data/README.rdoc

@@ -0,0 +1,257 @@
+=gmp
+
+gmp is library providing Ruby bindings to GMP library. Here is the introduction
+paragraph at http://gmplib.org/#WHAT :
+
+* "GMP is a free library for arbitrary precision arithmetic, operating on
+  signed integers, rational numbers, and floating point numbers. There is no
+  practical limit to the precision except the ones implied by the available
+  memory in the machine GMP runs on. GMP has a rich set of functions, and the
+  functions have a regular interface.
+
+* The main target applications for GMP are cryptography applications and
+  research, Internet security applications, algebra systems, computational
+  algebra research, etc.
+
+* GMP is carefully designed to be as fast as possible, both for small operands
+  and for huge operands. The speed is achieved by using fullwords as the basic
+  arithmetic type, by using fast algorithms, with highly optimised assembly
+  code for the most common inner loops for a lot of CPUs, and by a general
+  emphasis on speed.
+
+* GMP is faster than any other bignum library. The advantage for GMP increases
+  with the operand sizes for many operations, since GMP uses asymptotically
+  faster algorithms.
+
+* The first GMP release was made in 1991. It is continually developed and
+  maintained, with a new release about once a year.
+
+* GMP is distributed under the GNU LGPL. This license makes the library free to
+  use, share, and improve, and allows you to pass on the result. The license
+  gives freedoms, but also sets firm restrictions on the use with non-free
+  programs.
+
+* GMP is part of the GNU project. For more information about the GNU project,
+  please see the official GNU web site.
+
+* GMP's main target platforms are Unix-type systems, such as GNU/Linux,
+  Solaris, HP-UX, Mac OS X/Darwin, BSD, AIX, etc. It also is known to work on
+  Windoze in 32-bit mode.
+
+* GMP is brought to you by a team listed in the manual.
+
+* GMP is carefully developed and maintained, both technically and legally. We
+  of course inspect and test contributed code carefully, but equally
+  importantly we make sure we have the legal right to distribute the
+  contributions, meaning users can safely use GMP. To achieve this, we will ask
+  contributors to sign paperwork where they allow us to distribute their work."
+
+Only GMP 4 or newer is supported. The following environments have been tested by me:
+  gmp gem 0.1.4.2 on:
+  +-------------------------------------+-------------------+-----------+
+  |    Platform                         |       Ruby        |    GMP    |
+  +-------------------------------------+-------------------+-----------+
+  | Cygwin on x86                       | (MRI) Ruby 1.8.7  | GMP 4.3.1 |
+  | Linux (LinuxMint 7) on x86 (32-bit) | (MRI) Ruby 1.8.7  | GMP 4.3.1 |
+  | Mac OS X 10.5.7 on x86 (32-bit)     | (MRI) Ruby 1.8.6  | GMP 4.3.1 |
+  | Mac OS X 10.5.7 on x86 (32-bit)     | (MRI) Ruby 1.9.1  | GMP 4.3.1 |
+  +-------------------------------------+-------------------+-----------+
+
+<b>Note:</b> To get this running on Mac OS X (32-bit), I compiled GMP 4.3.1 with:
+  ./configure ABI=32 --disable-dependency-tracking
+
+=Authors
+
+* Tomasz Wegrzanowski
+* srawlins
+
+=Classes
+
+It provides module GMP with following classes:
+* GMP::Z - infinite precision integer numbers
+* GMP::Q - infinite precision rational numbers
+* GMP::F - arbitrary precision floating point numbers
+
+Numbers are created by using new().
+Constructors can take following arguments:
+
+  GMP::Z.new()
+  GMP::Z.new(GMP::Z)
+  GMP::Z.new(FixNum)
+  GMP::Z.new(BigNum)
+  GMP::Z.new(String)
+  GMP::Q.new()
+  GMP::Q.new(GMP::Q)
+  GMP::Q.new(String)
+  GMP::Q.new(any GMP::Z initializer)
+  GMP::Q.new(any GMP::Z initializer, any GMP::Z initializer)
+  GMP::F.new()
+  GMP::F.new(GMP::Z, precision=0)
+  GMP::F.new(GMP::Q, precision=0)
+  GMP::F.new(GMP::F)
+  GMP::F.new(GMP::F, precision)
+  GMP::F.new(String, precision=0)
+  GMP::F.new(FixNum, precision=0)
+  GMP::F.new(BigNum, precision=0)
+  GMP::F.new(Float,  precision=0)
+
+You can also call them as:
+        GMP.Z(args)
+        GMP.Q(args)
+  todo  GMP.F(args)
+
+=Methods
+
+  GMP::Z, GMP::Q and GMP::F
+    +                        addition
+    -                        substraction
+    *                        multiplication
+    to_s                     convert to string. For GMP::Z, this method takes
+                             one optional argument, a base. The base can be a
+                             Fixnum in the ranges [2, 62] or [-36, -2] or a
+                             Symbol: :bin, :oct, :dec, or :hex.
+    -@                       negation
+    neg!                     in-place negation
+    abs                      absolute value
+    asb!                     in-place absolute value
+    coerce                   promotion of arguments
+    ==                       equality test
+    <=>,>=,>,<=,<            comparisions
+  class methods of GMP::Z
+    fac(n)                   factorial of n
+    fib(n)                   nth fibonacci number
+    pow(n,m)                 n to mth power
+  GMP::Z and GMP::Q
+    swap                     efficiently swap contents of two objects, there
+                             is no GMP::F.swap because various GMP::F objects
+                             may have different precisions, which would make
+                             them unswapable
+  GMP::Z
+   .add!                     in-place addition
+   .sub!                     in-place subtraction
+    tdiv,fdiv,cdiv           truncate, floor and ceil division
+    tmod,fmod,cmod           truncate, floor and ceil modulus
+   .[],[]=                   testing and setting bits (as booleans)
+    scan0,scan1              starting at bitnr (1st arg), scan for a 0 or 1
+                             (respectively), then return the index of the
+                             first instance.
+    com                      2's complement
+    com!                     in-place 2's complement
+    &,|,^                    logical operations: and, or, xor
+    **                       power
+    powmod                   power modulo
+    even?                    is even
+    odd?                     is odd
+    <<                       shift left
+    >>                       shift right, floor
+    tshr                     shift right, truncate
+    lastbits_pos(n)          last n bits of object, modulo if negative
+    lastbits_sgn(n)          last n bits of object, preserve sign
+    power?                   is perfect power
+    square?                  is perfect square
+    sqrt                     square root
+    sqrt!                    change the object into its square root
+    sqrtrem                  square root, remainder
+    root(n)                  nth root
+    jacobi                   jacobi symbol
+    legendre                 legendre symbol
+    probab_prime?            0 if composite, 1 if probably prime, 2 if
+                             certainly prime
+    nextprime                next *probable* prime
+    nextprime!               change the object into its next *probable* prime
+    popcount                 the number of bits equal to 1
+    to_i                     convert to FixNum or BigNum
+    remove(n)                remove all occurences of factor n
+  GMP::Q and GMP::F
+    /                        division
+  GMP::Q
+    num                      numerator
+    den                      denominator
+    inv                      inversion
+    inv!                     in-place inversion
+    floor,ceil,trunc         nearest integer
+  class methods of GMP::F
+    default_prec             get default precision
+    default_prec=            set default precision
+  GMP::F
+    prec                     get precision
+    floor,ceil,trunc         nearest integer, GMP::F is returned, not GMP::Z
+    floor!,ceil!,trunc!      in-place nearest integer
+  GMP::F (only if MPFR is available)
+    exp                      e^object
+    expm1                    the same as (object.exp) - 1, with better precision
+    log                      natural logarithm of object
+    log2                     binary logarithm of object
+    log10                    decimal logarithm of object
+    log1p                    the same as (object + 1).log, with better precision
+    sqrt                     square root of the object
+    cos                      \
+    sin                      |
+    tan                      |
+    acos                     |
+    asin                     |
+    atan                     | trigonometric functions
+    cosh                     | of the object
+    sinh                     |
+    tanh                     |
+    aconh                    |
+    asinh                    |
+    atanh                    /
+    nan?                     \
+    infinite?                | type of floating point number
+    finite?                  |
+    number?                  /
+    **                       power
+
+=Known Issues
+
+* GMP::Z#pow does not appear to be working at all. Looking at the code, I don't
+  think it ever did.
+
+=Precision
+
+Precision can be explicitely set as second argument for GMP::F.new().
+
+If there is no explicit precision, highest precision of all GMP::F arguments is
+used. That doesn't ensure that result will be exact. For details, consult any
+paper about floating point arithmetics.
+
+Default precision can be explicitely set by passing 0 to GMP::F.new(). In
+particular, you can set precision of copy of GMP::F object by:
+  new_obj = GMP::F.new(old_obj, 0)
+
+Precision argument, and default_precision will be rounded up to whatever GMP
+thinks is appropriate.
+
+=Todo
+
+These are inherited from Tomasz. I will go through these and see which are
+still relevant.
+
+* mpz_fits_* and 31 vs. 32 integer variables
+* all appropriate module and class methods if there are any to add
+* fix all sign issues (don't know what these are)
+* floats with precision control
+* random numbers
+* to_s vs. inspect
+* check if mpz_addmul_ui would optimize some statements
+* some system that allows using denref and numref as normal ruby objects
+* should we allocate global temporary variables like Perl GMP does?
+* takeover code that replaces all Bignums with GMP::Z
+* better bignum parser
+* zero-copy method for strings generation
+* put rb_raise into nice macros
+* benchmarks against Python GMP and Perl GMP
+* dup methods
+* integrate F into system
+* should Z.[] bits be 0/1 or true/false, 0 is true, what might badly surprise users
+* seriously investigate Ruby Makefile-making system
+* any2small_integer()
+* check asm output, especially local memory efficiency
+* it might be better to use `register' for some local variables
+* powm with negative exponents
+* check if different sorting of operatations gives better cache usage
+* GMP::* op RubyFloat and RubyFloat op GMP::*
+* sort checks
+* check all new GMP4 operations
+* GMP::Q.to_s(base), GMP::F.to_s(base)

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,195 @@
+/*
+ * 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;
+
+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); }
+
+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);
+/*
+  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();
+  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);*/
+
+#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 ? */
+}