srawlins-gmp 0.1.4.2 → 0.1.5

data/ext/gmpz.h

@@ -1,283 +1,13 @@
+#ifndef _GMPZ_H_
+#define _GMPZ_H_
+
 /*
  * gmpz.h
  *
  * This file contains GMP::Z method definitions.
  */
 
-/*
- * call-seq: +(other)
- *
- * Adds this GMP::Z to other. Other can be
- * * GMP::Z
- * * Fixnum
- * * GMP::Q
- * * GMP::F
- * * Bignum
- */
-static VALUE r_gmpz_add(VALUE self, VALUE arg)
-{
-  MP_INT *self_val, *arg_val, *res_val;
-  VALUE res;
-
-  mpz_get_struct(self,self_val);
-
-  if (GMPZ_P(arg)) {
-    mpz_get_struct(arg,arg_val);
-    mpz_make_struct_init(res, res_val);
-    mpz_add (res_val, self_val, arg_val);
-  } else if (FIXNUM_P(arg)) {
-    mpz_make_struct_init(res, res_val);
-    if (FIX2INT(arg) > 0)
-      mpz_add_ui (res_val, self_val, FIX2INT(arg));
-    else
-      mpz_sub_ui (res_val, self_val, -FIX2INT(arg));
-  } else if (GMPQ_P(arg)) {
-    return r_gmpq_add(arg, self);
-  } else if (GMPF_P(arg)) {
-    return r_gmpf_add(arg, self);
-  } else if (BIGNUM_P(arg)) {
-    mpz_make_struct_init(res, res_val);
-    mpz_init (res_val);
-    mpz_set_bignum (res_val, arg);
-    mpz_add (res_val, res_val, self_val);
-  } else {
-    typeerror (ZQFXB);
-  }
-  return res;
-}
-
-static VALUE r_gmpz_add_self(VALUE self, VALUE arg)
-{
-  MP_INT *self_val, *arg_val;
-
-  mpz_get_struct(self,self_val);
-
-  if (GMPZ_P(arg)) {
-    mpz_get_struct(arg,arg_val);
-    mpz_add (self_val, self_val, arg_val);
-  } else if (FIXNUM_P(arg)) {
-    if (FIX2INT(arg) > 0)
-      mpz_add_ui (self_val, self_val, FIX2INT(arg));
-    else
-      mpz_sub_ui (self_val, self_val, -FIX2INT(arg));
-  } else if (BIGNUM_P(arg)) {
-    mpz_temp_from_bignum (arg_val, arg);
-    mpz_add (self_val, self_val, arg_val);
-    mpz_temp_free (arg_val);
-  } else {
-    typeerror (ZXB);
-  }
-  return Qnil;
-}
-
-static VALUE r_gmpz_sub(VALUE self, VALUE arg)
-{
-  MP_RAT *res_val_q, *arg_val_q;
-  MP_INT *self_val, *arg_val, *res_val;
-  MP_FLOAT *arg_val_f, *res_val_f;
-  VALUE res;
-  unsigned long prec;
-
-  mpz_get_struct(self,self_val);
-
-  if (GMPZ_P(arg)) {
-    mpz_make_struct_init(res, res_val);
-    mpz_get_struct(arg,arg_val);
-    mpz_sub (res_val, self_val, arg_val);
-  } else if (FIXNUM_P(arg)) {
-    mpz_make_struct_init(res, res_val);
-    if (FIX2INT(arg) > 0)
-      mpz_sub_ui (res_val, self_val, FIX2INT(arg));
-    else
-      mpz_add_ui (res_val, self_val, -FIX2INT(arg));
-  } else if (GMPQ_P(arg)) {
-    mpq_make_struct_init(res, res_val_q);
-    mpq_get_struct(arg,arg_val_q);
-    mpz_set (mpq_denref(res_val_q), mpq_denref(arg_val_q));
-    mpz_mul (mpq_numref(res_val_q), mpq_denref(arg_val_q), self_val);
-    mpz_sub (mpq_numref(res_val_q), mpq_numref(res_val_q), mpq_numref(arg_val_q));
-  } else if (GMPF_P(arg)) {
-    mpf_get_struct_prec (arg, arg_val_f, prec);
-    mpf_make_struct_init(res, res_val_f, prec);
-    mpf_set_z (res_val_f, self_val);
-    mpf_sub (res_val_f, res_val_f, arg_val_f);
-  } else if (BIGNUM_P(arg)) {
-    mpz_make_struct_init(res, res_val);
-    mpz_set_bignum (res_val, arg);
-    mpz_sub (res_val, self_val, res_val);
-  } else {
-    typeerror (ZQFXB);
-  }
-  return res;
-}
-
-static VALUE r_gmpz_sub_self(VALUE self, VALUE arg)
-{
-  MP_INT *self_val, *arg_val;
-
-  mpz_get_struct(self,self_val);
-
-  if (GMPZ_P(arg)) {
-    mpz_get_struct(arg, arg_val);
-    mpz_sub (self_val, self_val, arg_val);
-  } else if (FIXNUM_P(arg)) {
-    if (FIX2INT(arg) > 0)
-      mpz_sub_ui (self_val, self_val, FIX2INT(arg));
-    else
-      mpz_add_ui (self_val, self_val, -FIX2INT(arg));
-  } else if (BIGNUM_P(arg)) {
-    mpz_temp_from_bignum(arg_val, arg);
-    mpz_sub (self_val, self_val, arg_val);
-    mpz_temp_free (arg_val);
-  } else {
-    typeerror (ZXB);
-  }
-  return Qnil;
-}
-
-static VALUE r_gmpz_mul(VALUE self, VALUE arg)
-{
-  MP_INT *self_val, *arg_val, *res_val;
-  VALUE res;
-
-  mpz_get_struct(self,self_val);
-
-  if (GMPZ_P(arg)) {
-    mpz_make_struct_init(res, res_val);
-    mpz_get_struct(arg,arg_val);
-    mpz_mul (res_val, self_val, arg_val);
-  } else if (FIXNUM_P(arg)) {
-    mpz_make_struct_init(res, res_val);
-    mpz_mul_si (res_val, self_val, FIX2INT(arg));
-  } else if (GMPQ_P(arg)) {
-    return r_gmpq_mul(arg, self);
-  } else if (GMPF_P(arg)) {
-    return r_gmpf_mul(arg, self);
-  } else if (BIGNUM_P(arg)) {
-    mpz_make_struct_init(res, res_val);
-    mpz_set_bignum (res_val, arg);
-    mpz_mul (res_val, res_val, self_val);
-  } else {
-    typeerror (ZQFXB);
-  }
-  return res;
-}
-
-static VALUE r_gmpz_div(VALUE self, VALUE arg)
-{
-  MP_INT *self_val, *arg_val_z, *tmp_z;
-  MP_RAT *arg_val_q, *res_val_q;
-  MP_FLOAT *arg_val_f, *res_val_f;
-  VALUE res;
-  unsigned int prec;
-
-  mpz_get_struct(self,self_val);
-
-  if (GMPZ_P(arg)) {
-    mpz_get_struct(arg, arg_val_z);
-    if (mpz_cmp_ui(arg_val_z, 0) == 0)
-      rb_raise (rb_eZeroDivError, "divided by 0");
-    mpq_make_struct_init(res, res_val_q);
-    mpq_set_num (res_val_q, self_val);
-    mpq_set_den (res_val_q, arg_val_z);
-    mpq_canonicalize (res_val_q);
-  } else if (FIXNUM_P(arg)) {
-    if (FIX2INT(arg) == 0)
-      rb_raise (rb_eZeroDivError, "divided by 0");
-    mpq_make_struct_init(res, res_val_q);
-    mpq_set_num (res_val_q, self_val);
-    mpz_set_ui (mpq_denref(res_val_q), FIX2INT(arg));
-    mpq_canonicalize (res_val_q);
-  } else if (GMPQ_P(arg)) {
-    mpq_get_struct(arg, arg_val_q);
-    if (mpz_cmp_ui(mpq_numref(arg_val_q), 0) == 0)
-      rb_raise (rb_eZeroDivError, "divided by 0");
-    mpz_temp_init(tmp_z);
-    mpq_make_struct_init(res, res_val_q);
-    mpz_gcd (tmp_z, mpq_numref(arg_val_q), self_val);
-    mpz_divexact (mpq_numref(res_val_q), self_val, tmp_z);
-    mpz_divexact (mpq_denref(res_val_q), mpq_numref(arg_val_q), tmp_z);
-    mpz_mul (mpq_numref(res_val_q), mpq_numref(res_val_q), mpq_denref(arg_val_q));
-    mpz_temp_free(tmp_z);
-  } else if (GMPF_P(arg)) {
-    mpf_get_struct_prec (arg, arg_val_f, prec);
-    mpf_make_struct_init(res, res_val_f, prec);
-    mpf_set_z (res_val_f, self_val);
-    mpf_div (res_val_f, res_val_f, arg_val_f);
-  } else if (BIGNUM_P(arg)) {
-    mpq_make_struct_init(res, res_val_q);
-    mpz_set_bignum (mpq_denref(res_val_q), arg);
-    if (mpz_cmp_ui(mpq_denref(res_val_q), 0) == 0)
-      rb_raise (rb_eZeroDivError, "divided by 0");
-    mpq_set_num (res_val_q, self_val);
-    mpq_canonicalize (res_val_q);
-  } else {
-    typeerror (ZQFXB);
-  }
-  return res;
-}
-
-static VALUE r_gmpz_setbit(VALUE self, VALUE bitnr, VALUE set_to)
-{
-  MP_INT *self_val;
-  int bitnr_val;
-
-  mpz_get_struct(self, self_val);
-
-  if (FIXNUM_P(bitnr)) {
-    bitnr_val = FIX2INT (bitnr);
-  } else {
-    typeerror_as(X, "index");
-  }
-  if (RTEST(set_to)) {
-    mpz_setbit (self_val, bitnr_val);
-  } else {
-    mpz_clrbit (self_val, bitnr_val);
-  }
-  return Qnil;
-}
-
-static VALUE r_gmpz_getbit(VALUE self, VALUE bitnr)
-{
-  MP_INT *self_val;
-  int bitnr_val;
-  mpz_get_struct(self, self_val);
-  if (FIXNUM_P(bitnr)) {
-    bitnr_val = FIX2INT (bitnr);
-  } else {
-    typeerror_as(X, "index");
-  }
-  return mpz_tstbit(self_val, bitnr_val)?Qtrue:Qfalse;
-}
-
-static VALUE r_gmpz_scan0(VALUE self, VALUE bitnr)
-{
-  MP_INT *self_val;
-  int bitnr_val;
-  mpz_get_struct(self, self_val);
-  if (FIXNUM_P(bitnr)) {
-    bitnr_val = FIX2INT (bitnr);
-  } else {
-    typeerror_as(X, "index");
-  }
-  return INT2FIX(mpz_scan0(self_val, bitnr_val));
-}
-
-static VALUE r_gmpz_scan1(VALUE self, VALUE bitnr)
-{
-  MP_INT *self_val;
-  int bitnr_val;
-
-  mpz_get_struct(self, self_val);
-
-  if (FIXNUM_P(bitnr)) {
-    bitnr_val = FIX2INT (bitnr);
-  } else {
-    typeerror_as(X, "index");
-  }
-
-  return INT2FIX(mpz_scan1(self_val, bitnr_val));
-}
+#include <ruby_gmp.h>
 
 #define DEFUN_INT_COND_P(fname,mpz_fname) \
 static VALUE r_gmpz_##fname(VALUE self) \
@@ -287,547 +17,4 @@ static VALUE r_gmpz_##fname(VALUE self) \
   return mpz_fname(self_val)?Qtrue:Qfalse; \
 }
 
-DEFUN_INT_COND_P(is_even,mpz_even_p)
-DEFUN_INT_COND_P(is_odd,mpz_odd_p)
-DEFUN_INT_COND_P(is_square,mpz_perfect_square_p)
-DEFUN_INT_COND_P(is_power,mpz_perfect_power_p)
-
-static VALUE r_gmpz_sgn(VALUE self)
-{
-  MP_INT *self_val;
-  mpz_get_struct(self, self_val);
-  return INT2FIX(mpz_sgn(self_val));
-}
-
-static VALUE r_gmpz_powm(VALUE self, VALUE exp, VALUE mod)
-{
-  MP_INT *self_val, *res_val, *mod_val, *exp_val;
-  VALUE res;
-  int free_mod_val = 0;
-
-  if (GMPZ_P(mod)) {
-    mpz_get_struct(mod, mod_val);
-    if (mpz_sgn(mod_val) <= 0) {
-      rb_raise (rb_eRangeError, "modulus must be positive");
-    }
-  } else if (FIXNUM_P(mod)) {
-  if (FIX2INT(mod) <= 0) {
-    rb_raise (rb_eRangeError, "modulus must be positive");
-  }
-  mpz_temp_alloc (mod_val);
-  mpz_init_set_ui(mod_val, FIX2INT(mod));
-  free_mod_val = 1;
-  } else if (BIGNUM_P(mod)) {
-    mpz_temp_from_bignum (mod_val, mod);
-    if (mpz_sgn(mod_val) <= 0) {
-      mpz_temp_free(mod_val);
-      rb_raise (rb_eRangeError, "modulus must be positive");
-    }
-    free_mod_val = 1;
-  } else {
-    typeerror_as (ZXB, "modulus");
-  }
-  mpz_make_struct_init(res, res_val);
-  mpz_get_struct(self, self_val);
-
-  if (GMPZ_P(exp)) {
-    mpz_get_struct(exp, exp_val);
-    if (mpz_sgn(mod_val) < 0) {
-      rb_raise (rb_eRangeError, "exponent must be nonnegative");
-    }
-    mpz_powm (res_val, self_val, exp_val, mod_val);
-  } else if (FIXNUM_P(exp)) {
-    if (FIX2INT(exp) < 0)
-    {
-      if (free_mod_val)
-        mpz_temp_free(mod_val);
-      rb_raise (rb_eRangeError, "exponent must be nonnegative");
-    }
-    mpz_powm_ui (res_val, self_val, FIX2INT(exp), mod_val);
-  } else if (BIGNUM_P(exp)) {
-    mpz_temp_from_bignum (exp_val, exp);
-    mpz_powm (res_val, self_val, exp_val, mod_val);
-    mpz_temp_free (exp_val);
-  } else {
-    if (free_mod_val)
-      mpz_temp_free(mod_val);
-    typeerror_as (ZXB, "exponent");
-  }
-  if (free_mod_val)
-    mpz_temp_free(mod_val);
-  return res;
-}
-
-static VALUE r_gmpz_swap(VALUE self, VALUE arg)
-{
-  MP_INT *self_val, *arg_val;
-  if (!GMPZ_P(arg)) {
-    rb_raise(rb_eTypeError, "Can't swap GMP::Z with object of other class");
-  }
-  mpz_get_struct(self, self_val);
-  mpz_get_struct(arg, arg_val);
-  mpz_swap(self_val,arg_val);
-  return Qnil;
-}
-
-
-#define DEFUN_INT_F_UL(fname,mpz_fname,argname) \
-static VALUE r_gmpz_##fname(VALUE self, VALUE exp) \
-{ \
-  MP_INT *self_val, *res_val; \
-  VALUE res; \
-  unsigned long exp_val; \
- \
-  if (FIXNUM_P(exp)) { \
-    if (FIX2INT (exp) < 0) \
-      rb_raise (rb_eRangeError, argname " out of range"); \
-    exp_val = FIX2INT (exp); \
-  } else if (GMPZ_P(exp)) {\
-    mpz_get_struct (exp, res_val); \
-    if (!mpz_fits_ulong_p (res_val)) \
-      rb_raise (rb_eRangeError, argname " out of range"); \
-    exp_val = mpz_get_ui (res_val); \
-    if (exp_val == 0) \
-      rb_raise (rb_eRangeError, argname " out of range"); \
-  } else { \
-    typeerror_as (ZX, argname); \
-  } \
- \
-  mpz_make_struct_init(res, res_val); \
-  mpz_get_struct(self, self_val); \
-  mpz_fname(res_val, self_val, exp_val); \
- \
-  return res; \
-}
-
-DEFUN_INT_F_UL(pow,mpz_pow_ui,"exponent")
-DEFUN_INT_F_UL(shl,mpz_mul_2exp,"shift size")
-DEFUN_INT_F_UL(fshr,mpz_fdiv_q_2exp,"shift size")
-DEFUN_INT_F_UL(tshr,mpz_tdiv_q_2exp,"shift size")
-DEFUN_INT_F_UL(fshrm,mpz_fdiv_r_2exp,"mark size")
-DEFUN_INT_F_UL(tshrm,mpz_tdiv_r_2exp,"mark size")
-DEFUN_INT_F_UL(root,mpz_root,"root number")
-
-static int mpz_cmp_value (MP_INT *OP, VALUE arg)
-{
-  MP_RAT *arg_val_q;
-  MP_INT *arg_val_z;
-  int res;
-
-  if (GMPZ_P(arg)) {
-    mpz_get_struct(arg,arg_val_z);
-    return mpz_cmp (OP,arg_val_z);
-  } else if (FIXNUM_P(arg)) {
-    return mpz_cmp_si (OP, FIX2INT(arg));
-  } else if (GMPQ_P(arg)) {
-    mpq_get_struct(arg,arg_val_q);
-    mpz_temp_alloc (arg_val_z);
-    mpz_init(arg_val_z);
-    mpz_mul(arg_val_z, OP, mpq_denref(arg_val_q));
-    res = mpz_cmp (arg_val_z, mpq_numref(arg_val_q));
-    mpz_temp_free(arg_val_z);
-    return res;
-  } else if (GMPF_P(arg)) {
-    not_yet;
-  } else if (BIGNUM_P(arg)) {
-    mpz_temp_from_bignum (arg_val_z, arg);
-    res = mpz_cmp (OP, arg_val_z);
-    mpz_temp_free(arg_val_z);
-    return res;
-  } else {
-    typeerror_as (ZQFXB, "exponent");
-  }
-}
-
-static VALUE r_gmpz_eq(VALUE self, VALUE arg)
-{
-  MP_INT *self_val, *arg_val_z;
-  MP_RAT *arg_val_q;
-
-  mpz_get_struct (self, self_val);
-  if (GMPZ_P(arg)) {
-    mpz_get_struct(arg, arg_val_z);
-    return (mpz_cmp (self_val, arg_val_z)==0) ? Qtrue : Qfalse;
-  } else if (FIXNUM_P(arg)) {
-    return (mpz_cmp_si (self_val, FIX2INT(arg))==0) ? Qtrue : Qfalse;
-  } else if (GMPQ_P(arg)) {
-    mpq_get_struct(arg, arg_val_q);
-    if (mpz_cmp_ui(mpq_denref(arg_val_q), 1)==0)
-      return Qfalse;
-    return (mpz_cmp (self_val, mpq_numref(arg_val_q))==0) ? Qtrue : Qfalse;
-  } else if (BIGNUM_P(arg)) {
-    mpz_temp_from_bignum(arg_val_z, arg);
-    if (mpz_cmp (self_val, arg_val_z)==0) {
-      mpz_temp_free(arg_val_z);
-      return Qtrue;
-    } else {
-      mpz_temp_free(arg_val_z);
-      return Qfalse;
-    }
-  } else {
-    return Qfalse;
-  }
-}
-
-static VALUE r_gmpz_cmp(VALUE self, VALUE arg)
-{
-  MP_INT *self_val;
-  int res;
-  mpz_get_struct (self,self_val);
-  res = mpz_cmp_value(self_val, arg);
-  if (res > 0)
-    return INT2FIX(1);
-  else if (res == 0)
-    return INT2FIX(0);
-  else
-    return INT2FIX(-1);
-}
-
-#define DEFUN_INT_CMP(name,CMP_OP) \
-static VALUE r_gmpz_cmp_##name(VALUE self, VALUE arg) \
-{ \
-  MP_INT *self_val; \
-  mpz_get_struct (self,self_val); \
-  return (mpz_cmp_value(self_val, arg) CMP_OP 0)?Qtrue:Qfalse; \
-}
-
-DEFUN_INT_CMP(lt,<)
-DEFUN_INT_CMP(le,<=)
-DEFUN_INT_CMP(gt,>)
-DEFUN_INT_CMP(ge,>=)
-
-#define DEFUN_INT_DIV(fname,gmp_fname) \
-static VALUE r_gmpz_##fname(VALUE self, VALUE arg) \
-{ \
-  MP_INT *self_val, *arg_val, *res_val; \
-  VALUE res; \
-  int arg_val_i; \
-  \
-  mpz_get_struct(self, self_val); \
-  mpz_make_struct_init(res, res_val); \
-  \
-  if (GMPZ_P(arg)) { \
-    mpz_get_struct(arg,arg_val); \
-    if (mpz_cmp_ui(arg_val, 0) == 0) \
-      rb_raise (rb_eZeroDivError, "divided by 0"); \
-    gmp_fname (res_val, self_val, arg_val); \
-  } else if (FIXNUM_P(arg)) { \
-    arg_val_i = FIX2INT(arg); \
-    if (arg_val_i > 0) { \
-      gmp_fname##_ui (res_val, self_val, arg_val_i); \
-    } else if (arg_val_i == 0) { \
-      rb_raise (rb_eZeroDivError, "divided by 0"); \
-    } else { \
-      mpz_neg (res_val, self_val); \
-      gmp_fname##_ui (res_val, self_val, -arg_val_i); \
-    } \
-  } else if (BIGNUM_P(arg)) { \
-    mpz_set_bignum (res_val, arg); \
-    if (mpz_cmp_ui(res_val, 0) == 0) \
-      rb_raise (rb_eZeroDivError, "divided by 0"); \
-    gmp_fname (res_val, self_val, res_val); \
-  } else { \
-    typeerror(ZXB); \
-  } \
-  return res; \
-}
-
-DEFUN_INT_DIV(tdiv, mpz_tdiv_q)
-DEFUN_INT_DIV(tmod, mpz_tdiv_r)
-DEFUN_INT_DIV(fdiv, mpz_fdiv_q)
-DEFUN_INT_DIV(fmod, mpz_fdiv_r)
-DEFUN_INT_DIV(cdiv, mpz_cdiv_q)
-DEFUN_INT_DIV(cmod, mpz_cdiv_r)
-
-#define DEFUN_INT2INT(fname,mpz_fname)         \
-static VALUE r_gmpz_##fname(VALUE self)        \
-{                                              \
-  MP_INT *self_val, *res_val;                  \
-  VALUE res;                                   \
-  mpz_get_struct(self, self_val);              \
-  mpz_make_struct_init(res, res_val);          \
-  mpz_fname(res_val, self_val);                \
-  return res;                                  \
-}                                              \
-                                               \
-static VALUE r_gmpz_##fname##_self(VALUE self) \
-{                                              \
-  MP_INT *self_val;                            \
-  mpz_get_struct(self, self_val);              \
-  mpz_fname(self_val, self_val);               \
-  return Qnil;                                 \
-}
-
-DEFUN_INT2INT(abs, mpz_abs)
-DEFUN_INT2INT(neg, mpz_neg)
-DEFUN_INT2INT(com, mpz_com)
-DEFUN_INT2INT(sqrt, mpz_sqrt)
-DEFUN_INT2INT(nextprime, mpz_nextprime)
-
-/*
- * call-seq: probab_prime_p(reps)
- *
- * Determine whether n is prime. Return 2 if n is definitely prime, return 1 if
- * n is probably prime (without being certain), or return 0 if n is definitely
- * composite. 
- *
- * This function does some trial divisions, then some Miller-Rabin
- * probabilistic primality tests. reps controls how many such tests are done, 5
- * to 10 is a reasonable number, more will reduce the chances of a composite
- * being returned as �probably prime�.
- *
- * Miller-Rabin and similar tests can be more properly called compositeness
- * tests. Numbers which fail are known to be composite but those which pass
- * might be prime or might be composite. Only a few composites pass, hence
- * those which pass are considered probably prime. 
- */
-static VALUE r_gmpz_is_probab_prime(int argc, VALUE* argv, VALUE self)
-{
-  MP_INT *self_val;
-  int reps_val;
-  VALUE reps;
-  mpz_get_struct(self, self_val);
-  rb_scan_args(argc, argv, "01", &reps);
-  if(NIL_P(reps)){
-    reps = INT2FIX(5);
-  }
-  if (FIXNUM_P(reps)) {
-    reps_val = FIX2INT (reps);
-  } else {
-    typeerror_as(X, "reps");
-  }
-  return INT2FIX(mpz_probab_prime_p(self_val, reps_val));
-}
-
-static VALUE r_gmpz_popcount(VALUE self)
-{
-  MP_INT *self_val;
-  mpz_get_struct(self, self_val);
-  return INT2FIX(mpz_popcount(self_val));
-}
-
-static VALUE r_gmpz_jacobi(VALUE self)
-{
-  MP_INT *self_val, *res_val;
-  VALUE res;
-  mpz_get_struct(self, self_val);
-  if (mpz_sgn(self_val) != 1)
-    rb_raise(rb_eRangeError, "you can take jacobi symbol only of positive value");
-  if (mpz_even_p(self_val))
-    rb_raise(rb_eRangeError, "you can't take jacobi symbol of even value");
-  mpz_make_struct_init(res, res_val);
-  mpz_jacobi(res_val, self_val);
-  return res;
-}
-
-static VALUE r_gmpz_legendre(VALUE self)
-{
-  MP_INT *self_val, *res_val;
-  VALUE res;
-  mpz_get_struct(self, self_val);
-  if (mpz_sgn(self_val) != 1)
-    rb_raise(rb_eRangeError, "you can take legendre symbol only of positive value");
-  if (mpz_even_p(self_val))
-    rb_raise(rb_eRangeError, "you can't take legendre symbol of even value");
-    mpz_make_struct_init(res, res_val);
-  mpz_legendre(res_val, self_val);
-  return res;
-}
-
-#define DEFUN_INT_LOGIC(fname, mpz_fname) \
-static VALUE r_gmpz_##fname(VALUE self, VALUE arg) \
-{ \
-  MP_INT *self_val, *arg_val, *res_val; \
-  VALUE res; \
- \
-  mpz_get_struct(self, self_val); \
- \
-  mpz_make_struct(res, res_val); \
-  if (GMPZ_P(arg)) { \
-    mpz_get_struct(arg,arg_val); \
-    mpz_init (res_val); \
-    mpz_fname (res_val, self_val, arg_val); \
-  } else if (FIXNUM_P(arg)) { \
-    mpz_init_set_si (res_val, FIX2INT(arg)); \
-    mpz_fname (res_val, self_val, res_val); \
-  } else if (BIGNUM_P(arg)) { \
-    mpz_init (res_val); \
-    mpz_set_bignum (res_val, arg); \
-    mpz_fname (res_val, self_val, res_val); \
-  } else  { \
-    typeerror(ZXB); \
-  } \
-  return res; \
-}
-
-DEFUN_INT_LOGIC(and, mpz_and)
-DEFUN_INT_LOGIC(xor, mpz_xor)
-DEFUN_INT_LOGIC(or, mpz_ior)
-
-static VALUE r_gmpz_sqrtrem(VALUE self)
-{
-  MP_INT *self_val, *sqrt_val, *rem_val;
-  VALUE sqrt, rem;
-
-  mpz_get_struct (self, self_val);
-  mpz_make_struct_init(sqrt, sqrt_val);
-  mpz_make_struct_init(rem, rem_val);
-  mpz_sqrtrem (sqrt_val, rem_val, self_val);
-  return rb_assoc_new(sqrt, rem);
-}
-
-static VALUE r_gmpz_to_d(VALUE self)
-{
-  MP_INT *self_val;
-  mpz_get_struct (self, self_val);
-
-  return rb_float_new(mpz_get_d(self_val));
-}
-
-#define DEFUN_INT_SINGLETON_UI(fname,mpz_fname)  \
-static VALUE r_gmpzsg_##fname(VALUE klass, VALUE arg) \
-{ \
-  MP_INT *arg_val_z, *res_val; \
-  unsigned long arg_val_ul; \
-  VALUE res; \
- \
-  (void)klass; \
- \
-  if (FIXNUM_P(arg)) { \
-    arg_val_ul = FIX2INT (arg); \
-  } else if (GMPZ_P(arg)) { \
-    mpz_get_struct (arg, arg_val_z); \
-    if (!mpz_fits_ulong_p (arg_val_z)) \
-      rb_raise (rb_eRangeError, "argument out of range"); \
-    arg_val_ul = mpz_get_ui (arg_val_z); \
-    if (arg_val_ul == 0) \
-      rb_raise (rb_eRangeError, "argument out of range"); \
-  } else { \
-    typeerror_as (ZX, "argument"); \
-  } \
-  mpz_make_struct_init(res, res_val); \
-  mpz_fname (res_val, arg_val_ul); \
-  return res; \
-}
-
-DEFUN_INT_SINGLETON_UI(fib,mpz_fib_ui)
-DEFUN_INT_SINGLETON_UI(fac,mpz_fac_ui)
-
-static VALUE r_gmpzsg_pow(VALUE klass, VALUE base, VALUE exp)
-{
-  MP_INT *res_val;
-  VALUE res;
-
-  if (FIXNUM_P(base) && FIXNUM_P(exp))
-  {
-    if (FIX2INT(base) < 0)
-      rb_raise (rb_eRangeError, "base must not be negative");
-    if (FIX2INT(exp) < 0) 
-      rb_raise (rb_eRangeError, "exponent must not be negative");
-    mpz_make_struct_init (res, res_val);
-    mpz_ui_pow_ui (res_val, base, exp);
-    return res;
-  }
-  return r_gmpz_pow (r_gmpzsg_new(1, &base, klass), exp);
-}
-
-static VALUE r_gmpz_remove(VALUE self, VALUE arg)
-{
-  MP_INT *self_val, *arg_val, *res_val;
-  VALUE res;
-  int free_arg_val = 0;
-
-  mpz_get_struct(self,self_val);
-
-  if (GMPZ_P(arg)) {
-    mpz_get_struct(arg,arg_val);
-    if (mpz_sgn(arg_val) != 1)
-      rb_raise(rb_eRangeError, "argument must be positive");
-  } else if (FIXNUM_P(arg)) {
-    if (FIX2INT(arg) <= 0)
-      rb_raise(rb_eRangeError, "argument must be positive");
-    mpz_temp_alloc(arg_val);
-    mpz_init_set_ui(arg_val, FIX2INT(arg));
-  } else if (BIGNUM_P(arg)) {
-    mpz_temp_from_bignum(arg_val, arg);
-    if (mpz_sgn(arg_val) != 1) {
-      mpz_temp_free (arg_val);
-      rb_raise(rb_eRangeError, "argument must be positive");
-    }
-  } else {
-    typeerror(ZXB);
-  }
-
-  mpz_make_struct_init (res, res_val);
-  mpz_remove (res_val, self_val, arg_val);
-
-  if (free_arg_val)
-    mpz_temp_free(arg_val);
-
-  return res;
-}
-
-static VALUE r_gmpz_to_i(VALUE self)
-{
-  MP_INT *self_val;
-  char *str;
-  VALUE res;
-
-  mpz_get_struct(self, self_val);
-  if (mpz_fits_slong_p(self_val))
-    return rb_int2inum(mpz_get_si(self_val));
-  str = mpz_get_str(NULL, 0, self_val);
-  res = rb_cstr2inum (str, 10);
-  free (str);
-  return res;
-}
-
-static VALUE r_gmpz_cmpabs(VALUE self, VALUE arg)
-{
-  MP_INT *arg_val_z, *self_val;
-  MP_RAT *arg_val_q;
-  int res;
-
-  mpz_get_struct (self, self_val);
-
-  if (GMPZ_P(arg)) {
-    mpz_get_struct(arg,arg_val_z);
-    return INT2FIX(mpz_cmpabs (self_val, arg_val_z));
-  } else if (FIXNUM_P(arg)) {
-    if (FIX2INT(arg) >= 0)
-      return INT2FIX(mpz_cmpabs_ui (self_val, FIX2INT(arg)));
-    else
-      return INT2FIX(mpz_cmpabs_ui (self_val, -FIX2INT(arg)));
-  } else if (GMPQ_P(arg)) {
-    mpq_get_struct(arg,arg_val_q);
-    mpz_temp_alloc (arg_val_z);
-    mpz_init(arg_val_z);
-    mpz_mul(arg_val_z, self_val, mpq_denref(arg_val_q));
-    res = mpz_cmpabs (arg_val_z, mpq_numref(arg_val_q));
-    mpz_temp_free(arg_val_z);
-    return INT2FIX(res);
-  } else if (GMPF_P(arg)) {
-    not_yet;
-  } else if (BIGNUM_P(arg)) {
-    mpz_temp_from_bignum (arg_val_z, arg);
-    res = mpz_cmpabs (self_val, arg_val_z);
-    mpz_temp_free(arg_val_z);
-    return INT2FIX(res);
-  } else {
-    typeerror(ZQFXB);
-  }
-}
-
-static VALUE r_gmpz_to_s(VALUE self)
-{
-  MP_INT *self_val;
-  char *str;
-  VALUE res;
-
-  Data_Get_Struct(self, MP_INT, self_val);
-  str = mpz_get_str(NULL, 10, self_val);
-  res = rb_str_new2(str);
-  free (str);
-
-  return res;
-}
+#endif