gsl 1.12.109 → 1.14.5

data/examples/wavelet/wavelet1.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+n = 256
+nc = 20
+
+data = GSL::Vector.alloc(n)
+data.fscanf("ecg.dat")
+
+w = GSL::Wavelet.alloc("daubechies", 4)
+work = GSL::Wavelet::Workspace.alloc(n)
+
+# Choose as you like...
+data2 = w.transform(data, GSL::Wavelet::FORWARD, work)
+#data2 = data.wavelet_transform(w, GSL::Wavelet::FORWARD, work)
+#data2 = data.wavelet_transform_forward(w, work)
+#data2 = w.transform(data, work)
+#data2 = w.transform(data)
+#data2 = w.transform(data, GSL::Wavelet::FORWARD)
+#data2 = w.transform_forward(data, work)
+#data2 = w.transform_forward(data)
+#data2 = GSL::Wavelet.transform(w, data, GSL::Wavelet::FORWARD, work)
+#data2 = GSL::Wavelet.transform(w, data, GSL::Wavelet::FORWARD)
+#data2 = GSL::Wavelet.transform(w, data, work)
+#data2 = GSL::Wavelet.transform(w, data)
+#data2 = GSL::Wavelet.transform_forward(w, data, work)
+#data2 = GSL::Wavelet.transform_forward(w, data)
+
+perm = data2.abs.sort_index
+
+i = 0
+while (i + nc) < n
+  data2[perm[i]] = 0.0
+  i += 1  
+end
+
+# Choose as you like...
+data3 = w.transform(data2, GSL::Wavelet::BACKWARD, work)
+#data3 = data2.wavelet_transform(w, GSL::Wavelet::BACKWARD, work)
+#data3 = data2.wavelet_transform_inverse(w, work)
+#data3 = w.transform(data2, GSL::Wavelet::BACKWARD)
+#data3 = w.transform_inverse(data2, work)
+#data3 = w.transform_inverse(data2)
+#data3 = GSL::Wavelet.transform(w, data2, GSL::Wavelet::BACKWARD, work)
+#data3 = GSL::Wavelet.transform(w, data2, GSL::Wavelet::BACKWARD)
+#data3 = GSL::Wavelet.transform_inverse(w, data2, work)
+#data3 = GSL::Wavelet.transform_inverse(w, data2)
+
+GSL::graph(nil, data, data3, "-T X -C -g 3 -x 0 #{data.size} -L 'Red: data, Green: DWT'")
+

data/ext/extconf.rb

@@ -122,7 +122,12 @@ def check_version(configfile)
 
    if ver >= "1.12.90"
       configfile.printf("#ifndef GSL_1_13_LATER\n#define GSL_1_13_LATER\n#endif\n")
+    end
+
+    if ver >= "1.14"
+      configfile.printf("#ifndef GSL_1_14_LATER\n#define GSL_1_14_LATER\n#endif\n")
     end    
+    
   end
 end
 
@@ -219,6 +224,10 @@ begin
   end
   if RUBY_VERSION2 >= "1.9"
     RB_GSL_CONFIG.printf("#ifndef RUBY_1_9_LATER\n#define RUBY_1_9_LATER\n#endif\n")
+# Added 2010/Sep/29
+    if RUBY_VERSION2 >= "1.9.2"
+      RB_GSL_CONFIG.printf("#ifndef RUBY_1_9_2_LATER\n#define RUBY_1_9_2_LATER\n#endif\n")
+    end
   end
 
   RB_GSL_CONFIG.printf("\n#endif\n")

data/ext/gsl.c

@@ -188,6 +188,10 @@ void Init_rb_gsl()
 
 	Init_geometry(mgsl);
 
+#ifdef GSL_1_14_LATER
+	Init_multiset(mgsl);
+#endif
+
   rb_gsl_define_methods(mgsl);
 }
 
@@ -197,7 +201,7 @@ static void rb_gsl_define_intern(VALUE module)
 {
   rb_gsl_id_beg  = rb_intern("begin");
   rb_gsl_id_end  = rb_intern("end");
-  rb_gsl_id_excl = rb_intern("excl");
+  rb_gsl_id_excl = rb_intern("exclude_end?");
   rb_gsl_id_to_a = rb_intern("to_a");
   rb_gsl_id_name  = rb_intern("name");
   rb_gsl_id_size  = rb_intern("size");
@@ -244,6 +248,11 @@ static void rb_gsl_define_const(VALUE module)
   rb_define_const(module, "ROOT6_DBL_MIN", rb_float_new(GSL_ROOT6_DBL_MIN));
   rb_define_const(module, "LOG_DBL_MIN", rb_float_new(GSL_LOG_DBL_MIN));
 
+#ifdef GSL_1_14_LATER
+  rb_define_const(module, "MAJOR_VERSION", INT2FIX(GSL_MAJOR_VERSION));
+  rb_define_const(module, "MINOR_VERSION", INT2FIX(GSL_MINOR_VERSION));
+#endif
+
 }
 
 static VALUE rb_gsl_have_tensor(VALUE module)

data/ext/histogram.c

@@ -1144,7 +1144,9 @@ static int Gaussian_f(const gsl_vector *v, void *params, gsl_vector *f)
       rb_raise(rb_eIndexError, "wrong index");
     xi = (xl + xh)/2.0;
     yi = h->bin[i];
-    sqw = sqrt(yi);
+    //    sqw = sqrt(yi);
+    if (yi >= 1.0) sqw = 1.0/sqrt(yi);
+    else sqw = 1.0;
     gsl_vector_set(f, i-binstart, (amp*exp(-(xi - mu)*(xi - mu)/var/2.0) - yi)*sqw);
   }
   return GSL_SUCCESS;
@@ -1168,7 +1170,9 @@ static int Gaussian_df(const gsl_vector *v, void *params, gsl_matrix *J)
       rb_raise(rb_eIndexError, "wrong index");
     xi = (xl + xh)/2.0;
     yi = h->bin[i];
-    sqw = sqrt(yi);
+    //    sqw = sqrt(yi);
+    if (yi >= 1.0) sqw = 1.0/sqrt(yi);
+    else sqw = 1.0;
     y = exp(-(xi - mu)*(xi - mu)/var/2.0);
     gsl_matrix_set(J, i-binstart, 0, amp*y*(xi - mu)*(xi - mu)/2/var/var*sqw);
     gsl_matrix_set(J, i-binstart, 1, amp*y*(xi - mu)/var*sqw);

data/ext/integration.c

@@ -32,6 +32,10 @@ static VALUE cgsl_integration_qaws_table, cgsl_integration_qawo_table;
 
 static VALUE cgsl_integration_workspace;
 
+#ifdef GSL_1_14_LATER
+static VALUE cgsl_integration_glfixed_table;
+#endif
+
 static int get_a_b(int argc, VALUE *argv, int argstart, double *a, double *b);
 static int get_epsabs_epsrel(int argc, VALUE *argv, int argstart, 
 			     double *epsabs, double *epsrel);
@@ -1025,6 +1029,33 @@ static VALUE rb_gsl_integration_workspace_elist(VALUE obj)
   return Data_Wrap_Struct(cgsl_vector_view_ro, 0, free, v);
 }
 
+#ifdef GSL_1_14_LATER
+static VALUE rb_gsl_integration_glfixed_table_alloc(VALUE klass, VALUE n)
+{
+  gsl_integration_glfixed_table *t;
+  t = gsl_integration_glfixed_table_alloc(FIX2INT(n));
+  return Data_Wrap_Struct(cgsl_integration_glfixed_table, 0, gsl_integration_glfixed_table_free, t);
+}
+
+static VALUE rb_gsl_integration_glfixed(VALUE obj, VALUE aa, VALUE bb, VALUE tt)
+{
+  gsl_function *f;
+  double a, b;
+  gsl_integration_glfixed_table *t;
+  double res;
+  if (!rb_obj_is_kind_of(tt, cgsl_integration_glfixed_table)) {
+    rb_raise(rb_eTypeError, "Wrong arugment type (%s for GSL::Integration::Glfixed_table)",
+	     rb_class2name(CLASS_OF(tt)));
+  }
+  Data_Get_Struct(tt, gsl_integration_glfixed_table, t);
+  a = NUM2DBL(aa);
+  b = NUM2DBL(bb);
+  Data_Get_Struct(obj, gsl_function, f);
+  res = gsl_integration_glfixed(f, a, b, t);
+  return rb_float_new(res);
+}
+#endif
+
 void Init_gsl_integration(VALUE module)
 {
   VALUE mgsl_integ;
@@ -1125,6 +1156,14 @@ void Init_gsl_integration(VALUE module)
   rb_define_module_function(mgsl_integ, "qaws", rb_gsl_integration_qaws, -1);
   rb_define_module_function(mgsl_integ, "qawo", rb_gsl_integration_qawo, -1);
   rb_define_module_function(mgsl_integ, "qawf", rb_gsl_integration_qawf, -1);
+
+#ifdef GSL_1_14_LATER
+  cgsl_integration_glfixed_table = rb_define_class_under(mgsl_integ, "Glfixed_table", cGSL_Object);
+  rb_define_singleton_method(cgsl_integration_glfixed_table, "alloc",
+			     rb_gsl_integration_glfixed_table_alloc, 1);
+  rb_define_method(cgsl_function, "glfixed", rb_gsl_integration_glfixed, 3);
+#endif
+
 }
 
 #undef EPSABS_DEFAULT

data/ext/matrix_complex.c

@@ -651,7 +651,7 @@ static VALUE rb_gsl_matrix_complex_inspect(int argc, VALUE *argv, VALUE obj)
   gsl_matrix_complex *m;
 
   Data_Get_Struct(obj, gsl_matrix_complex, m);
-  sprintf(buf, "#<%s[%lu,%lu]:%#x>\n", rb_class2name(CLASS_OF(obj)), m->size1, m->size2, NUM2UINT(rb_obj_id(obj)));
+  sprintf(buf, "#<%s[%lu,%lu]:%#lx>\n", rb_class2name(CLASS_OF(obj)), m->size1, m->size2, NUM2ULONG(rb_obj_id(obj)));
   str = rb_str_new2(buf);
   return rb_str_concat(str, rb_gsl_matrix_complex_to_s(argc, argv, obj));
 }

data/ext/multiset.c

@@ -0,0 +1,214 @@
+#include "rb_gsl.h"
+
+#ifdef GSL_1_14_LATER
+
+VALUE cMultiset;
+
+VALUE rb_gsl_multiset_alloc(VALUE klass, VALUE nn, VALUE kk)
+{
+
+  gsl_multiset *m;
+  m = gsl_multiset_alloc(FIX2INT(nn), FIX2INT(kk));
+  return Data_Wrap_Struct(klass, 0, gsl_multiset_free, m);
+}
+
+VALUE rb_gsl_multiset_calloc(VALUE klass, VALUE nn, VALUE kk)
+{
+  gsl_multiset *m;
+  m = gsl_multiset_alloc(FIX2INT(nn), FIX2INT(kk));
+  return Data_Wrap_Struct(klass, 0, gsl_multiset_free, m);
+}
+	
+VALUE rb_gsl_multiset_init_first(VALUE mm)
+{
+  gsl_multiset *m;
+  Data_Get_Struct(mm, gsl_multiset, m);
+  gsl_multiset_init_first(m);
+  return Qnil;
+}
+
+VALUE rb_gsl_multiset_init_last(VALUE mm)
+{
+  gsl_multiset *m;
+  Data_Get_Struct(mm, gsl_multiset, m);
+  gsl_multiset_init_last(m);
+  return Qnil;
+}
+
+VALUE rb_gsl_multiset_memcpy(VALUE klass, VALUE m1, VALUE m2)
+{
+  gsl_multiset *mm1, *mm2;
+  if (!rb_obj_is_kind_of(m1, klass)) {
+    rb_raise(rb_eTypeError, "Wrong type %s (GSL::Multiset expected)", rb_class2name(CLASS_OF(m1)));
+  }
+  if (!rb_obj_is_kind_of(m2, klass)) {
+    rb_raise(rb_eTypeError, "Wrong type %s (GSL::Multiset expected)", rb_class2name(CLASS_OF(m2)));
+  }
+  Data_Get_Struct(m1, gsl_multiset, mm1);
+  Data_Get_Struct(m2, gsl_multiset, mm2);
+  return FIX2INT(gsl_multiset_memcpy(mm1, mm2));
+}
+
+VALUE rb_gsl_multiset_get(VALUE mm, VALUE i)
+{
+  gsl_multiset *m;
+  Data_Get_Struct(mm, gsl_multiset, m);
+  return INT2FIX(gsl_multiset_get(m, FIX2INT(i)));
+}
+
+VALUE rb_gsl_multiset_n(VALUE mm)
+{
+  gsl_multiset *m;
+  Data_Get_Struct(mm, gsl_multiset, m);
+  return INT2FIX(gsl_multiset_n(m));
+}
+
+VALUE rb_gsl_multiset_k(VALUE mm)
+{
+  gsl_multiset *m;
+  Data_Get_Struct(mm, gsl_multiset, m);
+  return INT2FIX(gsl_multiset_k(m));
+}
+
+VALUE rb_gsl_multiset_valid(VALUE mm)
+{
+  gsl_multiset *m;
+  Data_Get_Struct(mm, gsl_multiset, m);
+  return INT2FIX(gsl_multiset_valid(m));
+}
+
+VALUE rb_gsl_multiset_valid2(VALUE mm)
+{
+  gsl_multiset *m;
+  Data_Get_Struct(mm, gsl_multiset, m);
+  if (gsl_multiset_valid(m)) return Qtrue;
+  else return Qfalse;
+}
+
+VALUE rb_gsl_multiset_next(VALUE mm)
+{
+  gsl_multiset *m;
+  Data_Get_Struct(mm, gsl_multiset, m);
+  return INT2FIX(gsl_multiset_next(m));
+}
+
+VALUE rb_gsl_multiset_prev(VALUE mm)
+{
+  gsl_multiset *m;
+  Data_Get_Struct(mm, gsl_multiset, m);
+  return INT2FIX(gsl_multiset_prev(m));
+}
+
+VALUE rb_gsl_multiset_fwrite(VALUE mm, VALUE name)
+{
+  gsl_multiset *m;
+  FILE *fp = NULL;
+  int ret;
+  Data_Get_Struct(mm, gsl_multiset, m);
+  fp = fopen(STR2CSTR(name), "wb");
+  if (fp == NULL) {
+    rb_raise(rb_eIOError, "Cannot open file %s", STR2CSTR(name));
+  }
+  ret = gsl_multiset_fwrite(fp, m);
+  fclose(fp);
+  return INT2FIX(ret);
+}
+
+VALUE rb_gsl_multiset_fread(VALUE mm, VALUE name)
+{
+  gsl_multiset *m;
+  FILE *fp = NULL;
+  int ret;
+  Data_Get_Struct(mm, gsl_multiset, m);
+  fp = fopen(STR2CSTR(name), "wb");
+  if (fp == NULL) {
+    rb_raise(rb_eIOError, "Cannot open file %s", STR2CSTR(name));
+  }
+  ret = gsl_multiset_fread(fp, m);
+  fclose(fp);
+  return INT2FIX(ret);
+}
+
+VALUE rb_gsl_multiset_fprintf(VALUE mm, VALUE name, VALUE format)
+{
+  gsl_multiset *m;
+  FILE *fp = NULL;
+  int ret;
+  Data_Get_Struct(mm, gsl_multiset, m);
+  fp = fopen(STR2CSTR(name), "w");
+  if (fp == NULL) {
+    rb_raise(rb_eIOError, "Cannot open file %s", STR2CSTR(name));
+  }
+  ret = gsl_multiset_fprintf(fp, m, STR2CSTR(format));
+  fclose(fp);
+  return INT2FIX(ret);
+}
+
+VALUE rb_gsl_multiset_fscanf(VALUE mm, VALUE name)
+{
+  gsl_multiset *m;
+  FILE *fp = NULL;
+  int ret;
+  Data_Get_Struct(mm, gsl_multiset, m);
+  fp = fopen(STR2CSTR(name), "r");
+  if (fp == NULL) {
+    rb_raise(rb_eIOError, "Cannot open file %s", STR2CSTR(name));
+  }
+  ret = gsl_multiset_fscanf(fp, m);
+  fclose(fp);
+  return INT2FIX(ret);
+}
+
+VALUE rb_gsl_multiset_data(VALUE mm)
+{
+  gsl_multiset *m;
+  size_t *p;
+  gsl_vector_int *v;
+  size_t i;
+  Data_Get_Struct(mm, gsl_multiset, m);
+  p = gsl_multiset_data(m);
+  v = gsl_vector_int_alloc(m->k);
+  for (i = 0; i < v->size; i++) gsl_vector_int_set(v, i, p[i]);
+  return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, v);
+}
+
+VALUE rb_gsl_multiset_data2(VALUE mm, VALUE i)
+{
+  gsl_multiset *m;
+  size_t *p;
+  Data_Get_Struct(mm, gsl_multiset, m);
+  p = gsl_multiset_data(m);
+  return INT2FIX(p[i]);
+}
+		  
+void Init_multiset(VALUE module)
+{
+  cMultiset = rb_define_class_under(module, "Multiset", cGSL_Object);
+  rb_define_singleton_method(cMultiset, "alloc", rb_gsl_multiset_alloc, 2);
+  rb_define_singleton_method(cMultiset, "calloc", rb_gsl_multiset_calloc, 2);
+  rb_define_singleton_method(cMultiset, "memcpy", rb_gsl_multiset_memcpy, 2);
+  
+  rb_define_method(cMultiset, "init_first", rb_gsl_multiset_init_first, 0);
+  rb_define_method(cMultiset, "init_last", rb_gsl_multiset_init_last, 0);
+
+  rb_define_method(cMultiset, "get", rb_gsl_multiset_get, 1);
+  rb_define_alias(cMultiset, "[]", "get");
+
+  rb_define_method(cMultiset, "n", rb_gsl_multiset_n, 0);
+  rb_define_method(cMultiset, "k", rb_gsl_multiset_k, 0);
+  rb_define_method(cMultiset, "data", rb_gsl_multiset_data, 0);
+  rb_define_method(cMultiset, "data[]", rb_gsl_multiset_data2, 1);
+  rb_define_method(cMultiset, "valid", rb_gsl_multiset_valid, 0);
+  rb_define_method(cMultiset, "valid?", rb_gsl_multiset_valid2, 0);
+
+  rb_define_method(cMultiset, "next", rb_gsl_multiset_next, 0);
+  rb_define_method(cMultiset, "prev", rb_gsl_multiset_prev, 0);
+
+  rb_define_method(cMultiset, "fwrite", rb_gsl_multiset_fwrite, 1);
+  rb_define_method(cMultiset, "fread", rb_gsl_multiset_fread, 1);
+  rb_define_method(cMultiset, "fprintf", rb_gsl_multiset_fprintf, 2);
+  rb_define_method(cMultiset, "fscanf", rb_gsl_multiset_fscanf, 1);
+}
+
+#endif
+

data/ext/nmf.c

@@ -16,6 +16,7 @@
 #undef DEBUG
 
 #define mm(a, b) gsl_matrix_mult(a, b)
+//gsl_matrix * gsl_matrix_mult(gsl_matrix *a, gsl_matrix *b)
 gsl_matrix * gsl_matrix_mult(const gsl_matrix *a, const gsl_matrix *b)
 {
   gsl_matrix *c;
@@ -26,6 +27,7 @@ gsl_matrix * gsl_matrix_mult(const gsl_matrix *a, const gsl_matrix *b)
 }
 
 // pretty print
+//void pp(gsl_matrix *m)
 void pp(const gsl_matrix *m)
 {
   int r, c;
@@ -39,6 +41,7 @@ void pp(const gsl_matrix *m)
 }
 
 /* Returns a distance cost */
+//double difcost(gsl_matrix *a, gsl_matrix *b)
 double difcost(const gsl_matrix *a, const gsl_matrix *b)
 {
   int i, j;
@@ -50,6 +53,7 @@ double difcost(const gsl_matrix *a, const gsl_matrix *b)
     {
       d = gsl_matrix_get(a, i, j) - gsl_matrix_get(b, i, j);
       dif += d*d;
+	//      dif += pow(gsl_matrix_get(a, i, j) - gsl_matrix_get(b, i, j), 2);
     }
   }
   return dif;

data/ext/nmf_wrap.c

@@ -9,8 +9,10 @@
 #include <gsl/gsl_matrix.h>
 
 int gsl_matrix_nmf(gsl_matrix *v, int cols, gsl_matrix **w, gsl_matrix **h);
+//double difcost(gsl_matrix *a, gsl_matrix *b);
 double difcost(const gsl_matrix *a, const gsl_matrix *b);
 
+//VALUE mNMF;
 static VALUE mNMF;
 extern VALUE cgsl_matrix;
 
@@ -60,6 +62,7 @@ static VALUE difcost_wrap(VALUE obj, VALUE matrix1, VALUE matrix2)
  */
 static VALUE matrix_nmf(VALUE obj, VALUE cols)
 {
+  //  nmf_wrap(cgsl_matrix, obj, cols);
   return nmf_wrap(cgsl_matrix, obj, cols);
 }