crmf 0.1.1

data/ext/crmf/crmf.c

@@ -0,0 +1,1966 @@
+/* Copyright (C) 2022 Théotime Bollengier <theotime.bollengier@ensta-bretagne.fr>
+ *
+ * This file is part of CRMF. <https://gitlab.ensta-bretagne.fr/bollenth/crmf>
+ *
+ * CRMF 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.
+ *
+ * CRMF 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 CRMF. If not, see <https://www.gnu.org/licenses/>. 
+ */
+
+#include <ruby.h>
+#include "crmf.h"
+#include <mpfr.h>
+#include "crlibm.h"
+#include <fenv.h>
+
+static VALUE m_CRMF;
+static ID id_to_f;
+static ID id_to_s;
+static ID id_nearest;
+static ID id_down;
+static ID id_up;
+static ID id_zero;
+static ID id_away;
+static ID id_syminf;
+static ID id_sign;
+static ID id_sign_bit;
+static ID id_exponent_bits;
+static ID id_fraction_bits;
+static ID id_exponent;
+static ID id_significand;
+static ID id_isignificand;
+static ID id_flag;
+static ID id_infinity;
+static ID id_nan;
+static ID id_subnormal;
+static ID id_zero;
+
+
+/* Returns a hash containing the components of the float.
+ * 
+ * The returned hash contains the folowing fields:
+ *
+ * - **:sign_bit** An integer: 0 for positive, 1 for negative. Corresponds to bit 63.
+ * - **:exponent_bits** The biased exponent as an integer. Corresponds to bits 62 downto 52.
+ * - **:fraction_bits** The stored fraction bits (without the implicit leading 1). Corresponds to bits 51 downto 0.
+ * - **:sign** An integer: 1 for positive, -1 for negative
+ * - **:flag** A symbol, either _:nan_, _:infinite_, _:zero_, _:subnormal_ or _nil_. 
+ * - **:exponent** The unbiased exponent as an integer.
+ * - **:isignificand** An integer corresponding to _fraction\_bits_ plus the leading implicit 1 if not a subnormal.
+ * - **:significand** The significand part as a float, in the range [1.0, 2.0[, or less than 1.0 if the number is subnormal.
+ *
+ * The number can be retreived with `sign * 2**exponent * significand`
+ * @return [Hash{Symbol => Object}]
+ * @see build_up
+ */
+static VALUE crmf_float_break_down(VALUE self)
+{
+	union {
+		double d;
+		unsigned long long l;
+	} dudul;
+	dudul.d = NUM2DBL(self);
+	unsigned long long sign = (dudul.l >> 63) & 1;
+	unsigned long long expo = (dudul.l >> 52) & 0x7ff;
+	unsigned long long frac =  dudul.l & 0x000fffffffffffffULL;
+	VALUE h = rb_hash_new();
+	rb_hash_aset(h, rb_id2sym(id_sign_bit), ULL2NUM(sign));
+	rb_hash_aset(h, rb_id2sym(id_exponent_bits), RB_ULL2NUM(expo));
+	rb_hash_aset(h, rb_id2sym(id_fraction_bits), RB_ULL2NUM(frac));
+	rb_hash_aset(h, rb_id2sym(id_sign), INT2NUM((sign == 0) ? 1 : -1));
+
+	if (expo == 0x7ffULL) {
+		if (frac == 0ULL) // Infinity
+			rb_hash_aset(h, rb_id2sym(id_flag), rb_id2sym(id_infinity));
+		else // NaN
+			rb_hash_aset(h, rb_id2sym(id_flag), rb_id2sym(id_nan));
+	}
+	else if (expo == 0ULL) {
+		if (frac == 0ULL) { // Zero
+			rb_hash_aset(h, rb_id2sym(id_flag), rb_id2sym(id_zero));
+			rb_hash_aset(h, rb_id2sym(id_isignificand), INT2NUM(0));
+			rb_hash_aset(h, rb_id2sym(id_exponent), INT2NUM(-1022));
+			rb_hash_aset(h, rb_id2sym(id_significand), DBL2NUM(0.0));
+		}
+		else { // Subnormal
+			rb_hash_aset(h, rb_id2sym(id_flag), rb_id2sym(id_subnormal));
+			rb_hash_aset(h, rb_id2sym(id_isignificand), RB_ULL2NUM(frac));
+			rb_hash_aset(h, rb_id2sym(id_exponent), INT2NUM(-1022));
+			expo = 1023;
+			while ((frac & 0x0010000000000000ULL) == 0ULL) {
+				frac <<= 1;
+				expo -= 1;
+			}
+			dudul.l = (expo << 52) | (frac & 0x000fffffffffffffULL);
+			rb_hash_aset(h, rb_id2sym(id_significand), DBL2NUM(dudul.d));
+		}
+	}
+	else {
+		rb_hash_aset(h, rb_id2sym(id_flag), Qnil);
+		rb_hash_aset(h, rb_id2sym(id_isignificand), ULL2NUM(frac | 0x10000000000000ULL));
+		rb_hash_aset(h, rb_id2sym(id_exponent), INT2NUM((int)expo - 1023));
+		dudul.l &= 0x000fffffffffffffULL;
+		dudul.l |= 0x3ff0000000000000ULL;
+		rb_hash_aset(h, rb_id2sym(id_significand), DBL2NUM(dudul.d));
+	}
+
+	return h;
+}
+
+
+/* Build a float from its bit fields.
+ * @param sign_bit [Integer] 0 for positive, 1 for negative.
+ * @param exponent_bits [Integer] the biased exponent (exponent + 1023), from 0 to 2047.
+ * @param fraction_bits [Integer] the fraction bits of the significand, without the implicit leading 1. From 0 to 4503599627370495.
+ * @return [Float]
+ * @see Float#break_down
+ * @example
+ *  Float.build_up(0, 1023,  0) #=>  1.0 
+ *  Float.build_up(1, 1024,  0) #=> -2.0 
+ *  Float.build_up(0, 2047,  0) #=>  Infinity 
+ *  Float.build_up(1, 2047,  0) #=> -Infinity 
+ *  Float.build_up(0, 2047, 42) #=>  NaN 
+ *  Float.build_up(0,    0,  0) #=>  0.0 
+ *  Float.build_up(0,    0,  1) #=>  5.0e-324
+ */
+static VALUE crmf_float_build_up(VALUE self, VALUE sign_bit, VALUE exponent_bits, VALUE fraction_bits)
+{
+	long long sb, eb, fb;
+	union {
+		double d;
+		unsigned long long l;
+	} dudul;
+
+	if (!rb_integer_type_p(sign_bit))
+		rb_raise(rb_eTypeError, "expecting an integer as sign bit, not a %s", rb_obj_classname(sign_bit));
+	sb = NUM2LL(sign_bit);
+	if ((sb & 0xfffffffffffffffeULL) != 0)
+		rb_raise(rb_eArgError, "sign bit must be 0 or 1");
+
+	if (!rb_integer_type_p(exponent_bits))
+		rb_raise(rb_eTypeError, "expecting an integer as exponent bits, not a %s", rb_obj_classname(exponent_bits));
+	eb = NUM2LL(exponent_bits);
+	if ((eb & 0xfffffffffffff800ULL) != 0)
+		rb_raise(rb_eArgError, "exponent bits must be between 0 and 2047");
+
+	if (!rb_integer_type_p(fraction_bits))
+		rb_raise(rb_eTypeError, "expecting an integer as fraction bits, not a %s", rb_obj_classname(fraction_bits));
+	fb = NUM2LL(fraction_bits);
+	if ((fb & 0xfff0000000000000ULL) != 0)
+		rb_raise(rb_eArgError, "fraction bits must be between 0 and 4503599627370495");
+
+	dudul.l = (sb << 63) | (eb << 52) | fb;
+
+	return DBL2NUM(dudul.d);
+}
+
+
+/* Tels if the float is subnormal.
+ * That is, if its biased exponent is 0 and its fraction part is not null.
+ * @return [Boolean]
+ */
+static VALUE crmf_float_is_subnormal(VALUE self)
+{
+	union dul {
+		double d;
+		unsigned long long l;
+	} dudul;
+	dudul.d = NUM2DBL(self);
+	unsigned long long expo = (dudul.l >> 52) & 0x7ff;
+	unsigned long long frac =  dudul.l & 0x000fffffffffffffULL;
+	if (expo == 0ULL && frac != 0ULL)
+		return Qtrue;
+	return Qfalse;
+}
+
+
+static mpfr_rnd_t crmf_sym_to_rnd(VALUE s)
+{
+	if (!RB_TYPE_P(s, RUBY_T_SYMBOL))
+		rb_raise(rb_eTypeError, "expecting a symbol, not %s", rb_obj_classname(s));
+	ID sym = rb_sym2id(s);
+	mpfr_rnd_t rnd;
+	if (sym == id_nearest)
+		rnd = MPFR_RNDN;
+	else if (sym == id_down)
+		rnd = MPFR_RNDD;
+	else if (sym == id_up)
+		rnd = MPFR_RNDU;
+	else if (sym == id_zero)
+		rnd = MPFR_RNDZ;
+	else if (sym == id_away)
+		rnd = MPFR_RNDA;
+	else
+		rb_raise(rb_eArgError, "expecting :nearest, :down, :up, :zero or :away, not %" PRIsVALUE, s);
+	return rnd;
+}
+
+
+/* Convert _obj_ to a Float, rounding according to _rnd_.
+ * @return [Float]
+ * @overload to_float(obj, rnd = :nearest)
+ *  @param obj [Float, Integer, String, #to_f] object to convert
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_object_to_float(int argc, VALUE *argv, VALUE self)
+{
+	VALUE obj = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &obj, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfra, 53);
+	int type = rb_type(obj);
+	int t = 0;
+	if (type == RUBY_T_FLOAT) {
+		printf("RUBY_T_FLOAT\n");
+		double d = NUM2DBL(obj);
+		t = mpfr_set_d(mpfra, d, rndt);
+	}
+	else if (type == RUBY_T_FIXNUM) {
+		printf("RUBY_T_FIXNUM\n");
+		long int li = NUM2LL(obj);
+		t = mpfr_set_si(mpfra, li, rndt);
+	}
+	else if (type == RUBY_T_BIGNUM) {
+		printf("RUBY_T_BIGNUM\n");
+		obj = rb_funcallv(obj, id_to_s, 0, NULL);
+		const char *strptr = StringValuePtr(obj);
+		t = mpfr_set_str(mpfra, strptr, 10, rndt);
+	}
+	else if (type == RUBY_T_STRING) {
+		printf("RUBY_T_STRING\n");
+		const char *strptr = StringValuePtr(obj);
+		t = mpfr_set_str(mpfra, strptr, 10, rndt);
+	}
+	else {
+		obj = rb_funcallv(obj, id_to_f, 0, NULL);
+		double d = NUM2DBL(obj);
+		t = mpfr_set_d(mpfra, d, rndt);
+	}
+	mpfr_subnormalize(mpfra, t, rndt);
+	double d = mpfr_get_d(mpfra, rndt);
+	return DBL2NUM(d);
+}
+
+
+static void crmf_rbfloat_to_mpfr53(VALUE x, mpfr_t rx)
+{
+	if (RB_INTEGER_TYPE_P(x))
+		x = rb_funcallv(x, id_to_f, 0, NULL);
+	if (!RB_TYPE_P(x, RUBY_T_FLOAT))
+		rb_raise(rb_eTypeError, "expecting a Float, not a %s", rb_obj_classname(x));
+	double d = NUM2DBL(x);
+	int t = mpfr_set_d(rx, d, MPFR_RNDN);
+	if (t)
+		rb_raise(rb_eRuntimeError, "%" PRIsVALUE " could not be set to a mpfr_t without rounding", x);
+}
+
+
+/* Add _a_ and _b_, round according to _rnd_.
+ * @overload add(a, b, rnd = :nearest)
+ *  @param a [Float]
+ *  @param b [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_add(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a = Qnil, b = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	MPFR_DECL_INIT(mpfra, 53);
+	MPFR_DECL_INIT(mpfrb, 53);
+	rb_scan_args(argc, argv, "21", &a, &b, &rnd);
+	crmf_rbfloat_to_mpfr53(a, mpfra);
+	crmf_rbfloat_to_mpfr53(b, mpfrb);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	int t = mpfr_add(mpfra, mpfra, mpfrb, rndt);
+	mpfr_subnormalize(mpfra, t, rndt);
+	double d = mpfr_get_d(mpfra, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Subtract _b_ from _a_, round according to _rnd_.
+ * @overload sub(a, b, rnd = :nearest)
+ *  @param a [Float]
+ *  @param b [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_sub(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a = Qnil, b = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	MPFR_DECL_INIT(mpfra, 53);
+	MPFR_DECL_INIT(mpfrb, 53);
+	rb_scan_args(argc, argv, "21", &a, &b, &rnd);
+	crmf_rbfloat_to_mpfr53(a, mpfra);
+	crmf_rbfloat_to_mpfr53(b, mpfrb);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	int t = mpfr_sub(mpfra, mpfra, mpfrb, rndt);
+	mpfr_subnormalize(mpfra, t, rndt);
+	double d = mpfr_get_d(mpfra, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Multiply _a_ and _b_, rounding according to _rnd_.
+ * @overload mul(a, b, rnd = :nearest)
+ *  @param a [Float]
+ *  @param b [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_mul(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a = Qnil, b = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	MPFR_DECL_INIT(mpfra, 53);
+	MPFR_DECL_INIT(mpfrb, 53);
+	rb_scan_args(argc, argv, "21", &a, &b, &rnd);
+	crmf_rbfloat_to_mpfr53(a, mpfra);
+	crmf_rbfloat_to_mpfr53(b, mpfrb);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	int t = mpfr_mul(mpfra, mpfra, mpfrb, rndt);
+	mpfr_subnormalize(mpfra, t, rndt);
+	double d = mpfr_get_d(mpfra, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Divide _a_ by _b_, rounding according to _rnd_.
+ * @overload div(a, b, rnd = :nearest)
+ *  @param a [Float]
+ *  @param b [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_div(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a = Qnil, b = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	MPFR_DECL_INIT(mpfra, 53);
+	MPFR_DECL_INIT(mpfrb, 53);
+	rb_scan_args(argc, argv, "21", &a, &b, &rnd);
+	crmf_rbfloat_to_mpfr53(a, mpfra);
+	crmf_rbfloat_to_mpfr53(b, mpfrb);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	int t = mpfr_div(mpfra, mpfra, mpfrb, rndt);
+	mpfr_subnormalize(mpfra, t, rndt);
+	double d = mpfr_get_d(mpfra, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Return the square root of _a_ rounded in the direction _rnd_.
+ * Returns −0 if _a_ is −0, to be consistent with the IEEE 754 standard.
+ * Returns NaN if op is negative.
+ * @overload sqrt(a, rnd = :nearest)
+ *  @param a [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_sqrt(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &a, &rnd);
+	MPFR_DECL_INIT(mpfra, 53);
+	crmf_rbfloat_to_mpfr53(a, mpfra);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	int t = mpfr_sqrt(mpfra, mpfra, rndt);
+	mpfr_subnormalize(mpfra, t, rndt);
+	double d = mpfr_get_d(mpfra, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Return the cubic root of _a_ rounded in the direction _rnd_.
+ * @overload cbrt(a, rnd = :nearest)
+ *  @param a [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_cbrt(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &a, &rnd);
+	MPFR_DECL_INIT(mpfra, 53);
+	crmf_rbfloat_to_mpfr53(a, mpfra);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	int t = mpfr_cbrt(mpfra, mpfra, rndt);
+	mpfr_subnormalize(mpfra, t, rndt);
+	double d = mpfr_get_d(mpfra, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the _n_ th root of _a_ rounded in the direction _rnd_.
+ * For _n_ = 0, returns NaN.
+ * For _n_ odd (resp. even) and _a_ negative (including −Inf), returns a negative number (resp. NaN).
+ * If _a_ is zero, returns zero with the sign obtained by the usual limit rules,
+ * i.e., the same sign as _a_ if _n_ is odd, and negative if _n_ is even.
+ *
+ * This functions agree with the `rootn` function of the IEEE 754-2008 standard and
+ * the P754/D2.41 draft of the next standard (Section 9.2).
+ * Note that it is here restricted to _n_ >= 0.
+ * Functions allowing a negative _n_ may be implemented in the future. 
+ * @overload rootn(a, n, rnd = :nearest)
+ *  @param a [Float]
+ *  @param n [Integer] n >= 0
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_rootn(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a = Qnil, n = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "21", &a, &n, &rnd);
+	MPFR_DECL_INIT(mpfra, 53);
+	crmf_rbfloat_to_mpfr53(a, mpfra);
+	if (!rb_integer_type_p(n))
+		rb_raise(rb_eTypeError, "expecting an integer as second argument, not a %s", rb_obj_classname(n));
+	if (rb_funcall(n, id_syminf, 1, INT2NUM(0)) == Qtrue)
+		rb_raise(rb_eRangeError, "n must be >= 0, not %" PRIsVALUE, n);
+	unsigned long int nn = NUM2ULL(n);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	int t = mpfr_rootn_ui(mpfra, mpfra, nn, rndt);
+	mpfr_subnormalize(mpfra, t, rndt);
+	double d = mpfr_get_d(mpfra, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the positive difference of _a_ and _b_ rounded in the direction _rnd_.
+ * That is _a_ - _b_ if _a_ > _b_, +0 if _a_ <= _b_, and NaN if _a_ or _b_ is NaN. 
+ * @overload dim(a, b, rnd = :nearest)
+ *  @param a [Float]
+ *  @param b [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_dim(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a = Qnil, b = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "21", &a, &b, &rnd);
+	MPFR_DECL_INIT(mpfra, 53);
+	MPFR_DECL_INIT(mpfrb, 53);
+	crmf_rbfloat_to_mpfr53(a, mpfra);
+	crmf_rbfloat_to_mpfr53(b, mpfrb);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	int t = mpfr_dim(mpfra, mpfra, mpfrb, rndt);
+	mpfr_subnormalize(mpfra, t, rndt);
+	double d = mpfr_get_d(mpfra, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns (_a_ times _b_) + _c_ rounded in the direction _rnd_.
+ * 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.
+ * @overload fma(a, b, c, rnd = :nearest)
+ *  @param a [Float]
+ *  @param b [Float]
+ *  @param c [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_fma(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a = Qnil, b = Qnil, c = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "31", &a, &b, &c, &rnd);
+	MPFR_DECL_INIT(mpfra, 53);
+	MPFR_DECL_INIT(mpfrb, 53);
+	MPFR_DECL_INIT(mpfrc, 53);
+	crmf_rbfloat_to_mpfr53(a, mpfra);
+	crmf_rbfloat_to_mpfr53(b, mpfrb);
+	crmf_rbfloat_to_mpfr53(c, mpfrc);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	int t = mpfr_fma(mpfra, mpfra, mpfrb, mpfrc, rndt);
+	mpfr_subnormalize(mpfra, t, rndt);
+	double d = mpfr_get_d(mpfra, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns (_a_ times _b_) - _c_ rounded in the direction _rnd_.
+ * 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.
+ * @overload fms(a, b, c, rnd = :nearest)
+ *  @param a [Float]
+ *  @param b [Float]
+ *  @param c [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_fms(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a = Qnil, b = Qnil, c = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "31", &a, &b, &c, &rnd);
+	MPFR_DECL_INIT(mpfra, 53);
+	MPFR_DECL_INIT(mpfrb, 53);
+	MPFR_DECL_INIT(mpfrc, 53);
+	crmf_rbfloat_to_mpfr53(a, mpfra);
+	crmf_rbfloat_to_mpfr53(b, mpfrb);
+	crmf_rbfloat_to_mpfr53(c, mpfrc);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	int t = mpfr_fms(mpfra, mpfra, mpfrb, mpfrc, rndt);
+	mpfr_subnormalize(mpfra, t, rndt);
+	double d = mpfr_get_d(mpfra, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns (_a_ times _b_) + (_c_ times _d_) rounded in the direction _rnd_.
+ * 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. 
+ * @overload fmma(a, b, c, d, rnd = :nearest)
+ *  @param a [Float]
+ *  @param b [Float]
+ *  @param c [Float]
+ *  @param d [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_fmma(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a = Qnil, b = Qnil, c = Qnil, d = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "41", &a, &b, &c, &d, &rnd);
+	MPFR_DECL_INIT(mpfra, 53);
+	MPFR_DECL_INIT(mpfrb, 53);
+	MPFR_DECL_INIT(mpfrc, 53);
+	MPFR_DECL_INIT(mpfrd, 53);
+	crmf_rbfloat_to_mpfr53(a, mpfra);
+	crmf_rbfloat_to_mpfr53(b, mpfrb);
+	crmf_rbfloat_to_mpfr53(c, mpfrc);
+	crmf_rbfloat_to_mpfr53(d, mpfrd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	int t = mpfr_fmma(mpfra, mpfra, mpfrb, mpfrc, mpfrd, rndt);
+	mpfr_subnormalize(mpfra, t, rndt);
+	double r = mpfr_get_d(mpfra, rndt);
+	return DBL2NUM(r);
+}
+
+
+/* Returns (_a_ times _b_) - (_c_ times _d_) rounded in the direction _rnd_.
+ * 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. 
+ * @overload fmms(a, b, c, d, rnd = :nearest)
+ *  @param a [Float]
+ *  @param b [Float]
+ *  @param c [Float]
+ *  @param d [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_fmms(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a = Qnil, b = Qnil, c = Qnil, d = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "41", &a, &b, &c, &d, &rnd);
+	MPFR_DECL_INIT(mpfra, 53);
+	MPFR_DECL_INIT(mpfrb, 53);
+	MPFR_DECL_INIT(mpfrc, 53);
+	MPFR_DECL_INIT(mpfrd, 53);
+	crmf_rbfloat_to_mpfr53(a, mpfra);
+	crmf_rbfloat_to_mpfr53(b, mpfrb);
+	crmf_rbfloat_to_mpfr53(c, mpfrc);
+	crmf_rbfloat_to_mpfr53(d, mpfrd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	int t = mpfr_fmms(mpfra, mpfra, mpfrb, mpfrc, mpfrd, rndt);
+	mpfr_subnormalize(mpfra, t, rndt);
+	double r = mpfr_get_d(mpfra, rndt);
+	return DBL2NUM(r);
+}
+
+
+/* Returns the Euclidean norm of _x_ and _y_, rounded in the direction _rnd_.
+ * That is, the square root of the sum of the squares of _x_ and _y_.
+ * Special values are handled as described in the ISO C99 (Section F.9.4.3) and IEEE 754-2008 (Section 9.2.1)
+ * standards: If _x_ or _y_ is an infinity, then +Inf is returned, even if the other number is NaN.
+ * @overload hypot(a, b, rnd = :nearest)
+ *  @param a [Float]
+ *  @param b [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_hypot(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a = Qnil, b = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "21", &a, &b, &rnd);
+	MPFR_DECL_INIT(mpfra, 53);
+	MPFR_DECL_INIT(mpfrb, 53);
+	crmf_rbfloat_to_mpfr53(a, mpfra);
+	crmf_rbfloat_to_mpfr53(b, mpfrb);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	int t = mpfr_hypot(mpfra, mpfra, mpfrb, rndt);
+	mpfr_subnormalize(mpfra, t, rndt);
+	double d = mpfr_get_d(mpfra, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the natural logarithm of _x_, rounded in the direction _rnd_.
+ * Returns +0 if _x_ is 1 (in all rounding modes), for consistency with the ISO C99 and IEEE 754-2008 standards.
+ * Returns -Inf if _x_ is ±0 (i.e., the sign of the zero has no influence on the result).
+ * @overload log(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_log(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_log(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the logarithm base 2 of _x_, rounded in the direction _rnd_.
+ * Returns +0 if _x_ is 1 (in all rounding modes), for consistency with the ISO C99 and IEEE 754-2008 standards.
+ * Returns -Inf if _x_ is ±0 (i.e., the sign of the zero has no influence on the result).
+ * @overload log2(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_log2(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_log2(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the logarithm base 10 of _x_, rounded in the direction _rnd_.
+ * Returns +0 if _x_ is 1 (in all rounding modes), for consistency with the ISO C99 and IEEE 754-2008 standards.
+ * Returns -Inf if _x_ is ±0 (i.e., the sign of the zero has no influence on the result).
+ * @overload log10(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_log10(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_log10(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the natural logarithm of 1 + _x_, rounded in the direction _rnd_.
+ * Returns +0 if _x_ is -1.
+ * @overload log1p(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_log1p(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_log1p(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the exponential of _x_, rounded in the direction _rnd_.
+ * @overload exp(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_exp(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_exp(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the 2 power of _x_, rounded in the direction _rnd_.
+ * @overload exp2(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_exp2(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_exp2(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the 10 power of _x_, rounded in the direction _rnd_.
+ * @overload exp10(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_exp10(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_exp10(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the exp(_x_) - 1, rounded in the direction _rnd_.
+ * @overload expm1(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_expm1(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_expm1(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns _x_ raised to _y_, rounded in the direction _rnd_.
+ *
+ * Special values are handled as described in the ISO C99 and IEEE 754-2008 standards for the pow function:
+ * - pow(±0, y) returns plus or minus infinity for y a negative odd integer.
+ * - pow(±0, y) returns plus infinity for y negative and not an odd integer.
+ * - pow(±0, y) returns plus or minus zero for y a positive odd integer.
+ * - pow(±0, y) returns plus zero 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 plus infinity for 0 < abs(x) < 1, and plus zero for abs(x) > 1.
+ * - pow(x, +Inf) returns plus zero for 0 < abs(x) < 1, and plus infinity for abs(x) > 1.
+ * - pow(-Inf, y) returns minus zero for y a negative odd integer.
+ * - pow(-Inf, y) returns plus zero for y negative and not an odd integer.
+ * - pow(-Inf, y) returns minus infinity for y a positive odd integer.
+ * - pow(-Inf, y) returns plus infinity for y positive and not an odd integer.
+ * - pow(+Inf, y) returns plus zero for y negative, and plus infinity for y positive.
+ * @overload pow(x, y, rnd = :nearest)
+ *  @param x [Float]
+ *  @param y [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_pow(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, y = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "21", &x, &y, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	MPFR_DECL_INIT(mpfry, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	crmf_rbfloat_to_mpfr53(y, mpfry);
+	int t = mpfr_pow(mpfrx, mpfrx, mpfry, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns _x_ raised to the integer power _n_, rounded in the direction _rnd_.
+ *
+ * Special values are handled as described in the ISO C99 and IEEE 754-2008 standards for the pow function:
+ * - pow(±0, n) returns plus or minus infinity for _n_ a negative odd integer.
+ * - pow(±0, n) returns plus infinity for _n_ negative and not an odd integer.
+ * - pow(±0, n) returns plus or minus zero for _n_ a positive odd integer.
+ * - pow(±0, n) returns plus zero for _n_ positive and not an odd integer.
+ * - pow(+1, n) returns 1 for any _n_.
+ * - pow(x, 0) returns 1 for any _x_, even a NaN.
+ * - pow(-Inf, n) returns minus zero for _n_ negative and odd.
+ * - pow(-Inf, n) returns plus zero for _n_ negative and even.
+ * - pow(-Inf, n) returns minus infinity for _n_ positive and odd.
+ * - pow(-Inf, n) returns plus infinity for _n_ positive and even.
+ * - pow(+Inf, n) returns plus zero for _n_ negative, and plus infinity for _n_ positive.
+ * @overload pown(x, n, rnd = :nearest)
+ *  @param x [Float] base
+ *  @param n [Integer] exponent
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_pown(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, n = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "21", &x, &n, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	if (!rb_integer_type_p(n))
+		rb_raise(rb_eTypeError, "expecting an integer as second argument, not a %s", rb_obj_classname(n));
+	long int nn = NUM2LL(n);
+	int t = mpfr_pow_si(mpfrx, mpfrx, nn, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the cosine of _x_, rounded in the direction _rnd_.
+ * @overload cos(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_cos(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_cos(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the sine of _x_, rounded in the direction _rnd_.
+ * @overload sin(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_sin(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_sin(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the tangent of _x_, rounded in the direction _rnd_.
+ * @overload tan(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_tan(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_tan(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the arc-cosine of _x_, rounded in the direction _rnd_.
+ *
+ * Note that since `Float.acos(-1.0)` returns the floating-point number
+ * closest to _pi_ according to the given rounding mode,
+ * this number might not be in the output range 0 <= _acos(x)_ < _pi_ of the arc-cosine function;
+ * still, the result lies in the image of the output range by the rounding function.
+ * @overload acos(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_acos(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_acos(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the arc-sine of _x_, rounded in the direction _rnd_.
+ *
+ * Note that since `Float.asin(1)` returns the floating-point number
+ * closest to _pi_/2 according to the given rounding mode,
+ * this number might not be in the output range -_pi_/2 <= _asin(x)_ < _pi_/2 of the arc-sine function;
+ * still, the result lies in the image of the output range by the rounding function.
+ * The same holds for asin(-1).
+ * @overload asin(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_asin(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_asin(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the arc-tangent of _x_, rounded in the direction _rnd_.
+ *
+ * Note that since `Float.atan(Float::INFINITY)` returns the floating-point number
+ * closest to _pi_/2 according to the given rounding mode,
+ * this number might not be in the output range -_pi_/2 <= _atan(x)_ < _pi_/2 of the arc-tangent function;
+ * still, the result lies in the image of the output range by the rounding function.
+ * The same holds for atan(-Inf).
+ * @overload atan(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_atan(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_atan(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the arc-tangent2 of _y_ and _x_, rounded in the direction _rnd_.
+ *
+ * - if _x_ > 0, atan2(_y_, _x_) = atan(_y_/_x_);
+ * - if _x_ < 0, atan2(_y_, _x_) = sign(_y_)*(_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.
+ *
+ * `Float.atan2(y, 0)` does not raise any floating-point exception.
+ * Special values are handled as described in the ISO C99 and IEEE 754-2008 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.
+ *
+ * @overload atan2(y, x, rnd = :nearest)
+ *  @param y [Float]
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_atan2(int argc, VALUE *argv, VALUE self)
+{
+	VALUE y = Qnil, x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "21", &y, &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfry, 53);
+	crmf_rbfloat_to_mpfr53(y, mpfry);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_atan2(mpfrx, mpfry, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the hyperbolic cosine of _x_, rounded in the direction _rnd_.
+ * @overload cosh(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_cosh(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_cosh(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the hyperbolic sine of _x_, rounded in the direction _rnd_.
+ * @overload sinh(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_sinh(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_sinh(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the hyperbolic tangent of _x_, rounded in the direction _rnd_.
+ * @overload tanh(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_tanh(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_tanh(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the inverse hyperbolic cosine of _x_, rounded in the direction _rnd_.
+ * @overload acosh(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_acosh(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_acosh(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the inverse hyperbolic sine of _x_, rounded in the direction _rnd_.
+ * @overload asinh(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_asinh(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_asinh(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+/* Returns the inverse hyperbolic tangent of _x_, rounded in the direction _rnd_.
+ * @overload atanh(x, rnd = :nearest)
+ *  @param x [Float]
+ *  @param rnd [Symbol] :nearest, :down, :up, :zero or :away
+ */
+static VALUE crmf_float_atanh(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x = Qnil, rnd = Qnil;
+	mpfr_rnd_t rndt = MPFR_RNDN;
+	rb_scan_args(argc, argv, "11", &x, &rnd);
+	if (rnd != Qnil)
+		rndt = crmf_sym_to_rnd(rnd);
+	MPFR_DECL_INIT(mpfrx, 53);
+	crmf_rbfloat_to_mpfr53(x, mpfrx);
+	int t = mpfr_atanh(mpfrx, mpfrx, rndt);
+	mpfr_subnormalize(mpfrx, t, rndt);
+	double d = mpfr_get_d(mpfrx, rndt);
+	return DBL2NUM(d);
+}
+
+
+#define crmf_get_const_from_func(res, func, rnd) \
+  do {                                          \
+    MPFR_DECL_INIT(mpfrc, 53);                  \
+		int t;                                      \
+    t = func(mpfrc, rnd);                       \
+    mpfr_subnormalize(mpfrc, t, rnd);           \
+    res = mpfr_get_d(mpfrc, rnd);               \
+  } while(0)
+
+
+
+static VALUE crmf_exp_rn(VALUE self, VALUE x) {
+	return DBL2NUM(exp_rn(NUM2DBL(x)));
+}
+
+static VALUE crmf_exp_rd(VALUE self, VALUE x) {
+	return DBL2NUM(exp_rd(NUM2DBL(x)));
+}
+
+static VALUE crmf_exp_ru(VALUE self, VALUE x) {
+	return DBL2NUM(exp_ru(NUM2DBL(x)));
+}
+
+static VALUE crmf_exp_rz(VALUE self, VALUE x) {
+	return DBL2NUM(exp_rz(NUM2DBL(x)));
+}
+
+
+static VALUE crmf_log_rn(VALUE self, VALUE x) {
+	return DBL2NUM(log_rn(NUM2DBL(x)));
+}
+
+static VALUE crmf_log_rd(VALUE self, VALUE x) {
+	return DBL2NUM(log_rd(NUM2DBL(x)));
+}
+
+static VALUE crmf_log_ru(VALUE self, VALUE x) {
+	return DBL2NUM(log_ru(NUM2DBL(x)));
+}
+
+static VALUE crmf_log_rz(VALUE self, VALUE x) {
+	return DBL2NUM(log_rz(NUM2DBL(x)));
+}
+
+
+static VALUE crmf_log2_rn(VALUE self, VALUE x) {
+	return DBL2NUM(log2_rn(NUM2DBL(x)));
+}
+
+static VALUE crmf_log2_rd(VALUE self, VALUE x) {
+	return DBL2NUM(log2_rd(NUM2DBL(x)));
+}
+
+static VALUE crmf_log2_ru(VALUE self, VALUE x) {
+	return DBL2NUM(log2_ru(NUM2DBL(x)));
+}
+
+static VALUE crmf_log2_rz(VALUE self, VALUE x) {
+	return DBL2NUM(log2_rz(NUM2DBL(x)));
+}
+
+
+static VALUE crmf_log10_rn(VALUE self, VALUE x) {
+	return DBL2NUM(log10_rn(NUM2DBL(x)));
+}
+
+static VALUE crmf_log10_rd(VALUE self, VALUE x) {
+	return DBL2NUM(log10_rd(NUM2DBL(x)));
+}
+
+static VALUE crmf_log10_ru(VALUE self, VALUE x) {
+	return DBL2NUM(log10_ru(NUM2DBL(x)));
+}
+
+static VALUE crmf_log10_rz(VALUE self, VALUE x) {
+	return DBL2NUM(log10_rz(NUM2DBL(x)));
+}
+
+
+/* Returns exp(_x_) - 1, rounded to nearest */
+static VALUE crmf_expm1_rn(VALUE self, VALUE x) {
+	return DBL2NUM(expm1_rn(NUM2DBL(x)));
+}
+
+/* Returns exp(_x_) - 1, rounded down */
+static VALUE crmf_expm1_rd(VALUE self, VALUE x) {
+	return DBL2NUM(expm1_rd(NUM2DBL(x)));
+}
+
+/* Returns exp(_x_) - 1, rounded up */
+static VALUE crmf_expm1_ru(VALUE self, VALUE x) {
+	return DBL2NUM(expm1_ru(NUM2DBL(x)));
+}
+
+/* Returns exp(_x_) - 1, rounded toward zero */
+static VALUE crmf_expm1_rz(VALUE self, VALUE x) {
+	return DBL2NUM(expm1_rz(NUM2DBL(x)));
+}
+
+
+/* Returns log(_x_ + 1), rounded to nearest */
+static VALUE crmf_log1p_rn(VALUE self, VALUE x) {
+	return DBL2NUM(log1p_rn(NUM2DBL(x)));
+}
+
+/* Returns log(_x_ + 1), rounded down */
+static VALUE crmf_log1p_rd(VALUE self, VALUE x) {
+	return DBL2NUM(log1p_rd(NUM2DBL(x)));
+}
+
+/* Returns log(_x_ + 1), rounded up */
+static VALUE crmf_log1p_ru(VALUE self, VALUE x) {
+	return DBL2NUM(log1p_ru(NUM2DBL(x)));
+}
+
+/* Returns log(_x_ + 1), rounded toward zero */
+static VALUE crmf_log1p_rz(VALUE self, VALUE x) {
+	return DBL2NUM(log1p_rz(NUM2DBL(x)));
+}
+
+
+static VALUE crmf_cos_rn(VALUE self, VALUE x) {
+	return DBL2NUM(cos_rn(NUM2DBL(x)));
+}
+
+static VALUE crmf_cos_rd(VALUE self, VALUE x) {
+	return DBL2NUM(cos_rd(NUM2DBL(x)));
+}
+
+static VALUE crmf_cos_ru(VALUE self, VALUE x) {
+	return DBL2NUM(cos_ru(NUM2DBL(x)));
+}
+
+static VALUE crmf_cos_rz(VALUE self, VALUE x) {
+	return DBL2NUM(cos_rz(NUM2DBL(x)));
+}
+
+
+static VALUE crmf_sin_rn(VALUE self, VALUE x) {
+	return DBL2NUM(sin_rn(NUM2DBL(x)));
+}
+
+static VALUE crmf_sin_rd(VALUE self, VALUE x) {
+	return DBL2NUM(sin_rd(NUM2DBL(x)));
+}
+
+static VALUE crmf_sin_ru(VALUE self, VALUE x) {
+	return DBL2NUM(sin_ru(NUM2DBL(x)));
+}
+
+static VALUE crmf_sin_rz(VALUE self, VALUE x) {
+	return DBL2NUM(sin_rz(NUM2DBL(x)));
+}
+
+
+static VALUE crmf_tan_rn(VALUE self, VALUE x) {
+	return DBL2NUM(tan_rn(NUM2DBL(x)));
+}
+
+static VALUE crmf_tan_rd(VALUE self, VALUE x) {
+	return DBL2NUM(tan_rd(NUM2DBL(x)));
+}
+
+static VALUE crmf_tan_ru(VALUE self, VALUE x) {
+	return DBL2NUM(tan_ru(NUM2DBL(x)));
+}
+
+static VALUE crmf_tan_rz(VALUE self, VALUE x) {
+	return DBL2NUM(tan_rz(NUM2DBL(x)));
+}
+
+
+static VALUE crmf_acos_rn(VALUE self, VALUE x) {
+	return DBL2NUM(acos_rn(NUM2DBL(x)));
+}
+
+static VALUE crmf_acos_rd(VALUE self, VALUE x) {
+	return DBL2NUM(acos_rd(NUM2DBL(x)));
+}
+
+static VALUE crmf_acos_ru(VALUE self, VALUE x) {
+	return DBL2NUM(acos_ru(NUM2DBL(x)));
+}
+
+static VALUE crmf_acos_rz(VALUE self, VALUE x) {
+	return DBL2NUM(acos_rz(NUM2DBL(x)));
+}
+
+
+static VALUE crmf_asin_rn(VALUE self, VALUE x) {
+	return DBL2NUM(asin_rn(NUM2DBL(x)));
+}
+
+static VALUE crmf_asin_rd(VALUE self, VALUE x) {
+	return DBL2NUM(asin_rd(NUM2DBL(x)));
+}
+
+static VALUE crmf_asin_ru(VALUE self, VALUE x) {
+	return DBL2NUM(asin_ru(NUM2DBL(x)));
+}
+
+static VALUE crmf_asin_rz(VALUE self, VALUE x) {
+	return DBL2NUM(asin_rz(NUM2DBL(x)));
+}
+
+
+static VALUE crmf_atan_rn(VALUE self, VALUE x) {
+	return DBL2NUM(atan_rn(NUM2DBL(x)));
+}
+
+static VALUE crmf_atan_rd(VALUE self, VALUE x) {
+	return DBL2NUM(atan_rd(NUM2DBL(x)));
+}
+
+static VALUE crmf_atan_ru(VALUE self, VALUE x) {
+	return DBL2NUM(atan_ru(NUM2DBL(x)));
+}
+
+static VALUE crmf_atan_rz(VALUE self, VALUE x) {
+	return DBL2NUM(atan_rz(NUM2DBL(x)));
+}
+
+
+static VALUE crmf_cosh_rn(VALUE self, VALUE x) {
+	return DBL2NUM(cosh_rn(NUM2DBL(x)));
+}
+
+static VALUE crmf_cosh_rd(VALUE self, VALUE x) {
+	return DBL2NUM(cosh_rd(NUM2DBL(x)));
+}
+
+static VALUE crmf_cosh_ru(VALUE self, VALUE x) {
+	return DBL2NUM(cosh_ru(NUM2DBL(x)));
+}
+
+static VALUE crmf_cosh_rz(VALUE self, VALUE x) {
+	return DBL2NUM(cosh_rz(NUM2DBL(x)));
+}
+
+
+static VALUE crmf_sinh_rn(VALUE self, VALUE x) {
+	return DBL2NUM(sinh_rn(NUM2DBL(x)));
+}
+
+static VALUE crmf_sinh_rd(VALUE self, VALUE x) {
+	return DBL2NUM(sinh_rd(NUM2DBL(x)));
+}
+
+static VALUE crmf_sinh_ru(VALUE self, VALUE x) {
+	return DBL2NUM(sinh_ru(NUM2DBL(x)));
+}
+
+static VALUE crmf_sinh_rz(VALUE self, VALUE x) {
+	return DBL2NUM(sinh_rz(NUM2DBL(x)));
+}
+
+
+#define CRMF_MPFR_MONADIC(func, rnd)         \
+	MPFR_DECL_INIT(mpfrx, 53);                \
+	mpfr_set_d(mpfrx, NUM2DBL(x), MPFR_RNDN); \
+	int t = mpfr_##func(mpfrx, mpfrx, rnd);   \
+	mpfr_subnormalize(mpfrx, t, rnd);         \
+	double d = mpfr_get_d(mpfrx, rnd);        \
+	return DBL2NUM(d);
+
+
+static VALUE crmf_exp2_rz(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(exp2, MPFR_RNDZ)}
+static VALUE crmf_exp2_rd(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(exp2, MPFR_RNDD)}
+static VALUE crmf_exp2_ru(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(exp2, MPFR_RNDU)}
+static VALUE crmf_exp2_rn(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(exp2, MPFR_RNDN)}
+
+static VALUE crmf_exp10_rz(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(exp10, MPFR_RNDZ)}
+static VALUE crmf_exp10_rd(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(exp10, MPFR_RNDD)}
+static VALUE crmf_exp10_ru(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(exp10, MPFR_RNDU)}
+static VALUE crmf_exp10_rn(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(exp10, MPFR_RNDN)}
+
+static VALUE crmf_tanh_rz(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(tanh, MPFR_RNDZ)}
+static VALUE crmf_tanh_rd(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(tanh, MPFR_RNDD)}
+static VALUE crmf_tanh_ru(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(tanh, MPFR_RNDU)}
+static VALUE crmf_tanh_rn(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(tanh, MPFR_RNDN)}
+
+static VALUE crmf_acosh_rz(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(acosh, MPFR_RNDZ)}
+static VALUE crmf_acosh_rd(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(acosh, MPFR_RNDD)}
+static VALUE crmf_acosh_ru(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(acosh, MPFR_RNDU)}
+static VALUE crmf_acosh_rn(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(acosh, MPFR_RNDN)}
+
+static VALUE crmf_asinh_rz(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(asinh, MPFR_RNDZ)}
+static VALUE crmf_asinh_rd(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(asinh, MPFR_RNDD)}
+static VALUE crmf_asinh_ru(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(asinh, MPFR_RNDU)}
+static VALUE crmf_asinh_rn(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(asinh, MPFR_RNDN)}
+
+static VALUE crmf_atanh_rz(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(atanh, MPFR_RNDZ)}
+static VALUE crmf_atanh_rd(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(atanh, MPFR_RNDD)}
+static VALUE crmf_atanh_ru(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(atanh, MPFR_RNDU)}
+static VALUE crmf_atanh_rn(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(atanh, MPFR_RNDN)}
+
+static VALUE crmf_sqrt_rz(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(sqrt, MPFR_RNDZ)}
+static VALUE crmf_sqrt_rd(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(sqrt, MPFR_RNDD)}
+static VALUE crmf_sqrt_ru(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(sqrt, MPFR_RNDU)}
+static VALUE crmf_sqrt_rn(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(sqrt, MPFR_RNDN)}
+
+/* Cubic root, rounded toward zero. */
+static VALUE crmf_cbrt_rz(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(cbrt, MPFR_RNDZ)}
+/* Cubic root, rounded down */
+static VALUE crmf_cbrt_rd(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(cbrt, MPFR_RNDD)}
+/* Cubic root, rounded up */
+static VALUE crmf_cbrt_ru(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(cbrt, MPFR_RNDU)}
+/* Cubic root, rounded toward nearest */
+static VALUE crmf_cbrt_rn(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(cbrt, MPFR_RNDN)}
+
+
+#define CRMF_MPFR_DYADIC(x, y, func, rnd)         \
+	MPFR_DECL_INIT(mpfrx, 53);                     \
+	MPFR_DECL_INIT(mpfry, 53);                     \
+	mpfr_set_d(mpfrx, NUM2DBL(x), MPFR_RNDN);      \
+	mpfr_set_d(mpfry, NUM2DBL(y), MPFR_RNDN);      \
+	int t = mpfr_##func(mpfrx, mpfrx, mpfry, rnd); \
+	mpfr_subnormalize(mpfrx, t, rnd);              \
+	double d = mpfr_get_d(mpfrx, rnd);             \
+	return DBL2NUM(d);
+
+
+static VALUE crmf_pow_rz(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(x, y, pow, MPFR_RNDZ)}
+static VALUE crmf_pow_rd(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(x, y, pow, MPFR_RNDD)}
+static VALUE crmf_pow_ru(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(x, y, pow, MPFR_RNDU)}
+static VALUE crmf_pow_rn(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(x, y, pow, MPFR_RNDN)}
+
+static VALUE crmf_atan2_rz(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(y, x, atan2, MPFR_RNDZ)}
+static VALUE crmf_atan2_rd(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(y, x, atan2, MPFR_RNDD)}
+static VALUE crmf_atan2_ru(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(y, x, atan2, MPFR_RNDU)}
+static VALUE crmf_atan2_rn(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(y, x, atan2, MPFR_RNDN)}
+
+static VALUE crmf_hypot_rz(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(y, x, atan2, MPFR_RNDZ)}
+static VALUE crmf_hypot_rd(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(y, x, atan2, MPFR_RNDD)}
+static VALUE crmf_hypot_ru(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(y, x, atan2, MPFR_RNDU)}
+static VALUE crmf_hypot_rn(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(y, x, atan2, MPFR_RNDN)}
+
+
+#define CRMF_MPFR_DYADIC_INTEGER(x, n, func, rnd) \
+	MPFR_DECL_INIT(mpfrx, 53);                     \
+	mpfr_set_d(mpfrx, NUM2DBL(x), MPFR_RNDN);      \
+	int t = mpfr_##func(mpfrx, mpfrx, n, rnd);     \
+	mpfr_subnormalize(mpfrx, t, rnd);              \
+	double d = mpfr_get_d(mpfrx, rnd);             \
+	return DBL2NUM(d);
+
+
+/* @param x [Float]
+ * @param n [Integer] n ∈ ℤ
+ */
+static VALUE crmf_pown_rz(VALUE self, VALUE x, VALUE n) {CRMF_MPFR_DYADIC_INTEGER(x, NUM2LONG(n), pow_si, MPFR_RNDZ)}
+/* @param x [Float]
+ * @param n [Integer] n ∈ ℤ
+ */
+static VALUE crmf_pown_rd(VALUE self, VALUE x, VALUE n) {CRMF_MPFR_DYADIC_INTEGER(x, NUM2LONG(n), pow_si, MPFR_RNDD)}
+/* @param x [Float]
+ * @param n [Integer] n ∈ ℤ
+ */
+static VALUE crmf_pown_ru(VALUE self, VALUE x, VALUE n) {CRMF_MPFR_DYADIC_INTEGER(x, NUM2LONG(n), pow_si, MPFR_RNDU)}
+/* @param x [Float]
+ * @param n [Integer] n ∈ ℤ
+ */
+static VALUE crmf_pown_rn(VALUE self, VALUE x, VALUE n) {CRMF_MPFR_DYADIC_INTEGER(x, NUM2LONG(n), pow_si, MPFR_RNDN)}
+
+
+/* @param x [Float]
+ * @param n [Integer] n ∈ ℕ
+ */
+static VALUE crmf_rootn_rz(VALUE self, VALUE x, VALUE n) {CRMF_MPFR_DYADIC_INTEGER(x, NUM2ULONG(n), pow_si, MPFR_RNDZ)}
+/* @param x [Float]
+ * @param n [Integer] n ∈ ℕ
+ */
+static VALUE crmf_rootn_rd(VALUE self, VALUE x, VALUE n) {CRMF_MPFR_DYADIC_INTEGER(x, NUM2ULONG(n), pow_si, MPFR_RNDD)}
+/* @param x [Float]
+ * @param n [Integer] n ∈ ℕ
+ */
+static VALUE crmf_rootn_ru(VALUE self, VALUE x, VALUE n) {CRMF_MPFR_DYADIC_INTEGER(x, NUM2ULONG(n), pow_si, MPFR_RNDU)}
+/* @param x [Float]
+ * @param n [Integer] n ∈ ℕ
+ */
+static VALUE crmf_rootn_rn(VALUE self, VALUE x, VALUE n) {CRMF_MPFR_DYADIC_INTEGER(x, NUM2ULONG(n), pow_si, MPFR_RNDN)}
+
+
+static VALUE crmf_add_rz(VALUE self, VALUE x, VALUE y)
+{
+	double dx = NUM2DBL(x);
+	double dy = NUM2DBL(y);
+	fesetround(FE_TOWARDZERO);
+	double dr = dx + dy;
+	fesetround(FE_TONEAREST);
+	return DBL2NUM(dr);
+}
+
+static VALUE crmf_add_rd(VALUE self, VALUE x, VALUE y)
+{
+	double dx = NUM2DBL(x);
+	double dy = NUM2DBL(y);
+	fesetround(FE_DOWNWARD);
+	double dr = dx + dy;
+	fesetround(FE_TONEAREST);
+	return DBL2NUM(dr);
+}
+
+static VALUE crmf_add_ru(VALUE self, VALUE x, VALUE y)
+{
+	double dx = NUM2DBL(x);
+	double dy = NUM2DBL(y);
+	fesetround(FE_UPWARD);
+	double dr = dx + dy;
+	fesetround(FE_TONEAREST);
+	return DBL2NUM(dr);
+}
+
+static VALUE crmf_add_rn(VALUE self, VALUE x, VALUE y)
+{
+	double dx = NUM2DBL(x);
+	double dy = NUM2DBL(y);
+	fesetround(FE_TONEAREST);
+	double dr = dx + dy;
+	return DBL2NUM(dr);
+}
+
+
+static VALUE crmf_sub_rz(VALUE self, VALUE x, VALUE y)
+{
+	double dx = NUM2DBL(x);
+	double dy = NUM2DBL(y);
+	fesetround(FE_TOWARDZERO);
+	double dr = dx - dy;
+	fesetround(FE_TONEAREST);
+	return DBL2NUM(dr);
+}
+
+static VALUE crmf_sub_rd(VALUE self, VALUE x, VALUE y)
+{
+	double dx = NUM2DBL(x);
+	double dy = NUM2DBL(y);
+	fesetround(FE_DOWNWARD);
+	double dr = dx - dy;
+	fesetround(FE_TONEAREST);
+	return DBL2NUM(dr);
+}
+
+static VALUE crmf_sub_ru(VALUE self, VALUE x, VALUE y)
+{
+	double dx = NUM2DBL(x);
+	double dy = NUM2DBL(y);
+	fesetround(FE_UPWARD);
+	double dr = dx - dy;
+	fesetround(FE_TONEAREST);
+	return DBL2NUM(dr);
+}
+
+static VALUE crmf_sub_rn(VALUE self, VALUE x, VALUE y)
+{
+	double dx = NUM2DBL(x);
+	double dy = NUM2DBL(y);
+	fesetround(FE_TONEAREST);
+	double dr = dx - dy;
+	return DBL2NUM(dr);
+}
+
+
+static VALUE crmf_mul_rz(VALUE self, VALUE x, VALUE y)
+{
+	double dx = NUM2DBL(x);
+	double dy = NUM2DBL(y);
+	fesetround(FE_TOWARDZERO);
+	double dr = dx * dy;
+	fesetround(FE_TONEAREST);
+	return DBL2NUM(dr);
+}
+
+static VALUE crmf_mul_rd(VALUE self, VALUE x, VALUE y)
+{
+	double dx = NUM2DBL(x);
+	double dy = NUM2DBL(y);
+	fesetround(FE_DOWNWARD);
+	double dr = dx * dy;
+	fesetround(FE_TONEAREST);
+	return DBL2NUM(dr);
+}
+
+static VALUE crmf_mul_ru(VALUE self, VALUE x, VALUE y)
+{
+	double dx = NUM2DBL(x);
+	double dy = NUM2DBL(y);
+	fesetround(FE_UPWARD);
+	double dr = dx * dy;
+	fesetround(FE_TONEAREST);
+	return DBL2NUM(dr);
+}
+
+static VALUE crmf_mul_rn(VALUE self, VALUE x, VALUE y)
+{
+	double dx = NUM2DBL(x);
+	double dy = NUM2DBL(y);
+	fesetround(FE_TONEAREST);
+	double dr = dx * dy;
+	return DBL2NUM(dr);
+}
+
+
+static VALUE crmf_div_rz(VALUE self, VALUE x, VALUE y)
+{
+	double dx = NUM2DBL(x);
+	double dy = NUM2DBL(y);
+	fesetround(FE_TOWARDZERO);
+	double dr = dx / dy;
+	fesetround(FE_TONEAREST);
+	return DBL2NUM(dr);
+}
+
+static VALUE crmf_div_rd(VALUE self, VALUE x, VALUE y)
+{
+	double dx = NUM2DBL(x);
+	double dy = NUM2DBL(y);
+	fesetround(FE_DOWNWARD);
+	double dr = dx / dy;
+	fesetround(FE_TONEAREST);
+	return DBL2NUM(dr);
+}
+
+static VALUE crmf_div_ru(VALUE self, VALUE x, VALUE y)
+{
+	double dx = NUM2DBL(x);
+	double dy = NUM2DBL(y);
+	fesetround(FE_UPWARD);
+	double dr = dx / dy;
+	fesetround(FE_TONEAREST);
+	return DBL2NUM(dr);
+}
+
+static VALUE crmf_div_rn(VALUE self, VALUE x, VALUE y)
+{
+	double dx = NUM2DBL(x);
+	double dy = NUM2DBL(y);
+	fesetround(FE_TONEAREST);
+	double dr = dx / dy;
+	return DBL2NUM(dr);
+}
+
+
+
+CRMF_PUBLIC void Init_crmf() 
+{
+	id_to_f = rb_intern("to_f");
+	id_to_s = rb_intern("to_s");
+	id_nearest = rb_intern("nearest");
+	id_down = rb_intern("down");
+	id_up = rb_intern("up");
+	id_zero = rb_intern("zero");
+	id_away = rb_intern("away");
+	id_syminf = rb_intern("<");
+	id_sign = rb_intern("sign");
+	id_sign_bit = rb_intern("sign_bit");
+	id_exponent_bits = rb_intern("exponent_bits");
+	id_fraction_bits = rb_intern("fraction_bits");
+	id_exponent = rb_intern("exponent");
+	id_significand = rb_intern("significand");
+	id_isignificand = rb_intern("isignificand");
+	id_flag = rb_intern("flag");
+	id_infinity = rb_intern("infinity");
+	id_nan = rb_intern("nan");
+	id_subnormal = rb_intern("subnormal");
+	id_zero = rb_intern("zero");
+
+	m_CRMF = rb_define_module("CRMF");
+
+	mpfr_set_emin(-1073);
+	mpfr_set_emax(1024);
+
+	rb_define_module_function(rb_cFloat, "add",   crmf_float_add,   -1);
+	rb_define_module_function(rb_cFloat, "sub",   crmf_float_sub,   -1);
+	rb_define_module_function(rb_cFloat, "mul",   crmf_float_mul,   -1);
+	rb_define_module_function(rb_cFloat, "div",   crmf_float_div,   -1);
+	rb_define_module_function(rb_cFloat, "sqrt",  crmf_float_sqrt,  -1);
+	rb_define_module_function(rb_cFloat, "cbrt",  crmf_float_cbrt,  -1);
+	rb_define_module_function(rb_cFloat, "rootn", crmf_float_rootn, -1);
+	rb_define_module_function(rb_cFloat, "dim",   crmf_float_dim,   -1);
+	rb_define_module_function(rb_cFloat, "fma",   crmf_float_fma,   -1);
+	rb_define_module_function(rb_cFloat, "fms",   crmf_float_fms,   -1);
+	rb_define_module_function(rb_cFloat, "fmma",  crmf_float_fmma,  -1);
+	rb_define_module_function(rb_cFloat, "fmms",  crmf_float_fmms,  -1);
+	rb_define_module_function(rb_cFloat, "hypot", crmf_float_hypot, -1);
+	rb_define_module_function(rb_cFloat, "log",   crmf_float_log,   -1);
+	rb_define_module_function(rb_cFloat, "log2",  crmf_float_log2,  -1);
+	rb_define_module_function(rb_cFloat, "log10", crmf_float_log10, -1);
+	rb_define_module_function(rb_cFloat, "log1p", crmf_float_log1p, -1);
+	rb_define_module_function(rb_cFloat, "exp",   crmf_float_exp,   -1);
+	rb_define_module_function(rb_cFloat, "exp2",  crmf_float_exp2,  -1);
+	rb_define_module_function(rb_cFloat, "exp10", crmf_float_exp10, -1);
+	rb_define_module_function(rb_cFloat, "expm1", crmf_float_expm1, -1);
+	rb_define_module_function(rb_cFloat, "pow",   crmf_float_pow,   -1);
+	rb_define_module_function(rb_cFloat, "pown",  crmf_float_pown,  -1);
+	rb_define_module_function(rb_cFloat, "cos",   crmf_float_cos,   -1);
+	rb_define_module_function(rb_cFloat, "sin",   crmf_float_sin,   -1);
+	rb_define_module_function(rb_cFloat, "tan",   crmf_float_tan,   -1);
+	rb_define_module_function(rb_cFloat, "acos",  crmf_float_acos,  -1);
+	rb_define_module_function(rb_cFloat, "asin",  crmf_float_asin,  -1);
+	rb_define_module_function(rb_cFloat, "atan",  crmf_float_atan,  -1);
+	rb_define_module_function(rb_cFloat, "atan2", crmf_float_atan2, -1);
+	rb_define_module_function(rb_cFloat, "cosh",  crmf_float_cosh,  -1);
+	rb_define_module_function(rb_cFloat, "sinh",  crmf_float_sinh,  -1);
+	rb_define_module_function(rb_cFloat, "tanh",  crmf_float_tanh,  -1);
+	rb_define_module_function(rb_cFloat, "acosh", crmf_float_acosh, -1);
+	rb_define_module_function(rb_cFloat, "asinh", crmf_float_asinh, -1);
+	rb_define_module_function(rb_cFloat, "atanh", crmf_float_atanh, -1);
+
+	rb_define_module_function(m_CRMF, "to_float", crmf_object_to_float, -1);
+	rb_define_module_function(rb_cFloat, "build_up", crmf_float_build_up, 3);
+
+	rb_define_method(rb_cFloat, "break_down", crmf_float_break_down,   0);
+	rb_define_method(rb_cFloat, "subnormal?", crmf_float_is_subnormal, 0);
+
+	double d;
+
+	crmf_get_const_from_func(d, mpfr_const_log2, MPFR_RNDD);
+	// @return [Float] ↓log(2)↓
+	rb_define_const(m_CRMF, "LOG2_DOWN", DBL2NUM(d));
+
+	crmf_get_const_from_func(d, mpfr_const_log2, MPFR_RNDU);
+	// @return [Float] ↑log(2)↑
+	rb_define_const(m_CRMF, "LOG2_UP", DBL2NUM(d));
+
+	crmf_get_const_from_func(d, mpfr_const_pi, MPFR_RNDD);
+	// @return [Float] ↓𝛑↓
+	rb_define_const(m_CRMF, "PI_DOWN", DBL2NUM(d));
+
+	crmf_get_const_from_func(d, mpfr_const_pi, MPFR_RNDU);
+	// @return [Float] ↑𝛑↑
+	rb_define_const(m_CRMF, "PI_UP", DBL2NUM(d));
+
+	crmf_get_const_from_func(d, mpfr_const_euler, MPFR_RNDD);
+	// @return [Float] ↓euler↓
+	rb_define_const(m_CRMF, "EULER_DOWN", DBL2NUM(d));
+
+	crmf_get_const_from_func(d, mpfr_const_euler, MPFR_RNDU);
+	// @return [Float] ↑euler↑
+	rb_define_const(m_CRMF, "EULER_UP", DBL2NUM(d)); 
+
+
+	rb_define_module_function(m_CRMF, "exp_rz",   crmf_exp_rz,   1);
+	rb_define_module_function(m_CRMF, "exp_rd",   crmf_exp_rd,   1);
+	rb_define_module_function(m_CRMF, "exp_ru",   crmf_exp_ru,   1);
+	rb_define_module_function(m_CRMF, "exp_rn",   crmf_exp_rn,   1);
+	rb_define_module_function(m_CRMF, "exp2_rz",  crmf_exp2_rz,  1);
+	rb_define_module_function(m_CRMF, "exp2_rd",  crmf_exp2_rd,  1);
+	rb_define_module_function(m_CRMF, "exp2_ru",  crmf_exp2_ru,  1);
+	rb_define_module_function(m_CRMF, "exp2_rn",  crmf_exp2_rn,  1);
+	rb_define_module_function(m_CRMF, "exp10_rz", crmf_exp10_rz, 1);
+	rb_define_module_function(m_CRMF, "exp10_rd", crmf_exp10_rd, 1);
+	rb_define_module_function(m_CRMF, "exp10_ru", crmf_exp10_ru, 1);
+	rb_define_module_function(m_CRMF, "exp10_rn", crmf_exp10_rn, 1);
+	rb_define_module_function(m_CRMF, "log_rz",   crmf_log_rz,   1);
+	rb_define_module_function(m_CRMF, "log_rd",   crmf_log_rd,   1);
+	rb_define_module_function(m_CRMF, "log_ru",   crmf_log_ru,   1);
+	rb_define_module_function(m_CRMF, "log_rn",   crmf_log_rn,   1);
+	rb_define_module_function(m_CRMF, "log2_rz",  crmf_log2_rz,  1);
+	rb_define_module_function(m_CRMF, "log2_rd",  crmf_log2_rd,  1);
+	rb_define_module_function(m_CRMF, "log2_ru",  crmf_log2_ru,  1);
+	rb_define_module_function(m_CRMF, "log2_rn",  crmf_log2_rn,  1);
+	rb_define_module_function(m_CRMF, "log10_rz", crmf_log10_rz, 1);
+	rb_define_module_function(m_CRMF, "log10_rd", crmf_log10_rd, 1);
+	rb_define_module_function(m_CRMF, "log10_ru", crmf_log10_ru, 1);
+	rb_define_module_function(m_CRMF, "log10_rn", crmf_log10_rn, 1);
+	rb_define_module_function(m_CRMF, "expm1_rz", crmf_expm1_rz, 1);
+	rb_define_module_function(m_CRMF, "expm1_rd", crmf_expm1_rd, 1);
+	rb_define_module_function(m_CRMF, "expm1_ru", crmf_expm1_ru, 1);
+	rb_define_module_function(m_CRMF, "expm1_rn", crmf_expm1_rn, 1);
+	rb_define_module_function(m_CRMF, "log1p_rz", crmf_log1p_rz, 1);
+	rb_define_module_function(m_CRMF, "log1p_rd", crmf_log1p_rd, 1);
+	rb_define_module_function(m_CRMF, "log1p_ru", crmf_log1p_ru, 1);
+	rb_define_module_function(m_CRMF, "log1p_rn", crmf_log1p_rn, 1);
+	rb_define_module_function(m_CRMF, "cos_rz",   crmf_cos_rz,   1);
+	rb_define_module_function(m_CRMF, "cos_rd",   crmf_cos_rd,   1);
+	rb_define_module_function(m_CRMF, "cos_ru",   crmf_cos_ru,   1);
+	rb_define_module_function(m_CRMF, "cos_rn",   crmf_cos_rn,   1);
+	rb_define_module_function(m_CRMF, "sin_rz",   crmf_sin_rz,   1);
+	rb_define_module_function(m_CRMF, "sin_rd",   crmf_sin_rd,   1);
+	rb_define_module_function(m_CRMF, "sin_ru",   crmf_sin_ru,   1);
+	rb_define_module_function(m_CRMF, "sin_rn",   crmf_sin_rn,   1);
+	rb_define_module_function(m_CRMF, "tan_rz",   crmf_tan_rz,   1);
+	rb_define_module_function(m_CRMF, "tan_rd",   crmf_tan_rd,   1);
+	rb_define_module_function(m_CRMF, "tan_ru",   crmf_tan_ru,   1);
+	rb_define_module_function(m_CRMF, "tan_rn",   crmf_tan_rn,   1);
+	rb_define_module_function(m_CRMF, "acos_rz",  crmf_acos_rz,  1);
+	rb_define_module_function(m_CRMF, "acos_rd",  crmf_acos_rd,  1);
+	rb_define_module_function(m_CRMF, "acos_ru",  crmf_acos_ru,  1);
+	rb_define_module_function(m_CRMF, "acos_rn",  crmf_acos_rn,  1);
+	rb_define_module_function(m_CRMF, "asin_rz",  crmf_asin_rz,  1);
+	rb_define_module_function(m_CRMF, "asin_rd",  crmf_asin_rd,  1);
+	rb_define_module_function(m_CRMF, "asin_ru",  crmf_asin_ru,  1);
+	rb_define_module_function(m_CRMF, "asin_rn",  crmf_asin_rn,  1);
+	rb_define_module_function(m_CRMF, "atan_rz",  crmf_atan_rz,  1);
+	rb_define_module_function(m_CRMF, "atan_rd",  crmf_atan_rd,  1);
+	rb_define_module_function(m_CRMF, "atan_ru",  crmf_atan_ru,  1);
+	rb_define_module_function(m_CRMF, "atan_rn",  crmf_atan_rn,  1);
+	rb_define_module_function(m_CRMF, "cosh_rz",  crmf_cosh_rz,  1);
+	rb_define_module_function(m_CRMF, "cosh_rd",  crmf_cosh_rd,  1);
+	rb_define_module_function(m_CRMF, "cosh_ru",  crmf_cosh_ru,  1);
+	rb_define_module_function(m_CRMF, "cosh_rn",  crmf_cosh_rn,  1);
+	rb_define_module_function(m_CRMF, "sinh_rz",  crmf_sinh_rz,  1);
+	rb_define_module_function(m_CRMF, "sinh_rd",  crmf_sinh_rd,  1);
+	rb_define_module_function(m_CRMF, "sinh_ru",  crmf_sinh_ru,  1);
+	rb_define_module_function(m_CRMF, "sinh_rn",  crmf_sinh_rn,  1);
+	rb_define_module_function(m_CRMF, "tanh_rz",  crmf_tanh_rz,  1);
+	rb_define_module_function(m_CRMF, "tanh_rd",  crmf_tanh_rd,  1);
+	rb_define_module_function(m_CRMF, "tanh_ru",  crmf_tanh_ru,  1);
+	rb_define_module_function(m_CRMF, "tanh_rn",  crmf_tanh_rn,  1);
+	rb_define_module_function(m_CRMF, "acosh_rz", crmf_acosh_rz, 1);
+	rb_define_module_function(m_CRMF, "acosh_rd", crmf_acosh_rd, 1);
+	rb_define_module_function(m_CRMF, "acosh_ru", crmf_acosh_ru, 1);
+	rb_define_module_function(m_CRMF, "acosh_rn", crmf_acosh_rn, 1);
+	rb_define_module_function(m_CRMF, "asinh_rz", crmf_asinh_rz, 1);
+	rb_define_module_function(m_CRMF, "asinh_rd", crmf_asinh_rd, 1);
+	rb_define_module_function(m_CRMF, "asinh_ru", crmf_asinh_ru, 1);
+	rb_define_module_function(m_CRMF, "asinh_rn", crmf_asinh_rn, 1);
+	rb_define_module_function(m_CRMF, "atanh_rz", crmf_atanh_rz, 1);
+	rb_define_module_function(m_CRMF, "atanh_rd", crmf_atanh_rd, 1);
+	rb_define_module_function(m_CRMF, "atanh_ru", crmf_atanh_ru, 1);
+	rb_define_module_function(m_CRMF, "atanh_rn", crmf_atanh_rn, 1);
+	rb_define_module_function(m_CRMF, "sqrt_rz",  crmf_sqrt_rz,  1);
+	rb_define_module_function(m_CRMF, "sqrt_rd",  crmf_sqrt_rd,  1);
+	rb_define_module_function(m_CRMF, "sqrt_ru",  crmf_sqrt_ru,  1);
+	rb_define_module_function(m_CRMF, "sqrt_rn",  crmf_sqrt_rn,  1);
+	rb_define_module_function(m_CRMF, "cbrt_rz",  crmf_cbrt_rz,  1);
+	rb_define_module_function(m_CRMF, "cbrt_rd",  crmf_cbrt_rd,  1);
+	rb_define_module_function(m_CRMF, "cbrt_ru",  crmf_cbrt_ru,  1);
+	rb_define_module_function(m_CRMF, "cbrt_rn",  crmf_cbrt_rn,  1);
+	rb_define_module_function(m_CRMF, "pow_rz",   crmf_pow_rz,   2);
+	rb_define_module_function(m_CRMF, "pow_rd",   crmf_pow_rd,   2);
+	rb_define_module_function(m_CRMF, "pow_ru",   crmf_pow_ru,   2);
+	rb_define_module_function(m_CRMF, "pow_rn",   crmf_pow_rn,   2);
+	rb_define_module_function(m_CRMF, "atan2_rz", crmf_atan2_rz, 2);
+	rb_define_module_function(m_CRMF, "atan2_rd", crmf_atan2_rd, 2);
+	rb_define_module_function(m_CRMF, "atan2_ru", crmf_atan2_ru, 2);
+	rb_define_module_function(m_CRMF, "atan2_rn", crmf_atan2_rn, 2);
+	rb_define_module_function(m_CRMF, "hypot_rz", crmf_hypot_rz, 2);
+	rb_define_module_function(m_CRMF, "hypot_rd", crmf_hypot_rd, 2);
+	rb_define_module_function(m_CRMF, "hypot_ru", crmf_hypot_ru, 2);
+	rb_define_module_function(m_CRMF, "hypot_rn", crmf_hypot_rn, 2);
+	rb_define_module_function(m_CRMF, "pown_rz",  crmf_pown_rz,  2);
+	rb_define_module_function(m_CRMF, "pown_rd",  crmf_pown_rd,  2);
+	rb_define_module_function(m_CRMF, "pown_ru",  crmf_pown_ru,  2);
+	rb_define_module_function(m_CRMF, "pown_rn",  crmf_pown_rn,  2);
+	rb_define_module_function(m_CRMF, "rootn_rz", crmf_rootn_rz, 2);
+	rb_define_module_function(m_CRMF, "rootn_rd", crmf_rootn_rd, 2);
+	rb_define_module_function(m_CRMF, "rootn_ru", crmf_rootn_ru, 2);
+	rb_define_module_function(m_CRMF, "rootn_rn", crmf_rootn_rn, 2);
+	rb_define_module_function(m_CRMF, "add_rz",   crmf_add_rz,   2);
+	rb_define_module_function(m_CRMF, "add_rd",   crmf_add_rd,   2);
+	rb_define_module_function(m_CRMF, "add_ru",   crmf_add_ru,   2);
+	rb_define_module_function(m_CRMF, "add_rn",   crmf_add_rn,   2);
+	rb_define_module_function(m_CRMF, "sub_rz",   crmf_sub_rz,   2);
+	rb_define_module_function(m_CRMF, "sub_rd",   crmf_sub_rd,   2);
+	rb_define_module_function(m_CRMF, "sub_ru",   crmf_sub_ru,   2);
+	rb_define_module_function(m_CRMF, "sub_rn",   crmf_sub_rn,   2);
+	rb_define_module_function(m_CRMF, "mul_rz",   crmf_mul_rz,   2);
+	rb_define_module_function(m_CRMF, "mul_rd",   crmf_mul_rd,   2);
+	rb_define_module_function(m_CRMF, "mul_ru",   crmf_mul_ru,   2);
+	rb_define_module_function(m_CRMF, "mul_rn",   crmf_mul_rn,   2);
+	rb_define_module_function(m_CRMF, "div_rz",   crmf_div_rz,   2);
+	rb_define_module_function(m_CRMF, "div_rd",   crmf_div_rd,   2);
+	rb_define_module_function(m_CRMF, "div_ru",   crmf_div_ru,   2);
+	rb_define_module_function(m_CRMF, "div_rn",   crmf_div_rn,   2);
+
+	crlibm_init();
+}
+
+