ruby-mpfi 0.0.2

data/ext/mpfi/ruby_mpfi.h

@@ -0,0 +1,39 @@
+#ifndef _RUBY_MPFI_H_
+#define _RUBY_MPFI_H_
+
+#include <stdio.h>
+#include <ruby.h>
+#include <mpfr.h>
+#include <mpfi.h>
+#include <mpfi_io.h>
+#include "func_mpfi_extention.h"
+#include "ruby_mpfr.h"
+
+typedef __mpfi_struct MPFI;
+
+VALUE r_mpfi_class, r_mpfi_math;;
+
+#define r_mpfi_make_struct(ruby_var, c_var) { ruby_var = Data_Make_Struct(r_mpfi_class, MPFI, 0, r_mpfi_free, c_var); }
+#define r_mpfi_make_struct_init(ruby_var, c_var) { r_mpfi_make_struct(ruby_var, c_var); mpfi_init(c_var); }
+#define r_mpfi_make_struct_init2(ruby_var, c_var, prec) { r_mpfi_make_struct(ruby_var, c_var); mpfi_init2(c_var, prec); }
+#define r_mpfi_get_struct(c_var, ruby_var) { Data_Get_Struct(ruby_var, MPFI, c_var); }
+
+#define r_mpfi_temp_alloc(c_var) { c_var=ALLOC_N(MPFI, 1); }
+#define r_mpfi_temp_alloc_init(c_var) { r_mpfi_temp_alloc(c_var); mpfi_init(c_var); }
+#define r_mpfi_temp_alloc_init2(c_var, prec) { r_mpfi_temp_alloc(c_var); mpfi_init2(c_var, prec); }
+#define r_mpfi_temp_free(c_var) { mpfi_clear(c_var); free(c_var); }
+
+#define r_mpfi_left_ptr(c_var) (&((c_var)->left))
+#define r_mpfi_right_ptr(c_var) (&((c_var)->right))
+
+void r_mpfi_free(void *ptr);
+VALUE r_mpfi_make_new_fi_obj(MPFI *ptr);
+VALUE r_mpfi_new_fi_obj(VALUE obj);
+void r_mpfi_set_robj(MPFI *ptr, VALUE obj);
+
+int r_mpfi_subdivision2(int num, MPFI *ret, mpfi_t x);
+
+void r_mpfi_set_function_state(int num);
+VALUE r_mpfr_get_function_state(VALUE self);
+
+#endif /* _RUBY_MPFI_H_ */

data/ext/mpfi/ruby_mpfr.h

@@ -0,0 +1,38 @@
+#ifndef _RUBY_MPFR_H_
+#define _RUBY_MPFR_H_
+
+#include <ruby.h>
+#include <mpfr.h>
+#include <stdio.h>
+
+typedef __mpfr_struct MPFR;
+
+VALUE r_mpfr_class, r_mpfr_math;
+
+#define r_mpfr_make_struct(ruby_var, c_var) { ruby_var = Data_Make_Struct(r_mpfr_class, MPFR, 0, r_mpfr_free, c_var); }
+#define r_mpfr_make_struct_init(ruby_var, c_var) { r_mpfr_make_struct(ruby_var, c_var); mpfr_init(c_var); }
+#define r_mpfr_make_struct_init2(ruby_var, c_var, prec) { r_mpfr_make_struct(ruby_var, c_var); mpfr_init2(c_var, prec); }
+#define r_mpfr_get_struct(c_var, ruby_var) { Data_Get_Struct(ruby_var, MPFR, c_var); }
+
+#define r_mpfr_temp_alloc(var) { var=ALLOC_N(MPFR, 1); }
+#define r_mpfr_temp_alloc_init(var) { r_mpfr_temp_alloc(var); mpfr_init(var); }
+#define r_mpfr_temp_alloc_init2(var, prec) { r_mpfr_temp_alloc(var); mpfr_init2(var, prec); }
+#define r_mpfr_temp_free(var) { mpfr_clear(var); free(var); }
+
+#define r_mpfr_check_number(c_val) { if(mpfr_number_p(c_val) == 0) rb_raise(rb_eArgError, "Not an ordinary number."); }
+#define r_mpfr_check_positive_number(c_val) { if(mpfr_number_p(c_val) == 0 && mpfr_sgn(c_val) <= 0) rb_raise(rb_eArgError, "Not a positive number."); }
+#define r_mpfr_check_non_negative_number(c_val) { if(mpfr_number_p(c_val) == 0 && mpfr_sgn(c_val) < 0) rb_raise(rb_eArgError, "Not a non negative number."); }
+#define r_mpfr_check_negative_number(c_val) { if(mpfr_number_p(c_val) == 0 && mpfr_sgn(c_val) >= 0) rb_raise(rb_eArgError, "Not a negative number."); }
+#define r_mpfr_check_non_positive_number(c_val) { if(mpfr_number_p(c_val) == 0 && mpfr_sgn(c_val) > 0) rb_raise(rb_eArgError, "Not a non positive number."); }
+
+void r_mpfr_free(void *ptr);
+VALUE r_mpfr_new_fr_obj(VALUE obj);
+void r_mpfr_set_robj(MPFR *ptr, VALUE obj, mp_rnd_t rnd);
+
+mp_rnd_t r_mpfr_rnd_from_value(VALUE rnd);
+mp_rnd_t r_mpfr_rnd_from_optional_argument(int min, int max, int argc, VALUE *argv);
+mp_rnd_t r_mpfr_prec_from_optional_argument(int min, int max, int argc, VALUE *argv);
+void r_mpfr_get_rnd_prec_from_optional_arguments(mp_rnd_t *rnd, mp_prec_t *prec, int min, int max, int argc, VALUE *argv);
+
+#endif /* _RUBY_MPFR_H_ */
+

data/ext/mpfi/yasnippet_mpfi.el

@@ -0,0 +1,44 @@
+  (yas/define-snippets
+  'c-mode
+  '(("fu" "static VALUE r_mpfi_$1 (VALUE self$2){\n  $0\n}" "static VALUE r_mpfi_... (VALUE self ... )")
+  ("fu.1" "static VALUE r_mpfi_$1 (int argc, VALUE *argv, VALUE self){\n  $0\n}"
+  "static VALUE r_mpfi_... (int argc, VALUE *argv, VALUE self){")
+  ("me" "rb_define_method(r_mpfi_class, \"$1\", r_mpfi_$1$0, ${2:0});" "rb_define_method")
+  ("se" "  R_MPFI *ptr_self;\n  r_mpfi_get_struct(ptr_self, self);" "R_MPFI *ptr_self")
+  ("se.2" "  R_MPFI *ptr_self, *ptr_other;\n  r_mpfi_get_struct(ptr_self, self);\n  r_mpfi_get_struct(ptr_other, other);" "R_MPFI *ptr_self, *ptr_other")
+  ("se.3" "  R_MPFI *ptr_self, *ptr_ret;\n  r_mpfi_get_struct(ptr_self, self);\n  VALUE val_ret;\n  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(${1:max}, ${2:min}, argc, argv));\n$0  return val_ret;"
+   "R_MPFI *ptr_self, *ptr_ret; VALUE val_ret;")
+  ("ar" "  R_MPFI *ptr_a0, *ptr_ret;\n  r_mpfi_get_convert_struct(ptr_a0, argv[0]);\n  VALUE val_ret;\n  r_mpfi_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument(${1:max}, ${2:min}, argc, argv));\n$0  return val_ret;" "R_MPFI *ptr_a, *ptr_ret; VALUE val_ret;")
+  ("co" "r_mpfi_get_convert_struct(ptr_a$1, argv[$1]);$0" "convert_struct argv[i]")
+  ("re" "  VALUE val_ret;\n  R_MPFI *ptr_ret;\n  r_mpfi_make_struct_init2(val_ret, ptr_ret, $0);" "VALUE val_ret")
+  ("op" "r_mpfr_prec_from_optional_argument(${1:min}, ${2:max}, argc, argv)$0" "precision from optional arguments")
+  ))
+
+   ("fu.2" "static VALUE r_mpfi_$1 (VALUE self, VALUE *args){\n  $0\n  return ;\n}"
+    "static VALUE r_mpfi_... (VALUE self, VALUE *args){")
+
+
+(yas/define-snippets
+ 'c-mode
+ '(("func" "static VALUE r_mpfi_$1 (VALUE self){
+  R_MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  R_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_$1(ptr_ret, ptr_self));
+  return val_ret;
+}" "function with MPFR returned value and no argument")))
+
+(yas/define-snippets
+ 'c-mode
+ '(("func.2" "static VALUE r_mpfi_$1 (int argc, VALUE *argv, VALUE self){
+  R_MPFI *ptr_self;
+  r_mpfi_get_struct(ptr_self, self);
+  VALUE val_ret;
+  R_MPFR *ptr_ret;
+  r_mpfr_make_struct_init2(val_ret, ptr_ret, r_mpfr_prec_from_optional_argument($2, $3, argc, argv));
+  r_mpfi_set_function_state(mpfi_$1(ptr_ret, ptr_self));
+  return val_ret;
+}" "function with MPFR returned value and some arguments")))
+

data/ext/mpfi_complex/mpfi/extconf.rb

@@ -0,0 +1,10 @@
+require 'mkmf'
+
+$CFLAGS += " -Wall"
+
+dir_config("mpfr")
+dir_config("mpfi")
+dir_config("gmp")
+if have_header('mpfr.h') && have_library('mpfr') && have_header('gmp.h') && have_library('gmp')
+  create_makefile("mpfi/complex")
+end

data/ext/mpfi_complex/mpfi/func_mpfi_extention.h

@@ -0,0 +1,2 @@
+void mpfi_mid_interval(mpfi_t ret, mpfi_t x);
+int mpfi_subdivision(int num, mpfi_t *ret, mpfi_t x);

data/ext/mpfi_complex/mpfi/func_ruby_mpfi_complex.c

@@ -0,0 +1,130 @@
+#include "func_ruby_mpfi_complex.h"
+
+void mpfi_complex_init(MPFIComplex *x){
+  x->re = ALLOC_N(MPFI, 1);
+  x->im = ALLOC_N(MPFI, 1);
+  mpfi_init(x->re);
+  mpfi_init(x->im);
+}
+
+void mpfi_complex_clear(MPFIComplex *x){
+  mpfi_clear(x->re);
+  mpfi_clear(x->im);
+  free(x->re);
+  free(x->im);
+}
+
+void mpfi_complex_set_zeros(MPFIComplex *x){
+  mpfi_set_si(x->re, 0);
+  mpfi_set_si(x->im, 0);
+}
+
+void mpfi_complex_set_real_part(MPFIComplex *x, MPFI *a){
+  mpfi_set(x->re, a);
+}
+
+void mpfi_complex_set_imaginary_part(MPFIComplex *x, MPFI *a){
+  mpfi_set(x->im, a);
+}
+
+void mpfi_complex_set(MPFIComplex *new, MPFIComplex *x){
+  mpfi_set(new->re, x->re);
+  mpfi_set(new->im, x->im);
+}
+
+void mpfi_complex_conjugate(MPFIComplex *new, MPFIComplex *x){
+  mpfi_set(new->re, x->re);
+  mpfi_neg(new->im, x->im);
+}
+
+void mpfi_complex_add(MPFIComplex *new, MPFIComplex *x, MPFIComplex *y){
+  mpfi_add(new->re, x->re, y->re);
+  mpfi_add(new->im, x->im, y->im);
+}
+
+void mpfi_complex_sub(MPFIComplex *new, MPFIComplex *x, MPFIComplex *y){
+  mpfi_sub(new->re, x->re, y->re);
+  mpfi_sub(new->im, x->im, y->im);
+}
+
+void mpfi_complex_mul(MPFIComplex *new, MPFIComplex *x, MPFIComplex *y){
+  MPFI *t1, *t2, *t_re;
+  r_mpfi_temp_alloc_init2(t1, mpfi_complex_get_prec(new));
+  r_mpfi_temp_alloc_init2(t2, mpfi_complex_get_prec(new));
+  r_mpfi_temp_alloc_init2(t_re, mpfi_complex_get_prec(new));
+
+  mpfi_mul(t1, x->re, y->re);
+  mpfi_mul(t2, x->im, y->im);
+  mpfi_sub(t_re, t1, t2);
+
+  mpfi_mul(t1, x->re, y->im);
+  mpfi_mul(t2, x->im, y->re);
+  mpfi_add(new->im, t1, t2);
+
+  mpfi_set(new->re, t_re);
+
+  r_mpfi_temp_free(t1);
+  r_mpfi_temp_free(t2);
+  r_mpfi_temp_free(t_re);
+}
+
+void mpfi_complex_div(MPFIComplex *new, MPFIComplex *x, MPFIComplex *y){
+  MPFI *t1, *t2, *t_re, *deno;
+  r_mpfi_temp_alloc_init2(t1, mpfi_complex_get_prec(new));
+  r_mpfi_temp_alloc_init2(t2, mpfi_complex_get_prec(new));
+  r_mpfi_temp_alloc_init2(t_re, mpfi_complex_get_prec(new));
+  r_mpfi_temp_alloc_init2(deno, mpfi_complex_get_prec(new));
+
+  mpfi_mul(t2, y->re, y->re);
+  mpfi_mul(t1, y->im, y->im);
+  mpfi_add(deno, t2, t1);
+
+  mpfi_mul(t2, x->re, y->re);
+  mpfi_mul(t1, x->im, y->im);
+  mpfi_add(t2, t2, t1);
+  mpfi_div(t_re, t2, deno);
+
+  mpfi_mul(t2, x->im, y->re);
+  mpfi_mul(t1, x->re, y->im);
+  mpfi_sub(t2, t2, t1);
+  mpfi_div(new->im, t2, deno);
+
+  mpfi_set(new->re, t_re);
+
+  r_mpfi_temp_free(t1);
+  r_mpfi_temp_free(t2);
+  r_mpfi_temp_free(t_re);
+  r_mpfi_temp_free(deno);
+}
+
+/* void mpfi_complex_mul_real(MPFIComplex *new, MPFIComplex *x, MPFI *y){ */
+/*   mpfi_mul(new->re, x->re, y); */
+/*   mpfi_mul(new->im, x->im, y); */
+/* } */
+
+/* void mpfi_complex_mul_pure_imaginary(MPFIComplex *new, MPFIComplex *x, MPFI *y){ */
+/*   mpfi_mul(new->re, x->im, y); */
+/*   mpfi_neg(new->re, new->re); */
+/*   mpfi_mul(new->im, x->re, y); */
+/* } */
+
+/* void mpfi_complex_div_real(MPFIComplex *new, MPFIComplex *x, MPFI *y){ */
+/*   mpfi_div(new->re, x->re, y); */
+/*   mpfi_div(new->im, x->im, y); */
+/* } */
+
+/* void mpfi_complex_div_pure_imaginary(MPFIComplex *new, MPFIComplex *x, MPFI *y){ */
+/*   mpfi_div(new->re, x->im, y); */
+/*   mpfi_div(new->im, x->re, y); */
+/*   mpfi_neg(new->im, new->im); */
+/* } */
+
+/* void mpfi_complex_abs(MPFI *new, MPFIComplex *x){ */
+/*   MPFI *tmp; */
+/*   r_mpfi_temp_alloc_init(tmp); */
+/*   mpfi_mul(tmp, x->re, x->re); */
+/*   mpfi_mul(new, x->im, x->im); */
+/*   mpfi_add(new, new, tmp); */
+/*   mpfi_sqrt(new, new); */
+/*   r_mpfi_temp_free(tmp); */
+/* } */

data/ext/mpfi_complex/mpfi/func_ruby_mpfi_complex.h

@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <ruby.h>
+#include <mpfr.h>
+#include <mpfi.h>
+#include <mpfi_io.h>
+#include "ruby_mpfi.h"
+
+VALUE r_mpfi_complex;
+
+typedef struct __MPFIComplex{
+  MPFI *re;
+  MPFI *im;
+} MPFIComplex;
+
+/* Although x->re and x->im can have different precision from each other for MPFIComplex x, */
+/* we implement mpfi_complex_get_prec assuming that they have same presition. */
+#define mpfi_complex_get_prec(x) mpfi_get_prec(x->re)
+
+void mpfi_complex_init(MPFIComplex *x);
+void mpfi_complex_clear(MPFIComplex *x);
+void mpfi_complex_set_zeros(MPFIComplex *x);
+void mpfi_complex_set_real_part(MPFIComplex *x, MPFI *a);
+void mpfi_complex_set_imaginary_part(MPFIComplex *x, MPFI *a);
+void mpfi_complex_set(MPFIComplex *new, MPFIComplex *x);
+void mpfi_complex_conjugate(MPFIComplex *new, MPFIComplex *x);
+void mpfi_complex_add(MPFIComplex *new, MPFIComplex *x, MPFIComplex *y);
+void mpfi_complex_sub(MPFIComplex *new, MPFIComplex *x, MPFIComplex *y);
+void mpfi_complex_mul(MPFIComplex *new, MPFIComplex *x, MPFIComplex *y);
+void mpfi_complex_div(MPFIComplex *new, MPFIComplex *x, MPFIComplex *y);
+
+/* void mpfi_complex_mul_real(MPFIComplex *new, MPFIComplex *x, MPFI *y); */
+/* void mpfi_complex_mul_pure_imaginary(MPFIComplex *new, MPFIComplex *x, MPFI *y); */
+/* void mpfi_complex_div_real(MPFIComplex *new, MPFIComplex *x, MPFI *y); */
+/* void mpfi_complex_div_pure_imaginary(MPFIComplex *new, MPFIComplex *x, MPFI *y); */
+/* void mpfi_complex_abs(MPFI *new, MPFIComplex *x); */

data/ext/mpfi_complex/mpfi/ruby_mpfi.h

@@ -0,0 +1,39 @@
+#ifndef _RUBY_MPFI_H_
+#define _RUBY_MPFI_H_
+
+#include <stdio.h>
+#include <ruby.h>
+#include <mpfr.h>
+#include <mpfi.h>
+#include <mpfi_io.h>
+#include "func_mpfi_extention.h"
+#include "ruby_mpfr.h"
+
+typedef __mpfi_struct MPFI;
+
+VALUE r_mpfi_class, r_mpfi_math;;
+
+#define r_mpfi_make_struct(ruby_var, c_var) { ruby_var = Data_Make_Struct(r_mpfi_class, MPFI, 0, r_mpfi_free, c_var); }
+#define r_mpfi_make_struct_init(ruby_var, c_var) { r_mpfi_make_struct(ruby_var, c_var); mpfi_init(c_var); }
+#define r_mpfi_make_struct_init2(ruby_var, c_var, prec) { r_mpfi_make_struct(ruby_var, c_var); mpfi_init2(c_var, prec); }
+#define r_mpfi_get_struct(c_var, ruby_var) { Data_Get_Struct(ruby_var, MPFI, c_var); }
+
+#define r_mpfi_temp_alloc(c_var) { c_var=ALLOC_N(MPFI, 1); }
+#define r_mpfi_temp_alloc_init(c_var) { r_mpfi_temp_alloc(c_var); mpfi_init(c_var); }
+#define r_mpfi_temp_alloc_init2(c_var, prec) { r_mpfi_temp_alloc(c_var); mpfi_init2(c_var, prec); }
+#define r_mpfi_temp_free(c_var) { mpfi_clear(c_var); free(c_var); }
+
+#define r_mpfi_left_ptr(c_var) (&((c_var)->left))
+#define r_mpfi_right_ptr(c_var) (&((c_var)->right))
+
+void r_mpfi_free(void *ptr);
+VALUE r_mpfi_make_new_fi_obj(MPFI *ptr);
+VALUE r_mpfi_new_fi_obj(VALUE obj);
+void r_mpfi_set_robj(MPFI *ptr, VALUE obj);
+
+int r_mpfi_subdivision2(int num, MPFI *ret, mpfi_t x);
+
+void r_mpfi_set_function_state(int num);
+VALUE r_mpfr_get_function_state(VALUE self);
+
+#endif /* _RUBY_MPFI_H_ */

data/ext/mpfi_complex/mpfi/ruby_mpfi_complex.c

@@ -0,0 +1,217 @@
+#include "ruby_mpfi_complex.h"
+
+static ID object_id;
+
+void r_mpfi_complex_free(void *ptr){
+  mpfi_complex_clear(ptr);
+  free(ptr);
+}
+
+/* Allocation function for MPF::Complex. */
+static VALUE r_mpfi_complex_alloc (VALUE self){
+  MPFIComplex *ptr;
+  r_mpfi_make_complex_struct(self, ptr);
+  return self;
+}
+
+/* Initialization function for MPF::Complex. */
+static VALUE r_mpfi_complex_initialize (int argc, VALUE *argv, VALUE self){
+  MPFIComplex *ptr;
+  r_mpfi_get_complex_struct(ptr, self);
+  mpfi_complex_init(ptr);
+  switch (argc) {
+  case 0:
+    mpfi_complex_set_zeros(ptr);    
+    break;
+  case 1:
+    r_mpfi_set_robj(ptr->re, argv[0]);
+    mpfi_set_si(ptr->im, 0);
+    break;
+  case 2:
+    r_mpfi_set_robj(ptr->re, argv[0]);
+    r_mpfi_set_robj(ptr->im, argv[1]);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Number of MPF::Complex.new arguments must be lesser than three.");
+    break;
+  }
+  return Qtrue;
+}
+
+/* initialize_copy */
+static VALUE r_mpfi_complex_initialize_copy (VALUE self, VALUE other){
+  MPFIComplex *ptr_self, *ptr_other;
+  r_mpfi_get_complex_struct(ptr_self, self);
+  r_mpfi_get_complex_struct(ptr_other, other);
+  mpfi_complex_init(ptr_self);
+  mpfi_complex_set(ptr_self, ptr_other);
+  return Qtrue;
+}
+
+
+static VALUE r_mpfi_complex_real (VALUE self){
+  MPFIComplex *ptr_self;
+  r_mpfi_get_complex_struct(ptr_self, self);
+  VALUE ret;
+  MPFI *ptr_ret;
+  r_mpfi_make_struct_init(ret, ptr_ret);
+  mpfi_set(ptr_ret, ptr_self->re);
+  return ret;
+}
+
+static VALUE r_mpfi_complex_imaginary (VALUE self){
+  MPFIComplex *ptr_self;
+  r_mpfi_get_complex_struct(ptr_self, self);
+  VALUE ret;
+  MPFI *ptr_ret;
+  r_mpfi_make_struct_init(ret, ptr_ret);
+  mpfi_set(ptr_ret, ptr_self->im);
+  return ret;
+}
+
+static VALUE r_mpfi_complex_element (VALUE self, VALUE arg){
+  MPFIComplex *ptr_self;
+  r_mpfi_get_complex_struct(ptr_self, self);
+  VALUE ret;
+  MPFI *ptr_ret;
+  r_mpfi_make_struct_init(ret, ptr_ret);
+  switch(NUM2INT(arg)){
+  case 0:
+    mpfi_set(ptr_ret, ptr_self->re);
+    break;
+  case 1:
+    mpfi_set(ptr_ret, ptr_self->im);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Argument must be 0 or 1.");
+    break;
+  }
+  return ret;
+}
+
+static VALUE r_mpfi_complex_conjugate (VALUE self){
+  MPFIComplex *ptr_self, *ptr_ret;
+  r_mpfi_get_complex_struct(ptr_self, self);
+  VALUE ret;
+  r_mpfi_make_complex_struct_init(ret, ptr_ret);
+  mpfi_complex_conjugate(ptr_ret, ptr_self);
+  return ret;
+}
+
+/* static VALUE r_mpfi_complex_abs (VALUE self){ */
+/*   MPFIComplex *ptr_self; */
+/*   r_mpfi_get_complex_struct(ptr_self, self); */
+/*   VALUE ret; */
+/*   MPFI *ptr_ret; */
+/*   r_mpfi_make_struct_init(ret, ptr_ret); */
+/*   mpfi_complex_abs(ptr_ret, ptr_self); */
+/*   return ret; */
+/* } */
+
+
+
+static VALUE r_mpfi_complex_inspect(VALUE self){
+  MPFIComplex *ptr_s;
+  r_mpfi_get_complex_struct(ptr_s, self);
+  char *ret_str;
+  mpfr_asprintf(&ret_str, "#<MPFI:%lx,['%.Re %.Re', '%.Re %.Re'], [%d, %d]>",
+		NUM2LONG(rb_funcall(self, object_id, 0)), r_mpfi_left_ptr(ptr_s->re), r_mpfi_right_ptr(ptr_s->re), r_mpfi_left_ptr(ptr_s->im), r_mpfi_right_ptr(ptr_s->im),
+		mpfi_get_prec(ptr_s->re), mpfi_get_prec(ptr_s->im));
+  VALUE ret_val = rb_str_new2(ret_str);
+  mpfr_free_str(ret_str);
+  return ret_val;
+}
+
+/* Return array which has strings converted elements to. */
+static VALUE r_mpfi_complex_str_ary(VALUE self, VALUE format_str){
+  MPFIComplex *ptr_self;
+  r_mpfi_get_complex_struct(ptr_self, self);
+  char *format = StringValuePtr(format_str), *tmp_str;
+  VALUE ret_val[2];
+  gmp_asprintf(&tmp_str, format, ptr_self->re);
+  ret_val[0] = rb_str_new2(tmp_str);
+  free(tmp_str);
+  gmp_asprintf(&tmp_str, format, ptr_self->im);
+  ret_val[1] = rb_str_new2(tmp_str);
+  free(tmp_str);
+  return rb_ary_new4(2, ret_val);
+}
+
+
+
+static VALUE r_mpfi_complex_add (VALUE self, VALUE other){
+  MPFIComplex *ptr_self, *ptr_other, *ptr_ret;
+  r_mpfi_get_complex_struct(ptr_self, self);
+  r_mpfi_get_complex_struct(ptr_other, other);
+  VALUE ret;
+  r_mpfi_make_complex_struct_init(ret, ptr_ret);
+  mpfi_complex_add(ptr_ret, ptr_self, ptr_other);
+  return ret;
+}
+
+static VALUE r_mpfi_complex_sub (VALUE self, VALUE other){
+  MPFIComplex *ptr_self, *ptr_other, *ptr_ret;
+  r_mpfi_get_complex_struct(ptr_self, self);
+  r_mpfi_get_complex_struct(ptr_other, other);
+  VALUE ret;
+  r_mpfi_make_complex_struct_init(ret, ptr_ret);
+  mpfi_complex_sub(ptr_ret, ptr_self, ptr_other);
+  return ret;
+}
+
+static VALUE r_mpfi_complex_mul (VALUE self, VALUE other){
+  MPFIComplex *ptr_self, *ptr_other, *ptr_ret;
+  r_mpfi_get_complex_struct(ptr_self, self);
+  r_mpfi_get_complex_struct(ptr_other, other);
+  VALUE ret;
+  r_mpfi_make_complex_struct_init(ret, ptr_ret);
+  mpfi_complex_mul(ptr_ret, ptr_self, ptr_other);
+  return ret;
+}
+
+static VALUE r_mpfi_complex_div (VALUE self, VALUE other){
+  MPFIComplex *ptr_self, *ptr_other, *ptr_ret;
+  r_mpfi_get_complex_struct(ptr_self, self);
+  r_mpfi_get_complex_struct(ptr_other, other);
+  VALUE ret;
+  r_mpfi_make_complex_struct_init(ret, ptr_ret);
+  mpfi_complex_div(ptr_ret, ptr_self, ptr_other);
+  return ret;
+}
+
+
+
+
+void Init_complex(){
+  r_mpfi_complex = rb_define_class_under(rb_define_class("MPFI", rb_cNumeric), "Complex", rb_cObject);
+
+  rb_define_alloc_func(r_mpfi_complex, r_mpfi_complex_alloc);
+  rb_define_private_method(r_mpfi_complex, "initialize", r_mpfi_complex_initialize, -1);
+  rb_define_private_method(r_mpfi_complex, "initialize_copy", r_mpfi_complex_initialize_copy, 1);
+
+
+  rb_define_method(r_mpfi_complex, "real", r_mpfi_complex_real, 0);
+  rb_define_method(r_mpfi_complex, "imaginary", r_mpfi_complex_imaginary, 0);
+  rb_define_method(r_mpfi_complex, "element", r_mpfi_complex_element, 1);
+  rb_define_method(r_mpfi_complex, "conjugate", r_mpfi_complex_conjugate, 0);
+  rb_define_alias(r_mpfi_complex, "[]", "element");
+
+
+  rb_define_method(r_mpfi_complex, "inspect", r_mpfi_complex_inspect, 0);
+  rb_define_method(r_mpfi_complex, "str_ary", r_mpfi_complex_str_ary, 1);
+
+
+  rb_define_method(r_mpfi_complex, "add", r_mpfi_complex_add, 1);
+  rb_define_method(r_mpfi_complex, "sub", r_mpfi_complex_sub, 1);
+  rb_define_method(r_mpfi_complex, "mul", r_mpfi_complex_mul, 1);
+  rb_define_method(r_mpfi_complex, "div", r_mpfi_complex_div, 1);
+
+  rb_define_alias(r_mpfi_complex, "+", "add");
+  rb_define_alias(r_mpfi_complex, "-", "sub");
+  rb_define_alias(r_mpfi_complex, "*", "mul");
+  rb_define_alias(r_mpfi_complex, "/", "div");
+
+  object_id = rb_intern("object_id");
+    
+}
+

data/ext/mpfi_complex/mpfi/ruby_mpfi_complex.h

@@ -0,0 +1,15 @@
+#ifndef __RUBY_MPFI_COMPLEX__
+#define __RUBY_MPFI_COMPLEX__
+
+#include "func_ruby_mpfi_complex.h"
+
+#define r_mpfi_make_complex_struct(ruby_var, mpfi_complex_var) { ruby_var = Data_Make_Struct(r_mpfi_complex, MPFIComplex, 0, r_mpfi_complex_free, mpfi_complex_var); }
+#define r_mpfi_make_complex_struct_init(ruby_var, mpfi_complex_var) { ruby_var = Data_Make_Struct(r_mpfi_complex, MPFIComplex, 0, r_mpfi_complex_free, mpfi_complex_var); mpfi_complex_init(mpfi_complex_var);}
+#define r_mpfi_get_complex_struct(mpfi_complex_var, ruby_var) { Data_Get_Struct(ruby_var, MPFIComplex, mpfi_complex_var); }
+
+#define r_mpfi_complex_temp_alloc_init(mpfi_complex_var) { mpfi_complex_var = ALLOC_N(MPFIComplex, 1); mpfi_complex_init(mpfi_complex_var); }
+#define r_mpfi_complex_temp_free(mpfi_complex_var) { mpfi_complex_clear(mpfi_complex_var); free(mpfi_complex_var); }
+
+void r_mpfi_complex_free(void *ptr);
+
+#endif

data/ext/mpfi_complex/mpfi/ruby_mpfr.h

@@ -0,0 +1,38 @@
+#ifndef _RUBY_MPFR_H_
+#define _RUBY_MPFR_H_
+
+#include <ruby.h>
+#include <mpfr.h>
+#include <stdio.h>
+
+typedef __mpfr_struct MPFR;
+
+VALUE r_mpfr_class, r_mpfr_math;
+
+#define r_mpfr_make_struct(ruby_var, c_var) { ruby_var = Data_Make_Struct(r_mpfr_class, MPFR, 0, r_mpfr_free, c_var); }
+#define r_mpfr_make_struct_init(ruby_var, c_var) { r_mpfr_make_struct(ruby_var, c_var); mpfr_init(c_var); }
+#define r_mpfr_make_struct_init2(ruby_var, c_var, prec) { r_mpfr_make_struct(ruby_var, c_var); mpfr_init2(c_var, prec); }
+#define r_mpfr_get_struct(c_var, ruby_var) { Data_Get_Struct(ruby_var, MPFR, c_var); }
+
+#define r_mpfr_temp_alloc(var) { var=ALLOC_N(MPFR, 1); }
+#define r_mpfr_temp_alloc_init(var) { r_mpfr_temp_alloc(var); mpfr_init(var); }
+#define r_mpfr_temp_alloc_init2(var, prec) { r_mpfr_temp_alloc(var); mpfr_init2(var, prec); }
+#define r_mpfr_temp_free(var) { mpfr_clear(var); free(var); }
+
+#define r_mpfr_check_number(c_val) { if(mpfr_number_p(c_val) == 0) rb_raise(rb_eArgError, "Not an ordinary number."); }
+#define r_mpfr_check_positive_number(c_val) { if(mpfr_number_p(c_val) == 0 && mpfr_sgn(c_val) <= 0) rb_raise(rb_eArgError, "Not a positive number."); }
+#define r_mpfr_check_non_negative_number(c_val) { if(mpfr_number_p(c_val) == 0 && mpfr_sgn(c_val) < 0) rb_raise(rb_eArgError, "Not a non negative number."); }
+#define r_mpfr_check_negative_number(c_val) { if(mpfr_number_p(c_val) == 0 && mpfr_sgn(c_val) >= 0) rb_raise(rb_eArgError, "Not a negative number."); }
+#define r_mpfr_check_non_positive_number(c_val) { if(mpfr_number_p(c_val) == 0 && mpfr_sgn(c_val) > 0) rb_raise(rb_eArgError, "Not a non positive number."); }
+
+void r_mpfr_free(void *ptr);
+VALUE r_mpfr_new_fr_obj(VALUE obj);
+void r_mpfr_set_robj(MPFR *ptr, VALUE obj, mp_rnd_t rnd);
+
+mp_rnd_t r_mpfr_rnd_from_value(VALUE rnd);
+mp_rnd_t r_mpfr_rnd_from_optional_argument(int min, int max, int argc, VALUE *argv);
+mp_rnd_t r_mpfr_prec_from_optional_argument(int min, int max, int argc, VALUE *argv);
+void r_mpfr_get_rnd_prec_from_optional_arguments(mp_rnd_t *rnd, mp_prec_t *prec, int min, int max, int argc, VALUE *argv);
+
+#endif /* _RUBY_MPFR_H_ */
+

data/ext/mpfi_matrix/mpfi/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+dir_config('mpfr')
+dir_config('mpfi')
+dir_config('gmp')
+
+if have_header('mpfr.h') && have_library('mpfr') && have_header('mpfi.h') && have_library('mpfi') && have_header('gmp.h') && have_library('gmp')
+  create_makefile("mpfi/matrix")
+end

data/ext/mpfi_matrix/mpfi/func_mpfi_extention.h

@@ -0,0 +1,2 @@
+void mpfi_mid_interval(mpfi_t ret, mpfi_t x);
+int mpfi_subdivision(int num, mpfi_t *ret, mpfi_t x);