sollya 0.1.0

data/ext/mpfr_rb.c

@@ -0,0 +1,4408 @@
+/* Copyright (C) 2024 Théotime Bollengier <theotime.bollengier@ensta-bretagne.fr>
+ *
+ * This file is part of Sollya.rb. <https://gitlab.ensta-bretagne.fr/bollenth/sollya.rb>
+ *
+ * Sollya.rb 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.
+ *
+ * Sollya.rb 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 Sollya.rb. If not, see <https://www.gnu.org/licenses/>. 
+ */
+
+#include <ruby.h>
+#include <mpfr.h>
+
+
+VALUE c_MPFR;
+
+static ID id_rndn;
+static ID id_rndz;
+static ID id_rndu;
+static ID id_rndd;
+static ID id_rnda;
+static ID id_rndf;
+static ID id_rndna;
+static ID id_round_nearest;
+static ID id_toward_zero;
+static ID id_round_up;
+static ID id_round_down;
+static ID id_away_from_zero;
+static ID id_faithful_rounding;
+static ID id_nearest;
+static ID id_zero;
+static ID id_up;
+static ID id_down;
+static ID id_away;
+static ID id_faithful;
+static ID id_nearest_ties_away;
+static ID id_prec;
+static ID id_conv;
+static ID id_round;
+static ID id_decimals;
+static ID id_to_mpfr;
+static ID id_chchleft;
+static ID id_orpipe;
+
+static mpfr_rnd_t mpfrrb_default_rounding = MPFR_RNDN;
+static ID         mpfrrb_default_rounding_id;
+static gmp_randstate_t mpfrrb_gmp_randstate;
+
+
+
+void mpfrrb_bignum_to_mpz(VALUE bignum, mpz_ptr mpz)
+{
+	size_t byte_size = rb_absint_size(bignum, NULL);
+	mpz_realloc2(mpz, (byte_size+1)*8);
+	mpz->_mp_size = (byte_size + sizeof(mp_limb_t) - 1) / sizeof(mp_limb_t);
+	if (rb_integer_pack(bignum, mpz->_mp_d, mpz->_mp_alloc, sizeof(mp_limb_t), GMP_NAIL_BITS, INTEGER_PACK_LITTLE_ENDIAN) < 0) {
+		mpz->_mp_size = -mpz->_mp_size;
+	}
+}
+
+
+static VALUE mpfrrb_mpz_to_bignum(mpz_ptr mpz)
+{
+	int is_neg = 0;
+	int nb_limbs = mpz->_mp_size;
+	if (nb_limbs < 0) {
+		is_neg = 1;
+		nb_limbs = -nb_limbs;
+	}
+	return rb_integer_unpack(mpz->_mp_d, nb_limbs, sizeof(mp_limb_t), GMP_NAIL_BITS,
+								 INTEGER_PACK_LITTLE_ENDIAN | (is_neg ? INTEGER_PACK_NEGATIVE : 0));
+}
+
+
+void mpfrrb_rational_to_mpq(VALUE rational, mpq_ptr mpq)
+{
+	mpfrrb_bignum_to_mpz(rb_rational_num(rational), &mpq->_mp_num);
+	mpfrrb_bignum_to_mpz(rb_rational_den(rational), &mpq->_mp_den);
+}
+
+
+static VALUE mpfrrb_mpq_to_rational(mpq_ptr mpq)
+{
+	return rb_rational_new(mpfrrb_mpz_to_bignum(&mpq->_mp_num), mpfrrb_mpz_to_bignum(&mpq->_mp_den));
+}
+
+
+/* @return [self]
+ */
+static VALUE mpfrrb_MPFR_to_mpfr(VALUE self)
+{
+	return self;
+}
+
+
+/* Return the MPFR version
+ * @return [String]
+ */
+static VALUE mpfrrb_get_version(VALUE self)
+{
+	return rb_str_freeze(rb_str_new_cstr(mpfr_get_version()));
+}
+
+
+/* Return a string containing the ids of the patches applied to the MPFR library (contents of the PATCHES file), separated by spaces.
+ * @return [String]
+ */
+static VALUE mpfrrb_get_patches(VALUE self)
+{
+	return rb_str_freeze(rb_str_new_cstr(mpfr_get_patches()));
+}
+
+
+/* Set the default precision to be exactly `prec` bits, where `prec` can be any integer between {MPFR::PREC_MIN} and {MPFR::PREC_MAX}.
+ * The precision of a variable means the number of bits used to store its significand.
+ * All subsequent calls to `MPFR.new` will use this precision, but previously initialized variables are unaffected.
+ * The default precision is set to 53 bits initially.
+ * @return [Integer]
+ */
+static VALUE mpfrrb_set_default_prec(VALUE self, VALUE prec)
+{
+	mpfr_prec_t p = NUM2LL(prec);
+	if (p < MPFR_PREC_MIN || p > MPFR_PREC_MAX) {
+		rb_raise(rb_eRangeError, "precision must be between %d and %ld, %ld is invalid", MPFR_PREC_MIN, MPFR_PREC_MAX, p);
+	}
+	mpfr_set_default_prec(p);
+	return prec;
+}
+
+
+/* Return the current default MPFR precision in bits.
+ * @return [Integer]
+ * @see default_prec=
+ */
+static VALUE mpfrrb_get_default_prec(VALUE self)
+{
+	(void)self;
+	return LL2NUM(mpfr_get_default_prec());
+}
+
+
+static mpfr_rnd_t mpfrrb_sym2rnd(VALUE sym)
+{
+	if (RB_NIL_P(sym)) {
+		return mpfrrb_default_rounding;
+	}
+
+	ID id = rb_sym2id(sym);
+	mpfr_rnd_t rnd;
+
+	if (id == id_rndn || id == id_round_nearest || id == id_nearest) {
+		rnd = MPFR_RNDN;
+	} else if (id == id_rndu || id == id_round_up || id == id_up) {
+		rnd = MPFR_RNDU;
+	} else if (id == id_rndd || id == id_round_down || id == id_down) {
+		rnd = MPFR_RNDD;
+	} else if (id == id_rndz || id == id_toward_zero || id == id_zero) {
+		rnd = MPFR_RNDZ;
+	} else if (id == id_rnda || id == id_away_from_zero || id == id_away) {
+		rnd = MPFR_RNDA;
+	} else if (id == id_rndf || id == id_faithful_rounding || id == id_faithful) {
+		rnd = MPFR_RNDF;
+	} else if (id == id_rndna || id == id_nearest_ties_away) {
+		rnd = MPFR_RNDNA;
+	} else {
+		rb_raise(rb_eArgError, "expecting :rndn, :rndu, :rndd, :rndz, :rnda, :rndf, :rndna, :round_up, :round_down, :toward_zero, :away_from_zero or :faithful_rounding, not %" PRIsVALUE, sym);
+	}
+
+	return rnd;
+}
+
+
+static mpfr_rnd_t mpfrrb_get_round_single_keword(int argc, VALUE *argv)
+{
+	mpfr_rnd_t rnd = mpfrrb_default_rounding;
+	if (argc > 0) {
+		VALUE kw;
+		const ID kwkeys[1] = {id_round};
+		VALUE kwvalues[1] = {Qundef};
+		rb_scan_args(argc, argv, ":", &kw);
+		if (!NIL_P(kw)) {
+			rb_get_kwargs(kw, kwkeys, 0, 1, kwvalues);
+			if (kwvalues[0] != Qundef) {
+				rnd = mpfrrb_sym2rnd(kwvalues[0]);
+			}
+		}
+	}
+	return rnd;
+}
+
+
+static mpfr_rnd_t mpfrrb_get_4_args_and_round(int argc, VALUE *argv, VALUE *values)
+{
+	mpfr_rnd_t rnd = mpfrrb_default_rounding;
+	VALUE kw;
+	const ID kwkeys[1] = {id_round};
+	VALUE kwvalues[1] = {Qundef};
+	rb_scan_args(argc, argv, "4:", &values[0], &values[1], &values[2], &values[3], &kw);
+	if (!NIL_P(kw)) {
+		rb_get_kwargs(kw, kwkeys, 0, 1, kwvalues);
+		if (kwvalues[0] != Qundef) {
+			rnd = mpfrrb_sym2rnd(kwvalues[0]);
+		}
+	}
+	return rnd;
+}
+
+
+static mpfr_rnd_t mpfrrb_get_a_b_c_round(int argc, VALUE *argv, VALUE *a, VALUE *b, VALUE *c)
+{
+	mpfr_rnd_t rnd = mpfrrb_default_rounding;
+	VALUE kw;
+	const ID kwkeys[1] = {id_round};
+	VALUE kwvalues[1] = {Qundef};
+	rb_scan_args(argc, argv, "3:", a, b, c, &kw);
+	if (!NIL_P(kw)) {
+		rb_get_kwargs(kw, kwkeys, 0, 1, kwvalues);
+		if (kwvalues[0] != Qundef) {
+			rnd = mpfrrb_sym2rnd(kwvalues[0]);
+		}
+	}
+	return rnd;
+}
+
+
+static mpfr_rnd_t mpfrrb_get_a_b_round(int argc, VALUE *argv, VALUE *a, VALUE *b)
+{
+	mpfr_rnd_t rnd = mpfrrb_default_rounding;
+	VALUE kw;
+	const ID kwkeys[1] = {id_round};
+	VALUE kwvalues[1] = {Qundef};
+	rb_scan_args(argc, argv, "2:", a, b, &kw);
+	if (!NIL_P(kw)) {
+		rb_get_kwargs(kw, kwkeys, 0, 1, kwvalues);
+		if (kwvalues[0] != Qundef) {
+			rnd = mpfrrb_sym2rnd(kwvalues[0]);
+		}
+	}
+	return rnd;
+}
+
+
+static mpfr_rnd_t mpfrrb_get_b_round(int argc, VALUE *argv, VALUE *b)
+{
+	mpfr_rnd_t rnd = mpfrrb_default_rounding;
+	VALUE kw;
+	const ID kwkeys[1] = {id_round};
+	VALUE kwvalues[1] = {Qundef};
+	rb_scan_args(argc, argv, "1:", b, &kw);
+	if (!NIL_P(kw)) {
+		rb_get_kwargs(kw, kwkeys, 0, 1, kwvalues);
+		if (kwvalues[0] != Qundef) {
+			rnd = mpfrrb_sym2rnd(kwvalues[0]);
+		}
+	}
+	return rnd;
+}
+
+
+/* Set the default rounding used when the `:round` keyword is not set.
+ * The value can be:
+ * - `:rndn`, `:round_nearest`, `:nearest` : round to nearest, with the even rounding rule (roundTiesToEven in IEEE 754).
+ * - `:rndu`, `:round_up`, `:up` : round toward positive infinity (roundTowardPositive in IEEE 754). In case the number to be rounded lies exactly in the middle between two consecutive representable numbers, it is rounded to the one with an even significand; in radix 2, this means that the least significant bit is 0.
+ * - `:rndd`, `:round_down`, `:down` : round toward negative infinity (roundTowardNegative in IEEE 754).
+ * - `:rndz`, `:toward_zero`, `:zero` : round toward zero (roundTowardZero in IEEE 754).
+ * - `:rnda`, `:away_from_zero`, `:away` : round away from zero.
+ * - `:rndf`, `:faithful_rounding`, `:faithful` : faithful rounding. This feature is currently experimental.
+ * - `:rndna`, `:nearest_ties_away`
+ * @param rounding [Symbol]
+ * @return [Symbol]
+ */
+static VALUE mpfrrb_set_default_rounding(VALUE self, VALUE rounding)
+{
+	if (!RB_SYMBOL_P(rounding))
+		rb_raise(rb_eTypeError, "expecting a symbol, not a %s", rb_obj_classname(rounding));
+
+	mpfrrb_default_rounding = mpfrrb_sym2rnd(rounding);
+	mpfrrb_default_rounding_id = rb_sym2id(rounding);
+
+	return rounding;
+}
+
+
+/* Return the default rounding used when the `:round` keyword is not set.
+ * @return [Symbol]
+ * @see default_rounding=
+ */
+static VALUE mpfrrb_get_default_rounding(VALUE self)
+{
+	(void)self;
+	return rb_id2sym(mpfrrb_default_rounding_id);
+}
+
+
+static void mpfrrb_free(void *p)
+{
+	mpfr_ptr mp = (mpfr_ptr)p;
+	if (mp) {
+		mpfr_clear(mp);
+		free(mp);
+	}
+}
+
+
+static size_t mpfrrb_size(const void *p)
+{
+	mpfr_ptr mp = (mpfr_ptr)p;
+	mpfr_prec_t prec = mp->_mpfr_prec;
+	size_t limb_size;
+	if (prec >= 1) {
+		limb_size = ((prec - 1) / GMP_NUMB_BITS + 1 + 1)*sizeof(mp_limb_t);
+	} else {
+		limb_size = 0;
+	}
+	return sizeof(__mpfr_struct) + limb_size;
+}
+
+
+const rb_data_type_t mpfrrb_type = {
+	.wrap_struct_name = "MPFR",
+	.function = {
+		.dmark = NULL,
+		.dfree = mpfrrb_free,
+		.dsize = mpfrrb_size,
+	},
+	.parent = NULL,
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+
+mpfr_ptr mpfrrb_rb2ref_ext(VALUE obj) {
+	mpfr_ptr p;
+	TypedData_Get_Struct(obj, __mpfr_struct, &mpfrrb_type, p);
+	return p;
+}
+
+
+static inline mpfr_ptr mpfrrb_rb2ref(VALUE obj) {
+	mpfr_ptr p;
+	TypedData_Get_Struct(obj, __mpfr_struct, &mpfrrb_type, p);
+	return p;
+}
+
+
+VALUE mpfrrb_alloc(VALUE klass)
+{
+	mpfr_ptr mp = malloc(sizeof(__mpfr_struct));
+	memset(mp, 0, sizeof(__mpfr_struct));
+	return TypedData_Wrap_Struct(klass, &mpfrrb_type, mp);
+}
+
+
+static int mpfrrb_set_internal(mpfr_ptr mp, mpfr_rnd_t rnd, VALUE valrb, VALUE self)
+{
+	int r;
+	if (RB_FLOAT_TYPE_P(valrb)) {
+		r = mpfr_set_d(mp, NUM2DBL(valrb), rnd);
+	} else if (RB_FIXNUM_P(valrb)) {
+		r = mpfr_set_si(mp, NUM2LL(valrb), rnd);
+	} else if (RB_TYPE_P(valrb, T_BIGNUM)) {
+		mpz_t mpz;
+		mpz_init(mpz);
+		mpfrrb_bignum_to_mpz(valrb, mpz);
+		r = mpfr_set_z(mp, mpz, rnd);
+		mpz_clear(mpz);
+	} else if (RB_TYPE_P(valrb, T_RATIONAL)) {
+		mpq_t mpq;
+		mpq_init(mpq);
+		mpfrrb_rational_to_mpq(valrb, mpq);
+		r = mpfr_set_q(mp, mpq, rnd);
+		mpq_clear(mpq);
+	} else if (RB_TYPE_P(valrb, T_STRING)) {
+		const char *str = rb_string_value_cstr(&valrb);
+		char *endptr;
+		r = mpfr_strtofr(mp, str, &endptr, 0, rnd);
+		if (*endptr != '\0') {
+			rb_raise(rb_eRuntimeError, "cannot convert \"%" PRIsVALUE "\" into an MPFR object", valrb);
+		}
+	} else if (rb_obj_is_kind_of(valrb, c_MPFR)) {
+		r = mpfr_set(mp, mpfrrb_rb2ref(valrb), rnd);
+	} else {
+		rb_raise(rb_eTypeError, "expecting a float, an integer, a rational, a string or a %s, not a %s", rb_obj_classname(self), rb_obj_classname(valrb));
+	}
+	return r;
+}
+
+/* Create a new MPFR object of a given precision (number of bits), and optionaly initializes it with the given value in the rounding direction.
+ * @return [MPFR]
+ * @overload new(value = Float::NAN, round: MPFR.default_rounding, prec: MPFR.default_prec)
+ *  @param value [Float, Integer, Rational, String, MPFR]
+ *  @param round [Symbol] rounding direction, used only if `value` is given
+ *  @param prec [Integer] the precision of the MPFR object, that is the size in bits of the significand
+ */
+static VALUE mpfrrb_initialize(int argc, VALUE *argv, VALUE self)
+{
+	if (argc == 0) {
+		mpfr_init(mpfrrb_rb2ref(self));
+		return self;
+	}
+
+	VALUE valrb;
+	VALUE kw;
+	const ID kwkeys[2] = {id_prec, id_round};
+	VALUE kwvalues[2] = {Qundef, Qundef};
+	mpfr_rnd_t rnd = mpfrrb_default_rounding;
+	mpfr_prec_t prec = mpfr_get_default_prec();
+	rb_scan_args(argc, argv, "01:", &valrb, &kw);
+	if (!NIL_P(kw)) {
+		rb_get_kwargs(kw, kwkeys, 0, 2, kwvalues);
+		if (kwvalues[0] != Qundef) {
+			if (!rb_integer_type_p(kwvalues[0])) {
+				rb_raise(rb_eTypeError, "precision must be an integer, not a %s", rb_obj_classname(kwvalues[0]));
+			}
+			prec = NUM2ULL(kwvalues[0]);
+			if (prec < MPFR_PREC_MIN || prec > MPFR_PREC_MAX) {
+				rb_raise(rb_eRangeError, "precision must be between %d and %ld, %ld is invalid", MPFR_PREC_MIN, MPFR_PREC_MAX, prec);
+			}
+		}
+		if (kwvalues[1] != Qundef) {
+			rnd = mpfrrb_sym2rnd(kwvalues[1]);
+		}
+	}
+
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	mpfr_init2(mp, prec);
+
+	if (!NIL_P(valrb)) {
+		mpfrrb_set_internal(mp, rnd, valrb, self);
+	}
+	
+	return self;
+}
+
+
+/* Set the value of the MPFR object.
+ * @return [Integer]
+ * @overload set(value, round: MPFR.default_rounding)
+ *  @param value [Float, Integer, Rational, String, MPFR]
+ *  @param rnd [Symbol], either `:nearest`, `:up`, `:down`, `:zero`, `:rndn`, `:rndu`, `:rndd`, `:rndz`, `:rnda`, `:rndf`, `:rndna`, `:round_up`, `:round_down`, `:toward_zero`, `:away_from_zero` or `:faithful_rounding`
+ */
+static VALUE mpfrrb_set(int argc, VALUE *argv, VALUE self)
+{
+	VALUE valrb;
+	VALUE kw;
+	const ID kwkeys[1] = {id_round};
+	VALUE kwvalues[1] = {Qundef};
+	rb_scan_args(argc, argv, "1:", &valrb, &kw);
+	mpfr_rnd_t rnd = mpfrrb_default_rounding;
+	if (!NIL_P(kw)) {
+		rb_get_kwargs(kw, kwkeys, 0, 1, kwvalues);
+		if (kwvalues[0] != Qundef) {
+			rnd = mpfrrb_sym2rnd(kwvalues[0]);
+		}
+	}
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfrrb_set_internal(mp, rnd, valrb, self);
+	return INT2NUM(r);
+}
+
+
+/* Return a MPFR object with a precision of 53 bits whose value is self.
+ * @return [MPFR]
+ */
+static VALUE mpfrrb_Float_to_mpfr(VALUE self)
+{
+	VALUE obj = mpfrrb_alloc(c_MPFR);
+	mpfr_ptr mp = mpfrrb_rb2ref(obj);
+	mpfr_init2(mp, 53);
+	mpfr_set_d(mp, NUM2DBL(self), MPFR_RNDN);
+	return obj;
+}
+
+
+/* Return a MPFR object with a just enough bits of precision to accomodate the value of self.
+ * @return [MPFR]
+ */
+static VALUE mpfrrb_Integer_to_mpfr(VALUE self)
+{
+	if (RB_FIXNUM_P(self)) {
+		long int v = NUM2LL(self);
+		mpfr_prec_t p;
+		if (v > 0) {
+			p = (mpfr_prec_t)ceil(log2((double)(v + 1)));
+		} else if (v < 0) {
+			p = (mpfr_prec_t)ceil(log2((double)(1 - v)));
+		} else {
+			p = 1;
+		}
+		VALUE obj = mpfrrb_alloc(c_MPFR);
+		mpfr_ptr mp = mpfrrb_rb2ref(obj);
+		mpfr_init2(mp, p);
+		mpfr_set_si(mp, v, MPFR_RNDN);
+		return obj;
+	} else {
+		mpz_t mpz;
+		mpz_init(mpz);
+		mpfrrb_bignum_to_mpz(self, mpz);
+		int nlz_bits_ret;
+		size_t nb_bytes = rb_absint_size(self, &nlz_bits_ret);
+		mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret;
+		VALUE obj = mpfrrb_alloc(c_MPFR);
+		mpfr_ptr mp = mpfrrb_rb2ref(obj);
+		mpfr_init2(mp, p);
+		mpfr_set_z(mp, mpz, MPFR_RNDN);
+		mpz_clear(mpz);
+		return obj;
+	}
+}
+
+
+static VALUE mpfrrb_object_to_mpfr(VALUE obj)
+{
+	if (RB_FLOAT_TYPE_P(obj)) {
+		return mpfrrb_Float_to_mpfr(obj);
+	} else if (RB_INTEGER_TYPE_P(obj)) {
+		return mpfrrb_Integer_to_mpfr(obj);
+	} else if (rb_obj_is_kind_of(obj, c_MPFR)) {
+		return obj;
+	}
+	return rb_funcallv(obj, id_to_mpfr, 0, NULL);
+}
+
+
+/* Return the precision of `self`, i.e., the number of bits used to store its significand.
+ * @return [Integer]
+ */
+static VALUE mpfrrb_get_prec(VALUE self)
+{
+	return LL2NUM(mpfr_get_prec(mpfrrb_rb2ref(self)));
+}
+
+
+/* Set the precision of `self` to be exactly `prec` bits, and set its value to NaN.
+ * The previous value stored in `self` is lost.
+ * In case you want to keep the previous value stored in `self`, use {#prec_round} instead.
+ * @see prec_round
+ */
+static VALUE mpfrrb_set_prec(VALUE self, VALUE precrb)
+{
+	mpfr_prec_t prec = NUM2LL(precrb);
+	if (prec < MPFR_PREC_MIN || prec > MPFR_PREC_MAX) {
+		rb_raise(rb_eRangeError, "precision must be between %d and %ld, %ld is invalid", MPFR_PREC_MIN, MPFR_PREC_MAX, prec);
+	}
+	mpfr_set_prec(mpfrrb_rb2ref(self), prec);
+	return precrb;
+}
+
+
+// static VALUE mpfrrb_to_s_autoprec(mpfr_ptr mp, char conv, mpfr_rnd_t rnd)
+// {
+// 	VALUE res;
+// 	int ndigits = mpfr_get_str_ndigits(10, mpfr_get_prec(mp));
+// 	char *str = NULL;
+// 	char fmt[16];
+// 	ruby_snprintf(fmt, sizeof(fmt), "%%.*R*%c", conv);
+// 	int l = mpfr_asprintf(&str, fmt, ndigits, rnd, mp);
+// //	printf("ndigits = %d, str = \"%s\", l = %d\n", ndigits, str, l);
+// 	if (l < 1 || str == NULL) {
+// 		return Qnil;
+// 	}
+// 	int start_pos = -1;
+// 	int point_pos = -1;
+// 	int trail_pos = -1;
+// 	int i = 0;
+// 	char c;
+// 	while ((c = str[i]) != '\0') {
+// 		if (c >= '0' && c <= '9' && start_pos < 0) {
+// 			start_pos = i;
+// 		} else if (c == '.' && point_pos < 0) {
+// 			point_pos = i;
+// 		} else if (c != '-' && c != '+' && (c < '0' || c > '9') && trail_pos < 0) {
+// 			trail_pos = i;
+// 		}
+// 		i++;
+// 	}
+// 	if (trail_pos < 0) {
+// 		trail_pos = l;
+// 	}
+// //	printf("start_pos = %d, point_pos = %d, trail_pos = %d\n", start_pos, point_pos, trail_pos);
+// 	if (start_pos < 0 || point_pos < 0) {
+// 		goto mpfrrb_to_s_autoprec_end;
+// 	}
+// 	int integer_len = point_pos - start_pos;
+// 	int new_frac_len = ndigits - integer_len;
+// //	printf("integer_len = %d, new_frac_len = %d\n", integer_len, new_frac_len);
+// 	if (new_frac_len < 1) {
+// 		goto mpfrrb_to_s_autoprec_end;
+// 	}
+// 	int new_trail_pos = point_pos + new_frac_len + 1;
+// //	printf("new_trail_pos = %d\n", new_trail_pos);
+// 	if (new_trail_pos >= trail_pos || new_trail_pos == l) {
+// 		goto mpfrrb_to_s_autoprec_end;
+// 	}
+// 
+// 	while (1) {
+// 		c = str[trail_pos++];
+// 		str[new_trail_pos++] = c;
+// 		if (c == '\0') {
+// 			break;
+// 		}
+// 	}
+// 
+// mpfrrb_to_s_autoprec_end:
+// 	res = rb_str_new(str, l);
+// 	mpfr_free_str(str);
+// 	return res;
+// }
+
+
+/* Return a string representation of the number.
+ * @return [String]
+ * @overload to_s(conv: 'g', round: :nearest, decimals: nil)
+ *  @param conf [String]
+ *   The conversion specifier can be:
+ *   - `'a'`, `'A'`: hex float, C99 style,
+ *   - `'b'`: binary output,
+ *   - `'e'`, `'E'`: scientific-format float,
+ *   - `'f'`, `'F'`: fixed-point float,
+ *   - `'g'`, `'G'`: fixed-point or scientific float.
+ *  @param rnd [Symbol] Rounding direction, either `:rndn`, `:rndu`, `:rndd`, `:rndz`, `:rnda`, `:rndf`, `:rndna`, `:round_up`, `:round_down`, `:toward_zero`, `:away_from_zero` or `:faithful_rounding`
+ *  @param decimals [Integer] number of digits to display.
+ */
+static VALUE mpfrrb_to_s(int argc, VALUE *argv, VALUE self)
+{
+	VALUE kw;
+	const ID kwkeys[3] = {id_conv, id_round, id_decimals};
+	VALUE kwvalues[3] = {Qundef, Qundef, Qundef};
+
+	mpfr_rnd_t rnd = MPFR_RNDN;
+	char conv = 'g';
+	int n_decimals = 0;
+
+	rb_scan_args(argc, argv, ":", &kw);
+	if (!NIL_P(kw)) {
+		rb_get_kwargs(kw, kwkeys, 0, 3, kwvalues);
+		if (kwvalues[0] != Qundef) {
+			Check_Type(kwvalues[0], T_STRING);
+			const char *convstr = RSTRING_PTR(kwvalues[0]);
+			int len = RSTRING_LEN(kwvalues[0]);
+			if (len != 1 || (convstr[0] != 'a' && convstr[0] != 'A' && convstr[0] != 'b' && convstr[0] != 'e' && convstr[0] != 'E' && convstr[0] != 'f' && convstr[0] != 'F' && convstr[0] != 'g' && convstr[0] != 'G')) {
+				rb_raise(rb_eArgError, "conv must be 'a', 'A', 'b', 'e', 'E', 'f', 'F', 'g' or 'G', \"%" PRIsVALUE "\" is invalid", kwvalues[0]);
+			}
+			conv = convstr[0];
+		}
+		if (kwvalues[1] != Qundef) {
+			rnd = mpfrrb_sym2rnd(kwvalues[1]);
+		}
+		if (kwvalues[2] != Qundef) {
+			n_decimals = NUM2INT(kwvalues[2]);
+		}
+	}
+
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	if (mpfr_nan_p(mp)) {
+		return rb_sprintf("NaN");
+	} else if (mpfr_inf_p(mp)) {
+		if (mpfr_sgn(mp) < 0) {
+			return rb_sprintf("-Infinity");
+		} else {
+			return rb_sprintf("Infinity");
+		}
+	}
+
+//	if (n_decimals == 0 && conv != 'a' && conv != 'A' && conv != 'b' && conv != 'B') {
+//		return mpfrrb_to_s_autoprec(mp, conv, rnd);
+//	}
+	if (n_decimals == 0 && conv != 'a' && conv != 'A' && conv != 'b' && conv != 'B') {
+		n_decimals = mpfr_get_str_ndigits(10, mpfr_get_prec(mp));
+	}
+
+	char fmt[16];
+	char *str = NULL;
+	int s;
+	if (n_decimals > 0) {
+		ruby_snprintf(fmt, sizeof(fmt), "%%.*R*%c", conv);
+		s = mpfr_asprintf(&str, fmt, n_decimals, rnd, mp);
+	} else {
+		ruby_snprintf(fmt, sizeof(fmt), "%%R*%c", conv);
+		s = mpfr_asprintf(&str, fmt, rnd, mp);
+	}
+	if (s < 1 || str == NULL) {
+		return Qnil;
+	}
+	VALUE res = rb_str_new(str, s);
+	mpfr_free_str(str);
+	return res;
+}
+
+
+/* @return [Ingeger, nil] either -1 or 1
+ */
+static VALUE mpfrrb_get_sign(VALUE self)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	if (mpfr_nan_p(mp)) {
+		return Qnil;
+	}
+	return INT2NUM(mpfr_sgn(mp) >= 0 ? 1 : -1);
+}
+
+
+/* Set the sign of `self` to the sign of the argument.
+ * @param s [Integer], either 1 or -1
+ */
+static VALUE mpfrrb_set_sign(VALUE self, VALUE s)
+{
+	int p = NUM2INT(s);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	mpfr_setsign(mp, mp, p < 0, MPFR_RNDN);
+	return s;
+}
+
+
+/* Return the exponent of `self`, assuming that `self` is a non-zero ordinary number and the significand is considered in [1, 2).
+ * @return [Integer,nil]
+ */
+static VALUE mpfrrb_get_exponent(VALUE self)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	if (mpfr_nan_p(mp) || mpfr_inf_p(mp)) {
+		return Qnil;
+	} else if (mpfr_zero_p(mp)) {
+		return INT2NUM(0);
+	}
+	return LL2NUM(mpfr_get_exp(mp) - 1ll);
+}
+
+
+/* Set the exponent of `self` to `e`, assuming the significand in [1, 2).
+ * `self` must be an ordinary number (not nan, infinity nor zero).
+ * @param e [Integer]
+ */
+static VALUE mpfrrb_set_exponent(VALUE self, VALUE e)
+{
+	mpfr_exp_t p = NUM2LONG(e);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	if (!mpfr_regular_p(mp)) {
+		rb_raise(rb_eRuntimeError, "trying to set the exponent of a non-regular MPFR object");
+	}
+	p += 1;
+	mpfr_set_exp(mp, p);
+	return e;
+}
+
+
+/* Tels if self is zero.
+ * @return [Boolean]
+ */
+static VALUE mpfrrb_is_zero(VALUE self)
+{
+	return mpfr_zero_p(mpfrrb_rb2ref(self)) ? Qtrue : Qfalse;
+}
+
+
+/* Tels if self does not represent a number.
+ * @return [Boolean]
+ */
+static VALUE mpfrrb_is_nan(VALUE self)
+{
+	return mpfr_nan_p(mpfrrb_rb2ref(self)) ? Qtrue : Qfalse;
+}
+
+
+/* Tels if self is an infinity.
+ * @return [Boolean]
+ */
+static VALUE mpfrrb_is_infinite(VALUE self)
+{
+	return mpfr_inf_p(mpfrrb_rb2ref(self)) ? Qtrue : Qfalse;
+}
+
+
+/* Tels if self is neither an infinity nor NaN.
+ * @return [Boolean]
+ */
+static VALUE mpfrrb_is_finite(VALUE self)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	return mpfr_number_p(mp) ? Qtrue : Qfalse;
+}
+
+
+/* Tels if the fractional part of self is null.
+ * @return [Boolean]
+ */
+static VALUE mpfrrb_is_integer(VALUE self)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	return mpfr_integer_p(mp) ? Qtrue : Qfalse;
+}
+
+
+/* @return [Float]
+ * @overload to_f(round: MPFR.default_rounding)
+ *  @param rnd [Symbol]
+ */
+static VALUE mpfrrb_to_f(int argc, VALUE *argv, VALUE self)
+{
+	mpfr_rnd_t rnd = mpfrrb_get_round_single_keword(argc, argv);
+	return DBL2NUM(mpfr_get_d(mpfrrb_rb2ref(self), rnd));
+}
+
+
+/* @return [Integer]
+ * @overload to_i(round: MPFR.default_rounding)
+ *  @param rnd [Symbol]
+ */
+static VALUE mpfrrb_to_i(int argc, VALUE *argv, VALUE self)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	if (mpfr_nan_p(mp)) {
+		rb_raise(rb_eFloatDomainError, "NaN");
+	} else if (mpfr_inf_p(mp)) {
+		rb_raise(rb_eFloatDomainError, "Infinity");
+	} else if (mpfr_zero_p(mp)) {
+		return INT2NUM(0);
+	}
+
+	mpfr_rnd_t rnd = mpfrrb_get_round_single_keword(argc, argv);
+
+	if (mpfr_fits_slong_p(mp, rnd)) {
+		return LL2NUM(mpfr_get_si(mp, rnd));
+	}
+
+	mpz_t mpz;
+	mpz_init(mpz);
+	mpfr_get_z(mpz, mp, rnd);
+	VALUE rbint = mpfrrb_mpz_to_bignum(mpz);
+	mpz_clear(mpz);
+	return rbint;
+}
+
+
+/* Convert the MPFR object to a rational.
+ * Conversion is always exact, no rounding has to be specified.
+ * @return [Rational]
+ */
+static VALUE mpfrrb_to_r(VALUE self)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	if (mpfr_nan_p(mp)) {
+		rb_raise(rb_eFloatDomainError, "NaN");
+	} else if (mpfr_inf_p(mp)) {
+		rb_raise(rb_eFloatDomainError, "Infinity");
+	} else if (mpfr_zero_p(mp)) {
+		return rb_rational_new(INT2NUM(0), INT2NUM(1));
+	}
+
+	mpq_t mpq;
+	mpq_init(mpq);
+	mpfr_get_q(mpq, mp);
+	VALUE rat = mpfrrb_mpq_to_rational(mpq);
+	mpq_clear(mpq);
+	return rat;
+}
+
+
+/* Set `self` to NaN.
+ * @return [self]
+ */
+static VALUE mpfrrb_set_nan(VALUE self)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	mpfr_set_nan(mp);
+	return self;
+}
+
+
+/* Set `self` to zero.
+ * @return [self]
+ * @overload set_zero(sign = 1)
+ *  @param sign [Integer] the sign bit is set if `sign` < 0
+ */
+static VALUE mpfrrb_set_zero(int argc, VALUE *argv, VALUE self)
+{
+	VALUE signrb;
+	int sign = 1;
+	if (argc > 0) {
+		rb_scan_args(argc, argv, "01", &signrb);
+		if (!NIL_P(signrb)) {
+			sign = NUM2INT(signrb);
+		}
+	}
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	mpfr_set_zero(mp, sign);
+	return self;
+}
+
+
+/* Set `self` to infinity.
+ * @return [self]
+ * @overload set_infinity(sign = 1)
+ *  @param sign [Integer] the sign bit is set if `sign` < 0
+ */
+static VALUE mpfrrb_set_infinity(int argc, VALUE *argv, VALUE self)
+{
+	VALUE signrb;
+	int sign = 1;
+	if (argc > 0) {
+		rb_scan_args(argc, argv, "01", &signrb);
+		if (!NIL_P(signrb)) {
+			sign = NUM2INT(signrb);
+		}
+	}
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	mpfr_set_inf(mp, sign);
+	return self;
+}
+
+
+/* Round `self` according to `round` with precision `prec`.
+ * If `prec` is greater than or equal to the precision of `self`, then new space is allocated for the significand, and it is filled with zeros.
+ * Otherwise, the significand is rounded to precision `prec` with the given direction; no memory reallocation to free the unused limbs is done.
+ * In both cases, the precision of `self` is changed to `prec`.
+ * @return [Integer]
+ * @overload prec_round(prec, round: MPFR.default_rounding)
+ *  @param prec [Integer] The new precision. It must be an integer between MPFR::PREC_MIN and MPFR::PREC_MAX (otherwise the behavior is undefined). 
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_prec_round(int argc, VALUE *argv, VALUE self)
+{
+	VALUE precrb;
+	VALUE kw;
+	const ID kwkeys[1] = {id_round};
+	VALUE kwvalues[1] = {Qundef};
+	rb_scan_args(argc, argv, "1:", &precrb, &kw);
+	mpfr_rnd_t rnd = mpfrrb_default_rounding;
+	mpfr_prec_t prec = NUM2LL(precrb);
+	if (prec < MPFR_PREC_MIN || prec > MPFR_PREC_MAX) {
+		rb_raise(rb_eRangeError, "precision must be between %d and %ld, %ld is invalid", MPFR_PREC_MIN, MPFR_PREC_MAX, prec);
+	}
+	if (!NIL_P(kw)) {
+		rb_get_kwargs(kw, kwkeys, 0, 1, kwvalues);
+		if (kwvalues[0] != Qundef) {
+			rnd = mpfrrb_sym2rnd(kwvalues[0]);
+		}
+	}
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_prec_round(mp, prec, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set `self` to the logarithm of 2, rounded in the given direction.
+ * @return [Integer]
+ * @overload set_log2(round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_set_log2(int argc, VALUE *argv, VALUE self)
+{
+	mpfr_rnd_t rnd = mpfrrb_get_round_single_keword(argc, argv);
+	return INT2NUM(mpfr_const_log2(mpfrrb_rb2ref(self), rnd));
+}
+
+
+/* Set `self` to the value of Pi, rounded in the given direction.
+ * @return [Integer]
+ * @overload set_pi(round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_set_pi(int argc, VALUE *argv, VALUE self)
+{
+	mpfr_rnd_t rnd = mpfrrb_get_round_single_keword(argc, argv);
+	return INT2NUM(mpfr_const_pi(mpfrrb_rb2ref(self), rnd));
+}
+
+
+/* Set `self` to the value of of Euler's constant 0.577..., rounded in the given direction.
+ * @return [Integer]
+ * @overload set_euler(round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_set_euler(int argc, VALUE *argv, VALUE self)
+{
+	mpfr_rnd_t rnd = mpfrrb_get_round_single_keword(argc, argv);
+	return INT2NUM(mpfr_const_euler(mpfrrb_rb2ref(self), rnd));
+}
+
+
+/* Set `self` to the value of of Catalan's constant 0.915..., rounded in the given direction.
+ * @return [Integer]
+ * @overload set_catalan(round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_set_catalan(int argc, VALUE *argv, VALUE self)
+{
+	mpfr_rnd_t rnd = mpfrrb_get_round_single_keword(argc, argv);
+	return INT2NUM(mpfr_const_catalan(mpfrrb_rb2ref(self), rnd));
+}
+
+
+/* Return `[d, e]` such that 1 ≤ abs(d) < 2 and `d` times 2 raised to `e` equals `self` rounded to double precision,
+ * using the given rounding mode.
+ * @return [Array<Float, Integer>] 
+ * @overload get_d_2exp(round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_get_d_2exp(int argc, VALUE *argv, VALUE self)
+{
+	mpfr_rnd_t rnd = mpfrrb_get_round_single_keword(argc, argv);
+	long e = 0;
+	double d = mpfr_get_d_2exp(&e, mpfrrb_rb2ref(self), rnd);
+	d *= 2.0;
+	e -= 1;
+	VALUE rbd = DBL2NUM(d);
+	VALUE rbe = isfinite(d) ? LONG2NUM(e) : Qnil;
+	return rb_ary_new_from_args(2, rbd, rbe);
+}
+
+
+/* Return `[i, e]` such that `self` exactly equals `i` times 2 raised to the power `e`.
+ * @return [Array<Integer, Integer>] 
+ */
+static VALUE mpfrrb_get_i_2exp(VALUE self)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	if (mpfr_nan_p(mp)) {
+		rb_raise(rb_eFloatDomainError, "NaN");
+	} else if (mpfr_inf_p(mp)) {
+		rb_raise(rb_eFloatDomainError, "Infinity");
+	} else if (mpfr_zero_p(mp)) {
+		return rb_ary_new_from_args(2, INT2NUM(0), INT2NUM(0));
+	}
+
+	mpz_t mpz;
+	mpz_init(mpz);
+	mpfr_exp_t e = mpfr_get_z_2exp(mpz, mpfrrb_rb2ref(self));
+	VALUE rbi = mpfrrb_mpz_to_bignum(mpz);
+	mpz_clear(mpz);
+	return rb_ary_new_from_args(2, rbi, LL2NUM(e));
+}
+
+
+/* Return a new MPFR object from the value of `i` multiplied by two to the power `e`.
+ * The precision of the returned object is set to accomodate `i` exactly.
+ * @param i [Integer]
+ * @param e [Integer]
+ * @return [MPFR] i*2^e
+ */
+static VALUE mpfrrb_i_2exp(VALUE self, VALUE i, VALUE e)
+{
+	(void)self;
+	mpfr_exp_t ve = NUM2LL(e);
+	VALUE ret;
+	if (RB_FIXNUM_P(i)) {
+		long int v = NUM2LL(i);
+		mpfr_prec_t p;
+		if (v > 0) {
+			p = (mpfr_prec_t)ceil(log2((double)(v + 1)));
+		} else if (v < 0) {
+			p = (mpfr_prec_t)ceil(log2((double)(1 - v)));
+		} else {
+			p = 1;
+		}
+		ret = mpfrrb_alloc(c_MPFR);
+		mpfr_ptr mp = mpfrrb_rb2ref(ret);
+		mpfr_init2(mp, p);
+		mpfr_set_si_2exp(mp, v, ve, MPFR_RNDN);
+	} else if (RB_INTEGER_TYPE_P(i)) {
+		mpz_t mpz;
+		mpz_init(mpz);
+		mpfrrb_bignum_to_mpz(i, mpz);
+		int nlz_bits_ret;
+		size_t nb_bytes = rb_absint_size(i, &nlz_bits_ret);
+		mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret;
+		ret = mpfrrb_alloc(c_MPFR);
+		mpfr_ptr mp = mpfrrb_rb2ref(ret);
+		mpfr_init2(mp, p);
+		mpfr_set_z_2exp(mp, mpz, ve, MPFR_RNDN);
+		mpz_clear(mpz);
+	} else {
+		rb_raise(rb_eTypeError, "expecting an integer, not a %s", rb_obj_classname(i));
+	}
+
+	return ret;
+}
+
+
+/* Set the value of `self` to `a` + `b` rounded in the direction `round`.
+ * @return [Integer]
+ * @overload add(a, b, round: MPFR.default_rounding)
+ *  @param a [MPFR]
+ *  @param b [MPFR, Float, Integer, Rational]
+ */
+static VALUE mpfrrb_add(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a, b;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &a, &b);
+	a = mpfrrb_object_to_mpfr(a);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	mpfr_ptr mpa = mpfrrb_rb2ref(a);
+	int r;
+	if (RB_FLOAT_TYPE_P(b)) {
+		r = mpfr_add_d(mpr, mpa, NUM2DBL(b), rnd);
+	} else if (RB_FIXNUM_P(b)) {
+		r = mpfr_add_si(mpr, mpa, NUM2LL(b), rnd);
+	} else if (RB_INTEGER_TYPE_P(b)) {
+		mpz_t mpz;
+		mpz_init(mpz);
+		mpfrrb_bignum_to_mpz(b, mpz);
+		r = mpfr_add_z(mpr, mpa, mpz, rnd);
+		mpz_clear(mpz);
+	} else if (RB_TYPE_P(b, T_RATIONAL)) {
+		mpq_t mpq;
+		mpq_init(mpq);
+		mpfrrb_rational_to_mpq(b, mpq);
+		r = mpfr_add_q(mpr, mpa, mpq, rnd);
+		mpq_clear(mpq);
+	} else {
+		b = mpfrrb_object_to_mpfr(b);
+		r = mpfr_add(mpr, mpa, mpfrrb_rb2ref(b), rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set the value of `self` to `self` + `b` rounded in the direction `round`.
+ * @return [Integer]
+ * @overload add!(b, round: MPFR.default_rounding)
+ *  @param b [MPFR, Float, Integer, Rational]
+ */
+static VALUE mpfrrb_add_B(int argc, VALUE *argv, VALUE self)
+{
+	VALUE b;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &b);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (RB_FLOAT_TYPE_P(b)) {
+		r = mpfr_add_d(mpr, mpr, NUM2DBL(b), rnd);
+	} else if (RB_FIXNUM_P(b)) {
+		r = mpfr_add_si(mpr, mpr, NUM2LL(b), rnd);
+	} else if (RB_INTEGER_TYPE_P(b)) {
+		mpz_t mpz;
+		mpz_init(mpz);
+		mpfrrb_bignum_to_mpz(b, mpz);
+		r = mpfr_add_z(mpr, mpr, mpz, rnd);
+		mpz_clear(mpz);
+	} else if (RB_TYPE_P(b, T_RATIONAL)) {
+		mpq_t mpq;
+		mpq_init(mpq);
+		mpfrrb_rational_to_mpq(b, mpq);
+		r = mpfr_add_q(mpr, mpr, mpq, rnd);
+		mpq_clear(mpq);
+	} else {
+		b = mpfrrb_object_to_mpfr(b);
+		r = mpfr_add(mpr, mpr, mpfrrb_rb2ref(b), rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set the value of `self` to `a` - `b` rounded in the direction `round`.
+ * @return [Integer]
+ * @overload sub(a, b, round: MPFR.default_rounding)
+ *  @param a [MPFR, Float, Integer]
+ *  @param b [MPFR, Float, Integer, Rational]
+ */
+static VALUE mpfrrb_sub(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a, b;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &a, &b);
+	a = mpfrrb_object_to_mpfr(a);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (rb_obj_is_kind_of(a, c_MPFR)) {
+		mpfr_ptr mpa = mpfrrb_rb2ref(a);
+		if (RB_FLOAT_TYPE_P(b)) {
+			r = mpfr_sub_d(mpr, mpa, NUM2DBL(b), rnd);
+		} else if (RB_FIXNUM_P(b)) {
+			r = mpfr_sub_si(mpr, mpa, NUM2LL(b), rnd);
+		} else if (RB_INTEGER_TYPE_P(b)) {
+			mpz_t mpz;
+			mpz_init(mpz);
+			mpfrrb_bignum_to_mpz(b, mpz);
+			r = mpfr_sub_z(mpr, mpa, mpz, rnd);
+			mpz_clear(mpz);
+		} else if (RB_TYPE_P(b, T_RATIONAL)) {
+			mpq_t mpq;
+			mpq_init(mpq);
+			mpfrrb_rational_to_mpq(b, mpq);
+			r = mpfr_sub_q(mpr, mpa, mpq, rnd);
+			mpq_clear(mpq);
+		} else {
+			b = mpfrrb_object_to_mpfr(b);
+			r = mpfr_sub(mpr, mpa, mpfrrb_rb2ref(b), rnd);
+		}
+	} else {
+		b = mpfrrb_object_to_mpfr(b);
+		mpfr_ptr mpb = mpfrrb_rb2ref(b);
+		if (RB_FLOAT_TYPE_P(a)) {
+			r = mpfr_d_sub(mpr, NUM2DBL(a), mpb, rnd);
+		} else if (RB_FIXNUM_P(a)) {
+			r = mpfr_si_sub(mpr, NUM2LL(a), mpb, rnd);
+		} else if (RB_INTEGER_TYPE_P(a)) {
+			mpz_t mpz;
+			mpz_init(mpz);
+			mpfrrb_bignum_to_mpz(a, mpz);
+			r = mpfr_z_sub(mpr, mpz, mpb, rnd);
+			mpz_clear(mpz);
+		} else {
+			a = mpfrrb_object_to_mpfr(a);
+			r = mpfr_sub(mpr, mpfrrb_rb2ref(a), mpb, rnd);
+		}
+
+	}
+
+	return INT2NUM(r);
+}
+
+
+/* Set the value of `self` to `self` - `b` rounded in the direction `round`.
+ * @return [Integer]
+ * @overload sub!(b, round: MPFR.default_rounding)
+ *  @param b [MPFR, Float, Integer, Rational]
+ */
+static VALUE mpfrrb_sub_B(int argc, VALUE *argv, VALUE self)
+{
+	VALUE b;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &b);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (RB_FLOAT_TYPE_P(b)) {
+		r = mpfr_sub_d(mpr, mpr, NUM2DBL(b), rnd);
+	} else if (RB_FIXNUM_P(b)) {
+		r = mpfr_sub_si(mpr, mpr, NUM2LL(b), rnd);
+	} else if (RB_INTEGER_TYPE_P(b)) {
+		mpz_t mpz;
+		mpz_init(mpz);
+		mpfrrb_bignum_to_mpz(b, mpz);
+		r = mpfr_sub_z(mpr, mpr, mpz, rnd);
+		mpz_clear(mpz);
+	} else if (RB_TYPE_P(b, T_RATIONAL)) {
+		mpq_t mpq;
+		mpq_init(mpq);
+		mpfrrb_rational_to_mpq(b, mpq);
+		r = mpfr_sub_q(mpr, mpr, mpq, rnd);
+		mpq_clear(mpq);
+	} else {
+		b = mpfrrb_object_to_mpfr(b);
+		r = mpfr_sub(mpr, mpr, mpfrrb_rb2ref(b), rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set the value of `self` to `a` times `b` rounded in the direction `round`.
+ * @return [Integer]
+ * @overload mul(a, b, round: MPFR.default_rounding)
+ *  @param a [MPFR]
+ *  @param b [MPFR, Float, Integer, Rational]
+ */
+static VALUE mpfrrb_mul(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a, b;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &a, &b);
+	a = mpfrrb_object_to_mpfr(a);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	mpfr_ptr mpa = mpfrrb_rb2ref(a);
+	int r;
+	if (RB_FLOAT_TYPE_P(b)) {
+		r = mpfr_mul_d(mpr, mpa, NUM2DBL(b), rnd);
+	} else if (RB_FIXNUM_P(b)) {
+		r = mpfr_mul_si(mpr, mpa, NUM2LL(b), rnd);
+	} else if (RB_INTEGER_TYPE_P(b)) {
+		mpz_t mpz;
+		mpz_init(mpz);
+		mpfrrb_bignum_to_mpz(b, mpz);
+		r = mpfr_mul_z(mpr, mpa, mpz, rnd);
+		mpz_clear(mpz);
+	} else if (RB_TYPE_P(b, T_RATIONAL)) {
+		mpq_t mpq;
+		mpq_init(mpq);
+		mpfrrb_rational_to_mpq(b, mpq);
+		r = mpfr_mul_q(mpr, mpa, mpq, rnd);
+		mpq_clear(mpq);
+	} else {
+		b = mpfrrb_object_to_mpfr(b);
+		r = mpfr_mul(mpr, mpa, mpfrrb_rb2ref(b), rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set the value of `self` to `self` times `b` rounded in the direction `round`.
+ * @return [Integer]
+ * @overload mul!(b, round: MPFR.default_rounding)
+ *  @param b [MPFR, Float, Integer, Rational]
+ */
+static VALUE mpfrrb_mul_B(int argc, VALUE *argv, VALUE self)
+{
+	VALUE b;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &b);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (RB_FLOAT_TYPE_P(b)) {
+		r = mpfr_mul_d(mpr, mpr, NUM2DBL(b), rnd);
+	} else if (RB_FIXNUM_P(b)) {
+		r = mpfr_mul_si(mpr, mpr, NUM2LL(b), rnd);
+	} else if (RB_INTEGER_TYPE_P(b)) {
+		mpz_t mpz;
+		mpz_init(mpz);
+		mpfrrb_bignum_to_mpz(b, mpz);
+		r = mpfr_mul_z(mpr, mpr, mpz, rnd);
+		mpz_clear(mpz);
+	} else if (RB_TYPE_P(b, T_RATIONAL)) {
+		mpq_t mpq;
+		mpq_init(mpq);
+		mpfrrb_rational_to_mpq(b, mpq);
+		r = mpfr_mul_q(mpr, mpr, mpq, rnd);
+		mpq_clear(mpq);
+	} else {
+		b = mpfrrb_object_to_mpfr(b);
+		r = mpfr_mul(mpr, mpr, mpfrrb_rb2ref(b), rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set the value of `self` to `a` / `b` rounded in the direction `round`.
+ * @return [Integer]
+ * @overload div(a, b, round: MPFR.default_rounding)
+ *  @param a [MPFR, Float, Integer]
+ *  @param b [MPFR, Float, Integer, Rational]
+ */
+static VALUE mpfrrb_div(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a, b;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &a, &b);
+	a = mpfrrb_object_to_mpfr(a);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (rb_obj_is_kind_of(a, c_MPFR)) {
+		mpfr_ptr mpa = mpfrrb_rb2ref(a);
+		if (RB_FLOAT_TYPE_P(b)) {
+			r = mpfr_div_d(mpr, mpa, NUM2DBL(b), rnd);
+		} else if (RB_FIXNUM_P(b)) {
+			r = mpfr_div_si(mpr, mpa, NUM2LL(b), rnd);
+		} else if (RB_INTEGER_TYPE_P(b)) {
+			mpz_t mpz;
+			mpz_init(mpz);
+			mpfrrb_bignum_to_mpz(b, mpz);
+			r = mpfr_div_z(mpr, mpa, mpz, rnd);
+			mpz_clear(mpz);
+		} else if (RB_TYPE_P(b, T_RATIONAL)) {
+			mpq_t mpq;
+			mpq_init(mpq);
+			mpfrrb_rational_to_mpq(b, mpq);
+			r = mpfr_div_q(mpr, mpa, mpq, rnd);
+			mpq_clear(mpq);
+		} else {
+			b = mpfrrb_object_to_mpfr(b);
+			r = mpfr_div(mpr, mpa, mpfrrb_rb2ref(b), rnd);
+		}
+	} else {
+		b = mpfrrb_object_to_mpfr(b);
+		mpfr_ptr mpb = mpfrrb_rb2ref(b);
+		if (RB_FLOAT_TYPE_P(a)) {
+			r = mpfr_d_div(mpr, NUM2DBL(a), mpb, rnd);
+		} else if (RB_FIXNUM_P(a)) {
+			r = mpfr_si_div(mpr, NUM2LL(a), mpb, rnd);
+		} else {
+			a = mpfrrb_object_to_mpfr(a);
+			r = mpfr_div(mpr, mpfrrb_rb2ref(a), mpb, rnd);
+		}
+
+	}
+
+	return INT2NUM(r);
+}
+
+
+/* Set the value of `self` to `self` / `b` rounded in the direction `round`.
+ * @return [Integer]
+ * @overload div!(b, round: MPFR.default_rounding)
+ *  @param b [MPFR, Float, Integer, Rational]
+ */
+static VALUE mpfrrb_div_B(int argc, VALUE *argv, VALUE self)
+{
+	VALUE b;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &b);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (RB_FLOAT_TYPE_P(b)) {
+		r = mpfr_div_d(mpr, mpr, NUM2DBL(b), rnd);
+	} else if (RB_FIXNUM_P(b)) {
+		r = mpfr_div_si(mpr, mpr, NUM2LL(b), rnd);
+	} else if (RB_INTEGER_TYPE_P(b)) {
+		mpz_t mpz;
+		mpz_init(mpz);
+		mpfrrb_bignum_to_mpz(b, mpz);
+		r = mpfr_div_z(mpr, mpr, mpz, rnd);
+		mpz_clear(mpz);
+	} else if (RB_TYPE_P(b, T_RATIONAL)) {
+		mpq_t mpq;
+		mpq_init(mpq);
+		mpfrrb_rational_to_mpq(b, mpq);
+		r = mpfr_div_q(mpr, mpr, mpq, rnd);
+		mpq_clear(mpq);
+	} else {
+		b = mpfrrb_object_to_mpfr(b);
+		r = mpfr_div(mpr, mpr, mpfrrb_rb2ref(b), rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set self to the square of `a`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload sqr(a, round: MPFR.default_rounding)
+ *  @param a [MPFR]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_sqr(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &a);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (RB_FLOAT_TYPE_P(a)) {
+		MPFR_DECL_INIT(mpa, 53);
+		mpfr_set_d(mpa, NUM2DBL(a), MPFR_RNDN);
+		r = mpfr_sqr(mpr, mpa, rnd);
+	} else if (RB_FIXNUM_P(a)) {
+		MPFR_DECL_INIT(mpa, 64);
+		mpfr_set_si(mpa, NUM2LL(a), MPFR_RNDN);
+		r = mpfr_sqr(mpr, mpa, rnd);
+	} else {
+		a = mpfrrb_object_to_mpfr(a);
+		r = mpfr_sqr(mpr, mpfrrb_rb2ref(a), rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set self to the square of `self`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload sqr!(round: MPFR.default_rounding)
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_sqr_B(int argc, VALUE *argv, VALUE self)
+{
+	mpfr_rnd_t rnd = mpfrrb_get_round_single_keword(argc, argv);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_sqr(mp, mp, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set self to the square root of `a`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload sqrt(a, round: MPFR.default_rounding)
+ *  @param a [MPFR]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_sqrt(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &a);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (RB_FLOAT_TYPE_P(a)) {
+		MPFR_DECL_INIT(mpa, 53);
+		mpfr_set_d(mpa, NUM2DBL(a), MPFR_RNDN);
+		r = mpfr_sqrt(mpr, mpa, rnd);
+	} else if (RB_FIXNUM_P(a)) {
+		long int i = NUM2LL(a);
+		if (i < 0) {
+			mpfr_set_nan(mpr);
+			r = 0;
+		} else {
+			r = mpfr_sqrt_ui(mpr, i, rnd);
+		}
+	} else {
+		a = mpfrrb_object_to_mpfr(a);
+		r = mpfr_sqrt(mpr, mpfrrb_rb2ref(a), rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set self to the square root of `self`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload sqrt!(round: MPFR.default_rounding)
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_sqrt_B(int argc, VALUE *argv, VALUE self)
+{
+	mpfr_rnd_t rnd = mpfrrb_get_round_single_keword(argc, argv);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_sqrt(mp, mp, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set self to the reciprocal square root of `a`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload rec_sqrt(a, round: MPFR.default_rounding)
+ *  @param a [MPFR]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_rec_sqrt(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &a);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (RB_FLOAT_TYPE_P(a)) {
+		MPFR_DECL_INIT(mpa, 53);
+		mpfr_set_d(mpa, NUM2DBL(a), MPFR_RNDN);
+		r = mpfr_rec_sqrt(mpr, mpa, rnd);
+	} else if (RB_FIXNUM_P(a)) {
+		MPFR_DECL_INIT(mpa, 64);
+		mpfr_set_si(mpa, NUM2LL(a), MPFR_RNDN);
+		r = mpfr_rec_sqrt(mpr, mpa, rnd);
+	} else {
+		a = mpfrrb_object_to_mpfr(a);
+		r = mpfr_rec_sqrt(mpr, mpfrrb_rb2ref(a), rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set self to the reciprocal square root of `self`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload rec_sqrt!(round: MPFR.default_rounding)
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_rec_sqrt_B(int argc, VALUE *argv, VALUE self)
+{
+	mpfr_rnd_t rnd = mpfrrb_get_round_single_keword(argc, argv);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_rec_sqrt(mp, mp, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set self to the cubic root of `a`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload cbrt(a, round: MPFR.default_rounding)
+ *  @param a [MPFR]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_cbrt(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &a);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (RB_FLOAT_TYPE_P(a)) {
+		MPFR_DECL_INIT(mpa, 53);
+		mpfr_set_d(mpa, NUM2DBL(a), MPFR_RNDN);
+		r = mpfr_cbrt(mpr, mpa, rnd);
+	} else if (RB_FIXNUM_P(a)) {
+		MPFR_DECL_INIT(mpa, 64);
+		mpfr_set_si(mpa, NUM2LL(a), MPFR_RNDN);
+		r = mpfr_cbrt(mpr, mpa, rnd);
+	} else {
+		a = mpfrrb_object_to_mpfr(a);
+		r = mpfr_cbrt(mpr, mpfrrb_rb2ref(a), rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set self to the cubic root of `self`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload cbrt!(round: MPFR.default_rounding)
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_cbrt_B(int argc, VALUE *argv, VALUE self)
+{
+	mpfr_rnd_t rnd = mpfrrb_get_round_single_keword(argc, argv);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_cbrt(mp, mp, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set self to the nth root of `a`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload rootn(a, n, round: MPFR.default_rounding)
+ *  @param a [MPFR]
+ *  @param n [Integer]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_rootn(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a, n;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &a, &n);
+	long long i = NUM2LL(n);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (RB_FLOAT_TYPE_P(a)) {
+		MPFR_DECL_INIT(mpa, 53);
+		mpfr_set_d(mpa, NUM2DBL(a), MPFR_RNDN);
+		r = mpfr_rootn_si(mpr, mpa, i, rnd);
+	} else if (RB_FIXNUM_P(a)) {
+		MPFR_DECL_INIT(mpa, 64);
+		mpfr_set_si(mpa, NUM2LL(a), MPFR_RNDN);
+		r = mpfr_rootn_si(mpr, mpa, i, rnd);
+	} else {
+		a = mpfrrb_object_to_mpfr(a);
+		r = mpfr_rootn_si(mpr, mpfrrb_rb2ref(a), i, rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set self to the nth root of `self`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload rootn!(n, round: MPFR.default_rounding)
+ *  @param n [Integer]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_rootn_B(int argc, VALUE *argv, VALUE self)
+{
+	VALUE n;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &n);
+	long long i = NUM2LL(n);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_rootn_si(mp, mp, i, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set self to `-a`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload neg(a, round: MPFR.default_rounding)
+ *  @param a [MPFR]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_neg(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &a);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (RB_FLOAT_TYPE_P(a)) {
+		MPFR_DECL_INIT(mpa, 53);
+		mpfr_set_d(mpa, NUM2DBL(a), MPFR_RNDN);
+		r = mpfr_neg(mpr, mpa, rnd);
+	} else if (RB_FIXNUM_P(a)) {
+		MPFR_DECL_INIT(mpa, 64);
+		mpfr_set_si(mpa, NUM2LL(a), MPFR_RNDN);
+		r = mpfr_neg(mpr, mpa, rnd);
+	} else {
+		a = mpfrrb_object_to_mpfr(a);
+		r = mpfr_neg(mpr, mpfrrb_rb2ref(a), rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set self `-self`.
+ * @return [Integer]
+ */
+static VALUE mpfrrb_neg_B(VALUE self)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_neg(mp, mp, MPFR_RNDN);
+	return INT2NUM(r);
+}
+
+
+/* Set self to the absolute value of `a`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload abs(a, round: MPFR.default_rounding)
+ *  @param a [MPFR]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_abs(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &a);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (RB_FLOAT_TYPE_P(a)) {
+		MPFR_DECL_INIT(mpa, 53);
+		mpfr_set_d(mpa, NUM2DBL(a), MPFR_RNDN);
+		r = mpfr_abs(mpr, mpa, rnd);
+	} else if (RB_FIXNUM_P(a)) {
+		MPFR_DECL_INIT(mpa, 64);
+		mpfr_set_si(mpa, NUM2LL(a), MPFR_RNDN);
+		r = mpfr_abs(mpr, mpa, rnd);
+	} else {
+		a = mpfrrb_object_to_mpfr(a);
+		r = mpfr_abs(mpr, mpfrrb_rb2ref(a), rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set self to the absolute value of `self`.
+ * @return [Integer]
+ */
+static VALUE mpfrrb_abs_B(VALUE self)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_abs(mp, mp, MPFR_RNDN);
+	return INT2NUM(r);
+}
+
+
+/* Set `self` to the positive difference of `a` and `b`.
+ * That is: `a` - `b` rounded in the direction `round` if `a` > `b`, +0 if `a` ≤ `b`, and NaN if `a` or `b` is NaN.
+ * @return [Integer]
+ * @overload dim(a, b, round: MPFR.default_rounding)
+ *  @param a [MPFR]
+ *  @param b [MPFR]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_dim(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a, b;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &a, &b);
+	a = mpfrrb_object_to_mpfr(a);
+	b = mpfrrb_object_to_mpfr(b);
+	int r = mpfr_dim(mpfrrb_rb2ref(self), mpfrrb_rb2ref(a), mpfrrb_rb2ref(b), rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set self to `a` times 2 raised to `n`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload mul_2i(a, n, round: MPFR.default_rounding)
+ *  @param a [MPFR]
+ *  @param n [Integer]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_mul_2i(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a, n;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &a, &n);
+	long long i = NUM2LL(n);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (RB_FLOAT_TYPE_P(a)) {
+		MPFR_DECL_INIT(mpa, 53);
+		mpfr_set_d(mpa, NUM2DBL(a), MPFR_RNDN);
+		r = mpfr_mul_2si(mpr, mpa, i, rnd);
+	} else if (RB_FIXNUM_P(a)) {
+		MPFR_DECL_INIT(mpa, 64);
+		mpfr_set_si(mpa, NUM2LL(a), MPFR_RNDN);
+		r = mpfr_mul_2si(mpr, mpa, i, rnd);
+	} else {
+		a = mpfrrb_object_to_mpfr(a);
+		r = mpfr_mul_2si(mpr, mpfrrb_rb2ref(a), i, rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set self to `self` times 2 raised to `n`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload mul_2i!(n, round: MPFR.default_rounding)
+ *  @param n [Integer]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_mul_2i_B(int argc, VALUE *argv, VALUE self)
+{
+	VALUE n;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &n);
+	long long i = NUM2LL(n);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_mul_2si(mp, mp, i, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set self to `a` divided by 2 raised to `n`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload div_2i(a, n, round: MPFR.default_rounding)
+ *  @param a [MPFR]
+ *  @param n [Integer]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_div_2i(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a, n;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &a, &n);
+	long long i = NUM2LL(n);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (RB_FLOAT_TYPE_P(a)) {
+		MPFR_DECL_INIT(mpa, 53);
+		mpfr_set_d(mpa, NUM2DBL(a), MPFR_RNDN);
+		r = mpfr_div_2si(mpr, mpa, i, rnd);
+	} else if (RB_FIXNUM_P(a)) {
+		MPFR_DECL_INIT(mpa, 64);
+		mpfr_set_si(mpa, NUM2LL(a), MPFR_RNDN);
+		r = mpfr_div_2si(mpr, mpa, i, rnd);
+	} else {
+		a = mpfrrb_object_to_mpfr(a);
+		r = mpfr_div_2si(mpr, mpfrrb_rb2ref(a), i, rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set self to `self` divided by 2 raised to `n`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload div_2i!(n, round: MPFR.default_rounding)
+ *  @param n [Integer]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_div_2i_B(int argc, VALUE *argv, VALUE self)
+{
+	VALUE n;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &n);
+	long long i = NUM2LL(n);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_div_2si(mp, mp, i, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set self to the factorial of `n`, rounded int the direction `round`.
+ * @return [Integer]
+ * @overload fac(n, round: MPFR.default_rounding)
+ *  @param n [Integer]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_fac(int argc, VALUE *argv, VALUE self)
+{
+	VALUE n;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &n);
+	long long i = NUM2LL(n);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	if (i < 0) {
+		rb_raise(rb_eRangeError, "factorial of negative value");
+	}
+	int r = mpfr_fac_ui(mp, i, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set self to (`a` times `b`) plus `c`, rounded in the direction `round`.
+ * Concerning special values (signed zeros, infinities, NaN),
+ * these functions behave like a multiplication followed by a separate addition or subtraction.
+ * That is, the fused operation matters only for rounding.
+ * @return [Integer]
+ * @overload fma(a, b, c, round: MPFR.default_rounding)
+ *  @param a, b, c [MPFR]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_fma(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a, b, c;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_c_round(argc, argv, &a, &b, &c);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	mpfr_ptr mpa = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(a));
+	mpfr_ptr mpb = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(b));
+	mpfr_ptr mpc = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(c));
+	int r = mpfr_fma(mpr, mpa, mpb, mpc, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set self to (`a` times `b`) plus `self`, rounded in the direction `round`.
+ * Concerning special values (signed zeros, infinities, NaN),
+ * these functions behave like a multiplication followed by a separate addition or subtraction.
+ * That is, the fused operation matters only for rounding.
+ * @return [Integer]
+ * @overload fma!(a, b, round: MPFR.default_rounding)
+ *  @param a, b [MPFR]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_fma_B(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a, b;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &a, &b);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	mpfr_ptr mpa = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(a));
+	mpfr_ptr mpb = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(b));
+	int r = mpfr_fma(mpr, mpa, mpb, mpr, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set self to (`a` times `b`) minus `c`, rounded in the direction `round`.
+ * Concerning special values (signed zeros, infinities, NaN),
+ * these functions behave like a multiplication followed by a separate addition or subtraction.
+ * That is, the fused operation matters only for rounding.
+ * @return [Integer]
+ * @overload fms(a, b, c, round: MPFR.default_rounding)
+ *  @param a, b, c [MPFR]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_fms(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a, b, c;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_c_round(argc, argv, &a, &b, &c);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	mpfr_ptr mpa = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(a));
+	mpfr_ptr mpb = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(b));
+	mpfr_ptr mpc = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(c));
+	int r = mpfr_fms(mpr, mpa, mpb, mpc, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set self to (`a` times `b`) minus `self`, rounded in the direction `round`.
+ * Concerning special values (signed zeros, infinities, NaN),
+ * these functions behave like a multiplication followed by a separate addition or subtraction.
+ * That is, the fused operation matters only for rounding.
+ * @return [Integer]
+ * @overload fms!(a, b, round: MPFR.default_rounding)
+ *  @param a, b [MPFR]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_fms_B(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a, b;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &a, &b);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	mpfr_ptr mpa = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(a));
+	mpfr_ptr mpb = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(b));
+	int r = mpfr_fms(mpr, mpa, mpb, mpr, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set self to (`a` times `b`) plus (`c` times `d`), rounded in the direction `round`.
+ * In case the computation of `a` times `b` overflows or underflows (or that of `c` times `d`),
+ * the result is computed as if the two intermediate products were computed with rounding toward zero.
+ * @return [Integer]
+ * @overload fmma(a, b, c, d, round: MPFR.default_rounding)
+ *  @param a, b, c, d [MPFR]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_fmma(int argc, VALUE *argv, VALUE self)
+{
+	VALUE v[4];
+	mpfr_rnd_t rnd = mpfrrb_get_4_args_and_round(argc, argv, v);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	mpfr_ptr mpa = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(v[0]));
+	mpfr_ptr mpb = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(v[1]));
+	mpfr_ptr mpc = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(v[2]));
+	mpfr_ptr mpd = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(v[3]));
+	int r = mpfr_fmma(mpr, mpa, mpb, mpc, mpd, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set self to (`a` times `b`) minus (`c` times `d`), rounded in the direction `round`.
+ * In case the computation of `a` times `b` overflows or underflows (or that of `c` times `d`),
+ * the result is computed as if the two intermediate products were computed with rounding toward zero.
+ * @return [Integer]
+ * @overload fmms(a, b, c, d, round: MPFR.default_rounding)
+ *  @param a, b, c, d [MPFR]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_fmms(int argc, VALUE *argv, VALUE self)
+{
+	VALUE v[4];
+	mpfr_rnd_t rnd = mpfrrb_get_4_args_and_round(argc, argv, v);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	mpfr_ptr mpa = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(v[0]));
+	mpfr_ptr mpb = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(v[1]));
+	mpfr_ptr mpc = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(v[2]));
+	mpfr_ptr mpd = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(v[3]));
+	int r = mpfr_fmms(mpr, mpa, mpb, mpc, mpd, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set self to the Euclidean norm of `x` and `y`, i.e. the square root to the sum of the squares of `x` and `y`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload hypot(x, y, round: MPFR.default_rounding)
+ *  @param x, y [MPFR]
+ *  @param round [Symbol]
+ */
+static VALUE mpfrrb_hypot(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a, b;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &a, &b);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	mpfr_ptr mpa = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(a));
+	mpfr_ptr mpb = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(b));
+	int r = mpfr_hypot(mpr, mpa, mpb, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Return a positive value if `self` > `other`, zero if `self` = `other`, and a negative value if `self` < `other`.
+ * Returns `nil` if `other` is not comparable with `self`.
+ * @return [Integer, nil]
+ */
+static VALUE mpfrrb_cmp(VALUE self, VALUE other)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r;
+
+	if (mpfr_nan_p(mp)) {
+		return Qnil;
+	}
+	if (RB_FLOAT_TYPE_P(other)) {
+		r = mpfr_cmp_d(mp, NUM2DBL(other));
+	} else if (RB_FIXNUM_P(other)) {
+		r = mpfr_cmp_si(mp, NUM2LL(other));
+	} else if (RB_TYPE_P(other, T_BIGNUM)) {
+		mpz_t mpz;
+		mpz_init(mpz);
+		mpfrrb_bignum_to_mpz(other, mpz);
+		r = mpfr_cmp_z(mp, mpz);
+		mpz_clear(mpz);
+	} else if (RB_TYPE_P(other, T_RATIONAL)) {
+		mpq_t mpq;
+		mpq_init(mpq);
+		mpfrrb_rational_to_mpq(other, mpq);
+		r = mpfr_cmp_q(mp, mpq);
+		mpq_clear(mpq);
+	}  else if (rb_obj_is_kind_of(other, c_MPFR)) {
+		r = mpfr_cmp(mp, mpfrrb_rb2ref(other));
+	} else {
+		return Qnil;
+	}
+	return INT2NUM(r);
+}
+
+
+/* Returns an array with both `num` and `self` represented as MPFR objects.
+ * If `num` is a Rational, the returned array contains both `num` and `self` as rationals.
+ * @return [Array<MPFR,Rational>] `[num.to_mpfr, self]`
+ */
+static VALUE mpfrrb_coerce(VALUE self, VALUE num)
+{
+	if (RB_FLOAT_TYPE_P(num)) {
+		return rb_ary_new_from_args(2, mpfrrb_Float_to_mpfr(num), self);
+	} else if (RB_INTEGER_TYPE_P(num)) {
+		return rb_ary_new_from_args(2, mpfrrb_Integer_to_mpfr(num), self);
+	} else if (RB_TYPE_P(num, T_RATIONAL)) {
+		return rb_ary_new_from_args(2, num, mpfrrb_to_r(self));
+	} else {
+		rb_raise(rb_eArgError, "invalid value: %" PRIsVALUE, num);
+	}
+}
+
+
+/* Set self to the natural logarithm of `v`, rounded in the direction `round`.
+ * Set self to +0 if `v` is 1 (in all rounding modes), for consistency with the ISO C99 and IEEE 754 standards.
+ * Set self to -Inf if `v` is ±0 (i.e., the sign of the zero has no influence on the result).
+ * @return [Integer]
+ * @overload log(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_log(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &a);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+
+	if (RB_FLOAT_TYPE_P(a)) {
+		MPFR_DECL_INIT(mpa, 53);
+		mpfr_set_d(mpa, NUM2DBL(a), MPFR_RNDN);
+		r = mpfr_log(mpr, mpa, rnd);
+	} else if (RB_FIXNUM_P(a)) {
+		long int i = NUM2LL(a);
+		if (i < 0) {
+			mpfr_set_nan(mpr);
+			r = 0;
+		} else {
+			r = mpfr_log_ui(mpr, i, rnd);
+		}
+	} else if (RB_TYPE_P(a, T_BIGNUM)) {
+		mpz_t mpz;
+		mpz_init(mpz);
+		mpfrrb_bignum_to_mpz(a, mpz);
+		int nlz_bits_ret;
+		size_t nb_bytes = rb_absint_size(a, &nlz_bits_ret);
+		mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret;
+		mpfr_t mpa;
+		mpfr_init2(mpa, p);
+		mpfr_set_z(mpa, mpz, MPFR_RNDN);
+		mpz_clear(mpz);
+		r = mpfr_log(mpr, mpa, rnd);
+		mpfr_clear(mpa);
+	} else {
+		mpfr_ptr mpa = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(a));
+		r = mpfr_log(mpr, mpa, rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set self to the base 2 logarithm of `v`, rounded in the direction `round`.
+ * Set self to +0 if `v` is 1 (in all rounding modes), for consistency with the ISO C99 and IEEE 754 standards.
+ * Set self to -Inf if `v` is ±0 (i.e., the sign of the zero has no influence on the result).
+ * @return [Integer]
+ * @overload log2(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_log2(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &a);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+
+	if (RB_FLOAT_TYPE_P(a)) {
+		MPFR_DECL_INIT(mpa, 53);
+		mpfr_set_d(mpa, NUM2DBL(a), MPFR_RNDN);
+		r = mpfr_log2(mpr, mpa, rnd);
+	} else if (RB_FIXNUM_P(a)) {
+		MPFR_DECL_INIT(mpa, 64);
+		mpfr_set_si(mpa, NUM2LL(a), MPFR_RNDN);
+		r = mpfr_log2(mpr, mpa, rnd);
+	} else if (RB_TYPE_P(a, T_BIGNUM)) {
+		mpz_t mpz; mpz_init(mpz); mpfrrb_bignum_to_mpz(a, mpz);
+		int nlz_bits_ret; size_t nb_bytes = rb_absint_size(a, &nlz_bits_ret);
+		mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpa; mpfr_init2(mpa, p);
+		mpfr_set_z(mpa, mpz, MPFR_RNDN); mpz_clear(mpz);
+		r = mpfr_log2(mpr, mpa, rnd); mpfr_clear(mpa);
+	} else {
+		mpfr_ptr mpa = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(a));
+		r = mpfr_log2(mpr, mpa, rnd);
+	}
+	return INT2NUM(r);
+}
+
+
+#define MPFRRB_ONE_ARG_FUNC_BODY(func)                                                      \
+	VALUE a;                                                                                \
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &a);                                    \
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);                                                     \
+	int r;                                                                                  \
+	if (RB_FLOAT_TYPE_P(a)) {                                                               \
+		MPFR_DECL_INIT(mpa, 53);                                                            \
+		mpfr_set_d(mpa, NUM2DBL(a), MPFR_RNDN);                                             \
+		r = mpfr_##func(mpr, mpa, rnd);                                                     \
+	} else if (RB_FIXNUM_P(a)) {                                                            \
+		MPFR_DECL_INIT(mpa, 64);                                                            \
+		mpfr_set_si(mpa, NUM2LL(a), MPFR_RNDN);                                             \
+		r = mpfr_##func(mpr, mpa, rnd);                                                     \
+	} else if (RB_TYPE_P(a, T_BIGNUM)) {                                                    \
+		mpz_t mpz; mpz_init(mpz); mpfrrb_bignum_to_mpz(a, mpz);                             \
+		int nlz_bits_ret; size_t nb_bytes = rb_absint_size(a, &nlz_bits_ret);               \
+		mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpa; mpfr_init2(mpa, p);          \
+		mpfr_set_z(mpa, mpz, MPFR_RNDN); mpz_clear(mpz);                                    \
+		r = mpfr_##func(mpr, mpa, rnd); mpfr_clear(mpa);                                    \
+	} else {                                                                                \
+		mpfr_ptr mpa = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(a));                             \
+		r = mpfr_##func(mpr, mpa, rnd);                                                     \
+	}                                                                                       \
+	return INT2NUM(r)
+
+
+#define MPFRRB_TWO_ARG_FUNC_BODY(func)                                                      \
+	VALUE x, y;                                                                             \
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &x, &y);                              \
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);                                                     \
+	int r;                                                                                  \
+	if (RB_FLOAT_TYPE_P(x)) {                                                               \
+		MPFR_DECL_INIT(mpx, 53);                                                            \
+		mpfr_set_d(mpx, NUM2DBL(x), MPFR_RNDN);                                             \
+		if (RB_FLOAT_TYPE_P(y)) {                                                           \
+			MPFR_DECL_INIT(mpy, 53);                                                        \
+			mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);                                         \
+			r = mpfr_##func(mpr, mpx, mpy, rnd);                                            \
+		} else if (RB_FIXNUM_P(y)) {                                                        \
+			MPFR_DECL_INIT(mpy, 64);                                                        \
+			mpfr_set_si(mpy, NUM2LL(y), MPFR_RNDN);                                         \
+			r = mpfr_##func(mpr, mpx, mpy, rnd);                                            \
+		} else if (RB_TYPE_P(y, T_BIGNUM)) {                                                \
+			mpz_t mpzy; mpz_init(mpzy); mpfrrb_bignum_to_mpz(y, mpzy);                      \
+			int nlz_bits_ret; size_t nb_bytes = rb_absint_size(y, &nlz_bits_ret);           \
+			mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpy; mpfr_init2(mpy, p);      \
+			mpfr_set_z(mpy, mpzy, MPFR_RNDN); mpz_clear(mpzy);                              \
+			r = mpfr_##func(mpr, mpx, mpy, rnd); mpfr_clear(mpy);                           \
+		} else {                                                                            \
+			mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));                         \
+			r = mpfr_##func(mpr, mpx, mpy, rnd);                                            \
+		}                                                                                   \
+	} else if (RB_FIXNUM_P(x)) {                                                            \
+		MPFR_DECL_INIT(mpx, 64);                                                            \
+		mpfr_set_si(mpx, NUM2LL(x), MPFR_RNDN);                                             \
+		if (RB_FLOAT_TYPE_P(y)) {                                                           \
+			MPFR_DECL_INIT(mpy, 53);                                                        \
+			mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);                                         \
+			r = mpfr_##func(mpr, mpx, mpy, rnd);                                            \
+		} else if (RB_FIXNUM_P(y)) {                                                        \
+			MPFR_DECL_INIT(mpy, 64);                                                        \
+			mpfr_set_si(mpy, NUM2LL(y), MPFR_RNDN);                                         \
+			r = mpfr_##func(mpr, mpx, mpy, rnd);                                            \
+		} else if (RB_TYPE_P(y, T_BIGNUM)) {                                                \
+			mpz_t mpzy; mpz_init(mpzy); mpfrrb_bignum_to_mpz(y, mpzy);                      \
+			int nlz_bits_ret; size_t nb_bytes = rb_absint_size(y, &nlz_bits_ret);           \
+			mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpy; mpfr_init2(mpy, p);      \
+			mpfr_set_z(mpy, mpzy, MPFR_RNDN); mpz_clear(mpzy);                              \
+			r = mpfr_##func(mpr, mpx, mpy, rnd); mpfr_clear(mpy);                           \
+		} else {                                                                            \
+			mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));                         \
+			r = mpfr_##func(mpr, mpx, mpy, rnd);                                            \
+		}                                                                                   \
+	} else if (RB_TYPE_P(x, T_BIGNUM)) {                                                    \
+		mpz_t mpz; mpz_init(mpz); mpfrrb_bignum_to_mpz(x, mpz);                             \
+		int nlz_bits_ret; size_t nb_bytes = rb_absint_size(x, &nlz_bits_ret);               \
+		mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpx; mpfr_init2(mpx, p);          \
+		mpfr_set_z(mpx, mpz, MPFR_RNDN); mpz_clear(mpz);                                    \
+		if (RB_FLOAT_TYPE_P(y)) {                                                           \
+			MPFR_DECL_INIT(mpy, 53);                                                        \
+			mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);                                         \
+			r = mpfr_##func(mpr, mpx, mpy, rnd);                                            \
+		} else if (RB_FIXNUM_P(y)) {                                                        \
+			MPFR_DECL_INIT(mpy, 64);                                                        \
+			mpfr_set_si(mpy, NUM2LL(y), MPFR_RNDN);                                         \
+			r = mpfr_##func(mpr, mpx, mpy, rnd);                                            \
+		} else if (RB_TYPE_P(y, T_BIGNUM)) {                                                \
+			mpz_t mpzy; mpz_init(mpzy); mpfrrb_bignum_to_mpz(y, mpzy);                      \
+			int nlz_bits_ret; size_t nb_bytes = rb_absint_size(y, &nlz_bits_ret);           \
+			mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpy; mpfr_init2(mpy, p);      \
+			mpfr_set_z(mpy, mpzy, MPFR_RNDN); mpz_clear(mpzy);                              \
+			r = mpfr_##func(mpr, mpx, mpy, rnd); mpfr_clear(mpy);                           \
+		} else {                                                                            \
+			mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));                         \
+			r = mpfr_##func(mpr, mpx, mpy, rnd);                                            \
+		}                                                                                   \
+		mpfr_clear(mpx);                                                                    \
+	} else {                                                                                \
+		mpfr_ptr mpx = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(x));                             \
+		if (RB_FLOAT_TYPE_P(y)) {                                                           \
+			MPFR_DECL_INIT(mpy, 53);                                                        \
+			mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);                                         \
+			r = mpfr_##func(mpr, mpx, mpy, rnd);                                            \
+		} else if (RB_FIXNUM_P(y)) {                                                        \
+			MPFR_DECL_INIT(mpy, 64);                                                        \
+			mpfr_set_si(mpy, NUM2LL(y), MPFR_RNDN);                                         \
+			r = mpfr_##func(mpr, mpx, mpy, rnd);                                            \
+		} else if (RB_TYPE_P(y, T_BIGNUM)) {                                                \
+			mpz_t mpzy; mpz_init(mpzy); mpfrrb_bignum_to_mpz(y, mpzy);                      \
+			int nlz_bits_ret; size_t nb_bytes = rb_absint_size(y, &nlz_bits_ret);           \
+			mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpy; mpfr_init2(mpy, p);      \
+			mpfr_set_z(mpy, mpzy, MPFR_RNDN); mpz_clear(mpzy);                              \
+			r = mpfr_##func(mpr, mpx, mpy, rnd); mpfr_clear(mpy);                           \
+		} else {                                                                            \
+			mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));                         \
+			r = mpfr_##func(mpr, mpx, mpy, rnd);                                            \
+		}                                                                                   \
+	}                                                                                       \
+	return INT2NUM(r)
+
+
+#define MPFRRB_ONE_ARG_SL_FUNC_BODY(func)                                                   \
+	VALUE a, urb;                                                                           \
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &a, &urb);                            \
+	long int n = NUM2LL(urb);                                                               \
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);                                                     \
+	int r;                                                                                  \
+	if (RB_FLOAT_TYPE_P(a)) {                                                               \
+		MPFR_DECL_INIT(mpa, 53);                                                            \
+		mpfr_set_d(mpa, NUM2DBL(a), MPFR_RNDN);                                             \
+		r = mpfr_##func(mpr, mpa, n, rnd);                                                  \
+	} else if (RB_FIXNUM_P(a)) {                                                            \
+		MPFR_DECL_INIT(mpa, 64);                                                            \
+		mpfr_set_si(mpa, NUM2LL(a), MPFR_RNDN);                                             \
+		r = mpfr_##func(mpr, mpa, n, rnd);                                                  \
+	} else if (RB_TYPE_P(a, T_BIGNUM)) {                                                    \
+		mpz_t mpz; mpz_init(mpz); mpfrrb_bignum_to_mpz(a, mpz);                             \
+		int nlz_bits_ret; size_t nb_bytes = rb_absint_size(a, &nlz_bits_ret);               \
+		mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpa; mpfr_init2(mpa, p);          \
+		mpfr_set_z(mpa, mpz, MPFR_RNDN); mpz_clear(mpz);                                    \
+		r = mpfr_##func(mpr, mpa, n, rnd); mpfr_clear(mpa);                                 \
+	} else {                                                                                \
+		mpfr_ptr mpa = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(a));                             \
+		r = mpfr_##func(mpr, mpa, n, rnd);                                                  \
+	}                                                                                       \
+	return INT2NUM(r)
+
+
+#define MPFRRB_ONE_ARG_UL_FUNC_BODY(func)                                                   \
+	VALUE a, urb;                                                                           \
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &a, &urb);                            \
+	unsigned long int u = NUM2ULONG(urb);                                                   \
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);                                                     \
+	int r;                                                                                  \
+	if (RB_FLOAT_TYPE_P(a)) {                                                               \
+		MPFR_DECL_INIT(mpa, 53);                                                            \
+		mpfr_set_d(mpa, NUM2DBL(a), MPFR_RNDN);                                             \
+		r = mpfr_##func(mpr, mpa, u, rnd);                                                  \
+	} else if (RB_FIXNUM_P(a)) {                                                            \
+		MPFR_DECL_INIT(mpa, 64);                                                            \
+		mpfr_set_si(mpa, NUM2LL(a), MPFR_RNDN);                                             \
+		r = mpfr_##func(mpr, mpa, u, rnd);                                                  \
+	} else if (RB_TYPE_P(a, T_BIGNUM)) {                                                    \
+		mpz_t mpz; mpz_init(mpz); mpfrrb_bignum_to_mpz(a, mpz);                             \
+		int nlz_bits_ret; size_t nb_bytes = rb_absint_size(a, &nlz_bits_ret);               \
+		mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpa; mpfr_init2(mpa, p);          \
+		mpfr_set_z(mpa, mpz, MPFR_RNDN); mpz_clear(mpz);                                    \
+		r = mpfr_##func(mpr, mpa, u, rnd); mpfr_clear(mpa);                                 \
+	} else {                                                                                \
+		mpfr_ptr mpa = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(a));                             \
+		r = mpfr_##func(mpr, mpa, u, rnd);                                                  \
+	}                                                                                       \
+	return INT2NUM(r)
+
+
+#define MPFRRB_TWO_ARG_UL_FUNC_BODY(func)                                                   \
+	VALUE x, y, urb;                                                                        \
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_c_round(argc, argv, &x, &y, &urb);                      \
+	unsigned long int u = NUM2ULONG(urb);                                                   \
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);                                                     \
+	int r;                                                                                  \
+	if (RB_FLOAT_TYPE_P(x)) {                                                               \
+		MPFR_DECL_INIT(mpx, 53);                                                            \
+		mpfr_set_d(mpx, NUM2DBL(x), MPFR_RNDN);                                             \
+		if (RB_FLOAT_TYPE_P(y)) {                                                           \
+			MPFR_DECL_INIT(mpy, 53);                                                        \
+			mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);                                         \
+			r = mpfr_##func(mpr, mpx, mpy, u, rnd);                                         \
+		} else if (RB_FIXNUM_P(y)) {                                                        \
+			MPFR_DECL_INIT(mpy, 64);                                                        \
+			mpfr_set_si(mpy, NUM2LL(y), MPFR_RNDN);                                         \
+			r = mpfr_##func(mpr, mpx, mpy, u, rnd);                                         \
+		} else if (RB_TYPE_P(y, T_BIGNUM)) {                                                \
+			mpz_t mpzy; mpz_init(mpzy); mpfrrb_bignum_to_mpz(y, mpzy);                      \
+			int nlz_bits_ret; size_t nb_bytes = rb_absint_size(y, &nlz_bits_ret);           \
+			mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpy; mpfr_init2(mpy, p);      \
+			mpfr_set_z(mpy, mpzy, MPFR_RNDN); mpz_clear(mpzy);                              \
+			r = mpfr_##func(mpr, mpx, mpy, u, rnd); mpfr_clear(mpy);                        \
+		} else {                                                                            \
+			mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));                         \
+			r = mpfr_##func(mpr, mpx, mpy, u, rnd);                                         \
+		}                                                                                   \
+	} else if (RB_FIXNUM_P(x)) {                                                            \
+		MPFR_DECL_INIT(mpx, 64);                                                            \
+		mpfr_set_si(mpx, NUM2LL(x), MPFR_RNDN);                                             \
+		if (RB_FLOAT_TYPE_P(y)) {                                                           \
+			MPFR_DECL_INIT(mpy, 53);                                                        \
+			mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);                                         \
+			r = mpfr_##func(mpr, mpx, mpy, u, rnd);                                         \
+		} else if (RB_FIXNUM_P(y)) {                                                        \
+			MPFR_DECL_INIT(mpy, 64);                                                        \
+			mpfr_set_si(mpy, NUM2LL(y), MPFR_RNDN);                                         \
+			r = mpfr_##func(mpr, mpx, mpy, u, rnd);                                         \
+		} else if (RB_TYPE_P(y, T_BIGNUM)) {                                                \
+			mpz_t mpzy; mpz_init(mpzy); mpfrrb_bignum_to_mpz(y, mpzy);                      \
+			int nlz_bits_ret; size_t nb_bytes = rb_absint_size(y, &nlz_bits_ret);           \
+			mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpy; mpfr_init2(mpy, p);      \
+			mpfr_set_z(mpy, mpzy, MPFR_RNDN); mpz_clear(mpzy);                              \
+			r = mpfr_##func(mpr, mpx, mpy, u, rnd); mpfr_clear(mpy);                        \
+		} else {                                                                            \
+			mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));                         \
+			r = mpfr_##func(mpr, mpx, mpy, u, rnd);                                         \
+		}                                                                                   \
+	} else if (RB_TYPE_P(x, T_BIGNUM)) {                                                    \
+		mpz_t mpz; mpz_init(mpz); mpfrrb_bignum_to_mpz(x, mpz);                             \
+		int nlz_bits_ret; size_t nb_bytes = rb_absint_size(x, &nlz_bits_ret);               \
+		mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpx; mpfr_init2(mpx, p);          \
+		mpfr_set_z(mpx, mpz, MPFR_RNDN); mpz_clear(mpz);                                    \
+		if (RB_FLOAT_TYPE_P(y)) {                                                           \
+			MPFR_DECL_INIT(mpy, 53);                                                        \
+			mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);                                         \
+			r = mpfr_##func(mpr, mpx, mpy, u, rnd);                                         \
+		} else if (RB_FIXNUM_P(y)) {                                                        \
+			MPFR_DECL_INIT(mpy, 64);                                                        \
+			mpfr_set_si(mpy, NUM2LL(y), MPFR_RNDN);                                         \
+			r = mpfr_##func(mpr, mpx, mpy, u, rnd);                                         \
+		} else if (RB_TYPE_P(y, T_BIGNUM)) {                                                \
+			mpz_t mpzy; mpz_init(mpzy); mpfrrb_bignum_to_mpz(y, mpzy);                      \
+			int nlz_bits_ret; size_t nb_bytes = rb_absint_size(y, &nlz_bits_ret);           \
+			mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpy; mpfr_init2(mpy, p);      \
+			mpfr_set_z(mpy, mpzy, MPFR_RNDN); mpz_clear(mpzy);                              \
+			r = mpfr_##func(mpr, mpx, mpy, u, rnd); mpfr_clear(mpy);                        \
+		} else {                                                                            \
+			mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));                         \
+			r = mpfr_##func(mpr, mpx, mpy, u, rnd);                                         \
+		}                                                                                   \
+		mpfr_clear(mpx);                                                                    \
+	} else {                                                                                \
+		mpfr_ptr mpx = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(x));                             \
+		if (RB_FLOAT_TYPE_P(y)) {                                                           \
+			MPFR_DECL_INIT(mpy, 53);                                                        \
+			mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);                                         \
+			r = mpfr_##func(mpr, mpx, mpy, u, rnd);                                         \
+		} else if (RB_FIXNUM_P(y)) {                                                        \
+			MPFR_DECL_INIT(mpy, 64);                                                        \
+			mpfr_set_si(mpy, NUM2LL(y), MPFR_RNDN);                                         \
+			r = mpfr_##func(mpr, mpx, mpy, u, rnd);                                         \
+		} else if (RB_TYPE_P(y, T_BIGNUM)) {                                                \
+			mpz_t mpzy; mpz_init(mpzy); mpfrrb_bignum_to_mpz(y, mpzy);                      \
+			int nlz_bits_ret; size_t nb_bytes = rb_absint_size(y, &nlz_bits_ret);           \
+			mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpy; mpfr_init2(mpy, p);      \
+			mpfr_set_z(mpy, mpzy, MPFR_RNDN); mpz_clear(mpzy);                              \
+			r = mpfr_##func(mpr, mpx, mpy, u, rnd); mpfr_clear(mpy);                        \
+		} else {                                                                            \
+			mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));                         \
+			r = mpfr_##func(mpr, mpx, mpy, u, rnd);                                         \
+		}                                                                                   \
+	}                                                                                       \
+	return INT2NUM(r)
+
+
+#define MPFRRB_ONE_ARG_NO_RND_FUNC_BODY(func)                                               \
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);                                                     \
+	int r;                                                                                  \
+	if (RB_FLOAT_TYPE_P(op)) {                                                              \
+		MPFR_DECL_INIT(mpa, 53);                                                            \
+		mpfr_set_d(mpa, NUM2DBL(op), MPFR_RNDN);                                            \
+		r = mpfr_##func(mpr, mpa);                                                          \
+	} else if (RB_FIXNUM_P(op)) {                                                           \
+		MPFR_DECL_INIT(mpa, 64);                                                            \
+		mpfr_set_si(mpa, NUM2LL(op), MPFR_RNDN);                                            \
+		r = mpfr_##func(mpr, mpa);                                                          \
+	} else if (RB_TYPE_P(op, T_BIGNUM)) {                                                   \
+		mpz_t mpz; mpz_init(mpz); mpfrrb_bignum_to_mpz(op, mpz);                            \
+		int nlz_bits_ret; size_t nb_bytes = rb_absint_size(op, &nlz_bits_ret);              \
+		mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpa; mpfr_init2(mpa, p);          \
+		mpfr_set_z(mpa, mpz, MPFR_RNDN); mpz_clear(mpz);                                    \
+		r = mpfr_##func(mpr, mpa); mpfr_clear(mpa);                                         \
+	} else {                                                                                \
+		mpfr_ptr mpa = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(op));                            \
+		r = mpfr_##func(mpr, mpa);                                                          \
+	}                                                                                       \
+	return INT2NUM(r)
+
+
+#define MPFRRB_INT_MP_RND_FUNC_BODY(func)                                                   \
+	VALUE x, i;                                                                             \
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &i, &x);                              \
+	long int n = NUM2LL(i);                                                                 \
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);                                                     \
+	int r;                                                                                  \
+	if (RB_FLOAT_TYPE_P(x)) {                                                               \
+		MPFR_DECL_INIT(mpx, 53);                                                            \
+		mpfr_set_d(mpx, NUM2DBL(x), MPFR_RNDN);                                             \
+		r = mpfr_##func(mpr, n, mpx, rnd);                                                  \
+	} else if (RB_FIXNUM_P(x)) {                                                            \
+		MPFR_DECL_INIT(mpx, 64);                                                            \
+		mpfr_set_si(mpx, NUM2LL(x), MPFR_RNDN);                                             \
+		r = mpfr_##func(mpr, n, mpx, rnd);                                                  \
+	} else if (RB_TYPE_P(x, T_BIGNUM)) {                                                    \
+		mpz_t mpz; mpz_init(mpz); mpfrrb_bignum_to_mpz(x, mpz);                             \
+		int nlz_bits_ret; size_t nb_bytes = rb_absint_size(x, &nlz_bits_ret);               \
+		mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpx; mpfr_init2(mpx, p);          \
+		mpfr_set_z(mpx, mpz, MPFR_RNDN); mpz_clear(mpz);                                    \
+		r = mpfr_##func(mpr, n, mpx, rnd); mpfr_clear(mpx);                                 \
+	} else {                                                                                \
+		mpfr_ptr mpx = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(x));                             \
+		r = mpfr_##func(mpr, n, mpx, rnd);                                                  \
+	}                                                                                       \
+	return INT2NUM(r)
+
+
+/* Set self to the base ten logarithm of `v`, rounded in the direction `round`.
+ * Set self to +0 if `v` is 1 (in all rounding modes), for consistency with the ISO C99 and IEEE 754 standards.
+ * Set self to -Inf if `v` is ±0 (i.e., the sign of the zero has no influence on the result).
+ * @return [Integer]
+ * @overload log10(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_log10(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(log10);
+}
+
+
+/* Set self to the logarithm of one plus `v`, rounded in the direction `round`.
+ * Set self to -Inf if `v` is -1.
+ * @return [Integer]
+ * @overload logp1(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_log1p(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(log1p);
+}
+
+
+/* Set self to the logarithm of one plus `v` in radix two, rounded in the direction `round`.
+ * Set self to -Inf if `v` is -1.
+ * @return [Integer]
+ * @overload log2p1(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_log2p1(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(log2p1);
+}
+
+
+/* Set self to the logarithm of one plus `v` in radix ten, rounded in the direction `round`.
+ * Set self to -Inf if `v` is -1.
+ * @return [Integer]
+ * @overload log10p1(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_log10p1(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(log10p1);
+}
+
+
+/* Set self to the exponential of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload exp(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_exp(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(exp);
+}
+
+
+/* Set self to 2 power of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload exp2(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_exp2(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(exp2);
+}
+
+
+/* Set self to 10 power of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload exp10(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_exp10(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(exp10);
+}
+
+
+/* Set self to the exponential of `v` followed by a subtraction by one, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload expm1(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_expm1(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(expm1);
+}
+
+
+/* Set self to 2 power of `v` followed by a subtraction by one, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload exp2m1(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_exp2m1(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(exp2m1);
+}
+
+
+/* Set self to 10 power of `v` followed by a subtraction by one, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload exp10m1(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_exp10m1(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(exp10m1);
+}
+
+
+/* Set _self_ to `x` raised to `y`, rounded in the direction `round`.
+ * 
+ * Special values are handled as described in the ISO C99 and IEEE 754 standards for the _pow_ function:
+ * - pow(±0, _y_) returns ±Inf for _y_ a negative odd integer.
+ * - pow(±0, _y_) returns +Inf for _y_ negative and not an odd integer.
+ * - pow(±0, _y_) returns ±0 for _y_ a positive odd integer.
+ * - pow(±0, _y_) returns +0 for _y_ positive and not an odd integer.
+ * - pow(-1, ±Inf) returns 1.
+ * - pow(+1, _y_) returns 1 for any _y_, even a NaN.
+ * - pow(_x_, ±0) returns 1 for any _x_, even a NaN.
+ * - pow(_x_, _y_) returns NaN for finite negative _x_ and finite non-integer _y_.
+ * - pow(_x_, -Inf) returns +Inf for 0 < abs(_x_) < 1, and +0 for abs(_x_) > 1.
+ * - pow(_x_, +Inf) returns +0 for 0 < abs(_x_) < 1, and +Inf for abs(_x_) > 1.
+ * - pow(-Inf, _y_) returns -0 for _y_ a negative odd integer.
+ * - pow(-Inf, _y_) returns +0 for _y_ negative and not an odd integer.
+ * - pow(-Inf, _y_) returns -Inf for _y_ a positive odd integer.
+ * - pow(-Inf, _y_) returns +Inf for _y_ positive and not an odd integer.
+ * - pow(+Inf, _y_) returns +0 for _y_ negative, and +Inf for _y_ positive.
+ * @note When 0 is of integer type, it is regarded as +0 by these functions. We do not use the usual limit rules in this case, as these rules are not used for _pow_.
+ * @return [Integer]
+ * @overload pow(x, y, round: MPFR.default_rounding)
+ *  @param x [MPFR, Float, Integer]
+ *  @param y [MPFR, Float, Integer]
+ */
+static VALUE mpfrrb_pow(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, y;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &x, &y);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (RB_FLOAT_TYPE_P(x)) {
+		MPFR_DECL_INIT(mpx, 53);
+		mpfr_set_d(mpx, NUM2DBL(x), MPFR_RNDN);
+		if (RB_FLOAT_TYPE_P(y)) {
+			MPFR_DECL_INIT(mpy, 53);
+			mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);
+			r = mpfr_pow(mpr, mpx, mpy, rnd);
+		} else if (RB_FIXNUM_P(y)) {
+			long long n = NUM2LL(y);
+			r = mpfr_pow_si(mpr, mpx, n, rnd);
+		} else if (RB_TYPE_P(y, T_BIGNUM)) {
+			mpz_t mpzy;
+			mpz_init(mpzy);
+			mpfrrb_bignum_to_mpz(y, mpzy);
+			r = mpfr_pow_z(mpr, mpx, mpzy, rnd);
+			mpz_clear(mpzy);
+		} else {
+			mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));
+			r = mpfr_pow(mpr, mpx, mpy, rnd);
+		}
+	} else if (RB_FIXNUM_P(x)) {
+		long long xn = NUM2LL(x);
+		if (xn >= 0) {
+			if (RB_FLOAT_TYPE_P(y)) {
+				MPFR_DECL_INIT(mpy, 53);
+				mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);
+				r = mpfr_ui_pow(mpr, xn, mpy, rnd);
+			} else if (RB_FIXNUM_P(y)) {
+				long long yn = NUM2LL(y);
+				if (yn >= 0) {
+					r = mpfr_ui_pow_ui(mpr, xn, yn, rnd);
+				} else {
+					MPFR_DECL_INIT(mpx, 64);
+					mpfr_set_si(mpx, NUM2LL(x), MPFR_RNDN);
+					r = mpfr_pow_si(mpr, mpx, yn, rnd);
+				}
+			} else if (RB_TYPE_P(y, T_BIGNUM)) {
+				MPFR_DECL_INIT(mpx, 64);
+				mpfr_set_si(mpx, NUM2LL(x), MPFR_RNDN);
+				mpz_t mpzy;
+				mpz_init(mpzy);
+				mpfrrb_bignum_to_mpz(y, mpzy);
+				r = mpfr_pow_z(mpr, mpx, mpzy, rnd);
+				mpz_clear(mpzy);
+			} else {
+				mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));
+				r = mpfr_ui_pow(mpr, xn, mpy, rnd);
+			}
+		} else {
+			MPFR_DECL_INIT(mpx, 64);
+			mpfr_set_si(mpx, NUM2LL(x), MPFR_RNDN);
+			if (RB_FLOAT_TYPE_P(y)) {
+				MPFR_DECL_INIT(mpy, 53);
+				mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);
+				r = mpfr_pow(mpr, mpx, mpy, rnd);
+			} else if (RB_FIXNUM_P(y)) {
+				long long n = NUM2LL(y);
+				r = mpfr_pow_si(mpr, mpx, n, rnd);
+			} else if (RB_TYPE_P(y, T_BIGNUM)) {
+				mpz_t mpzy;
+				mpz_init(mpzy);
+				mpfrrb_bignum_to_mpz(y, mpzy);
+				r = mpfr_pow_z(mpr, mpx, mpzy, rnd);
+				mpz_clear(mpzy);
+			} else {
+				mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));
+				r = mpfr_pow(mpr, mpx, mpy, rnd);
+			}
+		}
+	} else if (RB_TYPE_P(x, T_BIGNUM)) {
+		mpz_t mpz; mpz_init(mpz); mpfrrb_bignum_to_mpz(x, mpz);
+		int nlz_bits_ret; size_t nb_bytes = rb_absint_size(x, &nlz_bits_ret);
+		mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpx; mpfr_init2(mpx, p);
+		mpfr_set_z(mpx, mpz, MPFR_RNDN); mpz_clear(mpz);
+		if (RB_FLOAT_TYPE_P(y)) {
+			MPFR_DECL_INIT(mpy, 53);
+			mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);
+			r = mpfr_pow(mpr, mpx, mpy, rnd);
+		} else if (RB_FIXNUM_P(y)) {
+			long long n = NUM2LL(y);
+			r = mpfr_pow_si(mpr, mpx, n, rnd);
+		} else if (RB_TYPE_P(y, T_BIGNUM)) {
+			mpz_t mpzy;
+			mpz_init(mpzy);
+			mpfrrb_bignum_to_mpz(y, mpzy);
+			r = mpfr_pow_z(mpr, mpx, mpzy, rnd);
+			mpz_clear(mpzy);
+		} else {
+			mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));
+			r = mpfr_pow(mpr, mpx, mpy, rnd);
+		}
+		mpfr_clear(mpx);
+	} else {
+		mpfr_ptr mpx = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(x));
+		if (RB_FLOAT_TYPE_P(y)) {
+			MPFR_DECL_INIT(mpy, 53);
+			mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);
+			r = mpfr_pow(mpr, mpx, mpy, rnd);
+		} else if (RB_FIXNUM_P(y)) {
+			long long n = NUM2LL(y);
+			r = mpfr_pow_si(mpr, mpx, n, rnd);
+		} else if (RB_TYPE_P(y, T_BIGNUM)) {
+			mpz_t mpzy;
+			mpz_init(mpzy);
+			mpfrrb_bignum_to_mpz(y, mpzy);
+			r = mpfr_pow_z(mpr, mpx, mpzy, rnd);
+			mpz_clear(mpzy);
+		} else {
+			mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));
+			r = mpfr_pow(mpr, mpx, mpy, rnd);
+		}
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set _self_ to the power `n` of one plus `x`, following IEEE 754 for the special cases and exceptions.
+ * In particular:
+ * - When `x` < -1, self is set to NaN.
+ * - When `n` is zero and `x` is NaN (like any value greater or equal to -1), self is set to 1.
+ * - When `x` = -1, self is set to +Inf for `n` < 0, and to +0 for `n` > 0.
+ * The other special cases follow the usual rules.
+ * @return [Integer]
+ * @overload compound(x, n, round: MPFR.default_rounding);
+ *  @param n [Integer]
+ */
+static VALUE mpfrrb_compound(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_SL_FUNC_BODY(compound_si);
+}
+
+
+/* Set self to the cosine of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload cos(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_cos(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(cos);
+}
+
+
+/* Set self to the sine of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload sin(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_sin(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(sin);
+}
+
+
+/* Set self to the tangent of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload tan(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_tan(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(tan);
+}
+
+
+/* Set self to the cosine of `x`, multiplied by 2 Pi and divided by `u`, rounded in the direction `round`.
+ *
+ * For example, if `u` equals 360, one gets the cosine for `x` in degrees.
+ * 
+ * When op multiplied by 2 and divided by u is a half-integer, the result is +0, following IEEE 754 (cosPi), so that the function is even.
+ * @return [Integer]
+ * @overload cosu(x, u, round: MPFR.default_rounding)
+ *  @param u [Integer]
+ */
+static VALUE mpfrrb_cosu(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_UL_FUNC_BODY(cosu);
+}
+
+
+/* Set self to the sine of `x`, multiplied by 2 Pi and divided by `u`, rounded in the direction `round`.
+ *
+ * For example, if `u` equals 360, one gets the osine for `x` in degrees.
+ * 
+ * When `x` multiplied by 2 and divided by `u` is an integer, the result is zero with the same sign as `x`, following IEEE 754 (sinPi),
+ * so that the function is odd.
+ * @return [Integer]
+ * @overload cosu(x, u, round: MPFR.default_rounding)
+ *  @param u [Integer]
+ */
+static VALUE mpfrrb_sinu(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_UL_FUNC_BODY(sinu);
+}
+
+
+/* Set self to the tangent of `x`, multiplied by 2 Pi and divided by `u`, rounded in the direction `round`.
+ *
+ * For example, if `u` equals 360, one gets the tangent for `x` in degrees.
+ * 
+ * The method {tanu} follows IEEE 754 (tanPi).
+ * @return [Integer]
+ * @overload cosu(x, u, round: MPFR.default_rounding)
+ *  @param u [Integer]
+ */
+static VALUE mpfrrb_tanu(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_UL_FUNC_BODY(tanu);
+}
+
+
+/* Set self to the cosine of `v` multiplied by Pi, rounded in the direction `round`.
+ * See the description of {#cosu} for special values.
+ * @return [Integer]
+ * @overload cospi(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_cospi(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(cospi);
+}
+
+
+/* Set self to the sine of `v` multiplied by Pi, rounded in the direction `round`.
+ * See the description of {#sinu} for special values.
+ * @return [Integer]
+ * @overload sinpi(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_sinpi(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(sinpi);
+}
+
+
+/* Set self to the tangent of `v` multiplied by Pi, rounded in the direction `round`.
+ * See the description of {#tanu} for special values.
+ * @return [Integer]
+ * @overload tanpi(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_tanpi(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(tanpi);
+}
+
+
+/* Set self to the secant of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload cot(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_sec(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(sec);
+}
+
+
+/* Set self to the cosecant of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload cot(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_csc(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(csc);
+}
+
+
+/* Set self to the cotangent of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload cot(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_cot(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(cot);
+}
+
+
+/* Set self to the arc-cosine of `v`, rounded in the direction `round`.
+ * Note that since acos(-1) returns the floating-point number closest to Pi according to the given rounding mode,
+ * this number might not be in the output range 0 ≤ self < Pi of the arc-cosine function; still, the result lies in the image of the output range by the rounding function.
+ * The same holds for asin(-1), asin(1), atan(-Inf), atan(+Inf) or for atan(`v`) with large `v` and small precision of self.
+ * @return [Integer]
+ * @overload acos(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_acos(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(acos);
+}
+
+
+/* Set self to the arc-sine of `v`, rounded in the direction `round`.
+ * Note that since acos(-1) returns the floating-point number closest to Pi according to the given rounding mode,
+ * this number might not be in the output range 0 ≤ self < Pi of the arc-cosine function; still, the result lies in the image of the output range by the rounding function.
+ * The same holds for asin(-1), asin(1), atan(-Inf), atan(+Inf) or for atan(`v`) with large `v` and small precision of self.
+ * @return [Integer]
+ * @overload asin(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_asin(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(asin);
+}
+
+
+/* Set self to the arc-tangent of `v`, rounded in the direction `round`.
+ * Note that since acos(-1) returns the floating-point number closest to Pi according to the given rounding mode,
+ * this number might not be in the output range 0 ≤ self < Pi of the arc-cosine function; still, the result lies in the image of the output range by the rounding function.
+ * The same holds for asin(-1), asin(1), atan(-Inf), atan(+Inf) or for atan(`v`) with large `v` and small precision of self.
+ * @return [Integer]
+ * @overload atan(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_atan(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(atan);
+}
+
+
+/* Set _self_ to the arc-cosine(x) multiplied by u and divided by 2 Pi.
+ * For example, if `u` equals 360, {acosu} yields the arc-cosine in degrees.
+ * @return [Integer]
+ * @overload acosu(x, u, round: MPFR.default_rounding)
+ *  @param u [Integer]
+ */
+static VALUE mpfrrb_acosu(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_UL_FUNC_BODY(acosu);
+}
+
+
+/* Set _self_ to the arc-sine(x) multiplied by u and divided by 2 Pi.
+ * For example, if `u` equals 360, {asinu} yields the arc-sine in degrees.
+ * @return [Integer]
+ * @overload asinu(x, u, round: MPFR.default_rounding)
+ *  @param u [Integer]
+ */
+static VALUE mpfrrb_asinu(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_UL_FUNC_BODY(asinu);
+}
+
+
+/* Set _self_ to the arc-tangent(x) multiplied by u and divided by 2 Pi.
+ * For example, if `u` equals 360, {asinu} yields the arc-tangent in degrees.
+ * @return [Integer]
+ * @overload atanu(x, u, round: MPFR.default_rounding)
+ *  @param u [Integer]
+ */
+static VALUE mpfrrb_atanu(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_UL_FUNC_BODY(atanu);
+}
+
+
+/* Set self to acos(`v`) divided by Pi, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload acos(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_acospi(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(acospi);
+}
+
+
+/* Set self to asin(`v`) divided by Pi, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload asin(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_asinpi(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(asinpi);
+}
+
+
+/* Set self to atan(`v`) divided by Pi, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload atanpi(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_atanpi(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(atanpi);
+}
+
+
+/* Set _self_ to the arc-tangent2 of `y` and `x`, rounded in the direction `round`.
+ * If `x` > 0, then `atan2(y, x)` returns `atan(y/x)`; if `x` < 0, then `atan2(y, x)` returns the sign of `y` multiplied
+ * by Pi - atan(abs(y/x)), thus a number from -Pi to Pi.
+ * As for {atan}, in case the exact mathematical result is +Pi or -Pi, its rounded result might be outside the function output range. 
+ *
+ * Special values are handled as described in the ISO C99 and IEEE 754 standards for the atan2 function:
+ * - atan2(+0, -0) returns +Pi.
+ * - atan2(-0, -0) returns -Pi.
+ * - atan2(+0, +0) returns +0.
+ * - atan2(-0, +0) returns -0.
+ * - atan2(+0, _x_) returns +Pi for _x_ < 0.
+ * - atan2(-0, _x_) returns -Pi for _x_ < 0.
+ * - atan2(+0, _x_) returns +0 for _x_ > 0.
+ * - atan2(-0, _x_) returns -0 for _x_ > 0.
+ * - atan2(_y_, 0) returns -Pi/2 for _y_ < 0.
+ * - atan2(_y_, 0) returns +Pi/2 for _y_ > 0.
+ * - atan2(+Inf, -Inf) returns +3*Pi/4.
+ * - atan2(-Inf, -Inf) returns -3*Pi/4.
+ * - atan2(+Inf, +Inf) returns +Pi/4.
+ * - atan2(-Inf, +Inf) returns -Pi/4.
+ * - atan2(+Inf, _x_) returns +Pi/2 for finite _x_.
+ * - atan2(-Inf, _x_) returns -Pi/2 for finite _x_.
+ * - atan2(_y_, -Inf) returns +Pi for finite _y_ > 0.
+ * - atan2(_y_, -Inf) returns -Pi for finite _y_ < 0.
+ * - atan2(_y_, +Inf) returns +0 for finite _y_ > 0.
+ * - atan2(_y_, +Inf) returns -0 for finite _y_ < 0.
+ * @return [Integer]
+ * @overload atan2(y, x, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_atan2(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_TWO_ARG_FUNC_BODY(atan2);
+}
+
+
+/* Behaves similarly to {atan2} except the result is multiplied by `u` and divided by 2 Pi.
+ * @return [Integer]
+ * @overload atan2u(y, x, u, round: MPFR.default_rounding)
+ *  @param u [Integer]
+ */
+static VALUE mpfrrb_atan2u(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_TWO_ARG_UL_FUNC_BODY(atan2u);
+}
+
+
+/* The same as {atan2u} with u = 2.
+ * @return [Integer]
+ * @overload atan2pi(y, x, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_atan2pi(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_TWO_ARG_FUNC_BODY(atan2pi);
+}
+
+
+/* Set self to the hyperbolic cosine of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload cosh(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_cosh(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(cosh);
+}
+
+
+/* Set self to the hyperbolic sine of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload sinh(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_sinh(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(sinh);
+}
+
+
+/* Set self to the hyperbolic tangent of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload tanh(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_tanh(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(tanh);
+}
+
+
+/* Set self to the hyperbolic secant of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload sech(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_sech(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(sech);
+}
+
+
+/* Set self to the hyperbolic cosecant of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload csch(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_csch(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(csch);
+}
+
+
+/* Set self to the hyperbolic cotangent of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload coth(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_coth(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(coth);
+}
+
+
+/* Set self to the inverse hyperbolic cossine of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload acosh(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_acosh(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(acosh);
+}
+
+
+/* Set self to the inverse hyperbolic sine of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload asinh(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_asinh(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(asinh);
+}
+
+
+/* Set self to the inverse hyperbolic tangent of `v`, rounded in the direction `round`.
+ * @return [Integer]
+ * @overload atanh(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_atanh(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(atanh);
+}
+
+
+/* Set self to the exponential integral of `v`, rounded in the direction`round`.
+ * This is the sum of Euler’s constant, of the logarithm of the absolute value of `v`, and of the sum for k from 1 to infinity of `v` to the power k, divided by k and the factorial of k.
+ * For positive `v`, it corresponds to the Ei function at `v` (see formula 5.1.10 from the Handbook of Mathematical Functions from Abramowitz and Stegun),
+ * and for negative `v`, to the opposite of the E1 function (sometimes called eint1) at -`v` (formula 5.1.1 from the same reference).
+ * @return [Integer]
+ * @overload eint(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_eint(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(eint);
+}
+
+
+/* Set self to real part of the dilogarithm of `v`, rounded in the direction`round`.
+ * MPFR defines the dilogarithm function as the integral of −log(1−t)/t from 0 to `v`.
+ * @return [Integer]
+ * @overload li2(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_li2(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(li2);
+}
+
+
+/* Set self to the value of the Gamma function on `v`, , rounded in the direction`round`.
+ * When `v` is a negative integer, self is set to NaN.
+ * @return [Integer]
+ * @overload gamma(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_gamma(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(gamma);
+}
+
+
+/* Set self to the value of the incomplete Gamma function on `x` and `y`, rounded in the direction `round`.
+ * (In the literature, `gamma_inc` is called upper incomplete Gamma function, or sometimes complementary incomplete Gamma function.)
+ * When `y` is zero and `x` is a negative integer, self is set to NaN.
+ *
+ * @note The current implementation of `gamma_inc` is slow for large values of self or `x`, in which case some internal overflow might also occur.
+ * @return [Integer]
+ * @overload gamma_inc(x, y, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_gamma_inc(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_TWO_ARG_FUNC_BODY(gamma_inc);
+}
+
+
+/* Set self to the value of the logarithm of the Gamma function on `v`, rounded in the direction`round`.
+ * When `v` is 1 or 2, set self to +0 (in all rounding modes).
+ * When `v` is an infinity or a non-positive integer, set self to +Inf, following the general rules on special values.
+ * When −2k − 1 < `v` < −2k, k being a non-negative integer, set self to NaN.
+ * @return [Integer]
+ * @overload lngamma(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_lngamma(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(lngamma);
+}
+
+
+/* Set self to the value of the Digamma (sometimes also called Psi) function on `v`, rounded in the direction`round`.
+ * When `v` is a negative integer, set self to NaN.
+ * @return [Integer]
+ * @overload digamma(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_digamma(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(digamma);
+}
+
+
+/* Set _self_ to the value of the Beta function at arguments `x` and `x`.
+ * @note The current code does not try to avoid internal overflow or underflow, and might use a huge internal precision in some cases.
+ * @return [Integer]
+ * @overload beta(x, y, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_beta(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_TWO_ARG_FUNC_BODY(beta);
+}
+
+
+/* Set self to the value of the Riemann Zeta function on `v`, rounded in the direction`round`.
+ * @return [Integer]
+ * @overload zeta(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_zeta(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(zeta);
+}
+
+
+/* Set self to the value of the error function on 'v', rounded in the direction `round`.
+ * @return [Integer]
+ * @overload erf(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_erf(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(erf);
+}
+
+
+/* Set self to the value of the complementary error function on 'v', rounded in the direction `round`.
+ * @return [Integer]
+ * @overload erfc(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_erfc(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(erfc);
+}
+
+
+/* Set self to the value of the first kind Bessel function of order 0, on `v`, rounded in the direction `round`.
+ * When `v` is NaN, self is always set to NaN.
+ * When `v` is positive or negative infinity, self is set to +0.
+ * When `v` is zero, and n is not zero, self is set to +0 or -0 depending on the parity and sign of n, and the sign of `v`.
+ * @return [Integer]
+ * @overload j0(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_j0(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(j0);
+}
+
+
+/* Set self to the value of the first kind Bessel function of order 1, on `v`, rounded in the direction `round`.
+ * When `v` is NaN, self is always set to NaN.
+ * When `v` is positive or negative infinity, self is set to +0.
+ * When `v` is zero, and n is not zero, self is set to +0 or -0 depending on the parity and sign of n, and the sign of `v`.
+ * @return [Integer]
+ * @overload j1(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_j1(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(j1);
+}
+
+
+/* Set self to the value of the first kind Bessel function of order `n`, on `v`, rounded in the direction `round`.
+ * When `v` is NaN, self is always set to NaN.
+ * When `v` is positive or negative infinity, self is set to +0.
+ * When `v` is zero, and n is not zero, self is set to +0 or -0 depending on the parity and sign of n, and the sign of `v`.
+ * @return [Integer]
+ * @overload jn(n, v, round: MPFR.default_rounding)
+ * 	@param n [Integer]
+ * 	@param v [MPFR]
+ */
+static VALUE mpfrrb_jn(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_INT_MP_RND_FUNC_BODY(jn);
+}
+
+
+/* Set self to the value of the second kind Bessel function of order 0 on `v`, rounded in the direction `round`.
+ * When `v` is NaN or negative, self is always set to NaN.
+ * When `v` is +Inf, self is set to +0.
+ * When `v` is zero, self is set to +Inf or -Inf depending on the parity and sign of `n`.
+ * @return [Integer]
+ * @overload y1(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_y0(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(y0);
+}
+
+
+/* Set self to the value of the second kind Bessel function of order 1 on `v`, rounded in the direction `round`.
+ * When `v` is NaN or negative, self is always set to NaN.
+ * When `v` is +Inf, self is set to +0.
+ * When `v` is zero, self is set to +Inf or -Inf depending on the parity and sign of `n`.
+ * @return [Integer]
+ * @overload y1(v, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_y1(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(y1);
+}
+
+
+/* Set self to the value of the second kind Bessel function of order `n` on `v`, rounded in the direction `round`.
+ * When `v` is NaN or negative, self is always set to NaN.
+ * When `v` is +Inf, self is set to +0.
+ * When `v` is zero, self is set to +Inf or -Inf depending on the parity and sign of `n`.
+ * @return [Integer]
+ * @overload yn(n, v, round: MPFR.default_rounding)
+ * 	@param n [Integer]
+ * 	@param v [MPFR]
+ */
+static VALUE mpfrrb_yn(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_INT_MP_RND_FUNC_BODY(yn);
+}
+
+
+/* Set _self_ to the arithmetic-geometric mean of `x` and `y`, rounded in the direction `round`.
+ * The arithmetic-geometric mean is the common limit of the sequences u_n and v_n, where u_0 = `x`, v_0 = `y`, u_(n+1)
+ * is the arithmetic mean of u_n and v_n, and v_(n+1) is the geometric mean of u_n and v_n.
+ *
+ * If any operand is negative and the other one is not zero, set _self_ to NaN.
+ *
+ * If any operand is zero and the other one is finite (resp. infinite), set _self_ to +0 (resp. NaN).
+ *
+ * @return [Integer]
+ * @overload agm(x, y, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_agm(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_TWO_ARG_FUNC_BODY(agm);
+}
+
+
+/* Set self to the value of the Airy function Ai on `x`, rounded in the direction `round`.
+ *
+ * When `x` is NaN, self is always set to NaN.
+ * When `x` is +Inf or -Inf, self is set to +0.
+ *
+ * The current implementation is not intended to be used with large arguments.
+ * It works with abs(x) typically smaller than 500.
+ * For larger arguments, other methods should be used and will be implemented in a future version.
+ * @return [Integer]
+ * @overload ai(x, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_ai(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(ai);
+}
+
+
+/* Set self to `op` rounded to the nearest representable integer in the direction `round`.
+ * @return [Integer]
+ * @overload rint(op, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_rint(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(rint);
+}
+
+
+/* Set self to `op` rounded to the next higher or equal representable integer.
+ * @return [Integer]
+ */
+static VALUE mpfrrb_ceil(VALUE self, VALUE op)
+{
+	MPFRRB_ONE_ARG_NO_RND_FUNC_BODY(ceil);
+}
+
+
+/* Set self to `op` rounded to the next lower or equal representable integer.
+ * @return [Integer]
+ */
+static VALUE mpfrrb_floor(VALUE self, VALUE op)
+{
+	MPFRRB_ONE_ARG_NO_RND_FUNC_BODY(floor);
+}
+
+
+/* Set self to `op` rounded to the nearest representable integer, rounding halfway cases away from zero.
+ * @return [Integer]
+ */
+static VALUE mpfrrb_round(VALUE self, VALUE op)
+{
+	MPFRRB_ONE_ARG_NO_RND_FUNC_BODY(round);
+}
+
+
+/* Set self to `op` rounded to the nearest representable integer, rounding halfway cases with the even-rounding rule.
+ * @return [Integer]
+ */
+static VALUE mpfrrb_roundeven(VALUE self, VALUE op)
+{
+	MPFRRB_ONE_ARG_NO_RND_FUNC_BODY(roundeven);
+}
+
+
+/* Set self to `op` rounded to the next representable integer toward zero.
+ * @return [Integer]
+ */
+static VALUE mpfrrb_trunc(VALUE self, VALUE op)
+{
+	MPFRRB_ONE_ARG_NO_RND_FUNC_BODY(trunc);
+}
+
+
+/* Set self to self rounded to the nearest representable integer in the direction `round`.
+ * @return [Integer]
+ * @overload rint!(round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_rint_B(int argc, VALUE *argv, VALUE self)
+{
+	mpfr_rnd_t rnd = mpfrrb_get_round_single_keword(argc, argv);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	return INT2NUM(mpfr_rint(mp, mp, rnd));
+}
+
+
+/* Set self to self rounded to the next higher or equal representable integer.
+ * @return [Integer]
+ */
+static VALUE mpfrrb_ceil_B(VALUE self)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	return INT2NUM(mpfr_ceil(mp, mp));
+}
+
+
+/* Set self to self rounded to the next lower or equal representable integer.
+ * @return [Integer]
+ */
+static VALUE mpfrrb_floor_B(VALUE self)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	return INT2NUM(mpfr_floor(mp, mp));
+}
+
+
+/* Set self to self rounded to the nearest representable integer, rounding halfway cases away from zero.
+ * @return [Integer]
+ */
+static VALUE mpfrrb_round_B(VALUE self)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	return INT2NUM(mpfr_round(mp, mp));
+}
+
+
+/* Set self to self rounded to the nearest representable integer, rounding halfway cases with the even-rounding rule.
+ * @return [Integer]
+ */
+static VALUE mpfrrb_roundeven_B(VALUE self)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	return INT2NUM(mpfr_roundeven(mp, mp));
+}
+
+
+/* Set self to self rounded to the next representable integer toward zero.
+ * @return [Integer]
+ */
+static VALUE mpfrrb_trunc_B(VALUE self)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	return INT2NUM(mpfr_trunc(mp, mp));
+}
+
+
+/* Set self to `op` rounded to the next higher or equal integer.
+ * If the result is not representable, it is rounded in the direction `round`.
+ * This method do perform a double rounding:
+ * first op is rounded to the nearest integer in the direction given by the method name,
+ * then this nearest integer (if not representable) is rounded in the given direction `round`.
+ * @return [Ingeger]
+ * @overload rint_ceil(op, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_rint_ceil(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(rint_ceil);
+}
+
+
+/* Set self to `op` rounded to the next lower or equal integer.
+ * If the result is not representable, it is rounded in the direction `round`.
+ * This method do perform a double rounding:
+ * first op is rounded to the nearest integer in the direction given by the method name,
+ * then this nearest integer (if not representable) is rounded in the given direction `round`.
+ * @return [Ingeger]
+ * @overload rint_floor(op, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_rint_floor(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(rint_floor);
+}
+
+
+/* Set self to `op` rounded to the nearest integer, rounding halfway cases away from zero.
+ * If the result is not representable, it is rounded in the direction `round`.
+ * This method do perform a double rounding:
+ * first op is rounded to the nearest integer in the direction given by the method name,
+ * then this nearest integer (if not representable) is rounded in the given direction `round`.
+ * @return [Ingeger]
+ * @overload rint_round(op, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_rint_round(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(rint_round);
+}
+
+
+/* Set self to `op` rounded to the nearest integer, rounding halfway cases to the nearest even integer.
+ * If the result is not representable, it is rounded in the direction `round`.
+ * This method do perform a double rounding:
+ * first op is rounded to the nearest integer in the direction given by the method name,
+ * then this nearest integer (if not representable) is rounded in the given direction `round`.
+ * @return [Ingeger]
+ * @overload rint_roundeven(op, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_rint_roundeven(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(rint_roundeven);
+}
+
+
+/* Set self to `op` rounded to the next integer toward zero.
+ * If the result is not representable, it is rounded in the direction `round`.
+ * This method do perform a double rounding:
+ * first op is rounded to the nearest integer in the direction given by the method name,
+ * then this nearest integer (if not representable) is rounded in the given direction `round`.
+ * @return [Ingeger]
+ * @overload rint_trunc(op, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_rint_trunc(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(rint_trunc);
+}
+
+
+/* Set self to the fractional part of `op`, having the same sign as `op`, rounded in the direction `round`.
+ * Unlike in {#rint}, `round` affects only how the exact fractional part is rounded, not how the fractional part is generated.
+ * When `op` is an integer or an infinity, set self to zero with the same sign as `op`.
+ * @return [Integer]
+ * @overload frac(op, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_frac(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_ONE_ARG_FUNC_BODY(frac);
+}
+
+
+/* Set simultaneously `ipart` to the integral part of `x` and `fpart` to the fractional part of `x`, rounded in the direction `round`
+ * with the corresponding precision of `ipart` and `fpart`.
+ * It is equivalent to `ipart.trunc(x, round: rnd)` and `fpart.frac(x, round: rnd)`.
+ * The variables `ipart` and `fpart` must be different.
+ * Return 0 iff both results are exact.
+ * @return [Integer]
+ * @overload modf(ipart, fpart, x, round: MPFR.default_rounding)
+ *  @param ipart [MPFR] output
+ *  @param fpart [MPFR] output
+ *  @param x [MPFR] input
+ * @see trunc
+ * @see frac
+ */
+static VALUE mpfrrb_modf(int argc, VALUE *argv, VALUE self)
+{
+	VALUE ipart, fpart, x;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_c_round(argc, argv, &ipart, &fpart, &x);
+	mpfr_ptr iop = mpfrrb_rb2ref(ipart);
+	mpfr_ptr fop = mpfrrb_rb2ref(fpart);
+	mpfr_ptr  op = mpfrrb_rb2ref(x);
+	int r = mpfr_modf(iop, fop, op, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set _self_ the the value of `x - ny`, rounded according to the direction `round`.
+ *
+ * `n` is the integer quotient of `x` divided by `y`, rounded toward zero.
+ *
+ * Special values are handled as described in Section F.9.7.1 of the ISO C99 standard:
+ * - If `x` is infinite or `y` is zero, _self_ is NaN.
+ * - If `y` is infinite and `x` is finite, _self_ is `x` rounded to the precision of _self_.
+ * - If _self_ is zero, it has the sign of `x`. The return value is the ternary value corresponding to _self_.
+ * @return [Integer]
+ * @overload fmod(x, y, round: MPFR.default_rounding)
+ * @see remainder
+ */
+static VALUE mpfrrb_fmod(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, y;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &x, &y);
+	mpfr_ptr mpr = mpfrrb_rb2ref(self);
+	int r;
+	if (RB_FLOAT_TYPE_P(x)) {
+		MPFR_DECL_INIT(mpx, 53);
+		mpfr_set_d(mpx, NUM2DBL(x), MPFR_RNDN);
+		if (RB_FLOAT_TYPE_P(y)) {
+			MPFR_DECL_INIT(mpy, 53);
+			mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);
+			r = mpfr_fmod(mpr, mpx, mpy, rnd);
+		} else if (RB_FIXNUM_P(y)) {
+			long long ly = NUM2LL(y);
+			if (ly >= 0) {
+				r = mpfr_fmod_ui(mpr, mpx, ly, rnd);
+			} else {
+				MPFR_DECL_INIT(mpy, 64);
+				mpfr_set_si(mpy, NUM2LL(y), MPFR_RNDN);
+				r = mpfr_fmod(mpr, mpx, mpy, rnd);
+			}
+		} else if (RB_TYPE_P(y, T_BIGNUM)) {
+			mpz_t mpzy; mpz_init(mpzy); mpfrrb_bignum_to_mpz(y, mpzy);
+			int nlz_bits_ret; size_t nb_bytes = rb_absint_size(y, &nlz_bits_ret);
+			mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpy; mpfr_init2(mpy, p);
+			mpfr_set_z(mpy, mpzy, MPFR_RNDN); mpz_clear(mpzy);
+			r = mpfr_fmod(mpr, mpx, mpy, rnd); mpfr_clear(mpy);
+		} else {
+			mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));
+			r = mpfr_fmod(mpr, mpx, mpy, rnd);
+		}
+	} else if (RB_FIXNUM_P(x)) {
+		MPFR_DECL_INIT(mpx, 64);
+		mpfr_set_si(mpx, NUM2LL(x), MPFR_RNDN);
+		if (RB_FLOAT_TYPE_P(y)) {
+			MPFR_DECL_INIT(mpy, 53);
+			mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);
+			r = mpfr_fmod(mpr, mpx, mpy, rnd);
+		} else if (RB_FIXNUM_P(y)) {
+			long long ly = NUM2LL(y);
+			if (ly >= 0) {
+				r = mpfr_fmod_ui(mpr, mpx, ly, rnd);
+			} else {
+				MPFR_DECL_INIT(mpy, 64);
+				mpfr_set_si(mpy, NUM2LL(y), MPFR_RNDN);
+				r = mpfr_fmod(mpr, mpx, mpy, rnd);
+			}
+		} else if (RB_TYPE_P(y, T_BIGNUM)) {
+			mpz_t mpzy; mpz_init(mpzy); mpfrrb_bignum_to_mpz(y, mpzy);
+			int nlz_bits_ret; size_t nb_bytes = rb_absint_size(y, &nlz_bits_ret);
+			mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpy; mpfr_init2(mpy, p);
+			mpfr_set_z(mpy, mpzy, MPFR_RNDN); mpz_clear(mpzy);
+			r = mpfr_fmod(mpr, mpx, mpy, rnd); mpfr_clear(mpy);
+		} else {
+			mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));
+			r = mpfr_fmod(mpr, mpx, mpy, rnd);
+		}
+	} else if (RB_TYPE_P(x, T_BIGNUM)) {
+		mpz_t mpz; mpz_init(mpz); mpfrrb_bignum_to_mpz(x, mpz);
+		int nlz_bits_ret; size_t nb_bytes = rb_absint_size(x, &nlz_bits_ret);
+		mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpx; mpfr_init2(mpx, p);
+		mpfr_set_z(mpx, mpz, MPFR_RNDN); mpz_clear(mpz);
+		if (RB_FLOAT_TYPE_P(y)) {
+			MPFR_DECL_INIT(mpy, 53);
+			mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);
+			r = mpfr_fmod(mpr, mpx, mpy, rnd);
+		} else if (RB_FIXNUM_P(y)) {
+			long long ly = NUM2LL(y);
+			if (ly >= 0) {
+				r = mpfr_fmod_ui(mpr, mpx, ly, rnd);
+			} else {
+				MPFR_DECL_INIT(mpy, 64);
+				mpfr_set_si(mpy, NUM2LL(y), MPFR_RNDN);
+				r = mpfr_fmod(mpr, mpx, mpy, rnd);
+			}
+		} else if (RB_TYPE_P(y, T_BIGNUM)) {
+			mpz_t mpzy; mpz_init(mpzy); mpfrrb_bignum_to_mpz(y, mpzy);
+			int nlz_bits_ret; size_t nb_bytes = rb_absint_size(y, &nlz_bits_ret);
+			mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpy; mpfr_init2(mpy, p);
+			mpfr_set_z(mpy, mpzy, MPFR_RNDN); mpz_clear(mpzy);
+			r = mpfr_fmod(mpr, mpx, mpy, rnd); mpfr_clear(mpy);
+		} else {
+			mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));
+			r = mpfr_fmod(mpr, mpx, mpy, rnd);
+		}
+		mpfr_clear(mpx);
+	} else {
+		mpfr_ptr mpx = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(x));
+		if (RB_FLOAT_TYPE_P(y)) {
+			MPFR_DECL_INIT(mpy, 53);
+			mpfr_set_d(mpy, NUM2DBL(y), MPFR_RNDN);
+			r = mpfr_fmod(mpr, mpx, mpy, rnd);
+		} else if (RB_FIXNUM_P(y)) {
+			long long ly = NUM2LL(y);
+			if (ly >= 0) {
+				r = mpfr_fmod_ui(mpr, mpx, ly, rnd);
+			} else {
+				MPFR_DECL_INIT(mpy, 64);
+				mpfr_set_si(mpy, NUM2LL(y), MPFR_RNDN);
+				r = mpfr_fmod(mpr, mpx, mpy, rnd);
+			}
+		} else if (RB_TYPE_P(y, T_BIGNUM)) {
+			mpz_t mpzy; mpz_init(mpzy); mpfrrb_bignum_to_mpz(y, mpzy);
+			int nlz_bits_ret; size_t nb_bytes = rb_absint_size(y, &nlz_bits_ret);
+			mpfr_prec_t p = nb_bytes*8 - nlz_bits_ret; mpfr_t mpy; mpfr_init2(mpy, p);
+			mpfr_set_z(mpy, mpzy, MPFR_RNDN); mpz_clear(mpzy);
+			r = mpfr_fmod(mpr, mpx, mpy, rnd); mpfr_clear(mpy);
+		} else {
+			mpfr_ptr mpy = mpfrrb_rb2ref(mpfrrb_object_to_mpfr(y));
+			r = mpfr_fmod(mpr, mpx, mpy, rnd);
+		}
+	}
+	return INT2NUM(r);
+}
+
+
+/* Set _self_ the the value of `x - ny`, rounded according to the direction `round`.
+ *
+ * `n` is the integer quotient of `x` divided by `y`, rounded to the nearest integer (ties rounded to even).
+ *
+ * Special values are handled as described in Section F.9.7.1 of the ISO C99 standard:
+ * - If `x` is infinite or `y` is zero, _self_ is NaN.
+ * - If `y` is infinite and `x` is finite, _self_ is `x` rounded to the precision of _self_.
+ * - If _self_ is zero, it has the sign of `x`. The return value is the ternary value corresponding to _self_.
+ * @return [Integer]
+ * @overload remainder(x, y, round: MPFR.default_rounding)
+ * @see fmod
+ */
+static VALUE mpfrrb_remainder(int argc, VALUE *argv, VALUE self)
+{
+	MPFRRB_TWO_ARG_FUNC_BODY(remainder);
+}
+
+
+/* Set self to the next (toward +Infinity) representable value.
+ * @return [self]
+ */
+static VALUE mpfrrb_nextabove_B(VALUE self)
+{
+	mpfr_nextabove(mpfrrb_rb2ref(self));
+	return self;
+}
+
+
+/* Set self to the previous (toward -Infinity) representable value.
+ * @return [self]
+ */
+static VALUE mpfrrb_nextbelow_B(VALUE self)
+{
+	mpfr_nextbelow(mpfrrb_rb2ref(self));
+	return self;
+}
+
+
+/* Free all caches and pools used by MPFR internally.
+ */
+static VALUE mpfrrb_free_cache(VALUE self)
+{
+	mpfr_free_cache();
+	return self;
+}
+
+
+/* This function rounds _self_ emulating subnormal number arithmetic.
+ * If _self_ is outside the subnormal exponent range of the emulated floating-point system,
+ * this function just propagates the ternary value `t`;
+ * otherwise, if `self.exponent` denotes the exponent of _self_,
+ * it rounds _self_ to precision `self.exponent - emin + 1` according to rounding mode `round` and previous ternary value `t`,
+ * avoiding double rounding problems.
+ * More precisely in the subnormal domain, denoting by _e_ the value of _emin_,
+ * _self_ is rounded in fixed-point arithmetic to an integer multiple of two to the power _e_ − 1;
+ * as a consequence, 1.5 multiplied by two to the power _e_ − 1 when `t` is zero is rounded to
+ * two to the power _e_ with rounding to nearest.
+ * 
+ * The precision `self.prec` of _self_ is not modified by this function.
+ * `round` and `t` must be the rounding mode and the returned ternary value used when computing _self_ (as in mpfr_check_range).
+ * The subnormal exponent range is from _emin_ to `emin + self.prec - 1`.
+ * If the result cannot be represented in the current exponent range of MPFR (due to a too small _emax_),
+ * the behavior is undefined. Note that unlike most functions, the result is compared to the exact one,
+ * not the input value _self_, i.e., the ternary value is propagated.
+ * 
+ * As usual, if the returned ternary value is non zero, the inexact flag is set.
+ * Moreover, if a second rounding occurred (because the input _self_ was in the subnormal range),
+ * the underflow flag is set.
+ * 
+ * Warning! If you change _emin_ (with {emin=}) just before calling mpfr_subnormalize,
+ * you need to make sure that the value is in the current exponent range of MPFR.
+ * But it is better to change _emin_ before any computation, if possible.
+ * 
+ * This is an example of how to emulate binary64 IEEE 754 arithmetic (a.k.a. double precision) using MPFR:
+ * 
+ * ```ruby
+ * MPFR.default_prec = 53
+ * MPFR.emin = -1073
+ * MPFR.emax =  1024
+ * xa = MPFR.new
+ * xb = MPFR.new
+ * 
+ * b = 34.3
+ * xb.set(b, round: :nearest)
+ * a = 0x11235.to_f * 2**-1037
+ * xa.set(a, round: :nearest)
+ * 
+ * a /= b
+ * i = xa.div(xa, xb, round: :nearest)
+ * i = xa.subnormalize(i, round: :nearest) # new ternary value
+ * ```
+ *
+ * Note that {emin=} and {emax=} are called early enough in order to make sure that all computed values
+ * are in the current exponent range.
+ * Warning! This emulates a double IEEE 754 arithmetic with correct rounding in the subnormal range,
+ * which may not be the case for your hardware.
+ * 
+ * Below is another example showing how to emulate fixed-point arithmetic in a specific case.
+ * Here we compute the sine of the integers 1 to 17 with a result in a fixed-point arithmetic rounded at two to the power -42
+ * (using the fact that the result is at most 1 in absolute value):
+ * 
+ * ```ruby
+ * MPFR.emin = -41
+ * x = MPFR.new(prec: 42)
+ * (1..17).each do |i|
+ *   x.set(i, round: :nearest)
+ *   inex = x.sin(x, round: :toward_zero)
+ *   x.subnormalize(inex, round: :toward_zero)
+ *   puts x
+ * end
+ * ```
+ *
+ * @return [Integer]
+ * @overload subnormalize(t, round: MPFR.default_rounding)
+ *  @param t [Integer]
+ *  @param round [Symbol]
+ * @see emin=
+ * @see emax=
+ */
+static VALUE mpfrrb_subnormalize(int argc, VALUE *argv, VALUE self)
+{
+	VALUE trb;
+	mpfr_rnd_t rnd = mpfrrb_get_b_round(argc, argv, &trb);
+	int t = NUM2INT(trb);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_subnormalize(mp, t, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Return the (current) smallest exponents allowed for a floating-point variable.
+ * The smallest positive value of a floating-point variable is one half times 2 raised to the smallest exponent.
+ * @return [Integer]
+ * @see emin=
+ */
+static VALUE mpfrrb_get_emin(VALUE self)
+{
+	(void)self;
+	return LL2NUM(mpfr_get_emin());
+}
+
+
+/* Set the smallest exponents allowed for a floating-point variable.
+ *
+ * For the subsequent operations, it is the user's responsibility to check that any floating-point value used as an input
+ * is in the new exponent range (for example using {#check_range}).
+ * If a floating-point value outside the new exponent range is used as an input, the default behavior is undefined.
+ *
+ * @note If `emin > emax` and a floating-point value needs to be produced as output, the behavior is undefined.
+ * @return [Integer]
+ */
+static VALUE mpfrrb_set_emin(VALUE self, VALUE e)
+{
+	(void)self;
+	mpfr_exp_t v = NUM2LL(e);
+	if (v < mpfr_get_emin_min() || v > mpfr_get_emin_max()) {
+		rb_raise(rb_eRangeError, "emin must be between %ld and %ld", mpfr_get_emin_min(), mpfr_get_emin_max());
+	}
+	mpfr_set_emin(v);
+	return e;
+}
+
+
+/* Return the (current) largest exponents allowed for a floating-point variable.
+ * The largest value has the form (1 − epsilon) times 2 raised to the largest exponent,
+ * where epsilon depends on the precision of the considered variable.
+ * @return [Integer]
+ * @see emax=
+ */
+static VALUE mpfrrb_get_emax(VALUE self)
+{
+	(void)self;
+	return LL2NUM(mpfr_get_emax());
+}
+
+
+/* Set the largest exponents allowed for a floating-point variable.
+ *
+ * For the subsequent operations, it is the user's responsibility to check that any floating-point value used as an input
+ * is in the new exponent range (for example using {#check_range}).
+ * If a floating-point value outside the new exponent range is used as an input, the default behavior is undefined.
+ *
+ * @note If `emin > emax` and a floating-point value needs to be produced as output, the behavior is undefined.
+ * @return [Integer]
+ */
+static VALUE mpfrrb_set_emax(VALUE self, VALUE e)
+{
+	(void)self;
+	mpfr_exp_t v = NUM2LL(e);
+	if (v < mpfr_get_emax_min() || v > mpfr_get_emax_max()) {
+		rb_raise(rb_eRangeError, "emax must be between %ld and %ld", mpfr_get_emax_min(), mpfr_get_emax_max());
+	}
+	mpfr_set_emax(v);
+	return e;
+}
+
+
+/* Set self to the minimum of `x` and `y`.
+ * If `x` and `y` are both NaN, then self is set to NaN.
+ * If `x` or `y` is NaN, then self is set to the numeric value.
+ * If `x` and `y` are zeros of different signs, then rop is set to -0.
+ * @return [Integer]
+ * @overload min(x, y, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_min(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, y;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &x, &y);
+	x = mpfrrb_object_to_mpfr(x);
+	y = mpfrrb_object_to_mpfr(y);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_min(mp, mpfrrb_rb2ref(x), mpfrrb_rb2ref(y), rnd);
+	return INT2NUM(r);
+}
+
+
+/* Set self to the maximum of `x` and `y`.
+ * If `x` and `y` are both NaN, then self is set to NaN.
+ * If `x` or `y` is NaN, then self is set to the numeric value.
+ * If `x` and `y` are zeros of different signs, then rop is set to +0.
+ * @return [Integer]
+ * @overload max(x, y, round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_max(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, y;
+	mpfr_rnd_t rnd = mpfrrb_get_a_b_round(argc, argv, &x, &y);
+	x = mpfrrb_object_to_mpfr(x);
+	y = mpfrrb_object_to_mpfr(y);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_max(mp, mpfrrb_rb2ref(x), mpfrrb_rb2ref(y), rnd);
+	return INT2NUM(r);
+}
+
+
+/* Generate a uniformly distributed random float in the interval 0 ≤ _self_ < 1.
+ * More precisely, the number can be seen as a float with a random non-normalized significand and exponent 0,
+ * which is then normalized (thus if _e_ denotes the exponent after normalization,
+ * then the least -_e_ significant bits of the significand are always 0).
+ *
+ * Return 0, unless the exponent is not in the current exponent range,
+ * in which case _self_ is set to NaN and a non-zero value is returned
+ * (this should never happen in practice, except in very specific cases).
+ *
+ * @return [Integer]
+ */
+static VALUE mpfrrb_urandomb(VALUE self)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_urandomb(mp, mpfrrb_gmp_randstate);
+	return INT2NUM(r);
+}
+
+
+/* Generate a uniformly distributed random float.
+ * The floating-point number _self_ can be seen as if a random real number is generated
+ * according to the continuous uniform distribution on the interval [0, 1] and then rounded in the direction `round`.
+ *
+ * @return [Integer]
+ * @overload urandom(round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_urandom(int argc, VALUE *argv, VALUE self)
+{
+	mpfr_rnd_t rnd = mpfrrb_get_round_single_keword(argc, argv);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_urandom(mp, mpfrrb_gmp_randstate, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Generate a random floating-point number according to a standard normal Gaussian distribution (with mean zero and variance one).
+ *
+ * The floating-point number _self_ can be seen as if a random real number were generated according to the standard normal
+ * Gaussian distribution and then rounded in the direction rnd.
+ *
+ * @return [Integer]
+ * @overload nrandom(round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_nrandom(int argc, VALUE *argv, VALUE self)
+{
+	mpfr_rnd_t rnd = mpfrrb_get_round_single_keword(argc, argv);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_nrandom(mp, mpfrrb_gmp_randstate, rnd);
+	return INT2NUM(r);
+}
+
+
+/* Generate a random floating-point number according to an exponential distribution, with mean one.
+ * Other characteristics are identical to {nrandom}.
+ * @return [Integer]
+ * @overload erandom(round: MPFR.default_rounding)
+ */
+static VALUE mpfrrb_erandom(int argc, VALUE *argv, VALUE self)
+{
+	mpfr_rnd_t rnd = mpfrrb_get_round_single_keword(argc, argv);
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	int r = mpfr_erandom(mp, mpfrrb_gmp_randstate, rnd);
+	return INT2NUM(r);
+}
+
+
+static VALUE mpfrrb_index_from_integer(mpfr_ptr mp, int index)
+{
+//	printf("prec: %ld\n", mp->_mpfr_prec);
+//	printf("sign: %d\n",  mp->_mpfr_sign);
+//	printf("exp:  %ld\n", mp->_mpfr_exp);
+//	printf("[-1]: 0x%016lx\n", mp->_mpfr_d[-1]);
+//	printf("[0]:  0x%016lx\n", mp->_mpfr_d[0]);
+//	if (mp->_mpfr_prec > GMP_NUMB_BITS) printf("[1]:  0x%016lx\n", mp->_mpfr_d[1]);
+//	printf("mpfrrb_index_from_integer(%d)\n", index);
+	int p = mpfr_get_prec(mp);
+	if (index > 0 || index <= -p) return INT2NUM(0);
+	index += p - 1 + (GMP_NUMB_BITS - p % GMP_NUMB_BITS) % GMP_NUMB_BITS;
+	int limb_nb = index / GMP_NUMB_BITS;
+	int bit_idx = index % GMP_NUMB_BITS;
+//	printf("limb_nb = %d\n", limb_nb);
+//	printf("bit_idx = %d\n", bit_idx);
+	int r = (mp->_mpfr_d[limb_nb] >> bit_idx) & 1;
+	return INT2NUM(r);
+}
+
+
+static VALUE mpfrrb_index_from_range(mpfr_ptr mp, int lsbpos, int msbpos)
+{
+	int p = mpfr_get_prec(mp);
+	if (lsbpos > msbpos) return Qnil;
+	if (msbpos <= -p || lsbpos > 0) return INT2NUM(0);
+	if (msbpos > 0) msbpos = 0;
+	int len = msbpos - lsbpos + 1;
+	int shift = 0;
+	if (lsbpos <= -p) {
+		shift = 1 - p - lsbpos;
+		len -= shift;
+		lsbpos = 1 - p;
+	}
+	if (len < 1) {
+		return Qnil;
+	} else if (len <= 64) {
+		uint64_t n = 0;
+		int i, j;
+		const int offst = (GMP_NUMB_BITS - p % GMP_NUMB_BITS) % GMP_NUMB_BITS;
+		for (i = 0, j = lsbpos; j <= msbpos; i++, j++) {
+			int index = j + p - 1 + offst;
+			int limb_nb = index / GMP_NUMB_BITS;
+			int bit_idx = index % GMP_NUMB_BITS;
+			int b = (mp->_mpfr_d[limb_nb] >> bit_idx) & 1;
+			n |= (uint64_t)b << i;
+		}
+		VALUE num = ULL2NUM(n);
+		if (shift) {
+			VALUE sh = INT2NUM(shift);
+			num = rb_funcallv(num, id_chchleft, 1, &sh);
+		}
+		return num;
+	} else {
+		VALUE num = INT2NUM(0);
+		const int offst = (GMP_NUMB_BITS - p % GMP_NUMB_BITS) % GMP_NUMB_BITS;
+		int c, nb_chunks = (len + 63) / 64;
+		for (c = 0; c < nb_chunks; c++) {
+			int lsb = lsbpos + c*64;
+			int msb = (lsb + 63) > msbpos ? msbpos : (lsb + 63);
+			uint64_t n = 0;
+			int i, j;
+			for (i = 0, j = lsb; j <= msb; i++, j++) {
+				int index = j + p - 1 + offst;
+				int limb_nb = index / GMP_NUMB_BITS;
+				int bit_idx = index % GMP_NUMB_BITS;
+				int b = (mp->_mpfr_d[limb_nb] >> bit_idx) & 1;
+				n |= (uint64_t)b << i;
+			}
+			VALUE chunk = ULL2NUM(n);
+			VALUE sh = INT2NUM(c*64);
+			chunk = rb_funcallv(chunk, id_chchleft, 1, &sh);
+			num = rb_funcallv(num, id_orpipe, 1, &chunk);
+		}
+		if (shift) {
+			VALUE sh = INT2NUM(shift);
+			num = rb_funcallv(num, id_chchleft, 1, &sh);
+		}
+		return num;
+	}
+}
+
+
+/* Returns bits from the significand, ignoring the sign or the exponent.
+ *
+ * The most significand bit is indexed at 0, the least significand bit is indexed at 1 - _prec_.
+ *
+ * In case _self_ is not finite (an infinite or NaN), _nil_ is retured.
+ *
+ * @param index [Integer, Range<Integer>]
+ * @return [Integer, nil]
+ */
+static VALUE mpfrrb_index(VALUE self, VALUE index)
+{
+	mpfr_ptr mp = mpfrrb_rb2ref(self);
+	if (mpfr_zero_p(mp)) {
+		return INT2NUM(0);
+	} else if (!mpfr_regular_p(mp)) {
+		return Qnil;
+	}
+	if (RB_FIXNUM_P(index)) {
+		return mpfrrb_index_from_integer(mp, NUM2INT(index));
+	} else if (rb_class_of(index) == rb_cRange) {
+		VALUE begrb, endrb;
+		int excl;
+		rb_range_values(index, &begrb, &endrb, &excl);
+		int beg = NUM2INT(begrb);
+		int end = NUM2INT(endrb);
+		int len = (end > beg ? end - beg : beg - end) + (excl ? 0 : 1);
+		if (len < 1) {
+			return Qnil;
+		}
+		if (beg < end) {
+			end = beg + len - 1; 
+		} else {
+			end = beg - len + 1;
+			int t = end;
+			end = beg;
+			beg = t;
+		}
+		return mpfrrb_index_from_range(mp, beg, end);
+	} else {
+		rb_raise(rb_eTypeError, "expecging an integer or a range, got a %s", rb_obj_classname(index));
+	}
+}
+
+
+/* Document-class: MPFR
+ *
+ * MPFR methods take as last argument a rounding mode, and have a return value of type integer, called the _ternary value_.
+ * The value stored in the receiver is correctly rounded, i.e., MPFR behaves as if it computed the result with an infinite precision, then rounded it to the precision of this variable.
+ * The input variables are regarded as exact (in particular, their precision does not affect the result).
+ *
+ * As a consequence, in case of a non-zero real rounded result,
+ * the error on the result is less than or equal to 1/2 ulp (unit in the last place) of that result in the rounding to nearest mode,
+ * and less than 1 ulp of that result in the directed rounding modes (a ulp is the weight of the least significant represented bit of the result after rounding).
+ *
+ * Unless documented otherwise, methods returning an integer return a ternary value.
+ * If the ternary value is zero, it means that the value stored in the receiver is the exact result of the corresponding mathematical function.
+ * If the ternary value is positive (resp. negative), it means the value stored in the receiver is greater (resp. lower) than the exact result.
+ * For example with the `:round_up` rounding mode, the ternary value is usually positive, except when the result is exact, in which case it is zero.
+ * In the case of an infinite result, it is considered as inexact when it was obtained by overflow, and exact otherwise.
+ * A NaN result (Not-a-Number) always corresponds to an exact return value.
+ * The opposite of a returned ternary value is guaranteed to be representable in an integer.
+*/
+
+
+void Init_mpfr(void)
+{
+	id_rndn              = rb_intern("rndn");
+	id_rndz              = rb_intern("rndz");
+	id_rndu              = rb_intern("rndu");
+	id_rndd              = rb_intern("rndd");
+	id_rnda              = rb_intern("rnda");
+	id_rndf              = rb_intern("rndf");
+	id_rndna             = rb_intern("rndna");
+	id_round_nearest     = rb_intern("round_nearest");
+	id_toward_zero       = rb_intern("toward_zero");
+	id_round_up          = rb_intern("round_up");
+	id_round_down        = rb_intern("round_down");
+	id_away_from_zero    = rb_intern("away_from_zero");
+	id_faithful_rounding = rb_intern("faithful_rounding");
+	id_nearest           = rb_intern("nearest");
+	id_zero              = rb_intern("zero");
+	id_up                = rb_intern("up");
+	id_down              = rb_intern("down");
+	id_away              = rb_intern("away");
+	id_faithful          = rb_intern("faithful");
+	id_nearest_ties_away = rb_intern("nearest_ties_away");
+	id_prec              = rb_intern("prec");
+	id_conv              = rb_intern("conv");
+	id_round             = rb_intern("round");
+	id_decimals          = rb_intern("decimals");
+	id_to_mpfr           = rb_intern("to_mpfr");
+	id_chchleft          = rb_intern("<<");
+	id_orpipe            = rb_intern("|");
+
+	mpfrrb_default_rounding_id = id_round_nearest;
+
+//	c_MPFR = rb_define_class("MPFR", rb_cObject);
+	c_MPFR = rb_define_class("MPFR", rb_cNumeric);
+
+	rb_define_module_function(c_MPFR, "version",           mpfrrb_get_version,          0);
+	rb_define_module_function(c_MPFR, "patches",           mpfrrb_get_patches,          0);
+	rb_define_module_function(c_MPFR, "default_prec",      mpfrrb_get_default_prec,     0);
+	rb_define_module_function(c_MPFR, "default_prec=",     mpfrrb_set_default_prec,     1);
+	rb_define_module_function(c_MPFR, "default_rounding",  mpfrrb_get_default_rounding, 0);
+	rb_define_module_function(c_MPFR, "default_rounding=", mpfrrb_set_default_rounding, 1);
+	rb_define_module_function(c_MPFR, "emin",              mpfrrb_get_emin,             0);
+	rb_define_module_function(c_MPFR, "emin=",             mpfrrb_set_emin,             1);
+	rb_define_module_function(c_MPFR, "emax",              mpfrrb_get_emax,             0);
+	rb_define_module_function(c_MPFR, "emax=",             mpfrrb_set_emax,             1);
+	rb_define_module_function(c_MPFR, "i_2exp",            mpfrrb_i_2exp,               2);
+	rb_define_module_function(c_MPFR, "free_cache",        mpfrrb_free_cache,           0);
+
+	/* The minimum precision that can be set for a MPFR object.
+	 * @return [Integer]
+	 */
+	rb_define_const(c_MPFR, "PREC_MIN", INT2NUM(MPFR_PREC_MIN));
+
+	/* The maximum precision that can be set for a MPFR object.
+	 * @return [Integer]
+	 */
+	rb_define_const(c_MPFR, "PREC_MAX", ULL2NUM(MPFR_PREC_MAX));
+
+	/* The minimum of the exponents allowed for {emin=}.
+	 * This value is implementation dependent, thus a program using `MPFR.emin = EMIN_MIN` may not be portable.
+	 * @return [Integer]
+	 */
+	rb_define_const(c_MPFR, "EMIN_MIN", LL2NUM(mpfr_get_emin_min()));
+
+	/* The maximum of the exponents allowed for {emin=}.
+	 * @return [Integer]
+	 */
+	rb_define_const(c_MPFR, "EMIN_MAX", LL2NUM(mpfr_get_emin_max()));
+
+	/* The minimum of the exponents allowed for {emax=}.
+	 * @return [Integer]
+	 */
+	rb_define_const(c_MPFR, "EMAX_MIN", LL2NUM(mpfr_get_emin_min()));
+
+	/* The maximum of the exponents allowed for {emax=}.
+	 * This value is implementation dependent, thus a program using `MPFR.emax = EMAX_MAX` may not be portable.
+	 * @return [Integer]
+	 */
+	rb_define_const(c_MPFR, "EMAX_MAX", LL2NUM(mpfr_get_emin_max()));
+
+	rb_define_alloc_func(c_MPFR, mpfrrb_alloc);
+	rb_undef_method(rb_class_of(c_MPFR), "allocate");
+//	rb_include_module(c_MPFR, rb_mComparable);
+	rb_define_method(c_MPFR, "initialize",   mpfrrb_initialize,   -1);
+
+	rb_define_method(c_MPFR, "to_s",         mpfrrb_to_s,         -1);
+	rb_define_method(c_MPFR, "to_f",         mpfrrb_to_f,         -1);
+	rb_define_method(c_MPFR, "to_i",         mpfrrb_to_i,         -1);
+	rb_define_method(c_MPFR, "to_r",         mpfrrb_to_r,          0);
+	rb_define_method(c_MPFR, "to_mpfr",      mpfrrb_MPFR_to_mpfr,  0);
+
+	rb_define_method(c_MPFR, "prec_round",   mpfrrb_prec_round,   -1);
+	rb_define_method(c_MPFR, "prec",         mpfrrb_get_prec,      0);
+	rb_define_method(c_MPFR, "prec=",        mpfrrb_set_prec,      1);
+	rb_define_method(c_MPFR, "sign",         mpfrrb_get_sign,      0);
+	rb_define_method(c_MPFR, "sign=",        mpfrrb_set_sign,      1);
+	rb_define_method(c_MPFR, "exponent",     mpfrrb_get_exponent , 0);
+	rb_define_method(c_MPFR, "exponent=",    mpfrrb_set_exponent , 1);
+
+	rb_define_method(c_MPFR, "set",          mpfrrb_set,          -1);
+	rb_define_method(c_MPFR, "set_nan",      mpfrrb_set_nan,       0);
+	rb_define_method(c_MPFR, "set_zero",     mpfrrb_set_zero,     -1);
+	rb_define_method(c_MPFR, "set_infinity", mpfrrb_set_infinity, -1);
+	rb_define_method(c_MPFR, "set_pi",       mpfrrb_set_pi,       -1);
+	rb_define_method(c_MPFR, "set_log2",     mpfrrb_set_log2,     -1);
+	rb_define_method(c_MPFR, "set_euler",    mpfrrb_set_euler,    -1);
+	rb_define_method(c_MPFR, "set_catalan",  mpfrrb_set_catalan,  -1);
+
+	rb_define_method(c_MPFR, "get_d_2exp",   mpfrrb_get_d_2exp,   -1);
+	rb_define_method(c_MPFR, "get_i_2exp",   mpfrrb_get_i_2exp,    0);
+
+	rb_define_method(c_MPFR, "zero?",        mpfrrb_is_zero,       0);
+	rb_define_method(c_MPFR, "nan?",         mpfrrb_is_nan,        0);
+	rb_define_method(c_MPFR, "infinite?",    mpfrrb_is_infinite,   0);
+	rb_define_method(c_MPFR, "finite?",      mpfrrb_is_finite,     0);
+	rb_define_method(c_MPFR, "integer?",     mpfrrb_is_integer,    0);
+
+	rb_define_method(c_MPFR, "add",          mpfrrb_add,          -1);
+	rb_define_method(c_MPFR, "add!",         mpfrrb_add_B,        -1);
+	rb_define_method(c_MPFR, "sub",          mpfrrb_sub,          -1);
+	rb_define_method(c_MPFR, "sub!",         mpfrrb_sub_B,        -1);
+	rb_define_method(c_MPFR, "mul",          mpfrrb_mul,          -1);
+	rb_define_method(c_MPFR, "mul!",         mpfrrb_mul_B,        -1);
+	rb_define_method(c_MPFR, "div",          mpfrrb_div,          -1);
+	rb_define_method(c_MPFR, "div!",         mpfrrb_div_B,        -1);
+	rb_define_method(c_MPFR, "sqr",          mpfrrb_sqr,          -1);
+	rb_define_method(c_MPFR, "sqr!",         mpfrrb_sqr_B,        -1);
+	rb_define_method(c_MPFR, "sqrt",         mpfrrb_sqrt,         -1);
+	rb_define_method(c_MPFR, "sqrt!",        mpfrrb_sqrt_B,       -1);
+	rb_define_method(c_MPFR, "rec_sqrt",     mpfrrb_rec_sqrt,     -1);
+	rb_define_method(c_MPFR, "rec_sqrt!",    mpfrrb_rec_sqrt_B,   -1);
+	rb_define_method(c_MPFR, "cbrt",         mpfrrb_cbrt,         -1);
+	rb_define_method(c_MPFR, "cbrt!",        mpfrrb_cbrt_B,       -1);
+	rb_define_method(c_MPFR, "rootn",        mpfrrb_rootn,        -1);
+	rb_define_method(c_MPFR, "rootn!",       mpfrrb_rootn_B,      -1);
+	rb_define_method(c_MPFR, "neg",          mpfrrb_neg,          -1);
+	rb_define_method(c_MPFR, "neg!",         mpfrrb_neg_B,         0);
+	rb_define_method(c_MPFR, "abs",          mpfrrb_abs,          -1);
+	rb_define_method(c_MPFR, "abs!",         mpfrrb_abs_B,         0);
+	rb_define_method(c_MPFR, "dim",          mpfrrb_dim,          -1);
+	rb_define_method(c_MPFR, "mul_2i",       mpfrrb_mul_2i,       -1);
+	rb_define_method(c_MPFR, "mul_2i!",      mpfrrb_mul_2i_B,     -1);
+	rb_define_method(c_MPFR, "div_2i",       mpfrrb_div_2i,       -1);
+	rb_define_method(c_MPFR, "div_2i!",      mpfrrb_div_2i_B,     -1);
+	rb_define_method(c_MPFR, "fac",          mpfrrb_fac,          -1);
+	rb_define_method(c_MPFR, "fma",          mpfrrb_fma,          -1);
+	rb_define_method(c_MPFR, "fma!",         mpfrrb_fma_B,        -1);
+	rb_define_method(c_MPFR, "fms",          mpfrrb_fms,          -1);
+	rb_define_method(c_MPFR, "fms!",         mpfrrb_fms_B,        -1);
+	rb_define_method(c_MPFR, "fmma",         mpfrrb_fmma,         -1);
+	rb_define_method(c_MPFR, "fmms",         mpfrrb_fmms,         -1);
+	rb_define_method(c_MPFR, "hypot",        mpfrrb_hypot,        -1);
+
+	rb_define_method(c_MPFR, "<=>",          mpfrrb_cmp,           1);
+	rb_define_method(c_MPFR, "coerce",       mpfrrb_coerce,        1);
+
+	rb_define_method(c_MPFR, "log",          mpfrrb_log,          -1);
+	rb_define_method(c_MPFR, "log2",         mpfrrb_log2,         -1);
+	rb_define_method(c_MPFR, "log10",        mpfrrb_log10,        -1);
+	rb_define_method(c_MPFR, "log1p",        mpfrrb_log1p,        -1);
+	rb_define_method(c_MPFR, "log2p1",       mpfrrb_log2p1,       -1);
+	rb_define_method(c_MPFR, "log10p1",      mpfrrb_log10p1,      -1);
+	rb_define_method(c_MPFR, "exp",          mpfrrb_exp,          -1);
+	rb_define_method(c_MPFR, "exp2",         mpfrrb_exp2,         -1);
+	rb_define_method(c_MPFR, "exp10",        mpfrrb_exp10,        -1);
+	rb_define_method(c_MPFR, "expm1",        mpfrrb_expm1,        -1);
+	rb_define_method(c_MPFR, "exp2m1",       mpfrrb_exp2m1,       -1);
+	rb_define_method(c_MPFR, "exp10m1",      mpfrrb_exp10m1,      -1);
+	rb_define_method(c_MPFR, "pow",          mpfrrb_pow,          -1);
+	rb_define_method(c_MPFR, "compound",     mpfrrb_compound,     -1);
+	rb_define_method(c_MPFR, "cos",          mpfrrb_cos,          -1);
+	rb_define_method(c_MPFR, "sin",          mpfrrb_sin,          -1);
+	rb_define_method(c_MPFR, "tan",          mpfrrb_tan,          -1);
+	rb_define_method(c_MPFR, "cosu",         mpfrrb_cosu,         -1);
+	rb_define_method(c_MPFR, "sinu",         mpfrrb_sinu,         -1);
+	rb_define_method(c_MPFR, "tanu",         mpfrrb_tanu,         -1);
+	rb_define_method(c_MPFR, "cospi",        mpfrrb_cospi,        -1);
+	rb_define_method(c_MPFR, "sinpi",        mpfrrb_sinpi,        -1);
+	rb_define_method(c_MPFR, "tanpi",        mpfrrb_tanpi,        -1);
+	rb_define_method(c_MPFR, "sec",          mpfrrb_sec,          -1);
+	rb_define_method(c_MPFR, "csc",          mpfrrb_csc,          -1);
+	rb_define_method(c_MPFR, "cot",          mpfrrb_cot,          -1);
+	rb_define_method(c_MPFR, "acos",         mpfrrb_acos,         -1);
+	rb_define_method(c_MPFR, "asin",         mpfrrb_asin,         -1);
+	rb_define_method(c_MPFR, "atan",         mpfrrb_atan,         -1);
+	rb_define_method(c_MPFR, "acosu",        mpfrrb_acosu,        -1);
+	rb_define_method(c_MPFR, "asinu",        mpfrrb_asinu,        -1);
+	rb_define_method(c_MPFR, "atanu",        mpfrrb_atanu,        -1);
+	rb_define_method(c_MPFR, "acospi",       mpfrrb_acospi,       -1);
+	rb_define_method(c_MPFR, "asinpi",       mpfrrb_asinpi,       -1);
+	rb_define_method(c_MPFR, "atanpi",       mpfrrb_atanpi,       -1);
+	rb_define_method(c_MPFR, "atan2",        mpfrrb_atan2,        -1);
+	rb_define_method(c_MPFR, "atan2u",       mpfrrb_atan2u,       -1);
+	rb_define_method(c_MPFR, "atan2pi",      mpfrrb_atan2pi,      -1);
+	rb_define_method(c_MPFR, "cosh",         mpfrrb_cosh,         -1);
+	rb_define_method(c_MPFR, "sinh",         mpfrrb_sinh,         -1);
+	rb_define_method(c_MPFR, "tanh",         mpfrrb_tanh,         -1);
+	rb_define_method(c_MPFR, "sech",         mpfrrb_sech,         -1);
+	rb_define_method(c_MPFR, "csch",         mpfrrb_csch,         -1);
+	rb_define_method(c_MPFR, "coth",         mpfrrb_coth,         -1);
+	rb_define_method(c_MPFR, "acosh",        mpfrrb_acosh,        -1);
+	rb_define_method(c_MPFR, "asinh",        mpfrrb_asinh,        -1);
+	rb_define_method(c_MPFR, "atanh",        mpfrrb_atanh,        -1);
+	rb_define_method(c_MPFR, "eint",         mpfrrb_eint,         -1);
+	rb_define_method(c_MPFR, "li2",          mpfrrb_li2,          -1);
+	rb_define_method(c_MPFR, "gamma",        mpfrrb_gamma,        -1);
+	rb_define_method(c_MPFR, "gamma_inc",    mpfrrb_gamma_inc,    -1);
+	rb_define_method(c_MPFR, "lngamma",      mpfrrb_lngamma,      -1);
+	rb_define_method(c_MPFR, "digamma",      mpfrrb_digamma,      -1);
+	rb_define_method(c_MPFR, "beta",         mpfrrb_beta,         -1);
+	rb_define_method(c_MPFR, "zeta",         mpfrrb_zeta,         -1);
+	rb_define_method(c_MPFR, "erf",          mpfrrb_erf,          -1);
+	rb_define_method(c_MPFR, "erfc",         mpfrrb_erfc,         -1);
+	rb_define_method(c_MPFR, "j0",           mpfrrb_j0,           -1);
+	rb_define_method(c_MPFR, "j1",           mpfrrb_j1,           -1);
+	rb_define_method(c_MPFR, "jn",           mpfrrb_jn,           -1);
+	rb_define_method(c_MPFR, "y0",           mpfrrb_y0,           -1);
+	rb_define_method(c_MPFR, "y1",           mpfrrb_y1,           -1);
+	rb_define_method(c_MPFR, "yn",           mpfrrb_yn,           -1);
+	rb_define_method(c_MPFR, "agm",          mpfrrb_agm,          -1);
+	rb_define_method(c_MPFR, "ai",           mpfrrb_ai,           -1);
+
+	rb_define_method(c_MPFR, "rint",           mpfrrb_rint,           -1);
+	rb_define_method(c_MPFR, "ceil",           mpfrrb_ceil,            1);
+	rb_define_method(c_MPFR, "floor",          mpfrrb_floor,           1);
+	rb_define_method(c_MPFR, "round",          mpfrrb_round,           1);
+	rb_define_method(c_MPFR, "roundeven",      mpfrrb_roundeven,       1);
+	rb_define_method(c_MPFR, "trunc",          mpfrrb_trunc,           1);
+	rb_define_method(c_MPFR, "rint!",          mpfrrb_rint_B,         -1);
+	rb_define_method(c_MPFR, "ceil!",          mpfrrb_ceil_B,          0);
+	rb_define_method(c_MPFR, "floor!",         mpfrrb_floor_B,         0);
+	rb_define_method(c_MPFR, "round!",         mpfrrb_round_B,         0);
+	rb_define_method(c_MPFR, "roundeven!",     mpfrrb_roundeven_B,     0);
+	rb_define_method(c_MPFR, "trunc!",         mpfrrb_trunc_B,         0);
+	rb_define_method(c_MPFR, "rint_ceil",      mpfrrb_rint_ceil,      -1);
+	rb_define_method(c_MPFR, "rint_floor",     mpfrrb_rint_floor,     -1);
+	rb_define_method(c_MPFR, "rint_round",     mpfrrb_rint_round,     -1);
+	rb_define_method(c_MPFR, "rint_roundeven", mpfrrb_rint_roundeven, -1);
+	rb_define_method(c_MPFR, "rint_trunc",     mpfrrb_rint_trunc,     -1);
+	rb_define_method(c_MPFR, "frac",           mpfrrb_frac,           -1);
+	rb_define_module_function(c_MPFR, "modf",  mpfrrb_modf,           -1);
+	rb_define_method(c_MPFR, "fmod",           mpfrrb_fmod,           -1);
+	rb_define_method(c_MPFR, "remainder",      mpfrrb_remainder,      -1);
+
+	rb_define_method(c_MPFR, "nextabove!",     mpfrrb_nextabove_B,     0);
+	rb_define_method(c_MPFR, "nextbelow!",     mpfrrb_nextbelow_B,     0);
+
+	/* @!group Random
+	 */
+	rb_define_method(c_MPFR, "urandomb",       mpfrrb_urandomb,        0);
+	rb_define_method(c_MPFR, "urandom",        mpfrrb_urandom,        -1);
+	rb_define_method(c_MPFR, "nrandom",        mpfrrb_nrandom,        -1);
+	rb_define_method(c_MPFR, "erandom",        mpfrrb_erandom,        -1);
+	/* @!endgroup
+	 */
+
+	rb_define_method(c_MPFR, "min",            mpfrrb_min,            -1);
+	rb_define_method(c_MPFR, "max",            mpfrrb_max,            -1);
+	rb_define_method(c_MPFR, "subnormalize",   mpfrrb_subnormalize,   -1);
+
+	rb_define_method(c_MPFR, "[]", mpfrrb_index, 1);
+
+	rb_define_alias(c_MPFR, "inspect", "to_s");
+
+	rb_define_method(rb_cFloat,   "to_mpfr", mpfrrb_Float_to_mpfr,   0);
+	rb_define_method(rb_cInteger, "to_mpfr", mpfrrb_Integer_to_mpfr, 0);
+
+	gmp_randinit_default(mpfrrb_gmp_randstate);
+	gmp_randseed_ui(mpfrrb_gmp_randstate, rb_genrand_ulong_limited(0xffffffffffffffffULL));
+
+//	Init_sollya();
+}
+
+