ruby-mpfi 0.0.2

data/ext/mpfi/ruby_mpfi.c

@@ -0,0 +1,1452 @@
+#include "ruby_mpfi.h"
+
+#define CLASS_VAL_FUNCTION_STATE "@@function_state"
+
+static ID eqq, to_s, new, class, method_defined, object_id;
+static VALUE __mpfi_class__, __mpfr_class__, __sym_to_s__, __sym_to_str__;
+
+
+/* ------------------------------ function state start ------------------------------ */
+
+/* Save the value of last function state. */
+void r_mpfi_set_function_state(int num){
+  rb_cv_set(r_mpfi_class, CLASS_VAL_FUNCTION_STATE, INT2NUM(num));
+}
+
+/* Return state of last function of MPFI. */
+VALUE r_mpfr_get_function_state(VALUE self){
+  return rb_cv_get(r_mpfi_class, CLASS_VAL_FUNCTION_STATE);
+}
+
+/* ------------------------------ function state end ------------------------------ */
+
+/* ------------------------------ allocation start ------------------------------ */
+
+void r_mpfi_free(void *ptr){
+  mpfi_clear(ptr);
+  free(ptr);
+}
+
+VALUE r_mpfi_make_new_fi_obj(MPFI *ptr){
+  VALUE ret;
+  MPFI *ptr_ret;
+  r_mpfi_make_struct_init(ret, ptr_ret);
+  mpfi_set(ptr_ret, ptr);
+  return ret;
+}
+
+/* VALUE obj must have method to_s or to_str. */
+static void r_mpfi_set_from_object (MPFI *ptr, VALUE obj){
+  if(RTEST(rb_funcall(rb_funcall(obj, class, 0), method_defined, 1, __sym_to_str__))){
+    char *str = StringValuePtr(obj);
+    mpfi_set_str(ptr, str, 10);
+  }else if(RTEST(rb_funcall(rb_funcall(obj, class, 0), method_defined, 1, __sym_to_s__))){
+    VALUE tmp = rb_funcall(obj, to_s, 0);
+    char *str = StringValuePtr(tmp);
+    mpfi_set_str(ptr, str, 10);
+  }
+}
+
+void r_mpfi_set_robj(MPFI *ptr, VALUE obj){
+  if(RTEST(rb_funcall(__mpfi_class__, eqq, 1, obj))){
+    MPFI *ptr_obj;
+    r_mpfi_get_struct(ptr_obj, obj);
+    mpfi_set(ptr, ptr_obj);
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, obj))){
+    MPFR *ptr_obj;
+    r_mpfr_get_struct(ptr_obj, obj);
+    mpfi_set_fr(ptr, ptr_obj);
+  }else{
+    switch(TYPE(obj)){
+    case T_FLOAT:
+      mpfi_set_d(ptr, NUM2DBL(obj));
+      break;
+    case T_FIXNUM:
+      mpfi_set_si(ptr, FIX2LONG(obj));
+      break;
+    default:
+      r_mpfi_set_from_object(ptr, obj);
+      break;
+    }
+  }
+}
+
+VALUE r_mpfi_new_fi_obj(VALUE obj){
+  if(RTEST(rb_funcall(__mpfi_class__, eqq, 1, obj))){
+    return obj;
+  }else{
+    return rb_funcall(__mpfi_class__, new, 1, obj);
+  }
+}
+
+/* Initializing and Assigning Intervals */
+static VALUE r_mpfi_alloc(VALUE self){
+  MPFI *ptr;
+  r_mpfi_make_struct(self, ptr);
+  return self;
+}
+
+static VALUE r_mpfi_initialize(int argc, VALUE *argv, VALUE self){
+  MPFI *ptr;
+  r_mpfi_get_struct(ptr, self);
+  switch(argc){
+  case 0:
+    mpfi_init(ptr);
+    break;
+  case 1:
+    mpfi_init(ptr);
+    r_mpfi_set_robj(ptr, argv[0]);
+    break;
+  case 2:
+    mpfi_init2(ptr, NUM2INT(argv[1]));
+    r_mpfi_set_robj(ptr, argv[0]);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Invalid number of arguments.");
+    break;
+  }
+  return Qtrue;
+}
+
+static VALUE r_mpfi_initialize_copy(VALUE self, VALUE other){
+  MPFI *ptr_self, *ptr_other;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfi_get_struct(ptr_other, other);
+  mpfi_init2(ptr_self, mpfi_get_prec(ptr_other));
+  mpfi_set(ptr_self, ptr_other);
+  return Qtrue;
+}
+
+/* Return array which have MPFI instance converted to from p1 and self. */
+static VALUE r_mpfi_coerce(VALUE self, VALUE other){
+  VALUE val_other;
+  MPFI *ptr_self, *ptr_other;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfi_make_struct_init2(val_other, ptr_other, mpfi_get_prec(ptr_self));
+  r_mpfi_set_robj(ptr_other, other);
+  return rb_ary_new3(2, val_other, self);
+}
+
+static VALUE r_mpfi_set (VALUE self, VALUE arg){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfi_set_robj(ptr_self, arg);
+  return self;
+}
+
+static VALUE r_mpfi_swap (VALUE self, VALUE other){
+  MPFI *ptr_self, *ptr_other;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfi_get_struct(ptr_other, other);
+  mpfi_swap(ptr_self, ptr_other);
+  return self;
+}
+
+/* ------------------------------ allocation end ------------------------------ */
+
+/* ------------------------------ Rounding Modes and Precision Handling start ------------------------------*/
+
+/* Need to consider returned value later. */
+/* mpfi_set_prec is different from reference manual. This is strange. */
+static VALUE r_mpfi_set_prec (VALUE self, VALUE prec){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  /* if(mpfi_set_prec(ptr_self, NUM2INT(prec)) != 0){ */
+  /*   rb_raise(rb_eRuntimeError, "Memory allocation failed for mpfi_set_prec."); */
+  /* } */
+  mpfi_set_prec(ptr_self, NUM2INT(prec));
+  return self;
+}
+
+/* Need to consider returned value later. */
+static VALUE r_mpfi_get_prec (VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  return INT2NUM((int)mpfi_get_prec(ptr_self));  
+}
+
+/* Need to consider returned value later. */
+static VALUE r_mpfi_round_prec (VALUE self, VALUE prec){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfi_set_function_state(mpfi_round_prec(ptr_self, NUM2INT(prec)));
+  return self;
+}
+/* ------------------------------ Rounding Modes and Precision Handling end ------------------------------*/
+
+/* ------------------------------ string start ------------------------------ */
+
+static VALUE r_mpfi_inspect(VALUE self){
+  MPFI *ptr_s;
+  r_mpfi_get_struct(ptr_s, self);
+  char *ret_str;
+  mpfr_asprintf(&ret_str, "#<MPFI:%lx,['%.Re %.Re'],%d>",
+		NUM2LONG(rb_funcall(self, object_id, 0)), r_mpfi_left_ptr(ptr_s), r_mpfi_right_ptr(ptr_s), mpfi_get_prec(ptr_s));
+  VALUE ret_val = rb_str_new2(ret_str);
+  mpfr_free_str(ret_str);
+  return ret_val;
+}
+
+static VALUE r_mpfi_to_str_ary(VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  char *ret_str1, *ret_str2;
+  mpfr_asprintf(&ret_str1, "%.Re", r_mpfi_left_ptr(ptr_self));
+  mpfr_asprintf(&ret_str2, "%.Re", r_mpfi_right_ptr(ptr_self));
+  VALUE str1 = rb_str_new2(ret_str1), str2 = rb_str_new2(ret_str2);
+  mpfr_free_str(ret_str1);
+  mpfr_free_str(ret_str2);
+  return rb_ary_new3(2, str1, str2);
+}
+
+/* Output self by sprintf. */
+static VALUE r_mpfi_to_strf_ary(VALUE self, VALUE format_str){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  char *format = StringValuePtr(format_str);
+  char *ret_str1, *ret_str2;
+  mpfr_asprintf(&ret_str1, format, r_mpfi_left_ptr(ptr_self));
+  mpfr_asprintf(&ret_str2, format, r_mpfi_right_ptr(ptr_self));
+  VALUE str1 = rb_str_new2(ret_str1), str2 = rb_str_new2(ret_str2);
+  mpfr_free_str(ret_str1);
+  mpfr_free_str(ret_str2);
+  return rb_ary_new3(2, str1, str2);
+}
+
+/* ------------------------------ string end ------------------------------ */
+
+/* ------------------------------ Basic Arithmetic Functions start ------------------------------ */
+
+static VALUE r_mpfi_add (VALUE self, VALUE other){
+  VALUE val_ret;
+  MPFI *ptr_self, *ptr_ret;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfi_make_struct_init(val_ret, ptr_ret);
+
+  if(RTEST(rb_funcall(__mpfi_class__, eqq, 1, other))){
+    MPFI *ptr_other;
+    r_mpfi_get_struct(ptr_other, other);
+    mpfi_add(ptr_ret, ptr_self, ptr_other);
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, other))){
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, other);
+    mpfi_add_fr(ptr_ret, ptr_self, ptr_other);
+  }else if(TYPE(other) == T_FIXNUM){
+    mpfi_add_si(ptr_ret, ptr_self, FIX2LONG(other));
+  }else if(TYPE(other) == T_FLOAT){
+    mpfi_add_d(ptr_ret, ptr_self, NUM2DBL(other));
+  }else{
+    MPFI *ptr_other;
+    volatile VALUE tmp_other = r_mpfi_new_fi_obj(other);
+    r_mpfi_get_struct(ptr_other, tmp_other);
+    mpfi_add(ptr_ret, ptr_self, ptr_other);
+  }
+  return val_ret;
+}
+
+static VALUE r_mpfi_sub (VALUE self, VALUE other){
+  VALUE val_ret;
+  MPFI *ptr_self, *ptr_ret;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfi_make_struct_init(val_ret, ptr_ret);
+
+  if(RTEST(rb_funcall(__mpfi_class__, eqq, 1, other))){
+    MPFI *ptr_other;
+    r_mpfi_get_struct(ptr_other, other);
+    mpfi_sub(ptr_ret, ptr_self, ptr_other);
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, other))){
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, other);
+    mpfi_sub_fr(ptr_ret, ptr_self, ptr_other);
+  }else if(TYPE(other) == T_FIXNUM){
+    mpfi_sub_si(ptr_ret, ptr_self, FIX2LONG(other));
+  }else if(TYPE(other) == T_FLOAT){
+    mpfi_sub_d(ptr_ret, ptr_self, NUM2DBL(other));
+  }else{
+    MPFI *ptr_other;
+    volatile VALUE tmp_other = r_mpfi_new_fi_obj(other);
+    r_mpfi_get_struct(ptr_other, tmp_other);
+    mpfi_sub(ptr_ret, ptr_self, ptr_other);
+  }
+  return val_ret;
+}
+
+static VALUE r_mpfi_mul (VALUE self, VALUE other){
+  VALUE val_ret;
+  MPFI *ptr_self, *ptr_ret;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfi_make_struct_init(val_ret, ptr_ret);
+
+  if(RTEST(rb_funcall(__mpfi_class__, eqq, 1, other))){
+    MPFI *ptr_other;
+    r_mpfi_get_struct(ptr_other, other);
+    mpfi_mul(ptr_ret, ptr_self, ptr_other);
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, other))){
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, other);
+    mpfi_mul_fr(ptr_ret, ptr_self, ptr_other);
+  }else if(TYPE(other) == T_FIXNUM){
+    mpfi_mul_si(ptr_ret, ptr_self, FIX2LONG(other));
+  }else if(TYPE(other) == T_FLOAT){
+    mpfi_mul_d(ptr_ret, ptr_self, NUM2DBL(other));
+  }else{
+    MPFI *ptr_other;
+    volatile VALUE tmp_other = r_mpfi_new_fi_obj(other);
+    r_mpfi_get_struct(ptr_other, tmp_other);
+    mpfi_mul(ptr_ret, ptr_self, ptr_other);
+  }
+  return val_ret;
+}
+
+static VALUE r_mpfi_div (VALUE self, VALUE other){
+  VALUE val_ret;
+  MPFI *ptr_self, *ptr_ret;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfi_make_struct_init(val_ret, ptr_ret);
+
+  if(RTEST(rb_funcall(__mpfi_class__, eqq, 1, other))){
+    MPFI *ptr_other;
+    r_mpfi_get_struct(ptr_other, other);
+    mpfi_div(ptr_ret, ptr_self, ptr_other);
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, other))){
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, other);
+    mpfi_div_fr(ptr_ret, ptr_self, ptr_other);
+  }else if(TYPE(other) == T_FIXNUM){
+    mpfi_div_si(ptr_ret, ptr_self, FIX2LONG(other));
+  }else if(TYPE(other) == T_FLOAT){
+    mpfi_div_d(ptr_ret, ptr_self, NUM2DBL(other));
+  }else{
+    MPFI *ptr_other;
+    volatile VALUE tmp_other = r_mpfi_new_fi_obj(other);
+    r_mpfi_get_struct(ptr_other, tmp_other);
+    mpfi_div(ptr_ret, ptr_self, ptr_other);
+  }
+  return val_ret;
+}
+
+static VALUE r_mpfi_mul_2si (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self, *ptr_ret;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  mpfi_mul_2si(ptr_ret, ptr_self, NUM2INT(argv[0]));
+  return val_ret;
+}
+
+static VALUE r_mpfi_div_2si (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self, *ptr_ret;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  mpfi_div_2si(ptr_ret, ptr_self, NUM2INT(argv[0]));
+  return val_ret;
+}
+
+static VALUE r_mpfi_neg(int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self, *ptr_ret;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(0, 1, argc, argv));
+  mpfi_neg(ptr_ret, ptr_self);
+  return val_ret;
+}
+
+static VALUE r_mpfi_inv(int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self, *ptr_ret;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(0, 1, argc, argv));
+  mpfi_inv(ptr_ret, ptr_self);
+  return val_ret;
+}
+
+static VALUE r_mpfi_abs(int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self, *ptr_ret;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(0, 1, argc, argv));
+  mpfi_abs(ptr_ret, ptr_self);
+  return val_ret;
+}
+
+/* ------------------------------ Basic Arithmetic Functions end ------------------------------ */
+
+/* ------------------------------ Comparison Functions start ------------------------------ */
+
+static VALUE r_mpfi_cmp (VALUE self, VALUE other){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  int ret;
+
+  if(RTEST(rb_funcall(__mpfi_class__, eqq, 1, other))){
+    MPFI *ptr_other;
+    r_mpfi_get_struct(ptr_other, other);
+    ret = mpfi_cmp(ptr_self, ptr_other);
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, other))){
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, other);
+    ret = mpfi_cmp_fr(ptr_self, ptr_other);
+  }else if(TYPE(other) == T_FIXNUM){
+    ret = mpfi_cmp_si(ptr_self, FIX2LONG(other));
+  }else if(TYPE(other) == T_FLOAT){
+    ret = mpfi_cmp_d(ptr_self, NUM2DBL(other));
+  }else{
+    MPFI *ptr_other;
+    volatile VALUE tmp_other = r_mpfi_new_fi_obj(other);
+    r_mpfi_get_struct(ptr_other, tmp_other);
+    ret = mpfi_cmp(ptr_self, ptr_other);
+  }
+  return NUM2INT(ret);
+}
+
+static VALUE r_mpfi_is_pos (VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  if (mpfi_is_pos(ptr_self) > 0) {
+    return Qtrue;
+  }else{
+    return Qnil;
+  }
+}
+
+static VALUE r_mpfi_is_strictly_pos (VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  if (mpfi_is_strictly_pos(ptr_self) > 0) {
+    return Qtrue;
+  }else{
+    return Qnil;
+  }
+}
+
+static VALUE r_mpfi_is_nonneg (VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  if (mpfi_is_nonneg(ptr_self) > 0) {
+    return Qtrue;
+  }else{
+    return Qnil;
+  }
+}
+
+static VALUE r_mpfi_is_neg (VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  if (mpfi_is_neg(ptr_self) > 0) {
+    return Qtrue;
+  }else{
+    return Qnil;
+  }
+}
+
+static VALUE r_mpfi_is_strictly_neg (VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  if (mpfi_is_strictly_neg(ptr_self) > 0) {
+    return Qtrue;
+  }else{
+    return Qnil;
+  }
+}
+
+static VALUE r_mpfi_is_nonpos (VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  if (mpfi_is_nonpos(ptr_self) > 0) {
+    return Qtrue;
+  }else{
+    return Qnil;
+  }
+}
+
+static VALUE r_mpfi_is_zero (VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  if (mpfi_is_zero(ptr_self) > 0) {
+    return Qtrue;
+  }else{
+    return Qnil;
+  }
+}
+
+static VALUE r_mpfi_has_zero (VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  if (mpfi_has_zero(ptr_self) > 0) {
+    return Qtrue;
+  }else{
+    return Qnil;
+  }
+}
+
+static VALUE r_mpfi_nan_p (VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  if (mpfi_nan_p(ptr_self) != 0) {
+    return Qtrue;
+  }else{
+    return Qnil;
+  }
+}
+
+static VALUE r_mpfi_inf_p (VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  if (mpfi_inf_p(ptr_self) != 0) {
+    return Qtrue;
+  }else{
+    return Qnil;
+  }
+}
+
+static VALUE r_mpfi_bounded_p (VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  if (mpfi_bounded_p(ptr_self) != 0) {
+    return Qtrue;
+  }else{
+    return Qnil;
+  }
+}
+
+/* Return true if self.right equals other.right and self.left equals other.right
+ by mpfr_equal_p. */
+static VALUE r_mpfi_equal_p (VALUE self, VALUE other){
+  MPFI *ptr_self, *ptr_other;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfi_get_struct(ptr_other, other);
+  if (mpfr_equal_p(r_mpfi_left_ptr(ptr_self), r_mpfi_left_ptr(ptr_other)) != 0 &&
+      mpfr_equal_p(r_mpfi_right_ptr(ptr_self), r_mpfi_right_ptr(ptr_other)) != 0) {
+    return Qtrue;
+  }else{
+    return Qnil;
+  }
+}
+
+/* ------------------------------ Comparison Functions end ------------------------------ */
+
+/* ------------------------------ Interval Functions with Floating-point Results start ------------------------------ */
+
+static VALUE r_mpfi_diam_abs (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  MPFR *ptr_ret;
+  r_mpfr_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(0, 1, argc, argv));
+  r_mpfi_set_function_state(mpfi_diam_abs(ptr_ret, ptr_self));
+  return val_ret;
+}
+
+static VALUE r_mpfi_diam_rel (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  MPFR *ptr_ret;
+  r_mpfr_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(0, 1, argc, argv));
+  r_mpfi_set_function_state(mpfi_diam_rel(ptr_ret, ptr_self));
+  return val_ret;
+}
+
+static VALUE r_mpfi_diam (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  MPFR *ptr_ret;
+  r_mpfr_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(0, 1, argc, argv));
+  r_mpfi_set_function_state(mpfi_diam(ptr_ret, ptr_self));
+  return val_ret;
+}
+
+static VALUE r_mpfi_mag (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  MPFR *ptr_ret;
+  r_mpfr_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(0, 1, argc, argv));
+  r_mpfi_set_function_state(mpfi_mag(ptr_ret, ptr_self));
+  return val_ret;
+}
+
+static VALUE r_mpfi_mig (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  MPFR *ptr_ret;
+  r_mpfr_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(0, 1, argc, argv));
+  r_mpfi_set_function_state(mpfi_mig(ptr_ret, ptr_self));
+  return val_ret;
+}
+
+static VALUE r_mpfi_mid (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  MPFR *ptr_ret;
+  r_mpfr_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(0, 1, argc, argv));
+  r_mpfi_set_function_state(mpfi_mid(ptr_ret, ptr_self));
+  return val_ret;
+}
+
+static VALUE r_mpfi_mid_interval (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self, *ptr_ret;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(0, 1, argc, argv));
+  mpfi_mid_interval(ptr_ret, ptr_self);
+  return val_ret;
+}
+
+static VALUE r_mpfi_alea (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  MPFR *ptr_ret;
+  r_mpfr_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(0, 1, argc, argv));
+  mpfi_alea(ptr_ret, ptr_self);
+  return val_ret;
+}
+
+/* ------------------------------ Interval Functions with Floating-point Results end ------------------------------ */
+
+/* ------------------------------ Conversion Functions start ------------------------------ */
+
+static VALUE r_mpfi_get_d(VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  return rb_float_new(mpfi_get_d(ptr_self));
+}
+
+static VALUE r_mpfi_get_fr(VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  MPFR *ptr_ret;
+  r_mpfr_make_struct_init2(val_ret, ptr_ret, mpfi_get_prec(ptr_self));
+  mpfi_get_fr(ptr_ret, ptr_self);
+  return val_ret;
+}
+/* ------------------------------ Conversion Functions end ------------------------------ */
+
+/* ------------------------------ Functions Operating on Endpoints start ------------------------------ */
+
+static VALUE r_mpfi_get_left (VALUE self){
+  VALUE val_ret;
+  MPFI *ptr_self;
+  MPFR *ptr_ret;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfr_make_struct_init2(val_ret, ptr_ret, mpfi_get_prec(ptr_self));
+  mpfi_get_left(ptr_ret, ptr_self);
+  return val_ret;
+}
+
+static VALUE r_mpfi_get_right (VALUE self){
+  VALUE val_ret;
+  MPFI *ptr_self;
+  MPFR *ptr_ret;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfr_make_struct_init2(val_ret, ptr_ret, mpfi_get_prec(ptr_self));
+  mpfi_get_right(ptr_ret, ptr_self);
+  return val_ret;
+}
+
+static VALUE r_mpfi_revert_if_needed (VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  if(mpfi_revert_if_needed(ptr_self) != 0){
+    return Qtrue;
+  }else{
+    return Qnil;
+  };
+}
+
+static VALUE r_mpfi_put (VALUE self, VALUE other){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+
+  if(RTEST(rb_funcall(__mpfi_class__, eqq, 1, other))){
+    MPFI *ptr_other;
+    r_mpfi_get_struct(ptr_other, other);
+    r_mpfi_set_function_state(mpfi_put(ptr_self, ptr_other));
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, other))){
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, other);
+    r_mpfi_set_function_state(mpfi_put_fr(ptr_self, ptr_other));
+  }else if(TYPE(other) == T_FIXNUM){
+    r_mpfi_set_function_state(mpfi_put_si(ptr_self, FIX2LONG(other)));
+  }else if(TYPE(other) == T_FLOAT){
+    r_mpfi_set_function_state(mpfi_put_d(ptr_self, NUM2DBL(other)));
+  }else{
+    MPFI *ptr_other;
+    volatile VALUE tmp_other = r_mpfi_new_fi_obj(other);
+    r_mpfi_get_struct(ptr_other, tmp_other);
+    r_mpfi_set_function_state(mpfi_put(ptr_self, ptr_other));
+  }
+  return self;
+}
+
+static VALUE r_mpfi_interv (VALUE self, VALUE a1, VALUE a2){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+
+  if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, a1)) && RTEST(rb_funcall(__mpfr_class__, eqq, 1, a2))){
+    MPFR *ptr_a1, *ptr_a2;
+    r_mpfr_get_struct(ptr_a1, a1);
+    r_mpfr_get_struct(ptr_a2, a2);
+    r_mpfi_set_function_state(mpfi_interv_fr(ptr_self, ptr_a1, ptr_a2));
+  }else if((TYPE(a1) == T_FIXNUM) && (TYPE(a2) == T_FIXNUM)){
+    r_mpfi_set_function_state(mpfi_interv_si(ptr_self, FIX2LONG(a1), FIX2LONG(a2)));
+  }else if((TYPE(a1) == T_FLOAT) && (TYPE(a2) == T_FLOAT)){
+    r_mpfi_set_function_state(mpfi_interv_d(ptr_self, NUM2DBL(a1), NUM2DBL(a2)));
+  }else{
+    MPFR *ptr_a1, *ptr_a2;
+    volatile VALUE tmp_a1 = r_mpfr_new_fr_obj(a1);
+    r_mpfr_get_struct(ptr_a1, tmp_a1);
+    volatile VALUE tmp_a2 = r_mpfr_new_fr_obj(a2);
+    r_mpfr_get_struct(ptr_a2, tmp_a2);
+    r_mpfi_set_function_state(mpfi_interv_fr(ptr_self, ptr_a1, ptr_a2));
+  }
+  return self;  
+}
+
+static VALUE r_mpfi_interval (int argc, VALUE *argv, VALUE self){
+  VALUE val_ret;
+  MPFI *ptr_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(2, 3, argc, argv));
+
+  if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, argv[0])) && RTEST(rb_funcall(__mpfr_class__, eqq, 1, argv[1]))){
+    MPFR *ptr_a0, *ptr_a1;
+    r_mpfr_get_struct(ptr_a0, argv[0]);
+    r_mpfr_get_struct(ptr_a1, argv[1]);
+    r_mpfi_set_function_state(mpfi_interv_fr(ptr_ret, ptr_a0, ptr_a1));
+  }else if((TYPE(argv[0]) == T_FIXNUM) && (TYPE(argv[1]) == T_FIXNUM)){
+    r_mpfi_set_function_state(mpfi_interv_si(ptr_ret, FIX2LONG(argv[0]), FIX2LONG(argv[1])));
+  }else if((TYPE(argv[0]) == T_FLOAT) && (TYPE(argv[1]) == T_FLOAT)){
+    r_mpfi_set_function_state(mpfi_interv_d(ptr_ret, NUM2DBL(argv[0]), NUM2DBL(argv[1])));
+  }else{
+    /* printf("r_mpfi_interval [start]\n"); */
+    MPFR *ptr_a0, *ptr_a1;
+    volatile VALUE tmp1 = r_mpfr_new_fr_obj(argv[0]), tmp2 = r_mpfr_new_fr_obj(argv[1]);
+    r_mpfr_get_struct(ptr_a0, tmp1);
+    r_mpfr_get_struct(ptr_a1, tmp2);
+    /* volatile VALUE tmp_argv0 = r_mpfr_new_fr_obj(argv[0]);
+       r_mpfr_get_struct(ptr_a0, tmp_argv0); */
+    /* volatile VALUE tmp_argv1 = r_mpfr_new_fr_obj(argv[1]);
+       r_mpfr_get_struct(ptr_a1, tmp_argv1); */
+    r_mpfi_set_function_state(mpfi_interv_fr(ptr_ret, ptr_a0, ptr_a1));
+    /* printf("r_mpfi_interval [end]\n"); */
+  }
+  return val_ret;
+}
+
+static VALUE r_mpfi_endpoints (VALUE self){
+  VALUE val_left, val_right;
+  MPFI *ptr_self;
+  MPFR *ptr_left, *ptr_right;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfr_make_struct_init2(val_left, ptr_left, mpfi_get_prec(ptr_self));
+  r_mpfr_make_struct_init2(val_right, ptr_right, mpfi_get_prec(ptr_self));
+  mpfi_get_left(ptr_left, ptr_self);
+  mpfi_get_right(ptr_right, ptr_self);
+  return rb_ary_new3(2, val_left, val_right);
+}
+
+/* ------------------------------ Functions Operating on Endpoints end ------------------------------ */
+
+/* ------------------------------ Set Functions on Intervals start ------------------------------ */
+
+/* This method corresponds to mpfi_is_strictly_inside. */
+static VALUE r_mpfi_strictly_include (VALUE self, VALUE other){
+  MPFI *ptr_self, *ptr_other;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfi_get_struct(ptr_other, other);
+  if(mpfi_is_strictly_inside(ptr_other, ptr_self) > 0){
+    return Qtrue;
+  }else{
+    return Qnil;
+  }
+}
+
+/* This method corresponds to mpfi_is_inside. */
+static VALUE r_mpfi_include (VALUE self, VALUE other){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  int result;
+  if(RTEST(rb_funcall(__mpfi_class__, eqq, 1, other))){
+    MPFI *ptr_other;
+    r_mpfi_get_struct(ptr_other, other);
+    result = mpfi_is_inside(ptr_other, ptr_self);
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, other))){
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, other);
+    result = mpfi_is_inside_fr(ptr_other, ptr_self);
+  }else if(TYPE(other) == T_FIXNUM){
+    result = mpfi_is_inside_si(FIX2LONG(other), ptr_self);
+  }else if(TYPE(other) == T_FLOAT){
+    result = mpfi_is_inside_d(NUM2DBL(other), ptr_self);
+  }else{
+    MPFI *ptr_other;
+    volatile VALUE tmp_other = r_mpfi_new_fi_obj(other);
+    r_mpfi_get_struct(ptr_other, tmp_other);
+    result = mpfi_is_inside(ptr_other, ptr_self);
+  }
+  if(result > 0){
+    return Qtrue;
+  }else{
+    return Qnil;
+  }
+}
+
+static VALUE r_mpfi_is_empty (VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  if(mpfi_is_empty(ptr_self) > 0){
+    return Qtrue;
+  }else{
+    return Qnil;
+  }
+}
+
+/* If the intersection of two intervals is empty, this method returns nil.
+   Otherwise, it returns the intersection. */
+static VALUE r_mpfi_intersect (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self, *ptr_a0, *ptr_ret;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfi_get_struct(ptr_a0, argv[0]);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_intersect(ptr_ret, ptr_self, ptr_a0));
+  if(mpfi_is_empty(ptr_ret) > 0){
+    return Qnil;
+  }else{
+    return val_ret;
+  }
+}
+
+/* This method returns the intersection of two intervals.
+   The returned value may be empty interval. */
+static VALUE r_mpfi_intersect2 (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self, *ptr_a0, *ptr_ret;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfi_get_struct(ptr_a0, argv[0]);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_intersect(ptr_ret, ptr_self, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_union (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self, *ptr_a0, *ptr_ret;
+  r_mpfi_get_struct(ptr_self, self);
+  r_mpfi_get_struct(ptr_a0, argv[0]);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_union(ptr_ret, ptr_self, ptr_a0));
+  return val_ret;
+}
+
+/* ------------------------------ Set Functions on Intervals end ------------------------------ */
+
+/* ------------------------------ Miscellaneous Interval Functions start ------------------------------ */
+
+static VALUE r_mpfi_increase (VALUE self, VALUE a0){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  MPFR *ptr_a0;
+  volatile VALUE tmp_a0 = r_mpfr_new_fr_obj(a0);
+  r_mpfr_get_struct(ptr_a0, tmp_a0);
+  r_mpfi_set_function_state(mpfi_increase(ptr_self, ptr_a0));
+  return self;
+}
+
+static VALUE r_mpfi_blow (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self, *ptr_ret;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_blow(ptr_ret, ptr_self, NUM2DBL(argv[0])));
+  return val_ret;
+}
+
+static VALUE r_mpfi_bisect (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self, *ptr_ret1, *ptr_ret2;
+  r_mpfi_get_struct(ptr_self, self);
+  int prec = r_mpfr_prec_from_optional_argument(0, 1, argc, argv);
+  VALUE val_ret1, val_ret2;
+  r_mpfi_make_struct_init2(val_ret1, ptr_ret1, prec);
+  r_mpfi_make_struct_init2(val_ret2, ptr_ret2, prec);
+  r_mpfi_set_function_state(mpfi_bisect(ptr_ret1, ptr_ret2, ptr_self));
+  return rb_ary_new3(2, val_ret1, val_ret2);
+}
+
+/* Retrun 0 if this function puts subdivision to *ret. */
+/* Otherwise, return -1. */
+void r_mpfi_subdivision_func(int num, MPFI *ret[], mpfi_t x){
+  int i;
+  mpfr_t l;
+  mpfr_init(l);
+  mpfr_sub(l, r_mpfi_right_ptr(x), r_mpfi_left_ptr(x), GMP_RNDD);
+  mpfr_div_si(l, l, num, GMP_RNDD);
+  mpfr_t x_diam;
+  mpfr_init(x_diam);
+  mpfi_diam_abs(x_diam, x);
+  if(mpfr_cmp(x_diam, l) > 0 && num > 1){
+    mpfr_set(r_mpfi_left_ptr(ret[0]), r_mpfi_left_ptr(x), GMP_RNDN);
+    mpfr_add(r_mpfi_right_ptr(ret[0]), r_mpfi_left_ptr(ret[0]), l, GMP_RNDU);
+
+    for(i = 1; i < num - 1; i ++){
+      mpfr_set(r_mpfi_left_ptr(ret[i]), r_mpfi_right_ptr(ret[i - 1]), GMP_RNDN);
+      mpfr_add(r_mpfi_right_ptr(ret[i]), r_mpfi_left_ptr(ret[i]), l, GMP_RNDU);
+    }
+
+    mpfr_set(r_mpfi_left_ptr(ret[i]), r_mpfi_right_ptr(ret[i - 1]), GMP_RNDN);
+    mpfr_set(r_mpfi_right_ptr(ret[i]), r_mpfi_right_ptr(x), GMP_RNDN);
+  }else{
+    mpfr_set(r_mpfi_left_ptr(ret[0]), r_mpfi_left_ptr(x), GMP_RNDN);
+    mpfr_set(r_mpfi_right_ptr(ret[0]), r_mpfi_right_ptr(x), GMP_RNDN);
+  }
+  mpfr_clear(x_diam);
+  mpfr_clear(l);
+}
+
+static VALUE r_mpfi_subdivision (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  int i, num = NUM2INT(argv[0]);
+  int prec = r_mpfr_prec_from_optional_argument(1, 2, argc, argv);
+  MPFI *f[num];
+  VALUE vf[num];
+  for(i = 0; i < num; i++){
+    r_mpfi_make_struct_init2(vf[i], f[i], prec);
+  }
+  r_mpfi_subdivision_func(num, f, ptr_self);
+  return rb_ary_new4(num, vf);
+}
+/* ------------------------------ Miscellaneous Interval Functions end ------------------------------ */
+
+/* ------------------------------ Mathematical Basic Arithmetic Functions start ------------------------------ */
+
+static VALUE r_mpfi_math_add (int argc, VALUE *argv, VALUE self){
+  VALUE val_ret;
+  MPFI *ptr_a0, *ptr_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(2, 3, argc, argv));
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  if(RTEST(rb_funcall(__mpfi_class__, eqq, 1, argv[1]))){
+    MPFI *ptr_other;
+    r_mpfi_get_struct(ptr_other, argv[1]);
+    r_mpfi_set_function_state(mpfi_add(ptr_ret, ptr_a0, ptr_other));
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, argv[1]))){
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, argv[1]);
+    r_mpfi_set_function_state(mpfi_add_fr(ptr_ret, ptr_a0, ptr_other));
+  }else if(TYPE(argv[1]) == T_FIXNUM){
+    r_mpfi_set_function_state(mpfi_add_si(ptr_ret, ptr_a0, FIX2LONG(argv[1])));
+  }else if(TYPE(argv[1]) == T_FLOAT){
+    r_mpfi_set_function_state(mpfi_add_d(ptr_ret, ptr_a0, NUM2DBL(argv[1])));
+  }else{
+    MPFI *ptr_a2;
+    volatile VALUE tmp_argv1 = r_mpfi_new_fi_obj(argv[1]);
+    r_mpfi_get_struct(ptr_a2, tmp_argv1);
+    r_mpfi_set_function_state(mpfi_add(ptr_ret, ptr_a0, ptr_a2));
+  }
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_sub (int argc, VALUE *argv, VALUE self){
+  VALUE val_ret;
+  MPFI *ptr_a0, *ptr_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(2, 3, argc, argv));
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  if(RTEST(rb_funcall(__mpfi_class__, eqq, 1, argv[1]))){
+    MPFI *ptr_other;
+    r_mpfi_get_struct(ptr_other, argv[1]);
+    r_mpfi_set_function_state(mpfi_sub(ptr_ret, ptr_a0, ptr_other));
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, argv[1]))){
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, argv[1]);
+    r_mpfi_set_function_state(mpfi_sub_fr(ptr_ret, ptr_a0, ptr_other));
+  }else if(TYPE(argv[1]) == T_FIXNUM){
+    r_mpfi_set_function_state(mpfi_sub_si(ptr_ret, ptr_a0, FIX2LONG(argv[1])));
+  }else if(TYPE(argv[1]) == T_FLOAT){
+    r_mpfi_set_function_state(mpfi_sub_d(ptr_ret, ptr_a0, NUM2DBL(argv[1])));
+  }else{
+    MPFI *ptr_a2;
+    volatile VALUE tmp_argv1 = r_mpfi_new_fi_obj(argv[1]);
+    r_mpfi_get_struct(ptr_a2, tmp_argv1);
+    r_mpfi_set_function_state(mpfi_sub(ptr_ret, ptr_a0, ptr_a2));
+  }
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_mul (int argc, VALUE *argv, VALUE self){
+  VALUE val_ret;
+  MPFI *ptr_a0, *ptr_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(2, 3, argc, argv));
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  if(RTEST(rb_funcall(__mpfi_class__, eqq, 1, argv[1]))){
+    MPFI *ptr_other;
+    r_mpfi_get_struct(ptr_other, argv[1]);
+    r_mpfi_set_function_state(mpfi_mul(ptr_ret, ptr_a0, ptr_other));
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, argv[1]))){
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, argv[1]);
+    r_mpfi_set_function_state(mpfi_mul_fr(ptr_ret, ptr_a0, ptr_other));
+  }else if(TYPE(argv[1]) == T_FIXNUM){
+    r_mpfi_set_function_state(mpfi_mul_si(ptr_ret, ptr_a0, FIX2LONG(argv[1])));
+  }else if(TYPE(argv[1]) == T_FLOAT){
+    r_mpfi_set_function_state(mpfi_mul_d(ptr_ret, ptr_a0, NUM2DBL(argv[1])));
+  }else{
+    MPFI *ptr_a2;
+    volatile VALUE tmp_argv1 = r_mpfi_new_fi_obj(argv[1]);
+    r_mpfi_get_struct(ptr_a2, tmp_argv1);
+    r_mpfi_set_function_state(mpfi_mul(ptr_ret, ptr_a0, ptr_a2));
+  }
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_div (int argc, VALUE *argv, VALUE self){
+  VALUE val_ret;
+  MPFI *ptr_a0, *ptr_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(2, 3, argc, argv));
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  if(RTEST(rb_funcall(__mpfi_class__, eqq, 1, argv[1]))){
+    MPFI *ptr_other;
+    r_mpfi_get_struct(ptr_other, argv[1]);
+    r_mpfi_set_function_state(mpfi_div(ptr_ret, ptr_a0, ptr_other));
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, argv[1]))){
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, argv[1]);
+    r_mpfi_set_function_state(mpfi_div_fr(ptr_ret, ptr_a0, ptr_other));
+  }else if(TYPE(argv[1]) == T_FIXNUM){
+    r_mpfi_set_function_state(mpfi_div_si(ptr_ret, ptr_a0, FIX2LONG(argv[1])));
+  }else if(TYPE(argv[1]) == T_FLOAT){
+    r_mpfi_set_function_state(mpfi_div_d(ptr_ret, ptr_a0, NUM2DBL(argv[1])));
+  }else{
+    MPFI *ptr_a2;
+    volatile VALUE tmp_argv1 = r_mpfi_new_fi_obj(argv[1]);
+    r_mpfi_get_struct(ptr_a2, tmp_argv1);
+    r_mpfi_set_function_state(mpfi_div(ptr_ret, ptr_a0, ptr_a2));
+  }
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_sqr (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_sqr(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_sqrt (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_sqrt(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+/* ------------------------------ Mathematical Basic Arithmetic Functions end ------------------------------ */
+
+/* ------------------------------ Special Functions start ------------------------------ */
+
+static VALUE r_mpfi_math_log (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_log(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_exp (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_exp(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_exp2 (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_exp2(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_cos (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_cos(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_sin (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_sin(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_tan (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_tan(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_acos (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_acos(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_asin (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_asin(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_atan (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_atan(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_cosh (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_cosh(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_sinh (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_sinh(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_tanh (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_tanh(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_acosh (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_acosh(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_asinh (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_asinh(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_atanh (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_atanh(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_log1p (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_log1p(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_expm1 (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_expm1(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_log2 (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_log2(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_log10 (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_a0, *ptr_ret;
+  volatile VALUE tmp_argv0 = r_mpfi_new_fi_obj(argv[0]);
+  r_mpfi_get_struct(ptr_a0, tmp_argv0);
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(1, 2, argc, argv));
+  r_mpfi_set_function_state(mpfi_log10(ptr_ret, ptr_a0));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_const_log2 (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_ret;
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(0, 1, argc, argv));
+  r_mpfi_set_function_state(mpfi_const_log2(ptr_ret));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_const_pi (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_ret;
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(0, 1, argc, argv));
+  r_mpfi_set_function_state(mpfi_const_pi(ptr_ret));
+  return val_ret;
+}
+
+static VALUE r_mpfi_math_const_euler (int argc, VALUE *argv, VALUE self){
+  MPFI *ptr_ret;
+  VALUE val_ret;
+  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(0, 1, argc, argv));
+  r_mpfi_set_function_state(mpfi_const_euler(ptr_ret));
+  return val_ret;
+}
+
+/* ------------------------------ Special Functions end ------------------------------ */
+
+void Init_mpfi(){
+  r_mpfi_class = rb_define_class("MPFI", rb_cNumeric);
+
+  /* ------------------------------ function state start ------------------------------ */
+  rb_define_class_variable(r_mpfi_class, CLASS_VAL_FUNCTION_STATE, INT2FIX(0));
+  rb_define_singleton_method(r_mpfi_class, "function_state", r_mpfr_get_function_state, 0);
+  /* ------------------------------ function state end ------------------------------ */
+
+  /* ------------------------------ allocation start ------------------------------ */
+  rb_define_alloc_func(r_mpfi_class, r_mpfi_alloc);
+  rb_define_private_method(r_mpfi_class, "initialize", r_mpfi_initialize, -1);
+  rb_define_private_method(r_mpfi_class, "initialize_copy", r_mpfi_initialize_copy, 1);
+
+  rb_define_method(r_mpfi_class, "coerce", r_mpfi_coerce, 1);
+  rb_define_method(r_mpfi_class, "set", r_mpfi_set, 1);
+  rb_define_method(r_mpfi_class, "swap", r_mpfi_swap, 1);
+  /* ------------------------------ allocation end ------------------------------ */
+
+  /* ------------------------------ Rounding Modes and Precision Handling start ------------------------------*/
+  rb_define_method(r_mpfi_class, "set_prec", r_mpfi_set_prec, 1);
+  rb_define_method(r_mpfi_class, "get_prec", r_mpfi_get_prec, 0);
+  rb_define_method(r_mpfi_class, "round_prec", r_mpfi_round_prec, 1);
+  /* ------------------------------ Rounding Modes and Precision Handling end ------------------------------*/
+
+  /* ------------------------------ string start ------------------------------ */
+  rb_define_method(r_mpfi_class, "inspect", r_mpfi_inspect, 0);
+
+  rb_define_method(r_mpfi_class, "to_str_ary", r_mpfi_to_str_ary, 0);
+  rb_define_method(r_mpfi_class, "to_strf_ary", r_mpfi_to_strf_ary, 1);
+  /* ------------------------------ string end ------------------------------ */
+
+  /* ------------------------------ Basic Arithmetic Functions start ------------------------------ */
+  rb_define_method(r_mpfi_class, "+", r_mpfi_add, 1);
+  rb_define_method(r_mpfi_class, "-", r_mpfi_sub, 1);
+  rb_define_method(r_mpfi_class, "*", r_mpfi_mul, 1);
+  rb_define_method(r_mpfi_class, "/", r_mpfi_div, 1);
+
+  rb_define_method(r_mpfi_class, "mul_2si", r_mpfi_mul_2si, -1);
+  rb_define_method(r_mpfi_class, "div_2si", r_mpfi_div_2si, -1);
+
+  rb_define_method(r_mpfi_class, "neg", r_mpfi_neg, -1);
+  rb_define_method(r_mpfi_class, "inv", r_mpfi_inv, -1);
+  rb_define_method(r_mpfi_class, "abs", r_mpfi_abs, -1);
+  /* ------------------------------ Basic Arithmetic Functions end ------------------------------ */
+
+  /* ------------------------------ Comparison Functions start ------------------------------ */
+  rb_define_method(r_mpfi_class, "cmp", r_mpfi_cmp, 1);
+  rb_define_method(r_mpfi_class, "is_pos", r_mpfi_is_pos, 0);
+  rb_define_method(r_mpfi_class, "is_strictly_pos", r_mpfi_is_strictly_pos, 0);
+  rb_define_method(r_mpfi_class, "is_nonneg", r_mpfi_is_nonneg, 0);
+  rb_define_method(r_mpfi_class, "is_neg", r_mpfi_is_neg, 0);
+  rb_define_method(r_mpfi_class, "is_strictly_neg", r_mpfi_is_strictly_neg, 0);
+  rb_define_method(r_mpfi_class, "is_nonpos", r_mpfi_is_nonpos, 0);
+  rb_define_method(r_mpfi_class, "is_zero", r_mpfi_is_zero, 0);
+  rb_define_method(r_mpfi_class, "has_zero", r_mpfi_has_zero, 0);
+  rb_define_method(r_mpfi_class, "nan_p", r_mpfi_nan_p, 0);
+  rb_define_method(r_mpfi_class, "inf_p", r_mpfi_inf_p, 0);
+  rb_define_method(r_mpfi_class, "bounded_p", r_mpfi_bounded_p, 0);
+  rb_define_method(r_mpfi_class, "equal_p", r_mpfi_equal_p, 1);
+
+  rb_define_alias(r_mpfi_class, "cmp", "<=>");
+  rb_define_alias(r_mpfi_class, "pos?", "is_pos");
+  rb_define_alias(r_mpfi_class, "strictly_pos?", "is_strictly_pos");
+  rb_define_alias(r_mpfi_class, "nonneg?", "is_nonneg");
+  rb_define_alias(r_mpfi_class, "neg?", "is_neg");
+  rb_define_alias(r_mpfi_class, "strictly_neg?", "is_strictly_neg");
+  rb_define_alias(r_mpfi_class, "nonpos?", "is_nonpos");
+  rb_define_alias(r_mpfi_class, "zero?", "is_zero");
+  rb_define_alias(r_mpfi_class, "has_zero?", "has_zero");
+  rb_define_alias(r_mpfi_class, "nan?", "nan_p");
+  rb_define_alias(r_mpfi_class, "inf?", "inf_p");
+  rb_define_alias(r_mpfi_class, "bounded?", "bounded_p");
+  rb_define_method(r_mpfi_class, "==", r_mpfi_equal_p, 1);
+  /* ------------------------------ Comparison Functions end ------------------------------ */
+
+  /* ------------------------------ Interval Functions with Floating-point Results start ------------------------------ */
+  rb_define_method(r_mpfi_class, "diam_abs", r_mpfi_diam_abs, -1);
+  rb_define_method(r_mpfi_class, "diam_rel", r_mpfi_diam_rel, -1);
+  rb_define_method(r_mpfi_class, "diam", r_mpfi_diam, -1);
+  rb_define_method(r_mpfi_class, "mag", r_mpfi_mag, -1);
+  rb_define_method(r_mpfi_class, "mig", r_mpfi_mig, -1);
+  rb_define_method(r_mpfi_class, "mid", r_mpfi_mid, -1);
+  rb_define_method(r_mpfi_class, "mid_interval", r_mpfi_mid_interval, -1);
+  rb_define_method(r_mpfi_class, "alea", r_mpfi_alea, -1);
+  /* ------------------------------ Interval Functions with Floating-point Results end ------------------------------ */
+
+  /* ------------------------------ Conversion Functions start ------------------------------ */
+  rb_define_method(r_mpfi_class, "get_d", r_mpfi_get_d, 0);
+  rb_define_method(r_mpfi_class, "get_fr", r_mpfi_get_fr, 0);
+  rb_define_alias(r_mpfi_class, "to_f", "get_d");
+  rb_define_alias(r_mpfi_class, "to_fr", "get_fr");
+  /* ------------------------------ Conversion Functions end ------------------------------ */
+
+  /* ------------------------------ Functions Operating on Endpoints start ------------------------------ */
+  rb_define_method(r_mpfi_class, "get_left", r_mpfi_get_left, 0);
+  rb_define_method(r_mpfi_class, "get_right", r_mpfi_get_right, 0);
+  rb_define_method(r_mpfi_class, "revert_if_needed", r_mpfi_revert_if_needed, 0);
+  rb_define_method(r_mpfi_class, "put", r_mpfi_put, 1);
+  rb_define_method(r_mpfi_class, "interv", r_mpfi_interv, 2);
+
+  rb_define_alias(r_mpfi_class, "left", "get_left");
+  rb_define_alias(r_mpfi_class, "right", "get_right");
+  rb_define_method(r_mpfi_class, "endpoints", r_mpfi_endpoints, 0);
+  
+  rb_define_singleton_method(r_mpfi_class, "interval", r_mpfi_interval, -1);
+  /* ------------------------------ Functions Operating on Endpoints end ------------------------------ */
+
+  /* ------------------------------ Set Functions on Intervals start ------------------------------ */
+  rb_define_method(r_mpfi_class, "strictly_include?", r_mpfi_strictly_include, 1);
+  rb_define_method(r_mpfi_class, "include?", r_mpfi_include, 1);
+  
+  rb_define_method(r_mpfi_class, "is_empty", r_mpfi_is_empty, 0);
+  rb_define_method(r_mpfi_class, "intersect", r_mpfi_intersect, -1);
+  rb_define_method(r_mpfi_class, "intersect2", r_mpfi_intersect2, -1);
+  rb_define_method(r_mpfi_class, "union", r_mpfi_union, -1);
+
+  rb_define_alias(r_mpfi_class, "empty?", "is_empty");
+  /* ------------------------------ Set Functions on Intervals end ------------------------------ */
+
+  /* ------------------------------ Miscellaneous Interval Functions start ------------------------------ */
+  rb_define_method(r_mpfi_class, "increase", r_mpfi_increase, 1);
+  rb_define_method(r_mpfi_class, "blow", r_mpfi_blow, -1);
+  rb_define_method(r_mpfi_class, "bisect", r_mpfi_bisect, -1);
+  rb_define_method(r_mpfi_class, "subdivision", r_mpfi_subdivision, -1);
+  /* ------------------------------ Miscellaneous Interval Functions end ------------------------------ */
+  
+  r_mpfi_math = rb_define_module_under(r_mpfi_class, "Math");  
+
+  /* ------------------------------ Mathematical Basic Arithmetic Functions start ------------------------------ */
+  rb_define_module_function(r_mpfi_math, "add", r_mpfi_math_add, -1);
+  rb_define_module_function(r_mpfi_math, "sub", r_mpfi_math_sub, -1);
+  rb_define_module_function(r_mpfi_math, "mul", r_mpfi_math_mul, -1);
+  rb_define_module_function(r_mpfi_math, "div", r_mpfi_math_div, -1);
+
+  rb_define_module_function(r_mpfi_math, "sqr", r_mpfi_math_sqr, -1);
+  rb_define_module_function(r_mpfi_math, "sqrt", r_mpfi_math_sqrt, -1);
+  /* ------------------------------ Mathematical Basic Arithmetic Functions end ------------------------------ */
+
+  /* ------------------------------ Special Functions start ------------------------------ */
+  rb_define_module_function(r_mpfi_math, "log", r_mpfi_math_log, -1);
+  rb_define_module_function(r_mpfi_math, "exp", r_mpfi_math_exp, -1);
+  rb_define_module_function(r_mpfi_math, "exp2", r_mpfi_math_exp2, -1);
+  rb_define_module_function(r_mpfi_math, "cos", r_mpfi_math_cos, -1);
+  rb_define_module_function(r_mpfi_math, "sin", r_mpfi_math_sin, -1);
+  rb_define_module_function(r_mpfi_math, "tan", r_mpfi_math_tan, -1);
+  rb_define_module_function(r_mpfi_math, "acos", r_mpfi_math_acos, -1);
+  rb_define_module_function(r_mpfi_math, "asin", r_mpfi_math_asin, -1);
+  rb_define_module_function(r_mpfi_math, "atan", r_mpfi_math_atan, -1);
+  rb_define_module_function(r_mpfi_math, "cosh", r_mpfi_math_cosh, -1);
+  rb_define_module_function(r_mpfi_math, "sinh", r_mpfi_math_sinh, -1);
+  rb_define_module_function(r_mpfi_math, "tanh", r_mpfi_math_tanh, -1);
+  rb_define_module_function(r_mpfi_math, "acosh", r_mpfi_math_acosh, -1);
+  rb_define_module_function(r_mpfi_math, "asinh", r_mpfi_math_asinh, -1);
+  rb_define_module_function(r_mpfi_math, "atanh", r_mpfi_math_atanh, -1);
+  rb_define_module_function(r_mpfi_math, "log1p", r_mpfi_math_log1p, -1);
+  rb_define_module_function(r_mpfi_math, "expm1", r_mpfi_math_expm1, -1);
+  rb_define_module_function(r_mpfi_math, "log2", r_mpfi_math_log2, -1);
+  rb_define_module_function(r_mpfi_math, "log10", r_mpfi_math_log10, -1);
+  rb_define_module_function(r_mpfi_math, "const_log2", r_mpfi_math_const_log2, -1);
+  rb_define_module_function(r_mpfi_math, "const_pi", r_mpfi_math_const_pi, -1);
+  rb_define_module_function(r_mpfi_math, "const_euler", r_mpfi_math_const_euler, -1);
+  /* ------------------------------ Special Functions end ------------------------------ */
+
+  eqq = rb_intern("===");
+  to_s = rb_intern("to_s");
+  new = rb_intern("new");
+  class = rb_intern("class");
+  object_id = rb_intern("object_id");
+  method_defined = rb_intern("method_defined?");
+  __mpfi_class__ = rb_eval_string("MPFI");
+  __mpfr_class__ = rb_eval_string("MPFR");
+  __sym_to_s__ = rb_eval_string(":to_s");
+  __sym_to_str__ = rb_eval_string(":to_str");
+
+}
+