ruby-mpfi 0.0.9 → 0.0.10

data/ext/mpfi_matrix/mpfi/func_mpfi_matrix.h

@@ -43,55 +43,54 @@ typedef struct __MPFIMatrix{
 /* (for example, mpfi_matrix_transpose), */
 /* you must use differnt pointer for returned value from that of an argument. */
 
-void mpfi_matrix_clear(MPFIMatrix *mat);
-void mpfi_matrix_init(MPFIMatrix *mat, int row, int column);
-void mpfi_matrix_set_zeros(MPFIMatrix *mat);
-void mpfi_matrix_set_element(MPFIMatrix *mat, int row, int col, MPFI *a);
-void mpfi_matrix_set(MPFIMatrix *new, MPFIMatrix *x);
-void mpfi_matrix_swap(MPFIMatrix *x, MPFIMatrix *y);
-
-void mpfi_matrix_row(MPFIMatrix *new, MPFIMatrix *x, int row);
-void mpfi_matrix_column(MPFIMatrix *new, MPFIMatrix *x, int column);
-void mpfi_matrix_transpose(MPFIMatrix *new, MPFIMatrix *x);
-void mpfi_matrix_neg(MPFIMatrix *new, MPFIMatrix *x);
-
-int mpfi_matrix_equal_p(MPFIMatrix *x, MPFIMatrix *y);
-void mpfi_matrix_add(MPFIMatrix *new, MPFIMatrix *x, MPFIMatrix *y);
-void mpfi_matrix_add_fr(MPFIMatrix *new, MPFIMatrix *x, MPFRMatrix *y);
-void mpfi_matrix_sub(MPFIMatrix *new, MPFIMatrix *x, MPFIMatrix *y);
-void mpfi_matrix_sub_fr(MPFIMatrix *new, MPFIMatrix *x, MPFRMatrix *y);
-void mpfi_matrix_mul(MPFIMatrix *new, MPFIMatrix *x, MPFIMatrix *y);
-void mpfi_matrix_mul_fr(MPFIMatrix *new, MPFIMatrix *x, MPFRMatrix *y);
-void mpfi_matrix_mul_scalar(MPFIMatrix *new, MPFIMatrix *x, MPFI *scalar);
-void mpfi_matrix_div_scalar(MPFIMatrix *new, MPFIMatrix *x, MPFI *scalar);
-
-int mpfi_matrix_include_p(MPFIMatrix *x, MPFIMatrix *y);
-int mpfi_matrix_include_fr_p(MPFIMatrix *x, MPFRMatrix *y);
-int mpfi_matrix_strictly_include_p(MPFIMatrix *x, MPFIMatrix *y);
-int mpfi_matrix_bounded_p(MPFIMatrix *x);
-void mpfi_matrix_mid(MPFRMatrix *ret, MPFIMatrix *x);
-void mpfi_matrix_mid_interval(MPFIMatrix *ret, MPFIMatrix *x);
-void mpfi_matrix_from_mpfr_matrix(MPFIMatrix *ret, MPFRMatrix *x);
-int mpfi_matrix_intersect(MPFIMatrix *ret, MPFIMatrix *x, MPFIMatrix *y);
-int mpfi_matrix_union(MPFIMatrix *z, MPFIMatrix *x, MPFIMatrix *y);
-
-void mpfi_matrix_inner_product(MPFI *pr, MPFIMatrix *x, MPFIMatrix *y);
-void mpfi_matrix_vector_distance(MPFI *distance, MPFIMatrix *x, MPFIMatrix *y);
-void mpfi_matrix_vector_distance_center_pts(MPFR *distance, MPFIMatrix *x, MPFIMatrix *y);
-void mpfi_matrix_vector_norm(MPFI *norm, MPFIMatrix *x);
-void mpfi_matrix_max_norm(MPFI *norm, MPFIMatrix *x);
-void mpfi_matrix_max_diam_abs(MPFR *diam, MPFIMatrix *x);
+void mpfi_matrix_clear (MPFIMatrix *mat);
+void mpfi_matrix_init (MPFIMatrix *mat, int row, int column);
+void mpfi_matrix_set_zeros (MPFIMatrix *mat);
+void mpfi_matrix_set_element (MPFIMatrix *mat, int row, int col, MPFI *a);
+void mpfi_matrix_set (MPFIMatrix *new, MPFIMatrix *x);
+void mpfi_matrix_swap (MPFIMatrix *x, MPFIMatrix *y);
+
+void mpfi_matrix_row (MPFIMatrix *new, MPFIMatrix *x, int row);
+void mpfi_matrix_column (MPFIMatrix *new, MPFIMatrix *x, int column);
+void mpfi_matrix_transpose (MPFIMatrix *new, MPFIMatrix *x);
+void mpfi_matrix_neg (MPFIMatrix *new, MPFIMatrix *x);
+
+int mpfi_matrix_equal_p (MPFIMatrix *x, MPFIMatrix *y);
+void mpfi_matrix_add (MPFIMatrix *new, MPFIMatrix *x, MPFIMatrix *y);
+void mpfi_matrix_add_fr (MPFIMatrix *new, MPFIMatrix *x, MPFRMatrix *y);
+void mpfi_matrix_sub (MPFIMatrix *new, MPFIMatrix *x, MPFIMatrix *y);
+void mpfi_matrix_sub_fr (MPFIMatrix *new, MPFIMatrix *x, MPFRMatrix *y);
+void mpfi_matrix_mul (MPFIMatrix *new, MPFIMatrix *x, MPFIMatrix *y);
+void mpfi_matrix_mul_fr (MPFIMatrix *new, MPFIMatrix *x, MPFRMatrix *y);
+void mpfi_matrix_mul_scalar (MPFIMatrix *new, MPFIMatrix *x, MPFI *scalar);
+void mpfi_matrix_div_scalar (MPFIMatrix *new, MPFIMatrix *x, MPFI *scalar);
+
+int mpfi_matrix_include_p (MPFIMatrix *x, MPFIMatrix *y);
+int mpfi_matrix_include_fr_p (MPFIMatrix *x, MPFRMatrix *y);
+int mpfi_matrix_strictly_include_p (MPFIMatrix *x, MPFIMatrix *y);
+int mpfi_matrix_bounded_p (MPFIMatrix *x);
+void mpfi_matrix_mid (MPFRMatrix *ret, MPFIMatrix *x);
+void mpfi_matrix_mid_interval (MPFIMatrix *ret, MPFIMatrix *x);
+void mpfi_matrix_from_mpfr_matrix (MPFIMatrix *ret, MPFRMatrix *x);
+int mpfi_matrix_intersect (MPFIMatrix *ret, MPFIMatrix *x, MPFIMatrix *y);
+int mpfi_matrix_union (MPFIMatrix *z, MPFIMatrix *x, MPFIMatrix *y);
+
+void mpfi_matrix_inner_product (MPFI *pr, MPFIMatrix *x, MPFIMatrix *y);
+void mpfi_matrix_vector_distance (MPFI *distance, MPFIMatrix *x, MPFIMatrix *y);
+void mpfi_matrix_vector_distance_center_pts (MPFR *distance, MPFIMatrix *x, MPFIMatrix *y);
+void mpfi_matrix_vector_norm (MPFI *norm, MPFIMatrix *x);
+void mpfi_matrix_max_norm (MPFI *norm, MPFIMatrix *x);
+void mpfi_matrix_max_diam_abs (MPFR *diam, MPFIMatrix *x);
 
 /* ----------------- vector ---------------- */
-void mpfi_col_vector_init(MPFIMatrix *mat, int row);
-void mpfi_row_vector_init(MPFIMatrix *mat, int column);
-int mpfi_vector_normalize(MPFIMatrix *new, MPFIMatrix *x);
-void mpfi_vector_midpoint(MPFIMatrix *new, MPFIMatrix *x, MPFIMatrix *y);
-int mpfi_vector_set_length(MPFIMatrix *new, MPFIMatrix *x, MPFR *l);
+void mpfi_col_vector_init (MPFIMatrix *mat, int row);
+void mpfi_row_vector_init (MPFIMatrix *mat, int column);
+int mpfi_vector_normalize (MPFIMatrix *new, MPFIMatrix *x);
+void mpfi_vector_midpoint (MPFIMatrix *new, MPFIMatrix *x, MPFIMatrix *y);
+int mpfi_vector_set_length (MPFIMatrix *new, MPFIMatrix *x, MPFR *l);
 
 /* ----------------- square matrix ----------------- */
 int mpfi_square_matrix_lu_decomp (MPFIMatrix *ret, int *indx, MPFIMatrix *x);
-void mpfi_square_matrix_determinant(MPFI *det, MPFIMatrix *x);
-void mpfi_square_matrix_qr_decomp(MPFIMatrix *q, MPFIMatrix *r, MPFIMatrix *x);
-void mpfi_square_matrix_identity(MPFIMatrix *id);
-
+void mpfi_square_matrix_determinant (MPFI *det, MPFIMatrix *x);
+void mpfi_square_matrix_qr_decomp (MPFIMatrix *q, MPFIMatrix *r, MPFIMatrix *x);
+void mpfi_square_matrix_identity (MPFIMatrix *id);

data/ext/mpfi_matrix/mpfi/ruby_mpfi_matrix.c

@@ -3,29 +3,29 @@
 static ID eqq;
 static VALUE __mpfr_matrix_class__, __mpfi_matrix_class__;
 
-void r_mpfi_matrix_free(void *ptr){
+void r_mpfi_matrix_free (void *ptr) {
   mpfi_matrix_clear(ptr);
   free(ptr);
 }
 
-void r_mpfi_matrix_suitable_matrix_init (VALUE *other, MPFIMatrix **ptr_other, int row, int column){
-  if(column == 1){
+void r_mpfi_matrix_suitable_matrix_init (VALUE *other, MPFIMatrix **ptr_other, int row, int column) {
+  if (column == 1) {
     r_mpfi_make_col_vector_struct(*other, *ptr_other);
     mpfi_col_vector_init(*ptr_other, row);
-  }else if (row == 1){
+  } else if (row == 1) {
     r_mpfi_make_row_vector_struct(*other, *ptr_other);
     mpfi_row_vector_init(*ptr_other, column);
-  }else{
-    if (row == column){
+  } else {
+    if (row == column) {
       r_mpfi_make_square_matrix_struct(*other, *ptr_other);
-    }else{  
+    } else {  
       r_mpfi_make_matrix_struct(*other, *ptr_other);
     }
     mpfi_matrix_init(*ptr_other, row, column);
   }
 }
 
-/* VALUE r_mpfi_matrix_copied_robj(VALUE old){ */
+/* VALUE r_mpfi_matrix_copied_robj (VALUE old) { */
 /*   MPFIMatrix *ptr_old, *ptr_ret; */
 /*   r_mpfi_get_matrix_struct(ptr_old, old); */
 /*   VALUE ret; */
@@ -34,7 +34,7 @@ void r_mpfi_matrix_suitable_matrix_init (VALUE *other, MPFIMatrix **ptr_other, i
 /*   return ret; */
 /* } */
 
-VALUE r_mpfi_matrix_robj(MPFIMatrix *x){
+VALUE r_mpfi_matrix_robj (MPFIMatrix *x) {
   VALUE ret;
   MPFIMatrix *ptr_ret;
   r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, x->row, x->column);
@@ -43,20 +43,20 @@ VALUE r_mpfi_matrix_robj(MPFIMatrix *x){
 }
 
 /* Allocation function for MPFI::Matrix. */
-static VALUE r_mpfi_matrix_alloc (VALUE self){
+static VALUE r_mpfi_matrix_alloc (VALUE self) {
   MPFIMatrix *ptr;
   r_mpfi_make_matrix_struct(self, ptr);
   return self;
 }
 
-/* static void r_mpfi_matrix_init_set_from_rmatrix(MPFIMatrix *x, VALUE src){ */
+/* static void r_mpfi_matrix_init_set_from_rmatrix (MPFIMatrix *x, VALUE src) { */
 /*   MPFIMatrix *ptr_src; */
 /*   r_mpfi_get_matrix_struct(ptr_src, src); */
 /*   mpfi_matrix_init(x, ptr_src->row, ptr_src->column); */
 /*   mpfi_matrix_set(x, ptr_src); */
 /* } */
 
-static void r_mpfi_matrix_set_initial_value(MPFIMatrix *ptr, int argc, VALUE *argv)
+static void r_mpfi_matrix_set_initial_value (MPFIMatrix *ptr, int argc, VALUE *argv)
 {
   int row, column, i, j;
   VALUE row_ary;
@@ -71,7 +71,8 @@ static void r_mpfi_matrix_set_initial_value(MPFIMatrix *ptr, int argc, VALUE *ar
 	rb_raise(rb_eArgError, "MPFI::Matrix.new needs Array which has arrays of same sizes.");
       }
       for (j = 0; j < column; j++) {
-	r_mpfi_set_robj(mpfi_matrix_get_element(ptr, i, j), rb_ary_entry(row_ary, j));
+        volatile VALUE el = rb_ary_entry(row_ary, j);
+	r_mpfi_set_robj(mpfi_matrix_get_element(ptr, i, j), el);
       }
     }
     break;
@@ -86,17 +87,17 @@ static void r_mpfi_matrix_set_initial_value(MPFIMatrix *ptr, int argc, VALUE *ar
 }
 
 /* Return new MPFI::Matrix instance. The same arguments as MPFI::Matrix.new is acceptable. */
-static VALUE r_mpfi_matrix_global_new(int argc, VALUE *argv, VALUE self)
+static VALUE r_mpfi_matrix_global_new (int argc, VALUE *argv, VALUE self)
 {
   MPFIMatrix *ptr;
   VALUE val;
-  r_mpfi_make_col_vector_struct(val, ptr);
+  r_mpfi_make_matrix_struct(val, ptr);
   r_mpfi_matrix_set_initial_value(ptr, argc, argv);
   return val;
 }
 
 /* Initialization function for MPFI::Matrix. */
-static VALUE r_mpfi_matrix_initialize (int argc, VALUE *argv, VALUE self){
+static VALUE r_mpfi_matrix_initialize (int argc, VALUE *argv, VALUE self) {
   MPFIMatrix *ptr;
   r_mpfi_get_matrix_struct(ptr, self);
   r_mpfi_matrix_set_initial_value(ptr, argc, argv);
@@ -104,21 +105,21 @@ static VALUE r_mpfi_matrix_initialize (int argc, VALUE *argv, VALUE self){
 }
 
 /* Allocation function for MPFI::SquareMatrix. */
-static VALUE r_mpfi_square_matrix_alloc (VALUE self){
+static VALUE r_mpfi_square_matrix_alloc (VALUE self) {
   MPFIMatrix *ptr;
   r_mpfi_make_square_matrix_struct(self, ptr);
   return self;
 }
 
-static void r_mpfi_square_matrix_set_initial_value(MPFIMatrix *ptr, VALUE arg)
+static void r_mpfi_square_matrix_set_initial_value (MPFIMatrix *ptr, VALUE arg)
 {
   int row, column, i, j;
   VALUE row_ary;
-  switch(TYPE(arg)){
+  switch (TYPE(arg)) {
   case T_ARRAY:
     row = RARRAY_LEN(arg);
     column = RARRAY_LEN(rb_ary_entry(arg, 0));
-    if(row == column){
+    if (row == column) {
       mpfi_matrix_init(ptr, row, column);
       for (i = 0; i < row; i++) {
 	row_ary = rb_ary_entry(arg, i);
@@ -129,7 +130,7 @@ static void r_mpfi_square_matrix_set_initial_value(MPFIMatrix *ptr, VALUE arg)
 	  r_mpfi_set_robj(mpfi_matrix_get_element(ptr, i, j), rb_ary_entry(row_ary, j));
 	}
       }
-    }else{
+    } else {
       rb_raise(rb_eArgError, "MPFI::SquareMatrix.new needs two dimensinal Array which has the same sizes of row and column.");
     }
     break;
@@ -145,7 +146,7 @@ static void r_mpfi_square_matrix_set_initial_value(MPFIMatrix *ptr, VALUE arg)
 }
 
 /* Return new MPFI::SquareMatrix instance. The same arguments as MPFI::SquareMatrix.new is acceptable. */
-static VALUE r_mpfi_square_matrix_global_new(int argc, VALUE arg)
+static VALUE r_mpfi_square_matrix_global_new (int argc, VALUE arg)
 {
   MPFIMatrix *ptr;
   VALUE val;
@@ -155,7 +156,7 @@ static VALUE r_mpfi_square_matrix_global_new(int argc, VALUE arg)
 }
 
 /* Initialization function for MPFI::SquareMatrix. */
-static VALUE r_mpfi_square_matrix_initialize (VALUE self, VALUE arg){
+static VALUE r_mpfi_square_matrix_initialize (VALUE self, VALUE arg) {
   MPFIMatrix *ptr;
   r_mpfi_get_matrix_struct(ptr, self);
   r_mpfi_square_matrix_set_initial_value(ptr, arg);
@@ -163,7 +164,7 @@ static VALUE r_mpfi_square_matrix_initialize (VALUE self, VALUE arg){
 }
 
 /* initialize_copy */
-static VALUE r_mpfi_matrix_initialize_copy (VALUE self, VALUE other){
+static VALUE r_mpfi_matrix_initialize_copy (VALUE self, VALUE other) {
   MPFIMatrix *ptr_self, *ptr_other;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_get_matrix_struct(ptr_other, other);
@@ -173,21 +174,22 @@ static VALUE r_mpfi_matrix_initialize_copy (VALUE self, VALUE other){
 }
 
 /* Allocation function for MPFI::ColumnVector. */
-static VALUE r_mpfi_col_vector_alloc (VALUE self){
+static VALUE r_mpfi_col_vector_alloc (VALUE self) {
   MPFIMatrix *ptr;
   r_mpfi_make_col_vector_struct(self, ptr);
   return self;
 }
 
-static void r_mpfi_col_vector_set_initial_value(MPFIMatrix *ptr, VALUE arg)
+static void r_mpfi_col_vector_set_initial_value (MPFIMatrix *ptr, VALUE arg)
 {
   int row, i;
-  switch(TYPE(arg)){
+  switch (TYPE(arg)) {
   case T_ARRAY:
     row = RARRAY_LEN(arg);
     mpfi_col_vector_init(ptr, row);
     for (i = 0; i < row; i++) {
-      r_mpfi_set_robj(mpfi_matrix_get_ptr(ptr, i), rb_ary_entry(arg, i));
+      volatile VALUE el = rb_ary_entry(arg, i);
+      r_mpfi_set_robj(mpfi_matrix_get_ptr(ptr, i), el);
     }
     break;
   case T_FIXNUM:
@@ -204,7 +206,7 @@ static void r_mpfi_col_vector_set_initial_value(MPFIMatrix *ptr, VALUE arg)
 }
 
 /* Return new MPFI::ColumnVector instance. The same arguments as MPFI::ColumnVector.new is acceptable. */
-static VALUE r_mpfi_col_vector_global_new(int argc, VALUE arg)
+static VALUE r_mpfi_col_vector_global_new (int argc, VALUE arg)
 {
   MPFIMatrix *ptr;
   VALUE val;
@@ -214,7 +216,7 @@ static VALUE r_mpfi_col_vector_global_new(int argc, VALUE arg)
 }
 
 /* Initialization function for MPFI::ColumnVector. */
-static VALUE r_mpfi_col_vector_initialize (VALUE self, VALUE arg){
+static VALUE r_mpfi_col_vector_initialize (VALUE self, VALUE arg) {
   MPFIMatrix *ptr;
   r_mpfi_get_matrix_struct(ptr, self);
   r_mpfi_col_vector_set_initial_value(ptr, arg);
@@ -222,21 +224,22 @@ static VALUE r_mpfi_col_vector_initialize (VALUE self, VALUE arg){
 }
 
 /* Allocation function for MPFI::RowVector. */
-static VALUE r_mpfi_row_vector_alloc (VALUE self){
+static VALUE r_mpfi_row_vector_alloc (VALUE self) {
   MPFIMatrix *ptr;
   r_mpfi_make_row_vector_struct(self, ptr);
   return self;
 }
 
-static void r_mpfi_row_vector_set_initial_value(MPFIMatrix *ptr, VALUE arg)
+static void r_mpfi_row_vector_set_initial_value (MPFIMatrix *ptr, VALUE arg)
 {
   int column, i;
-  switch(TYPE(arg)){
+  switch (TYPE(arg)) {
   case T_ARRAY:
     column = RARRAY_LEN(arg);
     mpfi_row_vector_init(ptr, column);
     for (i = 0; i < column; i++) {
-      r_mpfi_set_robj(mpfi_matrix_get_ptr(ptr, i), rb_ary_entry(arg, i));
+      volatile VALUE el = rb_ary_entry(arg, i);
+      r_mpfi_set_robj(mpfi_matrix_get_ptr(ptr, i), el);
     }
     break;
   case T_FIXNUM:
@@ -253,7 +256,7 @@ static void r_mpfi_row_vector_set_initial_value(MPFIMatrix *ptr, VALUE arg)
 }
 
 /* Return new MPFI::RowVector instance. The same arguments as MPFI::RowVector.new is acceptable. */
-static VALUE r_mpfi_row_vector_global_new(int argc, VALUE arg)
+static VALUE r_mpfi_row_vector_global_new (int argc, VALUE arg)
 {
   MPFIMatrix *ptr;
   VALUE val;
@@ -263,14 +266,14 @@ static VALUE r_mpfi_row_vector_global_new(int argc, VALUE arg)
 }
 
 /* Initialization function for MPFI::RowVector. */
-static VALUE r_mpfi_row_vector_initialize (VALUE self, VALUE arg){
+static VALUE r_mpfi_row_vector_initialize (VALUE self, VALUE arg) {
   MPFIMatrix *ptr;
   r_mpfi_get_matrix_struct(ptr, self);
   r_mpfi_row_vector_set_initial_value(ptr, arg);
   return Qtrue;
 }
 
-static VALUE r_mpfi_matrix_marshal_dump(VALUE self)
+static VALUE r_mpfi_matrix_marshal_dump (VALUE self)
 {
   MPFIMatrix *ptr;
   int i;
@@ -290,7 +293,7 @@ static VALUE r_mpfi_matrix_marshal_dump(VALUE self)
   return ret_ary;
 }
 
-static VALUE r_mpfi_matrix_marshal_load(VALUE self, VALUE dump_ary)
+static VALUE r_mpfi_matrix_marshal_load (VALUE self, VALUE dump_ary)
 {
   MPFIMatrix *ptr;
   int i;
@@ -303,7 +306,7 @@ static VALUE r_mpfi_matrix_marshal_load(VALUE self, VALUE dump_ary)
   ptr->size = ptr->row * ptr->column;
   ptr->data = ALLOC_N(MPFI, ptr->size);
 
-  for(i = 0; i < ptr->size; i++){
+  for (i = 0; i < ptr->size; i++) {
     dump_element = rb_ary_entry(dump_ary, i + 2);
     Check_Type(dump_element, T_STRING);
     dump = RSTRING_PTR(dump_element);
@@ -313,28 +316,28 @@ static VALUE r_mpfi_matrix_marshal_load(VALUE self, VALUE dump_ary)
 }
 
 /* Return size of data array which equals to column * row. */
-static VALUE r_mpfi_matrix_size (VALUE self){
+static VALUE r_mpfi_matrix_size (VALUE self) {
   MPFIMatrix *ptr_self;
   r_mpfi_get_matrix_struct(ptr_self, self);
   return INT2FIX(ptr_self->size);
 }
 
 /* Return column size of matrix. */
-static VALUE r_mpfi_matrix_column_size (VALUE self){
+static VALUE r_mpfi_matrix_column_size (VALUE self) {
   MPFIMatrix *ptr_self;
   r_mpfi_get_matrix_struct(ptr_self, self);
   return INT2FIX(ptr_self->column);
 }
 
 /* Return row size of matrix. */
-static VALUE r_mpfi_matrix_row_size (VALUE self){
+static VALUE r_mpfi_matrix_row_size (VALUE self) {
   MPFIMatrix *ptr_self;
   r_mpfi_get_matrix_struct(ptr_self, self);
   return INT2FIX(ptr_self->row);
 }
 
 /* Return element at _arg_.*/
-static VALUE r_mpfi_matrix_at (VALUE self, VALUE arg){
+static VALUE r_mpfi_matrix_at (VALUE self, VALUE arg) {
   MPFIMatrix *ptr_self;
   int i;
   r_mpfi_get_matrix_struct(ptr_self, self);
@@ -345,13 +348,13 @@ static VALUE r_mpfi_matrix_at (VALUE self, VALUE arg){
     r_mpfi_make_struct_init(ret, ptr_ret);
     mpfi_set(ptr_ret, ptr_self->data + i);
     return ret;
-  }else{
+  } else {
     return Qnil;
   }
 }
 
 /* Return element with _row_ and _column_.*/
-static VALUE r_mpfi_matrix_element (VALUE self, VALUE row, VALUE column){
+static VALUE r_mpfi_matrix_element (VALUE self, VALUE row, VALUE column) {
   MPFIMatrix *ptr_self;
   int i, j;
   r_mpfi_get_matrix_struct(ptr_self, self);
@@ -363,13 +366,13 @@ static VALUE r_mpfi_matrix_element (VALUE self, VALUE row, VALUE column){
     r_mpfi_make_struct_init(ret, ptr_ret);
     mpfi_set(ptr_ret, ptr_self->data + i + j * ptr_self->row);
     return ret;
-  }else{
+  } else {
     return Qnil;
   }
 }
 
 /* Set _robj_ to element of which row is _row_ and column is _column_. */
-static VALUE r_mpfi_matrix_set_element (VALUE self, VALUE row, VALUE column, VALUE robj){
+static VALUE r_mpfi_matrix_set_element (VALUE self, VALUE row, VALUE column, VALUE robj) {
   MPFIMatrix *ptr_self;
   int i, j;
   r_mpfi_get_matrix_struct(ptr_self, self);
@@ -382,40 +385,42 @@ static VALUE r_mpfi_matrix_set_element (VALUE self, VALUE row, VALUE column, VAL
 }
 
 /* Evaluate block with each element of matrix. */
-static VALUE r_mpfi_matrix_each_element (VALUE self){
+static VALUE r_mpfi_matrix_each_element (VALUE self) {
   MPFIMatrix *ptr_self;
   VALUE ret;
   int i, j;
+  RETURN_ENUMERATOR(self, 0, NULL);
   r_mpfi_get_matrix_struct(ptr_self, self);
   ret = Qnil;
   for (i = 0; i < ptr_self->row; i++) {
     for (j = 0; j < ptr_self->column; j++) {
-      volatile VALUE arg = r_mpfi_make_new_fi_obj(ptr_self->data + i + j * ptr_self->row);
-      ret = rb_yield(arg);
+      volatile VALUE el = r_mpfi_make_new_fi_obj(ptr_self->data + i + j * ptr_self->row);
+      ret = rb_yield(el);
     }
   }
   return ret;
 }
 
 /* Evaluate block with each element and its index. */
-static VALUE r_mpfi_matrix_each_element_with_index (VALUE self){
+static VALUE r_mpfi_matrix_each_element_with_index (VALUE self) {
   MPFIMatrix *ptr_self;
   VALUE ret, tmp_i;
   int i, j;
+  RETURN_ENUMERATOR(self, 0, NULL);
   r_mpfi_get_matrix_struct(ptr_self, self);
   ret = Qnil;
   for (i = 0; i < ptr_self->row; i++) {
     tmp_i = INT2NUM(i);
     for (j = 0; j < ptr_self->column; j++) {
-      volatile VALUE arg = r_mpfi_make_new_fi_obj(ptr_self->data + i + j * ptr_self->row);
-      ret = rb_yield(rb_ary_new3(3, arg, tmp_i, INT2NUM(j)));
+      volatile VALUE el = r_mpfi_make_new_fi_obj(ptr_self->data + i + j * ptr_self->row);
+      ret = rb_yield(rb_ary_new3(3, el, tmp_i, INT2NUM(j)));
     }
   }
   return ret;
 }
 
 /* Return one dimensinal array which has strings converted elements to. */
-static VALUE r_mpfi_matrix_str_ary_for_inspect(VALUE self){
+static VALUE r_mpfi_matrix_str_ary_for_inspect (VALUE self) {
   MPFIMatrix *ptr_self;
   char *tmp_str;
   VALUE ret_ary;
@@ -423,8 +428,8 @@ static VALUE r_mpfi_matrix_str_ary_for_inspect(VALUE self){
   r_mpfi_get_matrix_struct(ptr_self, self);
   ret_ary = rb_ary_new2(ptr_self->size);
   for (i = 0; i < ptr_self->size; i++) {
-    if(!mpfr_asprintf(&tmp_str, "%.Re %.Re",
-		      r_mpfi_left_ptr((ptr_self->data + i)), r_mpfi_right_ptr(ptr_self->data + i))) {
+    if (!mpfr_asprintf(&tmp_str, "%.Re %.Re",
+                       r_mpfi_left_ptr((ptr_self->data + i)), r_mpfi_right_ptr(ptr_self->data + i))) {
       rb_raise(rb_eFatal, "Can not allocate a string by mpfr_asprintf.");
     }
     rb_ary_store(ret_ary, i, rb_str_new2(tmp_str));
@@ -434,20 +439,20 @@ static VALUE r_mpfi_matrix_str_ary_for_inspect(VALUE self){
 }
 
 /* Return two dimensinal array which has strings converted elements to. */
-static VALUE r_mpfi_matrix_str_ary_for_inspect2(VALUE self){
+static VALUE r_mpfi_matrix_str_ary_for_inspect2 (VALUE self) {
   MPFIMatrix *ptr_self;
   char *tmp_str;
   int i, j;
   VALUE *ary, ret_ary;
   r_mpfi_get_matrix_struct(ptr_self, self);
   ary = ALLOC_N(VALUE, ptr_self->row);
-  for(i = 0; i < ptr_self->row; i++){
+  for (i = 0; i < ptr_self->row; i++) {
     ary[i] = rb_ary_new();
   }
   for (i = 0; i < ptr_self->size; i += ptr_self->row) {
     for (j = 0; j < ptr_self->row; j++) {
-      if(!mpfr_asprintf(&tmp_str, "%.Re %.Re",
-			r_mpfi_left_ptr((ptr_self->data + i + j)), r_mpfi_right_ptr(ptr_self->data + i + j))) {
+      if (!mpfr_asprintf(&tmp_str, "%.Re %.Re",
+                         r_mpfi_left_ptr((ptr_self->data + i + j)), r_mpfi_right_ptr(ptr_self->data + i + j))) {
 	rb_raise(rb_eFatal, "Can not allocate a string by mpfr_asprintf.");
       }
       rb_ary_push(ary[j], rb_str_new2(tmp_str));
@@ -459,14 +464,14 @@ static VALUE r_mpfi_matrix_str_ary_for_inspect2(VALUE self){
   return ret_ary;
 }
 
-static VALUE r_mpfi_matrix_to_str_ary(VALUE self){
+static VALUE r_mpfi_matrix_to_str_ary (VALUE self) {
   MPFIMatrix *ptr_self;
   char *tmp_str1, *tmp_str2;
   int i, j;
   VALUE *ary, ret_ary;
   r_mpfi_get_matrix_struct(ptr_self, self);
   ary = ALLOC_N(VALUE, ptr_self->row);
-  for(i = 0; i < ptr_self->row; i++){
+  for (i = 0; i < ptr_self->row; i++) {
     ary[i] = rb_ary_new();
   }
   for (i = 0; i < ptr_self->size; i += ptr_self->row) {
@@ -487,7 +492,7 @@ static VALUE r_mpfi_matrix_to_str_ary(VALUE self){
   return ret_ary;
 }
 
-static VALUE r_mpfi_matrix_to_strf_ary(VALUE self, VALUE format_str){
+static VALUE r_mpfi_matrix_to_strf_ary (VALUE self, VALUE format_str) {
   MPFIMatrix *ptr_self;
   char *tmp_str1, *tmp_str2, *format;
   int i, j;
@@ -495,15 +500,15 @@ static VALUE r_mpfi_matrix_to_strf_ary(VALUE self, VALUE format_str){
   r_mpfi_get_matrix_struct(ptr_self, self);
   format = StringValuePtr(format_str);
   ary = ALLOC_N(VALUE, ptr_self->row);
-  for(i = 0; i < ptr_self->row; i++){
+  for (i = 0; i < ptr_self->row; i++) {
     ary[i] = rb_ary_new();
   }
   for (i = 0; i < ptr_self->size; i += ptr_self->row) {
     for (j = 0; j < ptr_self->row; j++) {
-      if(!mpfr_asprintf(&tmp_str1, format, r_mpfi_left_ptr((ptr_self->data + i + j)))) {
+      if (!mpfr_asprintf(&tmp_str1, format, r_mpfi_left_ptr((ptr_self->data + i + j)))) {
 	rb_raise(rb_eFatal, "Can not allocate a string by mpfr_asprintf.");
       }
-      if(!mpfr_asprintf(&tmp_str2, format, r_mpfi_right_ptr(ptr_self->data + i + j))) {
+      if (!mpfr_asprintf(&tmp_str2, format, r_mpfi_right_ptr(ptr_self->data + i + j))) {
 	rb_raise(rb_eFatal, "Can not allocate a string by mpfr_asprintf.");
       }
       rb_ary_push(ary[j], rb_ary_new3(2, rb_str_new2(tmp_str1), rb_str_new2(tmp_str2)));
@@ -516,7 +521,7 @@ static VALUE r_mpfi_matrix_to_strf_ary(VALUE self, VALUE format_str){
   return ret_ary;
 }
 
-static VALUE r_mpfi_matrix_to_array(VALUE self){
+static VALUE r_mpfi_matrix_to_array (VALUE self) {
   MPFIMatrix *ptr_self;
   int i;
   VALUE ret_ary;
@@ -528,13 +533,13 @@ static VALUE r_mpfi_matrix_to_array(VALUE self){
   return ret_ary;
 }
 
-static VALUE r_mpfi_matrix_to_array2(VALUE self){
+static VALUE r_mpfi_matrix_to_array2 (VALUE self) {
   MPFIMatrix *ptr_self;
   int i, j;
   VALUE *ary, ret_ary;
   r_mpfi_get_matrix_struct(ptr_self, self);
   ary = ALLOC_N(VALUE, ptr_self->row);
-  for(i = 0; i < ptr_self->row; i++){
+  for (i = 0; i < ptr_self->row; i++) {
     ary[i] = rb_ary_new();
   }
   for (i = 0; i < ptr_self->size; i += ptr_self->row) {
@@ -553,11 +558,11 @@ static VALUE r_mpfi_matrix_row (VALUE self, VALUE arg) {
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   num = NUM2INT(arg);
-  if(num < ptr_self->row){
+  if (num < ptr_self->row) {
     r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, 1, ptr_self->column);
     mpfi_matrix_row(ptr_ret, ptr_self, num);
     return ret;
-  }else{
+  } else {
     return Qnil;
   }
 }
@@ -568,17 +573,17 @@ static VALUE r_mpfi_matrix_column (VALUE self, VALUE arg) {
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   num = NUM2INT(arg);
-  if(num < ptr_self->column){
+  if (num < ptr_self->column) {
     r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, ptr_self->row, 1);
     mpfi_matrix_column(ptr_ret, ptr_self, num);
     return ret;
-  }else{
+  } else {
     return Qnil;
   }
 }
 
 /* Return transposed matrix which is new object. */
-static VALUE r_mpfi_matrix_transpose (VALUE self){
+static VALUE r_mpfi_matrix_transpose (VALUE self) {
   MPFIMatrix *ptr_self, *ptr_ret;
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
@@ -588,7 +593,7 @@ static VALUE r_mpfi_matrix_transpose (VALUE self){
 }
 
 /* Transpose self. This method is destroying method. */
-static VALUE r_mpfi_matrix_transpose2 (VALUE self){
+static VALUE r_mpfi_matrix_transpose2 (VALUE self) {
   MPFIMatrix *ptr_self, tmp;
   int i;
   r_mpfi_get_matrix_struct(ptr_self, self);
@@ -605,7 +610,7 @@ static VALUE r_mpfi_matrix_transpose2 (VALUE self){
 }
 
 /* Return transposed matrix which is new object. */
-static VALUE r_mpfi_matrix_neg (VALUE self){
+static VALUE r_mpfi_matrix_neg (VALUE self) {
   MPFIMatrix *ptr_self, *ptr_ret;
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
@@ -616,7 +621,7 @@ static VALUE r_mpfi_matrix_neg (VALUE self){
 
 
 /* Return true if all elements of _self_ equal to corresponding elements of _other_. */
-static VALUE r_mpfi_matrix_equal_p (VALUE self, VALUE other){
+static VALUE r_mpfi_matrix_equal_p (VALUE self, VALUE other) {
   MPFIMatrix *ptr_self, *ptr_other;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_get_matrix_struct(ptr_other, other);
@@ -627,7 +632,7 @@ static VALUE r_mpfi_matrix_equal_p (VALUE self, VALUE other){
 }
 
 /* Return _self_ + _other_. */
-static VALUE r_mpfi_matrix_add (VALUE self, VALUE other){
+static VALUE r_mpfi_matrix_add (VALUE self, VALUE other) {
   MPFIMatrix *ptr_self, *ptr_other, *ptr_ret;
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
@@ -635,45 +640,45 @@ static VALUE r_mpfi_matrix_add (VALUE self, VALUE other){
   if (ptr_self->column == ptr_other->column && ptr_self->row == ptr_other->row) {
     r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, ptr_self->row, ptr_self->column);
     mpfi_matrix_add(ptr_ret, ptr_self, ptr_other);
-  }else{
+  } else {
     rb_raise(rb_eArgError, "Matrixes must have same size.");
   }
   return ret;
 }
 
 /* Return _self_ + _other_ which is MPFI::Matrix. */
-static VALUE r_mpfi_matrix_add2 (VALUE self, VALUE other){
+static VALUE r_mpfi_matrix_add2 (VALUE self, VALUE other) {
   MPFIMatrix *ptr_self, *ptr_ret;
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_make_matrix_struct(ret, ptr_ret);
 
-  if(RTEST(rb_funcall(__mpfi_matrix_class__, eqq, 1, other))){
+  if (RTEST(rb_funcall(__mpfi_matrix_class__, eqq, 1, other))) {
     MPFIMatrix *ptr_other;
     r_mpfi_get_matrix_struct(ptr_other, other);
     if (ptr_self->column == ptr_other->column && ptr_self->row == ptr_other->row) {
       r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, ptr_self->row, ptr_self->column);
       mpfi_matrix_add(ptr_ret, ptr_self, ptr_other);
-    }else{
+    } else {
       rb_raise(rb_eArgError, "Matrixes must have same size.");
     }
-  }else if(RTEST(rb_funcall(__mpfr_matrix_class__, eqq, 1, other))){
+  } else if (RTEST(rb_funcall(__mpfr_matrix_class__, eqq, 1, other))) {
     MPFRMatrix *ptr_other;
     r_mpfr_get_matrix_struct(ptr_other, other);
     if (ptr_self->column == ptr_other->column && ptr_self->row == ptr_other->row) {
       r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, ptr_self->row, ptr_self->column);
       mpfi_matrix_add_fr(ptr_ret, ptr_self, ptr_other);
-    }else{
+    } else {
       rb_raise(rb_eArgError, "Matrixes must have same size.");
-    }    
-  }else{
+    }
+  } else {
     rb_raise(rb_eArgError, "Argument matrix must be an instance of MPFI::Matrix or MPFR::Matrix.");
   }
   return ret;
 }
 
 /* Return _self_ - _other_. */
-static VALUE r_mpfi_matrix_sub (VALUE self, VALUE other){
+static VALUE r_mpfi_matrix_sub (VALUE self, VALUE other) {
   MPFIMatrix *ptr_self, *ptr_other, *ptr_ret;
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
@@ -682,120 +687,120 @@ static VALUE r_mpfi_matrix_sub (VALUE self, VALUE other){
   if (ptr_self->column == ptr_other->column && ptr_self->row == ptr_other->row) {
     r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, ptr_self->row, ptr_self->column);
     mpfi_matrix_sub(ptr_ret, ptr_self, ptr_other);
-  }else{
+  } else {
     rb_raise(rb_eArgError, "Matrixes must have same size.");
   }
   return ret;
 }
 
 /* Return _self_ - _other_ which is MPFI::Matrix. */
-static VALUE r_mpfi_matrix_sub2 (VALUE self, VALUE other){
+static VALUE r_mpfi_matrix_sub2 (VALUE self, VALUE other) {
   MPFIMatrix *ptr_self, *ptr_ret;
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_make_matrix_struct(ret, ptr_ret);
 
-  if(RTEST(rb_funcall(__mpfi_matrix_class__, eqq, 1, other))){
+  if (RTEST(rb_funcall(__mpfi_matrix_class__, eqq, 1, other))) {
     MPFIMatrix *ptr_other;
     r_mpfi_get_matrix_struct(ptr_other, other);
     if (ptr_self->column == ptr_other->column && ptr_self->row == ptr_other->row) {
       r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, ptr_self->row, ptr_self->column);
       mpfi_matrix_sub(ptr_ret, ptr_self, ptr_other);
-    }else{
+    } else {
       rb_raise(rb_eArgError, "Matrixes must have same size.");
     }
-  }else if(RTEST(rb_funcall(__mpfr_matrix_class__, eqq, 1, other))){
+  } else if (RTEST(rb_funcall(__mpfr_matrix_class__, eqq, 1, other))) {
     MPFRMatrix *ptr_other;
     r_mpfr_get_matrix_struct(ptr_other, other);
     if (ptr_self->column == ptr_other->column && ptr_self->row == ptr_other->row) {
       r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, ptr_self->row, ptr_self->column);
       mpfi_matrix_sub_fr(ptr_ret, ptr_self, ptr_other);
-    }else{
+    } else {
       rb_raise(rb_eArgError, "Matrixes must have same size.");
-    }    
-  }else{
+    }
+  } else {
     rb_raise(rb_eArgError, "Argument matrix must be an instance of MPFI::Matrix or MPFR::Matrix.");
   }
   return ret;
 }
 
-static VALUE r_mpfi_matrix_vector_inner_product (VALUE self, VALUE arg){
+static VALUE r_mpfi_matrix_vector_inner_product (VALUE self, VALUE arg) {
   MPFIMatrix *ptr_self, *ptr_arg;
   VALUE ret;
   MPFI *ptr_ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_get_matrix_struct(ptr_arg, arg);
   r_mpfi_make_struct_init(ret, ptr_ret);
-  if(ptr_self->size == ptr_arg->size){
+  if (ptr_self->size == ptr_arg->size) {
     mpfi_matrix_inner_product(ptr_ret, ptr_self, ptr_arg);
-  }else{
+  } else {
     rb_raise(rb_eArgError, "Vectors must have same size.");
   }
   return ret;
 }
 
 /* Return _self_ * _other_. */
-static VALUE r_mpfi_matrix_mul_matrix (VALUE self, VALUE other){
+static VALUE r_mpfi_matrix_mul_matrix (VALUE self, VALUE other) {
   MPFIMatrix *ptr_self, *ptr_other, *ptr_ret;
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_get_matrix_struct(ptr_other, other);
   r_mpfi_make_matrix_struct(ret, ptr_ret);
   if (ptr_self->column == ptr_other->row) {
-    if((ptr_other->column == 1) && (ptr_self->row == 1)){
+    if ((ptr_other->column == 1) && (ptr_self->row == 1)) {
       ret = r_mpfi_matrix_vector_inner_product(self, other);
-    }else{
+    } else {
       r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, ptr_self->row, ptr_other->column);
       mpfi_matrix_mul(ptr_ret, ptr_self, ptr_other);
     }
-  }else{
+  } else {
     rb_raise(rb_eArgError, "Row size of first matrixes must be same as colmun size of second matrixes.");
   }
   return ret;
 }
 
 /* Return _self_ * _other_ which is MPFI::Matrix. */
-static VALUE r_mpfi_matrix_mul_matrix2 (VALUE self, VALUE other){
+static VALUE r_mpfi_matrix_mul_matrix2 (VALUE self, VALUE other) {
   MPFIMatrix *ptr_self, *ptr_ret;
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_make_matrix_struct(ret, ptr_ret);
 
-  if(RTEST(rb_funcall(__mpfi_matrix_class__, eqq, 1, other))){
+  if (RTEST(rb_funcall(__mpfi_matrix_class__, eqq, 1, other))) {
     MPFIMatrix *ptr_other;
     r_mpfi_get_matrix_struct(ptr_other, other);
     if (ptr_self->column == ptr_other->row) {
       r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, ptr_self->row, ptr_other->column);
       mpfi_matrix_mul(ptr_ret, ptr_self, ptr_other);
-    }else{
+    } else {
       rb_raise(rb_eArgError, "Row size of first matrixes must be same as colmun size of second matrixes.");
     }
-  }else if(RTEST(rb_funcall(__mpfr_matrix_class__, eqq, 1, other))){
+  } else if (RTEST(rb_funcall(__mpfr_matrix_class__, eqq, 1, other))) {
     MPFRMatrix *ptr_other;
     r_mpfr_get_matrix_struct(ptr_other, other);
     if (ptr_self->column == ptr_other->row) {
       r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, ptr_self->row, ptr_other->column);
       mpfi_matrix_mul_fr(ptr_ret, ptr_self, ptr_other);
-    }else{
+    } else {
       rb_raise(rb_eArgError, "Row size of first matrixes must be same as colmun size of second matrixes.");
-    }    
-  }else{
+    }
+  } else {
     rb_raise(rb_eArgError, "Argument matrix must be an instance of MPFI::Matrix or MPFR::Matrix.");
   }
   return ret;
 }
 
 /* Return _scalar_ * _self_, where _scalar_ is scalar and _self_ is matrix. */
-static VALUE r_mpfi_matrix_mul_scalar (VALUE self, VALUE scalar){
+static VALUE r_mpfi_matrix_mul_scalar (VALUE self, VALUE scalar) {
   MPFIMatrix *ptr_self, *ptr_ret;
   MPFI *ptr_scalar;
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, ptr_self->row, ptr_self->column);
-  if(RTEST(rb_funcall(r_mpfi_class, eqq, 1, scalar))){
+  if (RTEST(rb_funcall(r_mpfi_class, eqq, 1, scalar))) {
     r_mpfi_get_struct(ptr_scalar, scalar);
     mpfi_matrix_mul_scalar(ptr_ret, ptr_self, ptr_scalar);
-  }else{
+  } else {
     r_mpfi_temp_alloc_init(ptr_scalar);
     r_mpfi_set_robj(ptr_scalar, scalar);
     mpfi_matrix_mul_scalar(ptr_ret, ptr_self, ptr_scalar);
@@ -804,16 +809,16 @@ static VALUE r_mpfi_matrix_mul_scalar (VALUE self, VALUE scalar){
   return ret;
 }
 
-static VALUE r_mpfi_matrix_div_scalar (VALUE self, VALUE scalar){
+static VALUE r_mpfi_matrix_div_scalar (VALUE self, VALUE scalar) {
   MPFIMatrix *ptr_self, *ptr_ret;
   MPFI *ptr_scalar;
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, ptr_self->row, ptr_self->column);
-  if(RTEST(rb_funcall(r_mpfi_class, eqq, 1, scalar))){
+  if (RTEST(rb_funcall(r_mpfi_class, eqq, 1, scalar))) {
     r_mpfi_get_struct(ptr_scalar, scalar);
     mpfi_matrix_div_scalar(ptr_ret, ptr_self, ptr_scalar);
-  }else{
+  } else {
     r_mpfi_temp_alloc_init(ptr_scalar);
     r_mpfi_set_robj(ptr_scalar, scalar);
     mpfi_matrix_div_scalar(ptr_ret, ptr_self, ptr_scalar);
@@ -823,41 +828,41 @@ static VALUE r_mpfi_matrix_div_scalar (VALUE self, VALUE scalar){
 }
 
 
-static VALUE r_mpfi_matrix_include_p (VALUE self, VALUE other){
+static VALUE r_mpfi_matrix_include_p (VALUE self, VALUE other) {
   MPFIMatrix *ptr_self;
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   ret = Qnil;
-  if(RTEST(rb_funcall(r_mpfi_matrix, eqq, 1, other))){
+  if (RTEST(rb_funcall(r_mpfi_matrix, eqq, 1, other))) {
     MPFIMatrix *ptr_other;
     r_mpfi_get_matrix_struct(ptr_other, other);
-    if(mpfi_matrix_include_p(ptr_self, ptr_other) == 0){
+    if (mpfi_matrix_include_p(ptr_self, ptr_other) == 0) {
       ret = Qtrue;
     }
-  }else if(RTEST(rb_funcall(r_mpfr_matrix, eqq, 1, other))){
+  } else if (RTEST(rb_funcall(r_mpfr_matrix, eqq, 1, other))) {
     MPFRMatrix *ptr_other;
     r_mpfr_get_matrix_struct(ptr_other, other);
-    if(mpfi_matrix_include_fr_p(ptr_self, ptr_other) == 0){
+    if (mpfi_matrix_include_fr_p(ptr_self, ptr_other) == 0) {
       ret = Qtrue;
     }
-  }else{
+  } else {
     rb_raise(rb_eArgError, "Argument must be MPFI::Matrix or MPFR::Matrix instance.");
   }
   return ret;
 }
 
-static VALUE r_mpfi_matrix_strictly_include_p (VALUE self, VALUE other){
+static VALUE r_mpfi_matrix_strictly_include_p (VALUE self, VALUE other) {
   MPFIMatrix *ptr_self;
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   ret = Qnil;
-  if(RTEST(rb_funcall(r_mpfi_matrix, eqq, 1, other))){
+  if (RTEST(rb_funcall(r_mpfi_matrix, eqq, 1, other))) {
     MPFIMatrix *ptr_other;
     r_mpfi_get_matrix_struct(ptr_other, other);
-    if(mpfi_matrix_strictly_include_p(ptr_self, ptr_other) == 0){
+    if (mpfi_matrix_strictly_include_p(ptr_self, ptr_other) == 0) {
       ret = Qtrue;
     }
-  }else{
+  } else {
     rb_raise(rb_eArgError, "Argument must be MPFI::Matrix instance.");
   }
   return ret;
@@ -866,14 +871,14 @@ static VALUE r_mpfi_matrix_strictly_include_p (VALUE self, VALUE other){
 static VALUE r_mpfi_matrix_bounded_p (VALUE self) {
   MPFIMatrix *ptr_self;
   r_mpfi_get_matrix_struct(ptr_self, self);
-  if(mpfi_matrix_bounded_p(ptr_self) == 0){
+  if (mpfi_matrix_bounded_p(ptr_self) == 0) {
     return Qtrue;
-  }else{
+  } else {
     return Qnil;
   }
 }
 
-static VALUE r_mpfi_matrix_mid (VALUE self){
+static VALUE r_mpfi_matrix_mid (VALUE self) {
   MPFIMatrix *ptr_self;
   VALUE val_ret;
   MPFRMatrix *ptr_ret;
@@ -883,7 +888,7 @@ static VALUE r_mpfi_matrix_mid (VALUE self){
   return val_ret;
 }
 
-static VALUE r_mpfi_matrix_mid_interval (VALUE self){
+static VALUE r_mpfi_matrix_mid_interval (VALUE self) {
   MPFIMatrix *ptr_self, *ptr_ret;
   VALUE val_ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
@@ -892,34 +897,34 @@ static VALUE r_mpfi_matrix_mid_interval (VALUE self){
   return val_ret;
 }
 
-static VALUE r_mpfi_matrix_intersect (VALUE self, VALUE other){
+static VALUE r_mpfi_matrix_intersect (VALUE self, VALUE other) {
   MPFIMatrix *ptr_self, *ptr_other, *ptr_ret;
   VALUE val_ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_get_matrix_struct(ptr_other, other);
   r_mpfi_matrix_suitable_matrix_init(&val_ret, &ptr_ret, ptr_self->row, ptr_self->column);
-  if(mpfi_matrix_intersect(ptr_ret, ptr_self, ptr_other) == 0){
+  if (mpfi_matrix_intersect(ptr_ret, ptr_self, ptr_other) == 0) {
     return val_ret;
-  }else{
+  } else {
     return Qnil;
   }
 }
 
-static VALUE r_mpfi_matrix_union (VALUE self, VALUE other){
+static VALUE r_mpfi_matrix_union (VALUE self, VALUE other) {
   MPFIMatrix *ptr_self, *ptr_other, *ptr_ret;
   VALUE val_ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_get_matrix_struct(ptr_other, other);
   r_mpfi_matrix_suitable_matrix_init(&val_ret, &ptr_ret, ptr_self->row, ptr_self->column);
-  if(mpfi_matrix_union(ptr_ret, ptr_self, ptr_other) == 0){
+  if (mpfi_matrix_union(ptr_ret, ptr_self, ptr_other) == 0) {
     return val_ret;
-  }else{
+  } else {
     return Qnil;
   }
 }
 
 
-static VALUE r_mpfi_matrix_max_diam_abs (VALUE self){
+static VALUE r_mpfi_matrix_max_diam_abs (VALUE self) {
   MPFIMatrix *ptr_self;
   MPFR *ptr_ret;
   VALUE ret_val;
@@ -930,14 +935,14 @@ static VALUE r_mpfi_matrix_max_diam_abs (VALUE self){
 }
 
 /* Return row size of matrix. */
-static VALUE r_mpfi_square_matrix_dim (VALUE self){
+static VALUE r_mpfi_square_matrix_dim (VALUE self) {
   MPFIMatrix *ptr_self;
   r_mpfi_get_matrix_struct(ptr_self, self);
   return INT2FIX(ptr_self->row);
 }
 
 /* Return [matrix_l, matrix_r, indx]. */
-static VALUE r_mpfi_square_matrix_lu_decomp (VALUE self){
+static VALUE r_mpfi_square_matrix_lu_decomp (VALUE self) {
   MPFIMatrix *ptr_self, *ptr_ret_l, *ptr_ret_u;
   VALUE ret_l, ret_u, ret, ret_indx_ary;
   int i, j, *indx;
@@ -945,23 +950,23 @@ static VALUE r_mpfi_square_matrix_lu_decomp (VALUE self){
   r_mpfi_matrix_suitable_matrix_init (&ret_l, &ptr_ret_l, ptr_self->row, ptr_self->column);
   r_mpfi_matrix_suitable_matrix_init (&ret_u, &ptr_ret_u, ptr_self->row, ptr_self->column);
   indx = ALLOC_N(int, ptr_self->row);
-  if(mpfi_square_matrix_lu_decomp (ptr_ret_u, indx, ptr_self) >= 0){
+  if (mpfi_square_matrix_lu_decomp (ptr_ret_u, indx, ptr_self) >= 0) {
     ret_indx_ary = rb_ary_new2(ptr_self->row);
-    for(i = 1; i < ptr_ret_u->row; i++){
-      for(j = 0; j < i; j++){
+    for (i = 1; i < ptr_ret_u->row; i++) {
+      for (j = 0; j < i; j++) {
 	mpfi_set(mpfi_matrix_get_element(ptr_ret_l, i, j), mpfi_matrix_get_element(ptr_ret_u, i, j));
 	mpfi_set_si(mpfi_matrix_get_element(ptr_ret_u, i, j), 0);
       }
     }
-    for(i = 0; i < ptr_ret_u->row; i++){
+    for (i = 0; i < ptr_ret_u->row; i++) {
       mpfi_set_si(mpfi_matrix_get_element(ptr_ret_l, i, i), 1);
     }
-    for(i = 0; i < ptr_ret_u->row; i++){
-      for(j = i + 1; j < ptr_ret_u->column; j++){
+    for (i = 0; i < ptr_ret_u->row; i++) {
+      for (j = i + 1; j < ptr_ret_u->column; j++) {
 	mpfi_set_si(mpfi_matrix_get_element(ptr_ret_l, i, j), 0);
       }
     }
-    for(i = 0; i < ptr_ret_u->row; i++){
+    for (i = 0; i < ptr_ret_u->row; i++) {
       rb_ary_store(ret_indx_ary, i, INT2NUM(indx[i]));
     }
     ret = rb_ary_new3(3, ret_l, ret_u, ret_indx_ary);
@@ -972,7 +977,7 @@ static VALUE r_mpfi_square_matrix_lu_decomp (VALUE self){
   return ret;
 }
 
-static VALUE r_mpfi_square_matrix_determinant (VALUE self){
+static VALUE r_mpfi_square_matrix_determinant (VALUE self) {
   MPFIMatrix *ptr_self;
   MPFI *ptr_ret;
   VALUE ret;
@@ -982,7 +987,7 @@ static VALUE r_mpfi_square_matrix_determinant (VALUE self){
   return ret;
 }
 
-static VALUE r_mpfi_square_matrix_qr_decomp (VALUE self){
+static VALUE r_mpfi_square_matrix_qr_decomp (VALUE self) {
   MPFIMatrix *ptr_self, *ptr_q, *ptr_r;
   VALUE q, r;
   r_mpfi_get_matrix_struct(ptr_self, self);
@@ -992,7 +997,7 @@ static VALUE r_mpfi_square_matrix_qr_decomp (VALUE self){
   return rb_ary_new3(2, q, r);
 }
 
-static VALUE r_mpfi_square_matrix_identity (VALUE self, VALUE size){
+static VALUE r_mpfi_square_matrix_identity (VALUE self, VALUE size) {
   VALUE ret;
   MPFIMatrix *ptr_ret;
   int s = NUM2INT(size);
@@ -1003,14 +1008,14 @@ static VALUE r_mpfi_square_matrix_identity (VALUE self, VALUE size){
 
 
 /* Return size of data array which equals to column * row. */
-static VALUE r_mpfi_vector_dim (VALUE self){
+static VALUE r_mpfi_vector_dim (VALUE self) {
   MPFIMatrix *ptr_self;
   r_mpfi_get_matrix_struct(ptr_self, self);
   return INT2FIX(ptr_self->size);
 }
 
 /* Take matrix for vector and return length of the vector. */
-static VALUE r_mpfi_vector_abs (VALUE self){
+static VALUE r_mpfi_vector_abs (VALUE self) {
   MPFIMatrix *ptr_self;
   VALUE ret;
   MPFI *ptr_ret;
@@ -1021,7 +1026,7 @@ static VALUE r_mpfi_vector_abs (VALUE self){
 }
 
 /* Return element at _arg_.*/
-static VALUE r_mpfi_vector_element (VALUE self, VALUE arg){
+static VALUE r_mpfi_vector_element (VALUE self, VALUE arg) {
   MPFIMatrix *ptr_self;
   int i;
   r_mpfi_get_matrix_struct(ptr_self, self);
@@ -1032,13 +1037,13 @@ static VALUE r_mpfi_vector_element (VALUE self, VALUE arg){
     r_mpfi_make_struct_init(ret, ptr_ret);
     mpfi_set(ptr_ret, ptr_self->data + i);
     return ret;
-  }else{
+  } else {
     return Qnil;
   }
 }
 
 /* Set _robj_ to _arg_ th element. */
-static VALUE r_mpfi_vector_set_element (VALUE self, VALUE arg, VALUE robj){
+static VALUE r_mpfi_vector_set_element (VALUE self, VALUE arg, VALUE robj) {
   MPFIMatrix *ptr_self;
   int i;
   r_mpfi_get_matrix_struct(ptr_self, self);
@@ -1050,83 +1055,81 @@ static VALUE r_mpfi_vector_set_element (VALUE self, VALUE arg, VALUE robj){
 }
 
 /* Evaluate block with each element of vector. */
-static VALUE r_mpfi_vector_each_element (VALUE self){
+static VALUE r_mpfi_vector_each_element (VALUE self) {
   MPFIMatrix *ptr_self;
-  VALUE ret, tmp;
-  MPFI *tmp_ptr;
+  VALUE ret;
   int i;
+  RETURN_ENUMERATOR(self, 0, NULL);
   ret = Qnil;
   r_mpfi_get_matrix_struct(ptr_self, self);
-  r_mpfi_make_struct_init(tmp, tmp_ptr);
   for (i = 0; i < ptr_self->size; i++) {
-    mpfi_set(tmp_ptr, ptr_self->data + i);
-    ret = rb_yield(tmp);
+    volatile VALUE el = r_mpfi_make_new_fi_obj(ptr_self->data + i);
+    ret = rb_yield(el);
   }
   return ret;
 }
 
 /* Evaluate block with each element and its index. */
-static VALUE r_mpfi_vector_each_element_with_index (VALUE self){
+static VALUE r_mpfi_vector_each_element_with_index (VALUE self) {
   MPFIMatrix *ptr_self;
-  VALUE ret, tmp;
-  MPFI *tmp_ptr;
+  VALUE ret;
   int i;
+  RETURN_ENUMERATOR(self, 0, NULL);
   r_mpfi_get_matrix_struct(ptr_self, self);
-  r_mpfi_make_struct_init(tmp, tmp_ptr);
   ret = Qnil;
   for (i = 0; i < ptr_self->size; i++) {
-    mpfi_set(tmp_ptr, ptr_self->data + i);
-    ret = rb_yield(rb_ary_new3(2, tmp, INT2NUM(i)));
+    volatile VALUE el = r_mpfi_make_new_fi_obj(ptr_self->data + i);
+    ret = rb_yield(rb_ary_new3(2, el, INT2NUM(i)));
   }
   return ret;
 }
 
-static VALUE r_mpfi_vector_inner_product (VALUE self, VALUE arg){
+static VALUE r_mpfi_vector_inner_product (VALUE self, VALUE arg) {
   MPFIMatrix *ptr_self, *ptr_arg;
   VALUE ret;
   MPFI *ptr_ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_get_matrix_struct(ptr_arg, arg);
   r_mpfi_make_struct_init(ret, ptr_ret);
-  if(ptr_self->size == ptr_arg->size){
+  if (ptr_self->size == ptr_arg->size) {
     mpfi_matrix_inner_product(ptr_ret, ptr_self, ptr_arg);
-  }else{
+  } else {
     rb_raise(rb_eArgError, "Vectors must have same size.");
   }
   return ret;
 }
 
-static VALUE r_mpfi_vector_distance_from (VALUE self, VALUE arg){
+static VALUE r_mpfi_vector_distance_from (VALUE self, VALUE arg) {
   MPFIMatrix *ptr_self, *ptr_arg;
   VALUE ret;
   MPFI *ptr_ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_get_matrix_struct(ptr_arg, arg);
   r_mpfi_make_struct_init(ret, ptr_ret);
-  if(ptr_self->size == ptr_arg->size){
+  if (ptr_self->size == ptr_arg->size) {
     mpfi_matrix_vector_distance(ptr_ret, ptr_self, ptr_arg);
-  }else{
+  } else {
     rb_raise(rb_eArgError, "Vectors must have same size.");
   }
   return ret;
 }
 
-static VALUE r_mpfi_vector_distance_center_pts (VALUE self, VALUE arg){
+static VALUE r_mpfi_vector_distance_center_pts (VALUE self, VALUE arg) {
   MPFIMatrix *ptr_self, *ptr_arg;
   VALUE ret;
   MPFR *ptr_ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_get_matrix_struct(ptr_arg, arg);
   r_mpfr_make_struct_init(ret, ptr_ret);
-  if(ptr_self->size == ptr_arg->size){
+  if (ptr_self->size == ptr_arg->size) {
     mpfi_matrix_vector_distance_center_pts(ptr_ret, ptr_self, ptr_arg);
-  }else{
+  } else {
     rb_raise(rb_eArgError, "Vectors must have same size.");
   }
   return ret;
 }
 
-static VALUE r_mpfi_vector_midpoint (VALUE self, VALUE arg){
+static VALUE r_mpfi_vector_midpoint (VALUE self, VALUE arg) {
   MPFIMatrix *ptr_self, *ptr_arg, *ptr_ret;
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
@@ -1136,50 +1139,50 @@ static VALUE r_mpfi_vector_midpoint (VALUE self, VALUE arg){
   return ret;
 }
 
-static VALUE r_mpfi_vector_normalize (VALUE self){
+static VALUE r_mpfi_vector_normalize (VALUE self) {
   MPFIMatrix *ptr_self, *ptr_ret;
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, ptr_self->row, ptr_self->column);
-  if(mpfi_vector_normalize(ptr_ret, ptr_self) == 0){
+  if (mpfi_vector_normalize(ptr_ret, ptr_self) == 0) {
     return ret;
-  }else{
+  } else {
     return Qnil;
   }
 }
 
 /* Return normalized vector of _self_. This method is destroy method. */
-static VALUE r_mpfi_vector_normalize2 (VALUE self){
+static VALUE r_mpfi_vector_normalize2 (VALUE self) {
   MPFIMatrix *ptr_self, tmp;
   VALUE ret;
   r_mpfi_get_matrix_struct(ptr_self, self);
   ret = self;
   mpfi_matrix_init(&tmp, ptr_self->column, ptr_self->row);
-  if(mpfi_vector_normalize(&tmp, ptr_self) == 0){
+  if (mpfi_vector_normalize(&tmp, ptr_self) == 0) {
     mpfi_matrix_set(ptr_self, &tmp);
-  }else{
+  } else {
     ret = Qnil;
   }
   mpfi_matrix_clear(&tmp);
   return ret;
 }
 
-static VALUE r_mpfi_vector_set_length (VALUE self, VALUE arg){
+static VALUE r_mpfi_vector_set_length (VALUE self, VALUE arg) {
   MPFIMatrix *ptr_self, *ptr_ret;
   VALUE ret, returned_value;
   MPFR *ptr_l;
   returned_value = Qnil;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, ptr_self->row, ptr_self->column);
-  if(RTEST(rb_funcall(r_mpfr_class, eqq, 1, arg))){
+  if (RTEST(rb_funcall(r_mpfr_class, eqq, 1, arg))) {
     r_mpfr_get_struct(ptr_l, arg);
-    if(mpfi_vector_set_length(ptr_ret, ptr_self, ptr_l) == 0){
+    if (mpfi_vector_set_length(ptr_ret, ptr_self, ptr_l) == 0) {
       returned_value = ret;
     }
-  }else{
+  } else {
     r_mpfr_temp_alloc_init(ptr_l);
     r_mpfr_set_robj(ptr_l, arg, GMP_RNDN);
-    if(mpfi_vector_set_length(ptr_ret, ptr_self, ptr_l) == 0){
+    if (mpfi_vector_set_length(ptr_ret, ptr_self, ptr_l) == 0) {
       returned_value = ret;
     }
     r_mpfr_temp_free(ptr_l);
@@ -1187,23 +1190,23 @@ static VALUE r_mpfi_vector_set_length (VALUE self, VALUE arg){
   return returned_value;
 }
 
-static VALUE r_mpfi_vector_set_length2 (VALUE self, VALUE arg){
+static VALUE r_mpfi_vector_set_length2 (VALUE self, VALUE arg) {
   MPFIMatrix *ptr_self, *ptr_ret;
   VALUE ret, returned_value;
   MPFR *ptr_l;
   returned_value = Qnil;
   r_mpfi_get_matrix_struct(ptr_self, self);
   r_mpfi_matrix_suitable_matrix_init (&ret, &ptr_ret, ptr_self->row, ptr_self->column);
-  if(RTEST(rb_funcall(r_mpfi_class, eqq, 1, arg))){
+  if (RTEST(rb_funcall(r_mpfi_class, eqq, 1, arg))) {
     r_mpfr_get_struct(ptr_l, arg);
-    if(mpfi_vector_set_length(ptr_ret, ptr_self, ptr_l) == 0){
+    if (mpfi_vector_set_length(ptr_ret, ptr_self, ptr_l) == 0) {
       mpfi_matrix_set(ptr_self, ptr_ret);
       returned_value = self;
     }
-  }else{
+  } else {
     r_mpfr_temp_alloc_init(ptr_l);
     r_mpfr_set_robj(ptr_l, arg, GMP_RNDN);
-    if(mpfi_vector_set_length(ptr_ret, ptr_self, ptr_l) == 0){
+    if (mpfi_vector_set_length(ptr_ret, ptr_self, ptr_l) == 0) {
       mpfi_matrix_set(ptr_self, ptr_ret);
       returned_value = self;
     }
@@ -1213,7 +1216,7 @@ static VALUE r_mpfi_vector_set_length2 (VALUE self, VALUE arg){
 }
 
 
-static VALUE r_mpfr_matrix_to_fi_matrix(VALUE self){
+static VALUE r_mpfr_matrix_to_fi_matrix (VALUE self) {
   MPFRMatrix *ptr;
   VALUE ret;
   MPFIMatrix *ptr_ret;
@@ -1223,7 +1226,7 @@ static VALUE r_mpfr_matrix_to_fi_matrix(VALUE self){
   return ret;
 }
 
-void Init_matrix(){
+void Init_matrix() {
   /* Initialization of MPFI::Matrix, MPFI::SquareMatrix, MPFI::ColumnVector and MPFI::RowVector */
   VALUE tmp_r_mpfi_class = rb_define_class("MPFI", rb_cNumeric);
   r_mpfi_matrix = rb_define_class_under(tmp_r_mpfi_class, "Matrix", rb_cObject);
@@ -1231,7 +1234,7 @@ void Init_matrix(){
   r_mpfi_col_vector = rb_define_class_under(tmp_r_mpfi_class, "ColumnVector", r_mpfi_matrix);
   r_mpfi_row_vector = rb_define_class_under(tmp_r_mpfi_class, "RowVector", r_mpfi_matrix);
 
-  rb_define_singleton_method(r_mpfi_matrix, "Matrix", r_mpfi_matrix_global_new, -1);
+  rb_define_singleton_method(tmp_r_mpfi_class, "Matrix", r_mpfi_matrix_global_new, -1);
   rb_define_alloc_func(r_mpfi_matrix, r_mpfi_matrix_alloc);
   rb_define_private_method(r_mpfi_matrix, "initialize", r_mpfi_matrix_initialize, -1);
   rb_define_private_method(r_mpfi_matrix, "initialize_copy", r_mpfi_matrix_initialize_copy, 1);
@@ -1312,7 +1315,7 @@ void Init_matrix(){
   rb_define_method(r_mpfi_square_matrix, "qr_decomp", r_mpfi_square_matrix_qr_decomp, 0);
 
   rb_define_singleton_method(r_mpfi_square_matrix, "identity", r_mpfi_square_matrix_identity, 1);
-  
+
   /* Initialization of MPFI::Vector module */
   r_mpfi_vector_module = rb_define_module_under(tmp_r_mpfi_class, "Vector");