ruby-mpfi 0.0.2

data/ext/mpfi_matrix/mpfi/func_mpfi_matrix.h

@@ -0,0 +1,103 @@
+#include <stdio.h>
+#include <ruby.h>
+#include <mpfr.h>
+#include <mpfi.h>
+#include <mpfi_io.h>
+#include "ruby_mpfr_matrix.h"
+#include "ruby_mpfi.h"
+#include "ruby_mpfi_complex.h"
+
+typedef struct __MPFIMatrix{
+  int row, column, size;
+  MPFI *data;
+} MPFIMatrix;
+
+/*
+  1 2 3
+  4 5 6
+
+  row = 2
+  column = 3
+  size = 6
+  MPFI *data 1 4 2 5 3 6
+
+  (i, j) element => data + i + row * j
+  0 <= i < 2, 0 <= j < 3
+*/
+
+#define r_mpfi_make_matrix_struct(ruby_var, mpfi_var) { ruby_var = Data_Make_Struct(r_mpfi_matrix, MPFIMatrix, 0, r_mpfi_matrix_free, mpfi_var); }
+#define r_mpfi_get_matrix_struct(mpfi_var, ruby_var) { Data_Get_Struct(ruby_var, MPFIMatrix, mpfi_var); }
+
+#define r_mpfi_make_square_matrix_struct(ruby_var, mpfi_var) { ruby_var = Data_Make_Struct(r_mpfi_square_matrix, MPFIMatrix, 0, r_mpfi_matrix_free, mpfi_var); }
+#define r_mpfi_make_col_vector_struct(ruby_var, mpfi_var) { ruby_var = Data_Make_Struct(r_mpfi_col_vector, MPFIMatrix, 0, r_mpfi_matrix_free, mpfi_var); }
+#define r_mpfi_make_row_vector_struct(ruby_var, mpfi_var) { ruby_var = Data_Make_Struct(r_mpfi_row_vector, MPFIMatrix, 0, r_mpfi_matrix_free, mpfi_var); }
+
+#define r_mpfi_matrix_temp_alloc_init(mpfi_var, i, j) { mpfi_var = ALLOC_N(MPFIMatrix, 1); mpfi_matrix_init(mpfi_var, i, j); }
+#define r_mpfi_matrix_temp_free(mpfi_var) { mpfi_matrix_clear(mpfi_var); free(mpfi_var); }
+
+#define mpfi_matrix_get_ptr(matrix, i) (matrix->data + i)
+#define mpfi_matrix_get_element(matrix, i, j) (matrix->data + i + matrix->row * j)
+
+
+/* Returned value may be same pointer as an argument which has always same size. */
+/* But if returned value may have different size from that of an argument */
+/* (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);
+
+/* ----------------- 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);
+
+/* ----------------- square matrix ----------------- */
+int mpfi_square_matrix_lu_decomp (MPFIMatrix *ret, int *indx, MPFIMatrix *x);
+void mpfi_2d_square_matrix_determinant(MPFI *det, MPFIMatrix *x);
+void mpfi_3d_square_matrix_determinant(MPFI *det, MPFIMatrix *x);
+void mpfi_square_matrix_determinant(MPFI *det, MPFIMatrix *x);
+void mpfi_square_matrix_qr_decomp(MPFIMatrix *q, MPFIMatrix *r, MPFIMatrix *x);
+int mpfi_2d_square_matrix_inverse_matrix(MPFIMatrix *inv, MPFIMatrix *x);
+int mpfi_2d_square_matrix_eigenvalue(MPFI *val1, MPFI *val2, MPFIMatrix *x);
+void mpfi_2d_square_matrix_real_eigenvector(MPFIMatrix *vec, MPFIMatrix *x, MPFI *eigenval);
+void mpfi_square_matrix_identity(MPFIMatrix *id);
+

data/ext/mpfi_matrix/mpfi/func_mpfr_matrix.h

@@ -0,0 +1,72 @@
+#include <stdio.h>
+#include <ruby.h>
+#include <mpfr.h>
+#include "ruby_mpfr.h"
+
+typedef struct __MPFRMatrix{
+  int row, column, size;
+  MPFR *data;
+} MPFRMatrix;
+
+/*
+  1 2 3
+  4 5 6
+
+  row = 2
+  column = 3
+  size = 6
+  MPFR *data 1 4 2 5 3 6
+
+  (i, j) element => data + i + row * j
+  0 <= i < 2, 0 <= j < 3
+*/
+
+#define r_mpfr_make_matrix_struct(ruby_var, c_var) { ruby_var = Data_Make_Struct(r_mpfr_matrix, MPFRMatrix, 0, r_mpfr_matrix_free, c_var); }
+#define r_mpfr_get_matrix_struct(c_var, ruby_var) { Data_Get_Struct(ruby_var, MPFRMatrix, c_var); }
+
+#define r_mpfr_make_square_matrix_struct(ruby_var, c_var) { ruby_var = Data_Make_Struct(r_mpfr_square_matrix, MPFRMatrix, 0, r_mpfr_matrix_free, c_var); }
+#define r_mpfr_make_col_vector_struct(ruby_var, c_var) { ruby_var = Data_Make_Struct(r_mpfr_col_vector, MPFRMatrix, 0, r_mpfr_matrix_free, c_var); }
+#define r_mpfr_make_row_vector_struct(ruby_var, c_var) { ruby_var = Data_Make_Struct(r_mpfr_row_vector, MPFRMatrix, 0, r_mpfr_matrix_free, c_var); }
+
+#define r_mpfr_matrix_temp_alloc_init(c_var, i, j) { c_var = ALLOC_N(MPFRMatrix, 1); mpfr_matrix_init(c_var, i, j); }
+#define r_mpfr_matrix_temp_free(c_var) { mpfr_matrix_clear(c_var); free(c_var); }
+
+#define mpfr_matrix_get_ptr(matrix, i) (matrix->data + i)
+#define mpfr_matrix_get_element(matrix, i, j) (matrix->data + i + matrix->row * j)
+
+void mpfr_matrix_clear(MPFRMatrix *mat);
+void mpfr_matrix_init(MPFRMatrix *mat, int row, int column);
+void mpfr_matrix_set_zeros(MPFRMatrix *mat);
+void mpfr_matrix_set_element(MPFRMatrix *mat, int row, int col, MPFR *a);
+void mpfr_matrix_set(MPFRMatrix *new, MPFRMatrix *x);
+void mpfr_matrix_swap(MPFRMatrix *x, MPFRMatrix *y);
+
+void mpfr_matrix_row(MPFRMatrix *new, MPFRMatrix *x, int row);
+void mpfr_matrix_column(MPFRMatrix *new, MPFRMatrix *x, int column);
+void mpfr_matrix_transpose(MPFRMatrix *new, MPFRMatrix *x);
+void mpfr_matrix_neg(MPFRMatrix *new, MPFRMatrix *x);
+
+int mpfr_matrix_equal_p(MPFRMatrix *x, MPFRMatrix *y);
+void mpfr_matrix_add(MPFRMatrix *new, MPFRMatrix *x, MPFRMatrix *y);
+void mpfr_matrix_sub(MPFRMatrix *new, MPFRMatrix *x, MPFRMatrix *y);
+void mpfr_matrix_mul(MPFRMatrix *new, MPFRMatrix *x, MPFRMatrix *y);
+void mpfr_matrix_mul_scalar(MPFRMatrix *new, MPFRMatrix *x, MPFR *scalar);
+void mpfr_matrix_div_scalar(MPFRMatrix *new, MPFRMatrix *x, MPFR *scalar);
+void mpfr_matrix_inner_product(MPFR *pr, MPFRMatrix *x, MPFRMatrix *y);
+void mpfr_matrix_vector_distance(MPFR *distance, MPFRMatrix *x, MPFRMatrix *y);
+void mpfr_matrix_vector_norm(MPFR *norm, MPFRMatrix *x);
+void mpfr_matrix_max_norm(MPFR *norm, MPFRMatrix *x);
+
+void mpfr_col_vector_init(MPFRMatrix *mat, int row);
+void mpfr_row_vector_init(MPFRMatrix *mat, int column);
+int mpfr_vector_normalize(MPFRMatrix *new, MPFRMatrix *x);
+int mpfr_vector_set_length(MPFRMatrix *new, MPFRMatrix *x, MPFR *l);
+void mpfr_vector_midpoint(MPFRMatrix *new, MPFRMatrix *x, MPFRMatrix *y);
+void mpfr_vector_dividing_point(MPFRMatrix *new, MPFRMatrix *x, MPFRMatrix *y, MPFR *div);
+
+int mpfr_square_matrix_lu_decomp (MPFRMatrix *ret, int *indx, MPFRMatrix *x);
+void mpfr_square_matrix_determinant(MPFR *det, MPFRMatrix *x);
+void mpfr_square_matrix_qr_decomp(MPFRMatrix *q, MPFRMatrix *r, MPFRMatrix *x);
+void mpfr_square_matrix_identity(MPFRMatrix *id);
+
+

data/ext/mpfi_matrix/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_matrix/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_matrix/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