ruby-mpfi 0.0.2

data/ext/mpfi_matrix/mpfi/func_mpfi_matrix.c

@@ -0,0 +1,795 @@
+#include "ruby_mpfi_matrix.h"
+
+void mpfi_matrix_init(MPFIMatrix *mat, int row, int column){
+  mat->row = row;
+  mat->column = column;
+  mat->size = row * column;
+  /* mat->data = (MPFI *)malloc(sizeof(MPFI) * mat->size); */
+  mat->data = ALLOC_N(MPFI, mat->size);
+  int i;
+  for(i = 0; i < mat->size; i++){
+    mpfi_init(mat->data + i);
+  }
+}
+
+void mpfi_matrix_set_zeros(MPFIMatrix *mat){
+  int i;
+  for(i = 0; i < mat->size; i++){
+    mpfi_set_si(mat->data + i, 0);
+  }
+}
+
+void mpfi_matrix_clear(MPFIMatrix *mat){
+  int i;
+  for(i = 0; i < mat->size; i++){
+    mpfi_clear(mat->data + i);
+  }
+  free(mat->data);
+}
+
+void mpfi_matrix_set_element(MPFIMatrix *mat, int row, int col, MPFI *a){
+  mpfi_set(mpfi_matrix_get_element(mat, row, col), a);
+}
+
+void mpfi_matrix_set(MPFIMatrix *new, MPFIMatrix *x){
+  int i;
+  for(i = 0; i < x->size; i++){
+    mpfi_set(new->data + i, x->data + i);
+  }
+}
+
+void mpfi_matrix_swap(MPFIMatrix *x, MPFIMatrix *y){
+  int i;
+  for (i = 0; i < x->size; i++) {
+    mpfi_swap(mpfi_matrix_get_ptr(x, i), mpfi_matrix_get_ptr(y, i));
+  }
+}
+
+void mpfi_matrix_row(MPFIMatrix *new, MPFIMatrix *x, int row){
+  int i;
+  for (i = 0; i < x->column; i++) {
+    mpfi_set(new->data + i, mpfi_matrix_get_element(x, row, i));
+  }
+}
+
+void mpfi_matrix_column(MPFIMatrix *new, MPFIMatrix *x, int column){
+  int i;
+  for (i = 0; i < x->row; i++) {
+    mpfi_set(new->data + i, mpfi_matrix_get_element(x, i, column));
+  }
+}
+
+void mpfi_matrix_transpose(MPFIMatrix *new, MPFIMatrix *x){
+  int i, j, index;
+  for(j = 0; j < x->column; j++){
+    index = j * x->row;
+    for(i = 0; i < x->row; i++){
+      mpfi_set(new->data + j + i * new->row, x->data + i + index);
+    }
+  }
+}
+
+void mpfi_matrix_neg(MPFIMatrix *new, MPFIMatrix *x){
+  int i;
+  for(i = 0; i < x->size; i++){
+    mpfi_neg(new->data + i, x->data + i);
+  }
+}
+
+/* Return 0 if *x and *y has the same elements. Otherwise return 1. */
+int mpfi_matrix_equal_p(MPFIMatrix *x, MPFIMatrix *y){
+  int i, ret = 0;
+  if (x->column == y->column && x->row == y->row) {
+    for (i = 0; i < x->size; i++) {
+      if (mpfr_equal_p(r_mpfi_left_ptr(x->data + i), r_mpfi_left_ptr(y->data + i)) == 0 ||
+	  mpfr_equal_p(r_mpfi_right_ptr(x->data + i), r_mpfi_right_ptr(y->data + i)) == 0) {
+	ret = 1;
+	break;
+      }
+    }
+  }else{
+    ret = 1;
+  }
+  return ret;
+}
+
+void mpfi_matrix_add(MPFIMatrix *new, MPFIMatrix *x, MPFIMatrix *y){
+  int i, j, index;
+  for(j = 0; j < x->column; j++){
+    index = j * x->row;
+    for(i = 0; i < x->row; i++){
+      mpfi_add(new->data + i + index, x->data + i + index, y->data + i + index);
+    }
+  }
+}
+
+void mpfi_matrix_add_fr(MPFIMatrix *new, MPFIMatrix *x, MPFRMatrix *y){
+  int i, j, index;
+  for(j = 0; j < x->column; j++){
+    index = j * x->row;
+    for(i = 0; i < x->row; i++){
+      mpfi_add_fr(new->data + i + index, x->data + i + index, y->data + i + index);
+    }
+  }
+}
+
+void mpfi_matrix_sub(MPFIMatrix *new, MPFIMatrix *x, MPFIMatrix *y){
+  int i, j, index;
+  for(j = 0; j < x->column; j++){
+    index = j * x->row;
+    for(i = 0; i < x->row; i++){
+      mpfi_sub(new->data + i + index, x->data + i + index, y->data + i + index);
+    }
+  }
+}
+
+void mpfi_matrix_sub_fr(MPFIMatrix *new, MPFIMatrix *x, MPFRMatrix *y){
+  int i, j, index;
+  for(j = 0; j < x->column; j++){
+    index = j * x->row;
+    for(i = 0; i < x->row; i++){
+      mpfi_sub_fr(new->data + i + index, x->data + i + index, y->data + i + index);
+    }
+  }
+}
+
+/* x and new must be different pointer from each other. */
+void mpfi_matrix_mul(MPFIMatrix *new, MPFIMatrix *x, MPFIMatrix *y){
+  int i, j, k, index, index_y;
+  MPFI *tmp;
+  r_mpfi_temp_alloc_init(tmp);
+  for(i = 0; i < new->size; i++){
+    mpfi_set_si(new->data + i, 0);
+  }
+  for(j = 0; j < y->column; j++){
+    for(i = 0; i < x->row; i++){
+      index = i + j * new->row;
+      index_y = j * y->row;
+      for(k = 0; k < x->column; k++){
+	mpfi_mul(tmp, x->data + i + k * x->row, y->data + k + index_y);
+	mpfi_add(new->data + index, new->data + index, tmp);
+      }
+    }
+  }
+  r_mpfi_temp_free(tmp);
+}
+
+/* x and new must be different pointer from each other. */
+void mpfi_matrix_mul_fr(MPFIMatrix *new, MPFIMatrix *x, MPFRMatrix *y){
+  int i, j, k, index, index_y;
+  MPFI *tmp;
+  r_mpfi_temp_alloc_init(tmp);
+  for(i = 0; i < new->size; i++){
+    mpfi_set_si(new->data + i, 0);
+  }
+  for(j = 0; j < y->column; j++){
+    for(i = 0; i < x->row; i++){
+      index = i + j * new->row;
+      index_y = j * y->row;
+      for(k = 0; k < x->column; k++){
+	mpfi_mul_fr(tmp, x->data + i + k * x->row, y->data + k + index_y);
+	mpfi_add(new->data + index, new->data + index, tmp);
+      }
+    }
+  }
+  r_mpfi_temp_free(tmp);
+}
+
+void mpfi_matrix_mul_scalar(MPFIMatrix *new, MPFIMatrix *x, MPFI *scalar){
+  int i;
+  for(i = 0; i < x->size; i++){
+    mpfi_mul(new->data + i, x->data + i, scalar);
+  }
+}
+
+void mpfi_matrix_div_scalar(MPFIMatrix *new, MPFIMatrix *x, MPFI *scalar){
+  int i;
+  for(i = 0; i < x->size; i++){
+    mpfi_div(new->data + i, x->data + i, scalar);
+  }
+}
+
+/* Return 0 if *x includes *y. Otherwise return 1. */
+int mpfi_matrix_include_p(MPFIMatrix *x, MPFIMatrix *y){
+  int i, ret = 0;
+  if (x->column == y->column && x->row == y->row) {
+    for (i = 0; i < x->size; i++) {
+      if (mpfi_is_inside(y->data + i, x->data + i) <= 0) {
+	ret = 1;
+	break;
+      }
+    }
+  }else{
+    ret = 1;
+  }
+  return ret;
+}
+
+/* Return 0 if *x includes *y. Otherwise return 1. */
+int mpfi_matrix_include_fr_p(MPFIMatrix *x, MPFRMatrix *y){
+  int i, ret = 0;
+  if (x->column == y->column && x->row == y->row) {
+    for (i = 0; i < x->size; i++) {
+      if (mpfi_is_inside_fr(y->data + i, x->data + i) <= 0) {
+	ret = 1;
+	break;
+      }
+    }
+  }else{
+    ret = 1;
+  }
+  return ret;
+}
+
+/* Return 0 if *x includes *y. Otherwise return 1. */
+int mpfi_matrix_strictly_include_p(MPFIMatrix *x, MPFIMatrix *y){
+  int i, ret = 0;
+  if (x->column == y->column && x->row == y->row) {
+    for (i = 0; i < x->size; i++) {
+      if (mpfi_is_strictly_inside(y->data + i, x->data + i) <= 0) {
+	ret = 1;
+	break;
+      }
+    }
+  }else{
+    ret = 1;
+  }
+  return ret;
+}
+
+/* Return 0 if *x is bonded. Otherwise return 1. */
+int mpfi_matrix_bounded_p(MPFIMatrix *x){
+  int ret = 0, i;
+  for (i = 0; i < x->size; i++) {
+    if (mpfi_bounded_p(x->data + i) == 0) {
+      ret = 1;
+      break;
+    }
+  }
+  return ret;
+}
+
+void mpfi_matrix_mid(MPFRMatrix *ret, MPFIMatrix *x){
+  int i;
+  for(i = 0; i < x->size; i++){
+    mpfi_mid(ret->data + i, x->data + i);
+  }
+}
+
+void mpfi_matrix_mid_interval(MPFIMatrix *ret, MPFIMatrix *x){
+  int i;
+  for(i = 0; i < x->size; i++){
+    mpfi_mid_interval(ret->data + i, x->data + i);
+  }
+}
+
+void mpfi_matrix_from_mpfr_matrix(MPFIMatrix *ret, MPFRMatrix *x){
+  int i;
+  for(i = 0; i < x->size; i++){
+    mpfi_set_fr(ret->data + i, x->data + i);
+  }
+}
+
+/* This function returns 0 if the intersection of two boxes exists. */
+/* Otherwise, it returns nonzero. */
+int mpfi_matrix_intersect(MPFIMatrix *z, MPFIMatrix *x, MPFIMatrix *y){
+  int ret = 0;
+  int i;
+  if (x->column == y->column && x->row == y->row) {
+    for(i = 0; i < x->size; i++){
+      mpfi_intersect(z->data + i, x->data + i, y->data + i);
+      if(ret == 0 && mpfi_is_empty(z->data + i)){
+	ret = 1;
+      }
+    }
+    return ret;
+  }else{
+    return -1;
+  }
+}
+
+/* Return -1 if size of matrixies is not same. */
+/* Otherwise, return 0 and set convex hull to MPFIMatrix *z. */
+int mpfi_matrix_union(MPFIMatrix *z, MPFIMatrix *x, MPFIMatrix *y){
+  int ret = 0;
+  int i;
+  if (x->column == y->column && x->row == y->row) {
+    for(i = 0; i < x->size; i++){
+      mpfi_union(z->data + i, x->data + i, y->data + i);
+    }
+    return ret;
+  }else{
+    return -1;
+  }
+}
+
+void mpfi_matrix_inner_product(MPFI *pr, MPFIMatrix *x, MPFIMatrix *y){
+  MPFI *tmp;
+  r_mpfi_temp_alloc_init(tmp);
+  int i;
+  mpfi_set_si(pr, 0);
+  for(i = 0; i < x->size; i++){
+    mpfi_mul(tmp, x->data + i, y->data + i);
+    mpfi_add(pr, pr, tmp);
+  }
+  r_mpfi_temp_free(tmp);
+}
+
+void mpfi_matrix_vector_distance(MPFI *distance, MPFIMatrix *x, MPFIMatrix *y){
+  MPFI *tmp;
+  r_mpfi_temp_alloc_init(tmp);
+  int i;
+  mpfi_set_si(distance, 0);
+  for(i = 0; i < x->size; i++){
+    mpfi_sub(tmp, x->data + i, y->data + i);
+    mpfi_mul(tmp, tmp, tmp);
+    mpfi_add(distance, distance, tmp);
+  }
+  mpfi_sqrt(distance, distance);
+  r_mpfi_temp_free(tmp);
+}
+
+void mpfi_matrix_vector_distance_center_pts(MPFR *distance, MPFIMatrix *x, MPFIMatrix *y){
+  MPFRMatrix *tmp_x, *tmp_y;
+  r_mpfr_matrix_temp_alloc_init(tmp_x, x->row, x->column);
+  r_mpfr_matrix_temp_alloc_init(tmp_y, y->row, y->column);
+  
+  mpfi_matrix_mid(tmp_x, x);
+  mpfi_matrix_mid(tmp_y, y);
+  mpfr_matrix_vector_distance(distance, tmp_x, tmp_y);
+
+  r_mpfr_matrix_temp_free(tmp_x);
+  r_mpfr_matrix_temp_free(tmp_y);
+}
+
+void mpfi_matrix_vector_norm(MPFI *norm, MPFIMatrix *x){
+  MPFI *tmp;
+  r_mpfi_temp_alloc_init(tmp);
+  int i;
+  mpfi_set_si(norm, 0);
+  for(i = 0; i < x->size; i++){
+    mpfi_mul(tmp, x->data + i, x->data + i);
+    mpfi_add(norm, norm, tmp);
+  }
+  mpfi_sqrt(norm, norm);
+  r_mpfi_temp_free(tmp);
+}
+
+void mpfi_matrix_max_norm(MPFI *norm, MPFIMatrix *x){
+  MPFI *tmp, *abs;
+  r_mpfi_temp_alloc_init(tmp);
+  r_mpfi_temp_alloc_init(abs);
+  int i;
+  mpfi_set_si(norm, 0);
+  for(i = 0; i < x->size; i++){
+    mpfi_abs(abs, x->data + i);
+    mpfi_intersect(tmp, abs, norm);
+    if(mpfi_is_empty(tmp) > 0){
+      if(mpfr_cmp(r_mpfi_right_ptr(abs), r_mpfi_left_ptr(norm)) > 0){
+	mpfi_set(norm, abs);
+      }
+    }else{
+      mpfi_union(norm, norm, abs);
+    }
+  }
+  r_mpfi_temp_free(tmp);
+  r_mpfi_temp_free(abs);
+}
+
+void mpfi_matrix_max_diam_abs(MPFR *diam, MPFIMatrix *x){
+  int i;
+  MPFR *tmp;
+  r_mpfr_temp_alloc_init(tmp);
+
+  mpfr_set_si(diam, 0, GMP_RNDN);
+  for (i = 0; i < x->size; i++) {
+    mpfi_diam_abs(tmp, x->data + i);
+    if(mpfr_cmp(tmp, diam) > 0){
+      mpfr_set(diam, tmp, GMP_RNDN);
+    }
+  }
+
+  r_mpfr_temp_free(tmp);
+}
+
+/* ------------------- vector --------------------- */
+
+void mpfi_col_vector_init(MPFIMatrix *mat, int row){
+  mat->row = row;
+  mat->column = 1;
+  mat->size = row;
+  /* mat->data = (MPFI *)malloc(sizeof(MPF) * mat->size); */
+  mat->data = ALLOC_N(MPFI, mat->size);
+  int i;
+  for(i = 0; i < mat->size; i++){
+    mpfi_init(mat->data + i);
+  }
+}
+
+void mpfi_row_vector_init(MPFIMatrix *mat, int column){
+  mat->row = 1;
+  mat->column = column;
+  mat->size = column;
+  /* mat->data = (MPFI *)malloc(sizeof(MPF) * mat->size); */
+  mat->data = ALLOC_N(MPFI, mat->size);
+  int i;
+  for(i = 0; i < mat->size; i++){
+    mpfi_init(mat->data + i);
+  }
+}
+
+/* If length of MPFIMatrix *x is zero, return 1. Otherwise return 0. */
+int mpfi_vector_normalize(MPFIMatrix *new, MPFIMatrix *x){
+  MPFRMatrix *fr_mat;
+  r_mpfr_matrix_temp_alloc_init(fr_mat, x->row, x->column);
+  mpfi_matrix_mid(fr_mat, x);
+  MPFR *norm;
+  r_mpfr_temp_alloc_init(norm);
+  mpfr_matrix_vector_norm(norm, fr_mat);
+  int i, j, index, ret = 0;
+  if(mpfr_cmp_ui(norm, 0) > 0){
+    for(j = 0; j < x->column; j++){
+      index = j * x->row;
+      for(i = 0; i < x->row; i++){
+	mpfi_div_fr(new->data + i + index, x->data + i + index, norm);
+      }
+    }
+  }else{
+    ret = 1;
+  }
+  r_mpfr_matrix_temp_free(fr_mat);
+  r_mpfr_temp_free(norm);
+  return ret;
+}
+
+void mpfi_vector_midpoint(MPFIMatrix *new, MPFIMatrix *x, MPFIMatrix *y){
+  int i;
+  for (i = 0; i < new->size; i++) {
+    mpfi_add(mpfi_matrix_get_ptr(new, i), mpfi_matrix_get_ptr(x, i), mpfi_matrix_get_ptr(y, i));
+    mpfi_div_ui(mpfi_matrix_get_ptr(new, i), mpfi_matrix_get_ptr(new, i), 2);
+  }
+}
+
+/* If length of MPFIMatrix *x is zero, return 1. Otherwise return 0. */
+int mpfi_vector_set_length(MPFIMatrix *new, MPFIMatrix *x, MPFR *length){
+  MPFI *norm_i;
+  MPFR *factor_r;
+  r_mpfi_temp_alloc_init(norm_i);
+  r_mpfr_temp_alloc_init(factor_r);
+  mpfi_matrix_vector_norm(norm_i, x);
+  mpfi_mid(factor_r, norm_i);
+  int i, j, index, ret = 0;
+  if(mpfr_cmp_ui(factor_r, 0) > 0){
+    mpfr_ui_div(factor_r, 1, factor_r, GMP_RNDN);
+    mpfr_mul(factor_r, factor_r, length, GMP_RNDN);
+    for(j = 0; j < x->column; j++){
+      index = j * x->row;
+      for(i = 0; i < x->row; i++){
+	mpfi_mul_fr(new->data + i + index, x->data + i + index, factor_r);
+      }
+    }
+  }else{
+    ret = 1;
+  }
+  r_mpfi_temp_free(norm_i);
+  r_mpfr_temp_free(factor_r);
+  return ret;
+}
+
+/* ---------------------- square matrix ------------------------- */
+
+/* Return 0 if we execute even permutation for matrix, 1 if odd permutation or */
+/* -1 if matrix is singular. */
+int mpfi_square_matrix_lu_decomp (MPFIMatrix *ret, int *indx, MPFIMatrix *x){
+  int i, j, k, imax, ret_val = 0;
+  MPFI *big, *sum, *dum, *tmp1, *tmp2;
+  MPFIMatrix *vv, *tmp_ret;
+  r_mpfi_matrix_temp_alloc_init(tmp_ret, ret->row, ret->column);
+
+  mpfi_matrix_set(tmp_ret, x);
+
+  r_mpfi_temp_alloc_init(big);
+  r_mpfi_temp_alloc_init(sum);
+  r_mpfi_temp_alloc_init(dum);
+  r_mpfi_temp_alloc_init(tmp1);
+  r_mpfi_temp_alloc_init(tmp2);
+  r_mpfi_matrix_temp_alloc_init(vv, x->size, 1);
+  for (i = 0; i < tmp_ret->row; i++) {
+    mpfi_set_si(big, 0);
+    for (j = 0; j < tmp_ret->column; j++) {
+      mpfi_abs(tmp1, mpfi_matrix_get_element(x, i, j));
+
+      mpfi_intersect(tmp2, tmp1, big);
+      if(mpfi_is_empty(tmp2) > 0){
+	if(mpfr_cmp(r_mpfi_right_ptr(tmp1), r_mpfi_left_ptr(big)) > 0){
+	  mpfi_set(big, tmp1);
+	}
+      }else{
+	mpfi_union(big, tmp1, big);
+      }
+    }
+    if (mpfi_has_zero(big) > 0) {
+      ret_val = -1;
+      break;
+    }
+    mpfi_ui_div(vv->data + i, 1, big);
+  }
+
+  if (ret_val >= 0) {
+    for (j = 0; j < tmp_ret->column; j++) {
+      for (i = 0; i < j; i++) {
+	mpfi_set(sum, mpfi_matrix_get_element(tmp_ret, i, j));
+	for (k = 0; k < i; k++) {
+	  mpfi_mul(tmp1, mpfi_matrix_get_element(tmp_ret, i, k), mpfi_matrix_get_element(tmp_ret, k, j));
+	  mpfi_sub(sum, sum, tmp1);
+	}
+	mpfi_set(mpfi_matrix_get_element(tmp_ret, i, j), sum);
+      }
+      mpfi_set_si(big, 0);
+      imax = j;
+      for (i = j; i < tmp_ret->row; i++) {
+        mpfi_set(sum, mpfi_matrix_get_element(tmp_ret, i, j));
+	for (k = 0; k < j; k++) {
+	  mpfi_mul(tmp1, mpfi_matrix_get_element(tmp_ret, i, k), mpfi_matrix_get_element(tmp_ret, k, j));
+	  mpfi_sub(sum, sum, tmp1);
+	}
+	mpfi_set(mpfi_matrix_get_element(tmp_ret, i, j), sum);
+	mpfi_abs(dum, sum);
+	mpfi_mul(dum, vv->data + i, dum);
+
+	mpfi_intersect(tmp2, dum, big);
+	if(mpfi_is_empty(tmp2) > 0){
+	  if(mpfr_cmp(r_mpfi_right_ptr(dum), r_mpfi_left_ptr(big)) > 0){
+	    mpfi_set(big, dum);
+	    imax = i;
+	  }
+	}else{
+	  mpfi_union(big, dum, big);
+	  imax = i;
+	}
+      }
+      if (j != imax) {
+	for (k = 0; k < tmp_ret->column; k++) {
+	  mpfi_set(dum, mpfi_matrix_get_element(tmp_ret, imax, k));
+	  mpfi_set(mpfi_matrix_get_element(tmp_ret, imax, k), mpfi_matrix_get_element(tmp_ret, j, k));
+	  mpfi_set(mpfi_matrix_get_element(tmp_ret, j, k), dum);
+	}
+	ret_val = (ret_val + 1) % 2;
+	mpfi_set(vv->data + imax, vv->data + j);
+      }
+      indx[j] = imax;
+      if (mpfi_has_zero(mpfi_matrix_get_element(tmp_ret, j, j)) > 0) {
+	ret_val = -1;
+	break;
+      }
+      if (j < tmp_ret->row - 1) {
+	mpfi_ui_div(dum, 1, mpfi_matrix_get_element(tmp_ret, j, j));
+	for (i = j + 1; i < tmp_ret->row; i++) {
+	  mpfi_mul(mpfi_matrix_get_element(tmp_ret, i, j), mpfi_matrix_get_element(tmp_ret, i, j), dum);
+	}
+      }
+    }
+  }
+  mpfi_matrix_set(ret, tmp_ret);
+  
+  r_mpfi_matrix_temp_free(tmp_ret);
+  r_mpfi_temp_free(big);
+  r_mpfi_temp_free(sum);
+  r_mpfi_temp_free(dum);
+  r_mpfi_temp_free(tmp1);
+  r_mpfi_temp_free(tmp2);
+  r_mpfi_matrix_temp_free(vv);
+  return ret_val;
+}
+
+void mpfi_2d_square_matrix_determinant(MPFI *det, MPFIMatrix *x){
+  MPFI *tmp;
+  r_mpfi_temp_alloc_init(tmp);
+  mpfi_mul(det, x->data, x->data + 3);
+  mpfi_mul(tmp, x->data + 1, x->data + 2);
+  mpfi_sub(det, det, tmp);
+  r_mpfi_temp_free(tmp);
+}
+
+void mpfi_3d_square_matrix_determinant(MPFI *det, MPFIMatrix *x){
+  MPFI *tmp;
+  r_mpfi_temp_alloc_init(tmp);
+
+  mpfi_mul(tmp, mpfi_matrix_get_element(x, 0, 0), mpfi_matrix_get_element(x, 1, 1));
+  mpfi_mul(tmp, mpfi_matrix_get_element(x, 2, 2), tmp);
+  mpfi_set(det, tmp);
+
+  mpfi_mul(tmp, mpfi_matrix_get_element(x, 0, 1), mpfi_matrix_get_element(x, 1, 2));
+  mpfi_mul(tmp, mpfi_matrix_get_element(x, 2, 0), tmp);
+  mpfi_add(det, det, tmp);
+
+  mpfi_mul(tmp, mpfi_matrix_get_element(x, 0, 2), mpfi_matrix_get_element(x, 1, 0));
+  mpfi_mul(tmp, mpfi_matrix_get_element(x, 2, 1), tmp);
+  mpfi_add(det, det, tmp);
+
+  mpfi_mul(tmp, mpfi_matrix_get_element(x, 0, 0), mpfi_matrix_get_element(x, 1, 2));
+  mpfi_mul(tmp, mpfi_matrix_get_element(x, 2, 1), tmp);
+  mpfi_sub(det, det, tmp);
+  
+  mpfi_mul(tmp, mpfi_matrix_get_element(x, 0, 1), mpfi_matrix_get_element(x, 1, 0));
+  mpfi_mul(tmp, mpfi_matrix_get_element(x, 2, 2), tmp);
+  mpfi_sub(det, det, tmp);
+  
+  mpfi_mul(tmp, mpfi_matrix_get_element(x, 0, 2), mpfi_matrix_get_element(x, 1, 1));
+  mpfi_mul(tmp, mpfi_matrix_get_element(x, 2, 0), tmp);
+  mpfi_sub(det, det, tmp);
+  
+  r_mpfi_temp_free(tmp);
+}
+
+void mpfi_square_matrix_determinant(MPFI *det, MPFIMatrix *x){
+  if (x->column == 2 && x->row == 2){
+    mpfi_2d_square_matrix_determinant(det, x);
+  }else if(x->column == 3 && x->row == 3){
+    mpfi_3d_square_matrix_determinant(det, x);
+  }else{
+    MPFIMatrix *ptr_lu;
+    r_mpfi_matrix_temp_alloc_init(ptr_lu, x->row, x->column);
+    int indx[x->row], i;
+    if((i = mpfi_square_matrix_lu_decomp (ptr_lu, indx, x)) >= 0){
+      if (i == 0) {
+	mpfi_set_si(det, 1);
+      } else if (i == 1) {
+	mpfi_set_si(det, -1);
+      }
+      for (i = 0; i < x->row; i++) {
+        mpfi_mul(det, det, mpfi_matrix_get_element(ptr_lu, i, i));
+      }
+    }else{
+      mpfi_set_ui(det, 0);
+    }
+    r_mpfi_matrix_temp_free(ptr_lu);
+  }
+
+}
+
+void mpfi_square_matrix_qr_decomp(MPFIMatrix *q, MPFIMatrix *r, MPFIMatrix *x){
+  MPFIMatrix *q_mat, *r_mat;
+  r_mpfi_matrix_temp_alloc_init(q_mat, q->row, q->column);
+  r_mpfi_matrix_temp_alloc_init(r_mat, r->row, r->column);
+
+  int size = x->row;
+  MPFIMatrix *ary;
+  r_mpfi_matrix_temp_alloc_init(ary, size, size);
+  mpfi_matrix_set(ary, x);
+  MPFI *tmp;
+  r_mpfi_temp_alloc_init(tmp);
+  int i, j, k, ind1, ind2, ind3;
+  for (i = 0; i < size; i++) {
+    ind1 = i * size;
+    ind2 = i + ind1;
+    mpfi_set_si(r_mat->data + ind2, 0);
+    for (j = 0; j < size; j++) {
+      mpfi_mul(tmp, ary->data + j + ind1, ary->data + j + ind1);
+      mpfi_add(r_mat->data + ind2, r_mat->data + ind2, tmp);
+    }
+    mpfi_sqrt(r_mat->data + ind2, r_mat->data + ind2);
+    for (j = 0; j < size; j++) {
+      mpfi_div(q_mat->data + j + ind1, ary->data + j + ind1, r_mat->data + ind2);
+    }
+    for (j = (i + 1); j < size; j++) {
+      ind2 = j * size;
+      ind3 = i + ind2;
+      mpfi_set_si(r_mat->data + ind3, 0);
+      for (k = 0; k < size; k++) {
+        mpfi_mul(tmp, q_mat->data + k + ind1, ary->data + k + ind2);
+	mpfi_add(r_mat->data + ind3, r_mat->data + ind3, tmp);
+      }
+      for (k = 0; k < size; k++) {
+        mpfi_mul(tmp, r_mat->data + ind3, q_mat->data + k + ind1);
+	mpfi_sub(ary->data + k + ind2, ary->data + k + ind2, tmp);
+      }
+    }
+  }
+  mpfi_matrix_set(q, q_mat);
+  mpfi_matrix_set(r, r_mat);
+
+  r_mpfi_matrix_temp_free(q_mat);
+  r_mpfi_matrix_temp_free(r_mat);
+  r_mpfi_matrix_temp_free(ary);
+  r_mpfi_temp_free(tmp);
+}
+
+/* If inverse matrix does not exist, return 1. Otherwise return 0. */
+int mpfi_2d_square_matrix_inverse_matrix(MPFIMatrix *inv, MPFIMatrix *x){
+  MPFIMatrix *t_mat;
+  r_mpfi_matrix_temp_alloc_init(t_mat, inv->row, inv->column);
+  MPFI *t_fi;
+  r_mpfi_temp_alloc_init(t_fi);
+  mpfi_2d_square_matrix_determinant(t_fi, x);
+  if(mpfi_has_zero(t_fi) > 0){
+    return 1;
+  }else{
+    mpfi_ui_div(t_fi, 1, t_fi);
+    mpfi_mul(t_mat->data, x->data + 3, t_fi);
+    mpfi_mul(t_mat->data + 3, x->data, t_fi);
+    mpfi_neg(t_fi, t_fi);
+    mpfi_mul(t_mat->data + 1, x->data + 1, t_fi);
+    mpfi_mul(t_mat->data + 2, x->data + 2, t_fi);
+  }
+  mpfi_matrix_set(inv, t_mat);
+  r_mpfi_matrix_temp_free(t_mat);
+  r_mpfi_temp_free(t_fi);
+  return 0;
+}
+
+/* x = -(sqrt(a11**2-2*a00*a11+4*a01*a10+a00**2)-a11-a00)/2.0E+0 */
+/* x = (sqrt(a11**2-2*a00*a11+4*a01*a10+a00**2)+a11+a00)/2.0E+0 */
+/* If there are two real eigenvalues, return positive number. */
+/* If only one eigenvalue exists, return 0. */
+/* If there are two complex eigenvalues, this functionreturn negative number and */
+/* first returned value is real part and second one is imaginary part. */
+int mpfi_2d_square_matrix_eigenvalue(MPFI *val1, MPFI *val2, MPFIMatrix *x){
+  int ret;
+  MPFI *d;
+  r_mpfi_temp_alloc_init(d);
+
+  mpfi_sub(val1, x->data, x->data + 3);
+  mpfi_mul(val1, val1, val1);
+  mpfi_mul(d, x->data + 1, x->data + 2);
+  mpfi_mul_ui(d, d, 4);
+  mpfi_add(d, d, val1);
+
+  mpfi_add(val1, x->data, x->data + 3);
+  mpfi_div_ui(val1, val1, 2);
+  if(mpfr_cmp_si(r_mpfi_right_ptr(d), 0) > 0){
+    ret = 1;
+    mpfi_sqrt(d, d);
+    mpfi_div_ui(d, d, 2);
+    mpfi_sub(val2, val1, d);
+    mpfi_add(val1, val1, d);
+  }else if(mpfr_cmp_si(r_mpfi_right_ptr(d), 0) < 0){
+    ret = -1;
+    mpfi_neg(d, d);
+    mpfi_sqrt(d, d);
+    mpfi_div_ui(val2, d, 2);
+  }else{
+    ret = 0;
+    mpfi_set(val2, val1);
+  }
+
+  r_mpfi_temp_free(d);
+  return ret;
+}
+
+void mpfi_2d_square_matrix_real_eigenvector(MPFIMatrix *vec, MPFIMatrix *x, MPFI *eigenval){
+  MPFIMatrix *tmp;
+  r_mpfi_matrix_temp_alloc_init(tmp, 2, 1);
+  MPFI *tmp_fi;
+  r_mpfi_temp_alloc_init(tmp_fi);
+  mpfi_sub(tmp_fi, x->data + 3, eigenval);
+  if(mpfi_has_zero(x->data + 1) > 0 && mpfi_has_zero(tmp_fi) > 0){
+    mpfi_set(tmp->data, x->data + 2);
+    mpfi_sub(tmp->data + 1, eigenval, x->data);
+  }else{
+    mpfi_sub(tmp->data, eigenval, x->data + 3);
+    mpfi_set(tmp->data + 1, x->data + 1);
+  }
+  if(mpfi_vector_normalize(vec, tmp) == 1){
+    gmp_printf("Argument matrix\n%.Ff\n%.Ff\n%.Ff\n%.Ff\n", x->data, x->data + 1, x->data + 2, x->data + 3);
+    gmp_printf("Argument eigenvalue\n%.Ff\n", eigenval);
+    rb_raise(rb_eArgError, "Invalid eigenvalue or eigenvector.");
+  }
+  r_mpfi_matrix_temp_free(tmp);
+  r_mpfi_temp_free(tmp_fi);
+}
+
+void mpfi_square_matrix_identity(MPFIMatrix *id){
+  int i, j, index;
+  for (j = 0; j < id->column; j++) {
+    index = j * id->row;
+    for (i = 0; i < id->row; i++) {
+      if(i == j){
+	mpfi_set_si(id->data + i + index, 1);
+      }else{
+	mpfi_set_si(id->data + i + index, 0);
+      }
+    }
+  }
+  
+}