gmp 0.1.7

data/ext/gmpz.h

@@ -0,0 +1,20 @@
+#ifndef _GMPZ_H_
+#define _GMPZ_H_
+
+/*
+ * gmpz.h
+ *
+ * This file contains GMP::Z method definitions.
+ */
+
+#include <ruby_gmp.h>
+
+#define DEFUN_INT_COND_P(fname,mpz_fname) \
+static VALUE r_gmpz_##fname(VALUE self) \
+{ \
+  MP_INT *self_val; \
+  mpz_get_struct(self, self_val); \
+  return mpz_fname(self_val)?Qtrue:Qfalse; \
+}
+
+#endif

data/ext/ruby_gmp.h

@@ -0,0 +1,199 @@
+#ifndef _RUBY_GMP_H_
+#define _RUBY_GMP_H_
+
+#include <stdio.h>
+#include <ruby.h>
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <gmp.h>
+
+#ifdef MPFR
+
+#ifdef HAVE_MPFR_H
+#include <mpfr.h>
+#endif /* HAVE_MPFR_H */
+
+#ifdef HAVE_MPF2MPFR_H
+#include <mpf2mpfr.h>
+#endif /* HAVE_MPF2MPFR_H */
+
+#endif /* MPFR */
+
+#include <stdlib.h>
+
+/*
+  MP_INT*, MP_RAT* and MP_FLOAT* are used because they don't have side-effects
+  of single-element arrays mp*_t
+
+  MP_FLOAT is defined here, as it's commented out in gmp.h
+*/
+#if defined(MPFR) && defined(HAVE_MPFR_H)
+typedef __mpfr_struct MP_FLOAT;
+#else
+typedef __mpf_struct MP_FLOAT;
+#endif /* HAVE_MPF2MPFR_H */
+
+#define mpz_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_INT, c_var); }
+#define mpq_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_RAT, c_var); }
+#define mpf_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_FLOAT, c_var); }
+#define mpf_get_struct_prec(ruby_var,c_var,prec) { mpf_get_struct(ruby_var,c_var); prec = mpf_get_prec(c_var); }
+#define mpz_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_Z, MP_INT, 0, r_gmpz_free, c_var); }
+#define mpq_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_Q, MP_RAT, 0, r_gmpq_free, c_var); }
+#define mpf_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_F, MP_FLOAT, 0, r_gmpf_free, c_var); }
+#define mpz_make_struct_init(ruby_var,c_var) { mpz_make_struct(ruby_var,c_var); mpz_init (c_var); }
+#define mpq_make_struct_init(ruby_var,c_var) { mpq_make_struct(ruby_var,c_var); mpq_init (c_var); }
+#define mpf_make_struct_init(ruby_var,c_var,prec) { mpf_make_struct(ruby_var,c_var); mpf_init2 (c_var,prec); }
+#define BIGNUM_P(value) (TYPE(value) == T_BIGNUM)
+#define FLOAT_P(value)  (TYPE(value) == T_FLOAT)
+#define STRING_P(value) (TYPE(value) == T_STRING)
+#define GMPZ_P(value)   (rb_obj_is_instance_of(value, cGMP_Z) == Qtrue)
+#define GMPQ_P(value)   (rb_obj_is_instance_of(value, cGMP_Q) == Qtrue)
+#define GMPF_P(value)   (rb_obj_is_instance_of(value, cGMP_F) == Qtrue)
+#define mpz_set_bignum(var_mpz,var_bignum) \
+  mpz_set_str (var_mpz, STR2CSTR (rb_funcall (var_bignum, rb_intern ("to_s"), 0)), 0);
+#define mpz_temp_alloc(var) { var=malloc(sizeof(MP_INT)); }
+#define mpz_temp_init(var) { mpz_temp_alloc(var); mpz_init(var); }
+#define mpz_temp_from_bignum(var,var_bignum)  \
+  { mpz_temp_alloc(var); mpz_init_set_str(var, STR2CSTR(rb_funcall(var_bignum, rb_intern("to_s"), 0)), 0); }
+#define mpz_temp_free(var) { mpz_clear(var); free(var); }
+#define mpf_temp_alloc(var) { var=malloc(sizeof(MP_FLOAT)); }
+#define mpf_temp_init(var,prec) { mpf_temp_alloc(var); mpf_init2(var,prec); }
+#define mpf_temp_free(var) { mpf_clear(var); free(var); }
+#define prec_max(prec,var) {if(mpf_get_prec(var) > prec) prec = mpf_get_prec(var); }
+
+#define EXPECTED_ZQFXBD "Expected GMP::Z, GMP::Q, GMP::F, FixNum, BigNum or Float"
+#define EXPECTED_ZQFXB "Expected GMP::Z, GMP::Q, GMP::F, FixNum or BigNum"
+#define EXPECTED_ZXB "Expected GMP::Z, FixNum or BigNum"
+#define EXPECTED_ZX "Expected GMP::Z or FixNum"
+#define EXPECTED_X "Expected FixNum"
+#define typeerror(expected) rb_raise(rb_eTypeError, EXPECTED_##expected)
+#define typeerror_as(expected, argname) rb_raise(rb_eTypeError, EXPECTED_##expected " as " argname)
+
+//should change exception type
+#define not_yet rb_raise(rb_eTypeError,"Not implemented yet")
+
+extern VALUE mGMP, cGMP_Z, cGMP_Q, cGMP_F;
+
+extern void r_gmpz_free(void *ptr);
+extern void r_gmpq_free(void *ptr);
+extern void r_gmpf_free(void *ptr);
+
+
+/* from gmpz.h */
+
+// Initializing, Assigning Integers
+extern VALUE r_gmpzsg_new(int argc, VALUE *argv, VALUE klass);
+extern VALUE r_gmpz_initialize(int argc, VALUE *argv, VALUE self);
+extern void mpz_set_value(MP_INT *target, VALUE source);
+extern VALUE r_gmpmod_z(int argc, VALUE *argv, VALUE module);
+extern VALUE r_gmpz_swap(VALUE self, VALUE arg);
+
+// Converting Integers
+extern VALUE r_gmpz_to_i(VALUE self);
+extern VALUE r_gmpz_to_d(VALUE self);
+extern VALUE r_gmpz_to_s(int argc, VALUE *argv, VALUE self);
+
+// Integer Arithmetic
+extern VALUE r_gmpz_add(VALUE self, VALUE arg);
+extern VALUE r_gmpz_add_self(VALUE self, VALUE arg);
+extern VALUE r_gmpz_sub(VALUE self, VALUE arg);
+extern VALUE r_gmpz_sub_self(VALUE self, VALUE arg);
+extern VALUE r_gmpz_mul(VALUE self, VALUE arg);
+
+// Integer Exponentiation
+extern VALUE r_gmpzsg_pow(VALUE klass, VALUE base, VALUE exp);
+
+// Number Theoretic Functions
+extern VALUE r_gmpz_remove(VALUE self, VALUE arg);
+
+// Integer Comparisons
+extern VALUE r_gmpz_eq(VALUE self, VALUE arg);
+extern VALUE r_gmpz_cmp(VALUE self, VALUE arg);
+extern VALUE r_gmpz_cmpabs(VALUE self, VALUE arg);
+
+// _unsorted_
+extern VALUE r_gmpz_div(VALUE self, VALUE arg);
+extern VALUE r_gmpz_is_probab_prime(int argc, VALUE* argv, VALUE self);
+extern VALUE r_gmpz_popcount(VALUE self);
+extern VALUE r_gmpz_jacobi(VALUE self);
+extern VALUE r_gmpz_legendre(VALUE self);
+extern VALUE r_gmpz_setbit(VALUE self, VALUE bitnr, VALUE set_to);
+extern VALUE r_gmpz_getbit(VALUE self, VALUE bitnr);
+extern VALUE r_gmpz_scan0(VALUE self, VALUE bitnr);
+extern VALUE r_gmpz_scan1(VALUE self, VALUE bitnr);
+extern VALUE r_gmpz_powm(VALUE self, VALUE exp, VALUE mod);
+extern VALUE r_gmpz_sgn(VALUE self);
+extern int mpz_cmp_value(MP_INT *OP, VALUE arg);
+
+
+
+/* from gmpq.h */
+
+// Initializing Rationals
+extern VALUE r_gmpqsg_new(int argc, VALUE *argv, VALUE klass);
+extern VALUE r_gmpmod_q(int argc, VALUE *argv, VALUE module);
+extern VALUE r_gmpq_swap(VALUE self, VALUE arg);
+
+// Rational Conversions
+extern VALUE r_gmpq_to_d(VALUE self);
+extern VALUE r_gmpq_to_s(VALUE self);
+
+// Rational Arithmetic
+extern VALUE r_gmpq_add(VALUE self, VALUE arg);
+extern VALUE r_gmpq_sub(VALUE self, VALUE arg);
+extern VALUE r_gmpq_mul(VALUE self, VALUE arg);
+extern VALUE r_gmpq_div(VALUE self, VALUE arg);
+extern VALUE r_gmpq_neg(VALUE self);
+extern VALUE r_gmpq_neg_self(VALUE self);
+extern VALUE r_gmpq_abs(VALUE self);
+extern VALUE r_gmpq_abs_self(VALUE self);
+extern VALUE r_gmpq_inv(VALUE self);
+extern VALUE r_gmpq_inv_self(VALUE self);
+
+// Comparing Rationals
+extern VALUE r_gmpq_eq(VALUE self, VALUE arg);
+extern VALUE r_gmpq_cmp(VALUE self, VALUE arg);
+extern int mpq_cmp_value(MP_RAT *OP, VALUE arg);
+extern VALUE r_gmpq_sgn(VALUE self);
+
+// Applying Integer Functions
+extern VALUE r_gmpq_num(VALUE self);
+extern VALUE r_gmpq_den(VALUE self);
+
+// _unsorted_
+
+
+/* from gmpf.h */
+
+// Initializing, Assigning Floats
+extern VALUE r_gmpfsg_new(int argc, VALUE *argv, VALUE klass);
+extern VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self);
+extern void mpf_set_value(MP_FLOAT *self_val, VALUE arg);
+extern VALUE r_gmpmod_f(int argc, VALUE *argv, VALUE module);
+
+// Converting Floats
+extern VALUE r_gmpf_to_d(VALUE self);
+extern VALUE r_gmpf_to_s(VALUE self);
+
+// Float Arithmetic
+extern VALUE r_gmpf_add(VALUE self, VALUE arg);
+extern VALUE r_gmpf_sub(VALUE self, VALUE arg);
+extern VALUE r_gmpf_mul(VALUE self, VALUE arg);
+extern VALUE r_gmpf_div(VALUE self, VALUE arg);
+
+// Float Comparison
+extern VALUE r_gmpf_eq(VALUE self, VALUE arg);
+extern VALUE r_gmpf_cmp(VALUE self, VALUE arg);
+extern int mpf_cmp_value(MP_FLOAT *OP, VALUE arg);
+
+// _unsorted_
+extern VALUE r_gmpf_sgn(VALUE self);
+extern VALUE r_gmpf_get_prec(VALUE self);
+
+
+extern void init_gmpz();
+extern void init_gmpq();
+extern void init_gmpf();
+
+#endif

data/ext/takeover.h

@@ -0,0 +1,36 @@
+#define DEFUN_TAKEOVER_LOGIC(fname, mpz_fname, old_fname) \
+static VALUE takeover_fixnum_##fname(int argc, VALUE *argv, VALUE self) \
+{ \
+  MP_INT *res_val, *arg_val; \
+  VALUE res; \
+\
+  if (argc != 1 || !GMPZ_P(argv[0])) { \
+    return rb_funcall2 (self, rb_intern (old_fname), argc, argv); \
+  } else { \
+    mpz_make_struct(res, res_val); \
+    mpz_get_struct(argv[0], arg_val); \
+    mpz_init_set_si (res_val, FIX2INT(self)); \
+    mpz_fname (res_val, res_val, arg_val); \
+    return res; \
+  } \
+} \
+\
+static VALUE takeover_bignum_##fname(int argc, VALUE *argv, VALUE self) \
+{\
+  MP_INT *res_val, *arg_val; \
+  VALUE res; \
+\
+  if (argc != 1 || !GMPZ_P(argv[0])) { \
+    return rb_funcall2 (self, rb_intern (old_fname), argc, argv); \
+  } else { \
+    mpz_get_struct(argv[0], arg_val); \
+    mpz_make_struct_init(res, res_val); \
+    mpz_set_bignum (res_val, self); \
+    mpz_fname (res_val, res_val, arg_val); \
+    return res; \
+  } \
+}
+
+DEFUN_TAKEOVER_LOGIC(and, mpz_and, "old_and")
+DEFUN_TAKEOVER_LOGIC(or, mpz_ior, "old_or")
+DEFUN_TAKEOVER_LOGIC(xor, mpz_xor, "old_xor")

data/manual.tex

@@ -0,0 +1,183 @@
+\documentclass[pdftex,10pt]{article}
+\usepackage{amsmath,amsfonts,url}
+\usepackage[pdftex]{graphicx}
+\setlength{\parindent}{0pt}
+\newcommand{\HRule}{\rule{\linewidth}{0.8mm}}
+\newcommand{\sectionline}{\rule{1.0\linewidth}{2.0pt}}
+\def\cour{\fontfamily{pcr}\selectfont}
+\usepackage[top=1.2in, bottom=0.8in, left=0.8in, right=0.8in]{geometry}
+\setcounter{tocdepth}{3}
+\title{gmp - Ruby bindings to the GMP library}
+\date{September 27, 2009}
+\author{Sam Rawlins}
+\begin{document}
+\huge{gmp}\\
+\HRule
+\begin{flushright}
+\large{Ruby bindings to the GMP library}\\
+\large{Edition 0.1.5}\\
+\large{27 September 2009}\\
+\end{flushright}
+\vfill
+\large{written by Sam Rawlins}\\
+\large{with extensive quoting from the GMP Manual}
+\newpage
+
+\vfill
+This manual describes how to use the gmp Ruby gem, which provides bindings to
+the GNU multiple precision arithmetic library, version 4.3.x.\\
+\\
+Copyright 2009 Sam Rawlins.\\
+No license yet.
+\newpage
+
+\tableofcontents
+\newpage
+
+\section{Introduction to GNU MP}
+
+This entire page is copied verbatim from the GMP Manual.\\\\
+
+GNU MP is a portable library written in C for arbitrary precision arithmetic on
+integers, rational numbers, and floating-point numbers. It aims to provide the
+fastest possible arithmetic for all applications that need higher precision
+than is directly supported by the basic C types.\\
+\\
+Many applications use just a few hundred bits of precision; but some
+applications may need thousands or even millions of bits. GMP is designed to
+give good performance for both, by choosing algorithms based on the sizes of
+the operands, and by carefully keeping the overhead at a minimum.\\
+\\
+The speed of GMP is achieved by using fullwords as the basic arithmetic type,
+by using sophisticated algorithms, by including carefully optimized assembly
+code for the most common inner loops for many different CPUs, and by a general
+emphasis on speed (as opposed to simplicity or elegance).\\
+\\
+There is assembly code for these CPUs: ARM, DEC Alpha 21064, 21164, and 21264,
+AMD 29000, AMD K6, K6-2, Athlon, and Athlon64, Hitachi SuperH and SH-2, HPPA
+1.0, 1.1, and 2.0, Intel Pentium, Pentium Pro/II/III, Pentium 4, generic x86,
+Intel IA-64, i960, Motorola MC68000, MC68020, MC88100, and MC88110,
+Motorola/IBM PowerPC 32 and 64, National NS32000, IBM POWER, MIPS R3000, R4000,
+SPARCv7, SuperSPARC, generic SPARCv8, UltraSPARC, DEC VAX, and Zilog Z8000.
+Some optimizations also for Cray vector systems, Clipper, IBM ROMP (RT), and
+Pyramid AP/XP.\\
+\\
+For up-to-date information on GMP, please see the GMP web pages at\\
+\\
+\indent \texttt{http://gmplib.org/}\\
+
+The latest version of the library is available at\\
+\\
+\texttt{ftp://ftp.gnu.org/gnu/gmp/}\\
+\\
+Many sites around the world mirror '\texttt{ftp.gnu.org}', please use a mirror
+near you, see \texttt{http://www.gnu.org/order/ftp.html} for a full list.\\
+\\
+There are three public mailing lists of interest. One for release
+announcements, one for general questions and discussions about usage of the GMP
+library, and one for bug reports. For more information, see\\
+\\
+\texttt{http://gmplib.org/mailman/listinfo/}.\\
+\\
+The proper place for bug reports is gmp-bugs@gmplib.org. See Chapter 4
+[Reporting Bugs], page 28 for information about reporting bugs.
+
+\section{Introduction to the gmp gem}
+
+The gmp Ruby gem is a Ruby library that provides bindings to GMP. The gem is
+incomplete, and will likely only include a subset of the GMP functions. It is
+built as a C extension for ruby, interacting with gmp.h. The gmp gem is not
+endorsed or supported by GNU or the GMP team. The gmp gem also does not ship
+with GMP, so GMP must be compiled separately.
+
+\section{Installing the gmp gem}
+
+\subsection{Prerequisites}
+OK. First, we've got a few requirements. To install the gmp gem, you need one
+of the following versions of Ruby:
+\begin{itemize}
+  \item (MRI) Ruby 1.8.6 - tested lightly.
+  \item (MRI) Ruby 1.8.7 - tested seriously.
+  \item (MRI) Ruby 1.9.1 - more of a "release candidate" state. Please report
+    bugs.
+\end{itemize}
+As you can see only Matz's Ruby Interpreter (MRI) is supported. I haven't even
+put a thought into trying other interpreters/VMs. I intend to look into FFI,
+which supposedly will allow me to load this extension into JRuby and Rubinius,
+not sure about others...\\
+
+Next is the platform, the combination of the architecture (processor) and OS.
+As far as I can tell, if you can compile GMP and Ruby on a given platform, you
+can use the gmp gem there too. Please report problems with that hypothesis.\\
+
+Lastly, GMP. GMP must be compiled and working. "and working" means you ran "make check" while installing GMP. The following versions of GMP have been tested:
+\begin{itemize}
+  \item GMP 4.3.1
+\end{itemize}
+
+That's all. I don't intend to test any older versions, maybe 4.3.0 for completeness.\\
+
+Here is a table of the exact environments I have tested the gmp gem on:\\\\
+
+\begin{tabular}{|l|r|r|} \hline
+             Platform             &       Ruby       &    GMP    \\ \hline \hline
+  Cygwin on x86                   & (MRI) Ruby 1.8.7 & GMP 4.3.1 \\ \hline
+  Linux (LinuxMint 7) on x86      & (MRI) Ruby 1.8.7 & GMP 4.3.1 \\ \hline
+  Mac OS X 10.5.7 on x86 (32-bit) & (MRI) Ruby 1.8.6 & GMP 4.3.1 \\ \hline
+  Mac OS X 10.5.7 on x86 (32-bit) & (MRI) Ruby 1.9.1 & GMP 4.3.1 \\ \hline
+\end{tabular}
+
+\subsection{Installing}
+You may clone the gmp gem's git repository with:\\
+\\
+\hangindent=0.5cm \texttt{git clone git://github.com/srawlins/gmp.git}\\
+
+Or you may install the gem from github:\\
+\\
+\hangindent=0.5cm \texttt{gem install srawlins-gmp}\\
+
+At this time, the gem does not self-compile (how does that work?). To compile the C
+extensions, do the following:\\
+\\
+\hangindent=0.5cm \texttt{cd <srawlins-gmp gem directory>/ext}\\
+\hangindent=0.5cm \texttt{ruby extconf.rb}\\
+\hangindent=0.5cm \texttt{make}\\
+
+There shouldn't be any errors, or warnings.
+
+\section{GMP and gmp gem basics}
+
+\subsection{Classes}
+The gmp gem includes the namespace \texttt{GMP} and three classes within \texttt{GMP}:
+\begin{itemize}
+  \item \texttt{GMP::Z} - Methods for signed integer arithmetic. There are at least 35
+    methods here (still accounting).
+  \item \texttt{GMP::Q} - Methods for rational number arithmetic. There are at least 6
+    methods here (still accounting).
+  \item \texttt{GMP::F} - Methods for floating-point arithmetic. There are at least 0
+    methods here (still accounting).
+\end{itemize}
+
+In addition to the above three classes, there is also one constant within \texttt{GMP}:
+\begin{itemize}
+  \item \texttt{GMP::GMP\_VERSION} - The version of GMP compiled into the gmp gem.
+\end{itemize}
+
+\section{Integer Functions}
+
+\subsection{Initializing, Assigning Integers}
+
+\large{\textbf{GMP::Z.new(a = 0)}}\\
+\large{\textbf{GMP::Z(a = 0)}}\\
+This method creates a new \texttt{GMP::Z} integer. It takes one optional argument for the value of the integer. This argument can be one of several classes. Here are some examples:
+\begin{verbatim}
+GMP::Z.new                  #=> 0           (default)
+GMP::Z.new(1)               #=> 1           (Ruby Fixnum)
+GMP::Z.new("127")           #=> 127         (Ruby String)
+GMP::Z.new(4294967296)      #=> 4294967296  (Ruby Bignum)
+GMP::Z.new(GMP::Z.new(31))  #=> 31          (GMP Integer)
+\end{verbatim}
+
+There is also a convenience method available, \texttt{GMP::Z()}.\\
+
+\end{document}

data/test/README

@@ -0,0 +1,41 @@
+TODO: Port everything to Test::Unit framework
+Test files 1-6 ported.
+
+Current version passes:
+  1-23
+Current version fails on these tests because:
+  none
+Tests:
+   1*   initializations and to_s
+   2*   basic integer arithmetics and coersion to Z
+   3*   integer logical operators
+   4*   comparisions between Z, Q, FixNum and BigNum
+   5*   basic rational arithmetics and coersion to Q
+   6    bit operations, scan0, scan1
+   7*   exponentiation and exponentiation modulo
+   8*   divide by zero exceptions
+   9*   sgn, neg, abs
+  10*   fibonacci, factorial, nextprime
+  11*   swap
+  12*   floor, ceil, truncate
+  13*   to_i, to_d
+  14*   shifts, last_bits
+  15*   logical tests, roots
+  16*   floating point init with and without explicit precision
+  17    basic floating point arithmetics and coersion to F
+  18    default_prec and default_prec=
+  19    integer division methods
+  20    mpfr - exp and log
+  21    mpfr - trigonometry
+  22    mpfr - type tests
+  23    mpfr - sqrt and power
+TODO:
+  jacobi, legendre, remove
+  gcd, lcm
+  cmpabs
+  integer and integer->rational division, modulo
+  more number theoretic functions
+  random numbers
+  range error exceptions
+  full coverage?
+  use more assert_in_delta