ruby-mpfi 0.0.5 → 0.0.6

data/Rakefile

@@ -14,7 +14,7 @@ $hoe = Hoe.spec 'ruby-mpfi' do
   self.developer 'Takayuki YAMAGUCHI', 'd@ytak.info'
   self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
   self.rubyforge_name       = self.name # TODO this is default value
-  self.extra_deps         = [['ruby-mpfr','>= 0.0.4']]
+  self.extra_deps         = [['ruby-mpfr','>= 0.0.11']]
   self.spec_extras[:extensions] = ["ext/mpfi/extconf.rb", "ext/mpfi_complex/mpfi/extconf.rb", "ext/mpfi_matrix/mpfi/extconf.rb"]
   self.extra_rdoc_files << 'README.rdoc'
 end

data/ext/mpfi/ruby_mpfi.c

@@ -15,7 +15,7 @@ void r_mpfi_set_function_state(int num)
 }
 
 /* Return state of last function of MPFI. */
-VALUE r_mpfr_get_function_state(VALUE self)
+VALUE r_mpfi_get_function_state(VALUE self)
 {
   return rb_cv_get(r_mpfi_class, CLASS_VAL_FUNCTION_STATE);
 }
@@ -216,6 +216,57 @@ static VALUE r_mpfi_swap (VALUE self, VALUE other)
   return self;
 }
 
+char *r_mpfi_dump_to_string(MPFI *ptr_s)
+{
+  char *ret_str, *str_right, *str_left;
+  str_left = r_mpfr_dump_to_string(r_mpfi_left_ptr(ptr_s));
+  str_right = r_mpfr_dump_to_string(r_mpfi_right_ptr(ptr_s));
+  if(!mpfr_asprintf(&ret_str, "%s %s", str_left, str_right)) {
+    rb_raise(rb_eFatal, "Can not allocate a string by mpfr_asprintf.");
+  }
+  mpfr_free_str(str_left);
+  mpfr_free_str(str_right);
+  return ret_str;
+}
+
+static VALUE r_mpfi_marshal_dump(VALUE self)
+{
+  MPFI *ptr_s;
+  r_mpfi_get_struct(ptr_s, self);
+  char *ret_str = r_mpfi_dump_to_string(ptr_s);
+  VALUE ret_val = rb_str_new2(ret_str);
+  mpfr_free_str(ret_str);
+  return ret_val;
+}
+
+void r_mpfi_load_string(MPFI *ptr_s, const char *dump)
+{
+  int i;
+  char *left;
+  i = 0;
+  while (dump[i] != ' ') {
+    i++;
+  }
+  i++;
+  left = malloc(sizeof(char) * i);
+  strncpy(left, dump, i - 1);
+  left[i - 1] = '\0';
+  r_mpfr_load_string(r_mpfi_left_ptr(ptr_s), left);
+  free(left);
+  r_mpfr_load_string(r_mpfi_right_ptr(ptr_s), dump + i);
+}
+
+static VALUE r_mpfi_marshal_load(VALUE self, VALUE dump_string)
+{
+  MPFI *ptr_s;
+  char *dump;
+  r_mpfi_get_struct(ptr_s, self);
+  Check_Type(dump_string, T_STRING);
+  dump = RSTRING_PTR(dump_string);
+  r_mpfi_load_string(ptr_s, dump);
+  return self;
+}
+
 /* ------------------------------ allocation end ------------------------------ */
 
 /* ------------------------------ Rounding Modes and Precision Handling start ------------------------------*/
@@ -264,8 +315,11 @@ static VALUE r_mpfi_inspect(VALUE self)
   MPFI *ptr_s;
   r_mpfi_get_struct(ptr_s, self);
   char *ret_str;
-  mpfr_asprintf(&ret_str, "#<MPFI:%lx,['%.Re %.Re'],%d>",
-  		NUM2LONG(rb_funcall(self, object_id, 0)), r_mpfi_left_ptr(ptr_s), r_mpfi_right_ptr(ptr_s), mpfi_get_prec(ptr_s));
+  if (!mpfr_asprintf(&ret_str, "#<MPFI:%lx,['%.Re %.Re'],%d>",
+		    NUM2LONG(rb_funcall(self, object_id, 0)), r_mpfi_left_ptr(ptr_s),
+		    r_mpfi_right_ptr(ptr_s), mpfi_get_prec(ptr_s))) {
+    rb_raise(rb_eFatal, "Can not allocate a string by mpfr_asprintf.");
+  }
   VALUE ret_val = rb_str_new2(ret_str);
   mpfr_free_str(ret_str);
   return ret_val;
@@ -277,8 +331,12 @@ static VALUE r_mpfi_to_str_ary(VALUE self)
   MPFI *ptr_self;
   r_mpfi_get_struct(ptr_self, self);
   char *ret_str1, *ret_str2;
-  mpfr_asprintf(&ret_str1, "%.Re", r_mpfi_left_ptr(ptr_self));
-  mpfr_asprintf(&ret_str2, "%.Re", r_mpfi_right_ptr(ptr_self));
+  if (!mpfr_asprintf(&ret_str1, "%.Re", r_mpfi_left_ptr(ptr_self))) {
+    rb_raise(rb_eFatal, "Can not allocate a string by mpfr_asprintf.");
+  }
+  if (!mpfr_asprintf(&ret_str2, "%.Re", r_mpfi_right_ptr(ptr_self))) {
+    rb_raise(rb_eFatal, "Can not allocate a string by mpfr_asprintf.");
+  }
   VALUE str1 = rb_str_new2(ret_str1), str2 = rb_str_new2(ret_str2);
   mpfr_free_str(ret_str1);
   mpfr_free_str(ret_str2);
@@ -292,8 +350,12 @@ static VALUE r_mpfi_to_strf_ary(VALUE self, VALUE format_str)
   r_mpfi_get_struct(ptr_self, self);
   char *format = StringValuePtr(format_str);
   char *ret_str1, *ret_str2;
-  mpfr_asprintf(&ret_str1, format, r_mpfi_left_ptr(ptr_self));
-  mpfr_asprintf(&ret_str2, format, r_mpfi_right_ptr(ptr_self));
+  if (!mpfr_asprintf(&ret_str1, format, r_mpfi_left_ptr(ptr_self))) {
+    rb_raise(rb_eFatal, "Can not allocate a string by mpfr_asprintf.");
+  }
+  if (!mpfr_asprintf(&ret_str2, format, r_mpfi_right_ptr(ptr_self))) {
+    rb_raise(rb_eFatal, "Can not allocate a string by mpfr_asprintf.");
+  }
   VALUE str1 = rb_str_new2(ret_str1), str2 = rb_str_new2(ret_str2);
   mpfr_free_str(ret_str1);
   mpfr_free_str(ret_str2);
@@ -1484,7 +1546,7 @@ void Init_mpfi()
 
   /* ------------------------------ function state start ------------------------------ */
   rb_define_class_variable(r_mpfi_class, CLASS_VAL_FUNCTION_STATE, INT2FIX(0));
-  rb_define_singleton_method(r_mpfi_class, "function_state", r_mpfr_get_function_state, 0);
+  rb_define_singleton_method(r_mpfi_class, "function_state", r_mpfi_get_function_state, 0);
   /* ------------------------------ function state end ------------------------------ */
 
   /* ------------------------------ allocation start ------------------------------ */
@@ -1507,6 +1569,9 @@ void Init_mpfi()
   /* ------------------------------ string start ------------------------------ */
   rb_define_method(r_mpfi_class, "inspect", r_mpfi_inspect, 0);
 
+  rb_define_method(r_mpfi_class, "marshal_dump", r_mpfi_marshal_dump, 0);
+  rb_define_method(r_mpfi_class, "marshal_load", r_mpfi_marshal_load, 1);
+
   rb_define_method(r_mpfi_class, "to_str_ary", r_mpfi_to_str_ary, 0);
   rb_define_method(r_mpfi_class, "to_strf_ary", r_mpfi_to_strf_ary, 1);
   /* ------------------------------ string end ------------------------------ */

data/ext/mpfi/ruby_mpfi.h

@@ -34,6 +34,9 @@ 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);
+VALUE r_mpfi_get_function_state(VALUE self);
+
+void r_mpfi_load_string(MPFI *ptr_s, const char *dump);
+char *r_mpfi_dump_to_string(MPFI *ptr_s);
 
 #endif /* _RUBY_MPFI_H_ */

data/ext/mpfi/ruby_mpfr.h

@@ -26,13 +26,19 @@ VALUE r_mpfr_class, r_mpfr_math;
 #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_make_new_fr_obj(MPFR *ptr);
+VALUE r_mpfr_make_new_fr_obj2(MPFR *ptr, int prec);
 VALUE r_mpfr_new_fr_obj(VALUE obj);
 void r_mpfr_set_robj(MPFR *ptr, VALUE obj, mp_rnd_t rnd);
+VALUE r_mpfr_robj_to_mpfr(VALUE obj, int argc, VALUE *argv);
 
 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);
 
+char *r_mpfr_dump_to_string(MPFR *ptr_s);
+void r_mpfr_load_string(MPFR *ptr_s, const char *dump);
+
 #endif /* _RUBY_MPFR_H_ */
 

data/ext/mpfi_complex/mpfi/ruby_mpfi.h

@@ -34,6 +34,9 @@ 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);
+VALUE r_mpfi_get_function_state(VALUE self);
+
+void r_mpfi_load_string(MPFI *ptr_s, const char *dump);
+char *r_mpfi_dump_to_string(MPFI *ptr_s);
 
 #endif /* _RUBY_MPFI_H_ */

data/ext/mpfi_complex/mpfi/ruby_mpfi_complex.c

@@ -132,9 +132,12 @@ 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));
+  if (!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))) {
+    rb_raise(rb_eFatal, "Can not allocate a string by mpfr_asprintf.");
+  }
   VALUE ret_val = rb_str_new2(ret_str);
   mpfr_free_str(ret_str);
   return ret_val;

data/ext/mpfi_complex/mpfi/ruby_mpfr.h

@@ -26,13 +26,19 @@ VALUE r_mpfr_class, r_mpfr_math;
 #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_make_new_fr_obj(MPFR *ptr);
+VALUE r_mpfr_make_new_fr_obj2(MPFR *ptr, int prec);
 VALUE r_mpfr_new_fr_obj(VALUE obj);
 void r_mpfr_set_robj(MPFR *ptr, VALUE obj, mp_rnd_t rnd);
+VALUE r_mpfr_robj_to_mpfr(VALUE obj, int argc, VALUE *argv);
 
 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);
 
+char *r_mpfr_dump_to_string(MPFR *ptr_s);
+void r_mpfr_load_string(MPFR *ptr_s, const char *dump);
+
 #endif /* _RUBY_MPFR_H_ */
 

data/ext/mpfi_matrix/mpfi/ruby_mpfi.h

@@ -34,6 +34,9 @@ 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);
+VALUE r_mpfi_get_function_state(VALUE self);
+
+void r_mpfi_load_string(MPFI *ptr_s, const char *dump);
+char *r_mpfi_dump_to_string(MPFI *ptr_s);
 
 #endif /* _RUBY_MPFI_H_ */

data/ext/mpfi_matrix/mpfi/ruby_mpfi_matrix.c

@@ -208,7 +208,7 @@ static VALUE r_mpfi_col_vector_global_new(int argc, VALUE arg)
 {
   MPFIMatrix *ptr;
   VALUE val;
-  r_mpfi_make_matrix_struct(val, ptr);
+  r_mpfi_make_col_vector_struct(val, ptr);
   r_mpfi_col_vector_set_initial_value(ptr, arg);
   return val;
 }
@@ -270,6 +270,48 @@ static VALUE r_mpfi_row_vector_initialize (VALUE self, VALUE arg){
   return Qtrue;
 }
 
+static VALUE r_mpfi_matrix_marshal_dump(VALUE self)
+{
+  MPFIMatrix *ptr;
+  r_mpfi_get_matrix_struct(ptr, self);
+  int i;
+  char *tmp_str;
+  VALUE ret_ary;
+  ret_ary = rb_ary_new();
+  rb_ary_push(ret_ary, INT2FIX(ptr->row));
+  rb_ary_push(ret_ary, INT2FIX(ptr->column));
+
+  for (i = 0; i < ptr->size; i++) {
+    tmp_str = r_mpfi_dump_to_string(ptr->data + i);
+    rb_ary_push(ret_ary, rb_str_new2(tmp_str));
+    mpfr_free_str(tmp_str);
+  }
+
+  return ret_ary;
+}
+
+static VALUE r_mpfi_matrix_marshal_load(VALUE self, VALUE dump_ary)
+{
+  MPFIMatrix *ptr;
+  r_mpfi_get_matrix_struct(ptr, self);
+
+  ptr->row = NUM2INT(rb_ary_entry(dump_ary, 0));
+  ptr->column = NUM2INT(rb_ary_entry(dump_ary, 1));
+  ptr->size = ptr->row * ptr->column;
+  ptr->data = ALLOC_N(MPFI, ptr->size);
+  int i;
+  char *dump;
+  VALUE dump_element;
+
+  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);
+    r_mpfi_load_string(ptr->data + i, dump);
+  }
+  return self;
+}
+
 /* Return size of data array which equals to column * row. */
 static VALUE r_mpfi_matrix_size (VALUE self){
   MPFIMatrix *ptr_self;
@@ -373,8 +415,10 @@ static VALUE r_mpfi_matrix_str_ary_for_inspect(VALUE self){
   VALUE ret_val[ptr_self->size];
   int i;
   for (i = 0; i < ptr_self->size; i++) {
-    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.");
+    }
     ret_val[i] = rb_str_new2(tmp_str);
     mpfr_free_str(tmp_str);
   }
@@ -393,8 +437,10 @@ static VALUE r_mpfi_matrix_str_ary_for_inspect2(VALUE self){
   }
   for (i = 0; i < ptr_self->size; i += ptr_self->row) {
     for (j = 0; j < ptr_self->row; j++) {
-      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));
       mpfr_free_str(tmp_str);
     }
@@ -413,8 +459,12 @@ static VALUE r_mpfi_matrix_to_str_ary(VALUE self){
   }
   for (i = 0; i < ptr_self->size; i += ptr_self->row) {
     for (j = 0; j < ptr_self->row; j++) {
-      mpfr_asprintf(&tmp_str1, "%.Re", r_mpfi_left_ptr((ptr_self->data + i + j)));
-      mpfr_asprintf(&tmp_str2, "%.Re", r_mpfi_right_ptr(ptr_self->data + i + j));
+      if (!mpfr_asprintf(&tmp_str1, "%.Re", 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, "%.Re", 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)));
       mpfr_free_str(tmp_str1);
       mpfr_free_str(tmp_str2);
@@ -435,8 +485,12 @@ static VALUE r_mpfi_matrix_to_strf_ary(VALUE self, VALUE format_str){
   }
   for (i = 0; i < ptr_self->size; i += ptr_self->row) {
     for (j = 0; j < ptr_self->row; j++) {
-      mpfr_asprintf(&tmp_str1, format, r_mpfi_left_ptr((ptr_self->data + i + j)));
-      mpfr_asprintf(&tmp_str2, format, r_mpfi_right_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))) {
+	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)));
       mpfr_free_str(tmp_str1);
       mpfr_free_str(tmp_str2);
@@ -1151,6 +1205,9 @@ void Init_matrix(){
   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);
 
+  rb_define_method(r_mpfi_matrix, "marshal_dump", r_mpfi_matrix_marshal_dump, 0);
+  rb_define_method(r_mpfi_matrix, "marshal_load", r_mpfi_matrix_marshal_load, 1);
+
   rb_define_singleton_method(tmp_r_mpfi_class, "SquareMatrix", r_mpfi_square_matrix_global_new, 1);
   rb_define_alloc_func(r_mpfi_square_matrix, r_mpfi_square_matrix_alloc);
   rb_define_private_method(r_mpfi_square_matrix, "initialize", r_mpfi_square_matrix_initialize, 1);
@@ -1228,9 +1285,6 @@ void Init_matrix(){
   /* Initialization of MPFI::Vector module */
   r_mpfi_vector_module = rb_define_module_under(tmp_r_mpfi_class, "Vector");
 
-  rb_include_module(r_mpfi_col_vector, r_mpfi_vector_module);
-  rb_include_module(r_mpfi_row_vector, r_mpfi_vector_module);
-
   rb_define_method(r_mpfi_vector_module, "[]=", r_mpfi_vector_set_element, 2);
   rb_define_method(r_mpfi_vector_module, "[]", r_mpfi_vector_element, 1);
   rb_define_method(r_mpfi_vector_module, "each_element", r_mpfi_vector_each_element, 0);
@@ -1256,6 +1310,8 @@ void Init_matrix(){
 
   rb_define_method(r_mpfr_matrix, "to_fi_matrix", r_mpfr_matrix_to_fi_matrix, 0);
 
+  rb_include_module(r_mpfi_col_vector, r_mpfi_vector_module);
+  rb_include_module(r_mpfi_row_vector, r_mpfi_vector_module);
 
   eqq = rb_intern("===");
   __mpfr_matrix_class__ = rb_eval_string("MPFR::Matrix");

data/ext/mpfi_matrix/mpfi/ruby_mpfr.h

@@ -26,13 +26,19 @@ VALUE r_mpfr_class, r_mpfr_math;
 #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_make_new_fr_obj(MPFR *ptr);
+VALUE r_mpfr_make_new_fr_obj2(MPFR *ptr, int prec);
 VALUE r_mpfr_new_fr_obj(VALUE obj);
 void r_mpfr_set_robj(MPFR *ptr, VALUE obj, mp_rnd_t rnd);
+VALUE r_mpfr_robj_to_mpfr(VALUE obj, int argc, VALUE *argv);
 
 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);
 
+char *r_mpfr_dump_to_string(MPFR *ptr_s);
+void r_mpfr_load_string(MPFR *ptr_s, const char *dump);
+
 #endif /* _RUBY_MPFR_H_ */
 

data/lib/mpfi/version.rb

@@ -1 +1 @@
-RUBY_MPFI_VERSION = '0.0.5'
+RUBY_MPFI_VERSION = '0.0.6'

data/spec/mpfi_matrix/mpfi_vector_spec.rb

@@ -1,5 +1,19 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 
+describe MPFI::ColumnVector, "when creating MPFI::ColumnVector method" do
+  it "should return MPFI::ColumnVector" do
+    MPFI::ColumnVector([1, 2]).should be_an_instance_of MPFI::ColumnVector
+    MPFI::ColumnVector(3).should be_an_instance_of MPFI::ColumnVector
+  end
+end
+
+describe MPFI::RowVector, "when creating MPFI::RowVector method" do
+  it "should return MPFI::ColumnVector" do
+    MPFI::RowVector([1, 2]).should be_an_instance_of MPFI::RowVector
+    MPFI::ColumnVector(3).should be_an_instance_of MPFI::ColumnVector
+  end
+end
+
 describe MPFI::ColumnVector, "when dividing to some parts" do
   before(:all) do
     MPFR.set_default_prec(128)

metadata

@@ -2,7 +2,7 @@
 name: ruby-mpfi
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - Takayuki YAMAGUCHI
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-16 00:00:00 +09:00
+date: 2011-02-26 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -21,7 +21,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.0.4
+        version: 0.0.11
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency