gsl 1.12.108

data/ext/combination.c

@@ -0,0 +1,283 @@
+/*
+  combination.c
+  Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library)
+    (C) Copyright 2004 by Yoshiki Tsunesada
+
+  Ruby/GSL is free software: you can redistribute it and/or modify it
+  under the terms of the GNU General Public License.
+  This library is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY.
+*/
+
+#include "rb_gsl_config.h"
+#ifdef GSL_1_1_LATER
+#include "rb_gsl_common.h"
+#include "rb_gsl_array.h"
+
+static VALUE cgsl_combination_data;
+
+static VALUE rb_gsl_combination_new(VALUE klass, VALUE n, VALUE k)
+{
+  gsl_combination *c = NULL;
+  CHECK_FIXNUM(n);CHECK_FIXNUM(k);
+  c = gsl_combination_alloc(FIX2INT(n), FIX2INT(k));
+  return Data_Wrap_Struct(klass, 0, gsl_combination_free, c);
+}
+
+static VALUE rb_gsl_combination_calloc(VALUE klass, VALUE n, VALUE k)
+{
+  gsl_combination *c = NULL;
+  CHECK_FIXNUM(n);CHECK_FIXNUM(k);
+  c = gsl_combination_calloc(FIX2INT(n), FIX2INT(k));
+  return Data_Wrap_Struct(klass, 0, gsl_combination_free, c);
+}
+
+static VALUE rb_gsl_combination_init_first(VALUE obj)
+{
+  gsl_combination *c = NULL;
+  Data_Get_Struct(obj, gsl_combination, c);
+  gsl_combination_init_first(c);
+  return obj;
+}
+
+static VALUE rb_gsl_combination_init_last(VALUE obj)
+{
+  gsl_combination *c = NULL;
+  Data_Get_Struct(obj, gsl_combination, c);
+  gsl_combination_init_last(c);
+  return obj;
+}
+
+#ifdef GSL_1_4_LATER
+/* singleton */
+static VALUE rb_gsl_combination_memcpy(VALUE klass, VALUE dst, VALUE src)
+{
+  gsl_combination *c, *c2;
+  if (!rb_obj_is_kind_of(dst, klass))
+    rb_raise(rb_eTypeError, "wrong argument type %s (Combination expected)",
+	     rb_class2name(CLASS_OF(dst)));
+  if (!rb_obj_is_kind_of(src, klass))
+    rb_raise(rb_eTypeError, "wrong argument type %s (Combination expected)",
+	     rb_class2name(CLASS_OF(src)));
+
+  Data_Get_Struct(dst, gsl_combination, c2);
+  Data_Get_Struct(src, gsl_combination, c);
+  gsl_combination_memcpy(c2, c);
+  return dst;
+}
+
+static VALUE rb_gsl_combination_clone(VALUE obj)
+{
+  gsl_combination *c, *c2;
+  Data_Get_Struct(obj, gsl_combination, c);
+  c2 = gsl_combination_alloc(c->n, c->k);
+  gsl_combination_memcpy(c2, c);
+  return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_combination_free, c2);
+}
+#endif
+
+static VALUE rb_gsl_combination_get(VALUE obj, VALUE ii)
+{
+  gsl_combination *c = NULL;
+  size_t i;
+  CHECK_FIXNUM(ii);
+  Data_Get_Struct(obj, gsl_combination, c);
+  i = FIX2INT(ii);
+  if (i > c->n) rb_raise(rb_eIndexError, "index out of range");
+  return INT2FIX(gsl_combination_get(c, i));
+}
+
+static VALUE rb_gsl_combination_set(VALUE obj, VALUE ii, VALUE val)
+{
+  gsl_combination *c = NULL;
+  size_t i;
+  CHECK_FIXNUM(ii);
+  CHECK_FIXNUM(val);
+  Data_Get_Struct(obj, gsl_combination, c);
+  i = FIX2INT(ii);
+  c->data[i] = FIX2INT(val);
+  return obj;
+}
+
+static VALUE rb_gsl_combination_n(VALUE obj)
+{
+  gsl_combination *c = NULL;
+  Data_Get_Struct(obj, gsl_combination, c);
+  return INT2FIX(gsl_combination_n(c));
+
+}
+static VALUE rb_gsl_combination_k(VALUE obj)
+{
+  gsl_combination *c = NULL;
+  Data_Get_Struct(obj, gsl_combination, c);
+  return INT2FIX(gsl_combination_k(c));
+}
+
+static VALUE rb_gsl_combination_data(VALUE obj)
+{
+  gsl_combination *c = NULL;
+  gsl_permutation *p = NULL;
+  Data_Get_Struct(obj, gsl_combination, c);
+  p = ALLOC(gsl_permutation);
+  p->size = c->k;
+  p->data = c->data;
+  return Data_Wrap_Struct(cgsl_combination_data, 0, free, p);
+}
+
+static VALUE rb_gsl_combination_valid(VALUE obj)
+{
+  gsl_combination *c = NULL;
+  Data_Get_Struct(obj, gsl_combination, c);
+  return INT2FIX(gsl_combination_valid(c));
+}
+
+static VALUE rb_gsl_combination_valid2(VALUE obj)
+{
+  gsl_combination *c = NULL;
+  Data_Get_Struct(obj, gsl_combination, c);
+  if(gsl_combination_valid(c)) return Qtrue;
+  else return Qfalse;
+}
+
+static VALUE rb_gsl_combination_next(VALUE obj)
+{
+  gsl_combination *c = NULL;
+  Data_Get_Struct(obj, gsl_combination, c);
+  return INT2FIX(gsl_combination_next(c));
+}
+static VALUE rb_gsl_combination_prev(VALUE obj)
+{
+  gsl_combination *c = NULL;
+  Data_Get_Struct(obj, gsl_combination, c);
+  return INT2FIX(gsl_combination_prev(c));
+}
+
+static VALUE rb_gsl_combination_fwrite(VALUE obj, VALUE io)
+{
+  gsl_combination *h = NULL;
+  FILE *f = NULL;
+  int status, flag = 0;
+  Data_Get_Struct(obj, gsl_combination, h);
+  f = rb_gsl_open_writefile(io, &flag);
+  status = gsl_combination_fwrite(f, h);
+  if (flag == 1) fclose(f);
+  return INT2FIX(status);
+}
+
+static VALUE rb_gsl_combination_fread(VALUE obj, VALUE io)
+{
+  gsl_combination *h = NULL;
+  FILE *f = NULL;
+  int status, flag = 0;
+
+  Data_Get_Struct(obj, gsl_combination, h);
+  f = rb_gsl_open_readfile(io, &flag);
+  status = gsl_combination_fread(f, h);
+  if (flag == 1) fclose(f);
+  return INT2FIX(status);
+}
+
+static VALUE rb_gsl_combination_fprintf(int argc, VALUE *argv, VALUE obj)
+{
+  gsl_combination *h = NULL;
+  FILE *fp = NULL;
+  int status, flag = 0;
+
+  if (argc != 1 && argc != 2) rb_raise(rb_eArgError, 
+				       "wrong number of arguments (%d for 1 or 2)", argc);
+
+  Data_Get_Struct(obj, gsl_combination, h);
+  fp = rb_gsl_open_writefile(argv[0], &flag);
+  switch (argc) {
+  case 1:
+    status = gsl_combination_fprintf(fp, h, "%u\n");
+    break;
+  default:
+    Check_Type(argv[1], T_STRING);
+    status = gsl_combination_fprintf(fp, h, STR2CSTR(argv[1]));
+    break;
+  }
+  if (flag == 1) fclose(fp);
+  return INT2FIX(status);
+}
+
+static VALUE rb_gsl_combination_printf(int argc, VALUE *argv, VALUE obj)
+{
+  gsl_combination *h = NULL;
+  int status;
+  Data_Get_Struct(obj, gsl_combination, h);
+  switch (argc) {
+  case 0:
+    status = gsl_combination_fprintf(stdout, h, "%u\n");
+    break;
+  default:
+    Check_Type(argv[0], T_STRING);
+    status = gsl_combination_fprintf(stdout, h, STR2CSTR(argv[0]));
+    break;
+  }
+  return INT2FIX(status);
+}
+
+
+static VALUE rb_gsl_combination_fscanf(VALUE obj, VALUE io)
+{
+  gsl_combination *h = NULL;
+  FILE *f = NULL;
+  int status, flag = 0;
+  Data_Get_Struct(obj, gsl_combination, h);
+  f = rb_gsl_open_readfile(io, &flag);
+  status = gsl_combination_fscanf(f, h);
+  if (flag == 1) fclose(f);
+  return INT2FIX(status);
+}
+
+static VALUE rb_gsl_combination_equal(VALUE obj, VALUE other)
+{
+  gsl_combination *p1 = NULL, *p2 = NULL;
+  size_t i;
+  Data_Get_Struct(obj, gsl_combination, p1);
+  Data_Get_Struct(other, gsl_combination, p2);
+  if (p1->k != p2->k) return Qfalse;
+  for (i = 0; i < p1->k; i++)
+    if (p1->data[i] != p2->data[i]) return Qfalse;
+  return Qtrue;
+}
+
+void Init_gsl_combination(VALUE module)
+{
+  VALUE cgsl_combination;
+  cgsl_combination = rb_define_class_under(module, "Combination", cGSL_Object);
+  cgsl_combination_data = rb_define_class_under(cgsl_combination, "Data", 
+						cgsl_permutation);
+  rb_define_singleton_method(cgsl_combination, "new", rb_gsl_combination_new, 2);
+  rb_define_singleton_method(cgsl_combination, "alloc", rb_gsl_combination_new, 2);
+  rb_define_singleton_method(cgsl_combination, "calloc", rb_gsl_combination_calloc, 2);
+  rb_define_method(cgsl_combination, "init_first", rb_gsl_combination_init_first, 0);
+  rb_define_method(cgsl_combination, "init_last", rb_gsl_combination_init_last, 0);
+#ifdef GSL_1_4_LATER
+  rb_define_singleton_method(cgsl_combination, "memcpy", rb_gsl_combination_memcpy, 2);
+  rb_define_method(cgsl_combination, "clone", rb_gsl_combination_clone, 0);
+#endif
+  rb_define_method(cgsl_combination, "get", rb_gsl_combination_get, 1);
+  rb_define_alias(cgsl_combination, "[]", "get");
+  rb_define_method(cgsl_combination, "set", rb_gsl_combination_set, 2);
+  rb_define_alias(cgsl_combination, "[]=", "set");
+
+  rb_define_method(cgsl_combination, "n", rb_gsl_combination_n, 0);
+  rb_define_method(cgsl_combination, "k", rb_gsl_combination_k, 0);
+  rb_define_method(cgsl_combination, "data", rb_gsl_combination_data, 0);
+  rb_define_method(cgsl_combination, "valid", rb_gsl_combination_valid, 0);
+  rb_define_method(cgsl_combination, "valid?", rb_gsl_combination_valid2, 0);
+  rb_define_method(cgsl_combination, "next", rb_gsl_combination_next, 0);
+  rb_define_method(cgsl_combination, "prev", rb_gsl_combination_prev, 0);
+
+  rb_define_method(cgsl_combination, "fwrite", rb_gsl_combination_fwrite, 1);
+  rb_define_method(cgsl_combination, "fread", rb_gsl_combination_fread, 1);
+  rb_define_method(cgsl_combination, "fprintf", rb_gsl_combination_fprintf, -1);
+  rb_define_method(cgsl_combination, "printf", rb_gsl_combination_printf, -1);
+  rb_define_method(cgsl_combination, "fscanf", rb_gsl_combination_fscanf, 1);
+
+  rb_define_method(cgsl_combination, "equal?", rb_gsl_combination_equal, 1);
+  rb_define_alias(cgsl_combination, "==", "equal?");
+}
+#endif

data/ext/common.c

@@ -0,0 +1,325 @@
+/*
+  common.c
+  Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library)
+    (C) Copyright 2001-2006 by Yoshiki Tsunesada
+
+  Ruby/GSL is free software: you can redistribute it and/or modify it
+  under the terms of the GNU General Public License.
+  This library is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY.
+*/
+
+#include "rb_gsl_config.h"
+
+#include "rb_gsl_array.h"
+#include "rb_gsl_histogram.h"
+#include <string.h>
+#include <ctype.h>
+
+FILE* rb_gsl_open_writefile(VALUE io, int *flag)
+{
+#ifdef RUBY_1_9_LATER
+  rb_io_t *fptr = NULL;
+#else
+  OpenFile *fptr = NULL;
+#endif
+  FILE *fp = NULL;
+  char *name;
+  switch (TYPE(io)) {
+  case T_STRING:
+    name = RSTRING_PTR(io);
+    fp = fopen(name, "w");
+    *flag = 1;
+    break;
+  case T_FILE:
+    GetOpenFile(io, fptr);
+    /*
+#ifdef RUBY_1_9_LATER
+    name = STR2CSTR(fptr->pathv);
+#else
+    name = fptr->path;
+#endif
+    */
+    rb_io_check_writable(fptr);
+#ifdef RUBY_1_9_LATER
+    fp = rb_io_stdio_file(fptr);
+#else
+    fp = GetWriteFile(fptr);
+#endif
+    *flag = 0;
+    break;
+  default:
+    rb_raise(rb_eTypeError, "argv 1 String or File expected");
+    break;
+  }
+  //  if (fp == NULL) rb_raise(rb_eIOError, "Cannot open file %s.", name);
+  if (fp == NULL) rb_raise(rb_eIOError, "Cannot open file.");
+  return fp;
+}
+
+FILE* rb_gsl_open_readfile(VALUE io, int *flag)
+{
+#ifdef RUBY_1_9_LATER
+  rb_io_t *fptr = NULL;
+#else
+  OpenFile *fptr = NULL;
+#endif
+  FILE *fp = NULL;
+  char *name;
+  switch (TYPE(io)) {
+  case T_STRING:
+    name = RSTRING_PTR(io);
+    fp = fopen(name, "r");
+    *flag = 1;
+    break;
+  case T_FILE:
+    GetOpenFile(io, fptr);
+    /*
+#ifdef RUBY_1_9_LATER
+    name = STR2CSTR(fptr->pathv);
+#else
+    name = fptr->path;
+#endif
+    */
+    rb_io_check_readable(fptr);
+#ifdef RUBY_1_9_LATER
+    fp = rb_io_stdio_file(fptr);
+#else
+    fp = fptr->f;
+#endif
+    *flag = 0;
+    break;
+  default:
+    rb_raise(rb_eTypeError, "argv 1 String or File expected");
+    break;
+  }
+  //  if (fp == NULL) rb_raise(rb_eIOError, "Cannot open file %s.", name);
+  if (fp == NULL) rb_raise(rb_eIOError, "Cannot open file");
+  return fp;
+}
+
+VALUE rb_gsl_obj_read_only(int argc, VALUE *argv, VALUE obj)
+{
+  rb_raise(rb_eRuntimeError, "Read only object.");
+}
+
+int str_tail_grep(const char *s0, const char *s1)
+{
+  int len0, len1;
+  char *p = NULL;
+  len0 = strlen(s0);
+  len1 = strlen(s1);
+  p = (char *) s0 + len0 - len1;
+  return strcmp(p, s1);
+}
+
+int str_head_grep(const char *s0, const char *s1)
+{
+  int len0, len1;
+  size_t i, len;
+  char *p0, *p1;
+  len0 = strlen(s0);
+  len1 = strlen(s1);
+  len = (size_t) GSL_MIN_INT(len0, len1);
+  p0 = (char *) s0;
+  p1 = (char *) s1;
+  for (i = 0; i < len; i++) if (*p0++ != *p1++) return 1;
+  return 0;
+}
+
+size_t count_columns(const char *str)
+{
+  size_t n = 0;
+  int flag = 1;
+  char *p;
+  p = (char *) str;
+  do {
+    if (isspace(*p)) {
+      flag = 1;
+    } else {
+      if (flag == 1) {
+	flag = 0;
+	n++;
+      }
+    }
+    p++;
+  } while (*p != '\0' && *p != '\n');
+  return n;
+}
+
+char* str_scan_double(const char *str, double *val)
+{
+  char buf[256];
+  char *p, *q;
+  double x;
+  int flag = 0;
+  p = (char *) str;
+  q = buf;
+  do {
+    if (isspace(*p)) {
+      if (flag == 0) {
+	/* do nothing */
+      } else {
+	break;
+      }
+    } else {
+      *q++ = *p;
+      flag = 1;
+    }
+    p++;
+  } while (*p != '\0' && *p != '\n');
+  if (flag == 0) {
+    *val = 0;
+    return NULL;
+  }
+  *q = '\0';
+  flag = sscanf(buf, "%lf", &x);
+  if (flag == 1) {
+    *val = x;
+    return p;
+  } else {
+    *val = 0;
+    return NULL;
+  }
+}
+
+char* str_scan_int(const char *str, int *val)
+{
+  char buf[256];
+  char *p, *q;
+  int x;
+  int flag = 0;
+  p = (char *) str;
+  q = buf;
+  do {
+    if (isspace(*p)) {
+      if (flag == 0) {
+	/* do nothing */
+      } else {
+	break;
+      }
+    } else {
+      *q++ = *p;
+      flag = 1;
+    }
+    p++;
+  } while (*p != '\0' && *p != '\n');
+  if (flag == 0) {
+    *val = 0;
+    return NULL;
+  }
+  *q = '\0';
+  flag = sscanf(buf, "%d", &x);
+  if (flag == 1) {
+    *val = x;
+    return p;
+  } else {
+    *val = 0;
+    return NULL;
+  }
+}
+
+double* get_ptr_double3(VALUE obj, size_t *size, size_t *stride, int *flag)
+{
+  gsl_vector *v;
+#ifdef HAVE_NARRAY_H
+  double *ptr;
+  struct NARRAY *na;
+  if (NA_IsNArray(obj)) {
+    obj = na_change_type(obj, NA_DFLOAT);
+    GetNArray(obj, na);
+    ptr = (double *) na->ptr;
+    *size = na->total;
+    *stride = 1;
+    *flag = 1;
+    return ptr;
+  }
+#endif
+  CHECK_VECTOR(obj);
+  Data_Get_Struct(obj, gsl_vector, v);
+  *size = v->size;
+  *stride = v->stride;
+  *flag = 0;
+  return v->data;
+}
+
+gsl_complex ary2complex(VALUE obj)
+{
+  gsl_complex *z, c;
+  switch (TYPE(obj)) {
+  case T_ARRAY:
+    GSL_SET_REAL(&c, NUM2DBL(rb_ary_entry(obj, 0)));
+    GSL_SET_IMAG(&c, NUM2DBL(rb_ary_entry(obj, 1)));
+    break;
+  default:
+    if (COMPLEX_P(obj)) {
+      Data_Get_Struct(obj, gsl_complex, z);
+      c = *z;
+    } else {
+      rb_raise(rb_eTypeError, "wrong argument type %s (Array or Complex expected)",
+	       rb_class2name(CLASS_OF(obj)));
+    }
+    break;
+  }
+  return c;
+}
+
+VALUE vector_eval_create(VALUE obj, double (*func)(double))
+{
+  gsl_vector *vnew;
+  size_t i, size, stride;
+  double *ptr;
+  ptr = get_vector_ptr(obj, &stride, &size);
+  vnew = gsl_vector_alloc(size);
+  for (i = 0; i < size; i++) {
+    gsl_vector_set(vnew, i, (*func)(ptr[i*stride]));
+  }
+  return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);
+}
+
+VALUE matrix_eval_create(VALUE obj, double (*func)(double))
+{
+  gsl_matrix *m, *mnew;
+  size_t i, j;
+  Data_Get_Struct(obj, gsl_matrix, m);
+  mnew = gsl_matrix_alloc(m->size1, m->size2);
+  for (i = 0; i < m->size1; i++) {
+    for (j = 0; j < m->size2; j++) {
+      gsl_matrix_set(mnew, i, j, (*func)(gsl_matrix_get(m, i, j)));
+    }
+  }
+  return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
+}
+
+VALUE rb_gsl_ary_eval1(VALUE ary, double (*f)(double))
+{
+  VALUE ary2;
+  size_t i, n;
+  double val;
+  //  n = RARRAY(ary)->len;
+  n = RARRAY_LEN(ary);
+  ary2 = rb_ary_new2(n);
+  for (i = 0; i < n; i++) {
+    val = (*f)(NUM2DBL(rb_ary_entry(ary, i)));
+    rb_ary_store(ary2, i, rb_float_new(val));
+  }
+  return ary2;
+}
+
+#ifdef HAVE_NARRAY_H
+VALUE rb_gsl_nary_eval1(VALUE ary, double (*f)(double))
+{
+  VALUE ary2;
+  struct NARRAY *na;
+  double *ptr1, *ptr2;
+  size_t i, n;
+  ary = na_change_type(ary, NA_DFLOAT);
+  GetNArray(ary, na);
+  ptr1 = (double *) na->ptr;
+  n = na->total;
+  ary2 = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(ary));
+  ptr2 = NA_PTR_TYPE(ary2, double*);
+  for (i = 0; i < n; i++) ptr2[i] = (*f)(ptr1[i]);
+  return ary2;
+}
+#endif