gsl 1.12.108

data/README.rdoc

@@ -0,0 +1,29 @@
+== Description
+Ruby/GSL, a ruby interface to GSL (GNU Scientific library)
+
+== Installation
+   (0) Make sure the command "gsl-config" is in search path.
+   (1) % ruby setup.rb config
+   (2) % ruby setup.rb setup
+   (3) % ruby setup.rb install (as root)
+
+See also html/index.html.
+
+== Reference
+
+See ((<URL:http://rb-gsl.rubyforge.org/ref.html>)).
+
+== Licence
+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.
+
+== Bug Report
+Any bug reports are welcome.
+If you encounter bugs in Ruby/GSL, please e-mail to me, or
+submit reports from http://rubyforge.org/projects/rb-gsl/.
+
+== Author
+Yoshiki Tsunesada
+y-tsunesada at mm dot em-net dot ne dot jp

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+spec = Gem::Specification.new do |s|
+  # Basics
+  s.name = 'gsl'
+  s.version = File.readlines('VERSION')[0].chomp
+  s.summary = 'Ruby interface to GSL'
+  s.description = 'RubyGSL is a Ruby interface to the GNU Scientific Library, for numerical computing with Ruby'
+  #s.platform = Gem::Platform::Ruby
+  s.required_ruby_version = '>= 1.8.1'
+  s.requirements << 'GSL (http://www.gnu.org/software/gsl/)'
+  # plotlib?
+  s.add_dependency('narray', '>= 0.5.9')
+
+  # About
+  s.authors = ['Yoshiki Tsunesada', 'David MacMahon']
+  s.email = 'y-tsunesada@mm.em-net.ne.jp'
+  s.homepage = 'http://rb-gsl.rubyforge.org/'
+  s.rubyforge_project = 'rb-gsl' 
+
+  # Files, Libraries, and Extensions
+  s.files = FileList[
+    'README.rdoc',
+    'VERSION',
+    'Rakefile',
+    'ext/*',
+    'lib/**/*',
+    'include/*'
+  ].to_a
+  s.require_paths = ['lib', 'lib/gsl', 'lib/ool', 'ext']
+  #s.autorequire = nil
+  #s.bindir = 'bin'
+  #s.executables = []
+  #s.default_executable = nil
+
+  # C compilation
+  s.extensions = %w[ ext/extconf.rb ]
+
+  # Documentation TODO
+  #s.rdoc_options = []
+  #s.has_rdoc = false
+  #s.extra_rdoc_files = []
+
+  # Testing TODO
+  #s.test_files = []
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+task :default => :gem

data/VERSION

@@ -0,0 +1,2 @@
+1.12.90
+

data/ext/MANIFEST

@@ -0,0 +1,119 @@
+alf.c
+array.c
+array_complex.c
+blas.c
+blas1.c
+blas2.c
+blas3.c
+block.c
+block_source.c
+bspline.c
+bundle.c
+cdf.c
+cheb.c
+combination.c
+common.c
+complex.c
+const.c
+const_additional.c
+cqp.c
+deriv.c
+dht.c
+diff.c
+dirac.c
+eigen.c
+error.c
+fcmp.c
+fft.c
+fit.c
+fresnel.c
+function.c
+geometry.c
+graph.c
+gsl.c
+gsl_narray.c
+histogram.c
+histogram2d.c
+histogram3d.c
+histogram3d_source.c
+histogram_find.c
+histogram_oper.c
+ieee.c
+integration.c
+interp.c
+jacobi.c
+linalg.c
+linalg_complex.c
+math.c
+matrix.c
+matrix_complex.c
+matrix_double.c
+matrix_int.c
+matrix_source.c
+min.c
+monte.c
+multifit.c
+multimin.c
+multimin_fsdf.c
+multiroots.c
+ndlinear.c
+nmf.c
+nmf_wrap.c
+ntuple.c
+odeiv.c
+ool.c
+oper_complex_source.c
+permutation.c
+poly.c
+poly2.c
+poly_source.c
+qrng.c
+randist.c
+rational.c
+rng.c
+root.c
+sf.c
+sf_airy.c
+sf_bessel.c
+sf_clausen.c
+sf_coulomb.c
+sf_coupling.c
+sf_dawson.c
+sf_debye.c
+sf_dilog.c
+sf_elementary.c
+sf_ellint.c
+sf_elljac.c
+sf_erfc.c
+sf_exp.c
+sf_expint.c
+sf_fermi_dirac.c
+sf_gamma.c
+sf_gegenbauer.c
+sf_hyperg.c
+sf_laguerre.c
+sf_lambert.c
+sf_legendre.c
+sf_log.c
+sf_mathieu.c
+sf_power.c
+sf_psi.c
+sf_synchrotron.c
+sf_transport.c
+sf_trigonometric.c
+sf_zeta.c
+signal.c
+siman.c
+sort.c
+spline.c
+stats.c
+sum.c
+tamu_anova.c
+tensor.c
+tensor_source.c
+vector.c
+vector_complex.c
+vector_double.c
+vector_int.c
+vector_source.c
+wavelet.c

data/ext/alf.c

@@ -0,0 +1,206 @@
+/*
+ * Ruby interface for ALF, a library to calculate associated Legendre functions by Patrick Alken
+ * Based on ALF-0.1
+ */
+#ifdef HAVE_ALF_ALF_H
+#include "rb_gsl.h"
+
+static VALUE cWspace;
+static VALUE rb_alf_alloc(VALUE klass, VALUE lmax)
+{
+  alf_workspace *w = NULL;
+  w = alf_alloc(FIX2INT(lmax));
+  return Data_Wrap_Struct(cWspace, 0, alf_free, w);
+}
+
+static VALUE rb_alf_params(VALUE obj, VALUE csphase, VALUE cnorm, VALUE norm)
+{
+  alf_workspace *w;
+  int ret;
+  Data_Get_Struct(obj, alf_workspace, w);
+  ret = alf_params(FIX2INT(csphase), FIX2INT(cnorm), (alf_norm_t) FIX2INT(norm), w);
+  return INT2FIX(ret); 
+}
+
+static void define_constants(VALUE klass)
+{
+  rb_define_const(klass, "NORM_NONE", INT2FIX((int) ALF_NORM_NONE));
+  rb_define_const(klass, "NORM_SPHARM", INT2FIX((int) ALF_NORM_SPHARM));
+  rb_define_const(klass, "NORM_ORTHO", INT2FIX((int) ALF_NORM_ORTHO));
+  rb_define_const(klass, "NORM_SCHMIDT", INT2FIX((int) ALF_NORM_SCHMIDT));
+}
+
+/**
+ * arguments:
+ *   - Plm_array(x) : lmax = w->lmax, A new vector is created
+ *   - Plm_array(x, result) : lmax = w->lmax, the given vector is used
+ *   - Plm_array(lmax, x) : A new vector is created
+ *   - Plm_array(lmax, x, result) : Same as C Plm_array()
+ *   - Plm_array(x, result, deriv) : lmax = w->lmax, calcurate Plm_deriv_array(lmax, x, result, deriv)
+ *   - Plm_array(lmax, x, result, deriv) : Same as C alf_Plm_deriv_array
+ */
+static VALUE rb_alf_Plm_array(int argc, VALUE *argv, VALUE obj)
+{
+  alf_workspace *w = NULL;
+  gsl_vector *res = NULL, *deriv = NULL;
+  int lmax;
+  double x;
+  VALUE ret;
+  Data_Get_Struct(obj, alf_workspace, w);
+  switch (argc) {
+  case 1:
+    x = NUM2DBL(argv[0]);
+    lmax = w->lmax;
+    res = gsl_vector_alloc(alf_array_size(lmax));
+    ret = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, res);
+    break;
+  case 2: // Plm_array(x, result) or Plm_array(lmax, x)
+    if (VECTOR_P(argv[1])) {
+      x = NUM2DBL(argv[0]);
+      Data_Get_Struct(argv[1], gsl_vector, res);
+      lmax = w->lmax;
+      if (res->size < alf_array_size(lmax)) {
+	rb_raise(rb_eRuntimeError, "Vector length is too small. (%d for >= %d\n", (int) res->size,
+		 (int) alf_array_size(lmax));
+      }
+      ret = argv[1];      
+    } else { 
+      lmax = FIX2INT(argv[0]);
+      x = NUM2DBL(argv[1]);
+      res = gsl_vector_alloc(alf_array_size(lmax));
+      ret = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, res);
+    }
+    break;
+  case 3: // Plm_array(lmax, x, result) or Plm_array(x, result, deriv)
+    if (VECTOR_P(argv[1])) {
+      CHECK_VECTOR(argv[2]);
+      lmax = w->lmax;
+      x = NUM2DBL(argv[0]);
+      Data_Get_Struct(argv[1], gsl_vector, res);
+      Data_Get_Struct(argv[2], gsl_vector, deriv);
+      ret = argv[1];
+    } else {
+      lmax = FIX2INT(argv[0]);
+      x = NUM2DBL(argv[1]);
+      CHECK_VECTOR(argv[2]);
+      Data_Get_Struct(argv[2], gsl_vector, res);
+      if (res->size < alf_array_size(lmax)) {
+	rb_raise(rb_eRuntimeError, "Vector length is too small. (%d for >= %d\n", (int) res->size,
+		 (int) alf_array_size(lmax));
+      }
+      ret = argv[2];
+    }
+    break;
+  case 4:
+    CHECK_VECTOR(argv[2]); CHECK_VECTOR(argv[3])
+    lmax = FIX2INT(argv[0]);
+    x = NUM2DBL(argv[1]);
+    Data_Get_Struct(argv[2], gsl_vector, res);
+    Data_Get_Struct(argv[3], gsl_vector, deriv);
+    ret = argv[2];
+    break;
+  default:
+    rb_raise(rb_eArgError, "Wrong number of argumentso (%d for 1-3)\n", argc);
+  }
+  if (argc == 4 && deriv != NULL) alf_Plm_deriv_array(lmax, x, res->data, deriv->data, w);
+  else alf_Plm_array(lmax, x, res->data, w);
+  return ret;
+}
+
+/**
+ * arguments:
+ *   - Plm_deriv_array(x) : lmax = w->lmax, two new vectors are created and returned as an array
+ *   - Plm_array(lmax, x) : Two new vectors are created and returned as an array
+ *   - Plm_array(lmax, x, result, deriv) : Same as C alf_Plm_deriv_array()
+ */
+static VALUE rb_alf_Plm_deriv_array(int argc, VALUE *argv, VALUE obj)
+{
+  alf_workspace *w = NULL;
+  gsl_vector *res = NULL, *deriv = NULL;
+  int lmax;
+  double x;
+  VALUE ret1, ret2, ary;
+  Data_Get_Struct(obj, alf_workspace, w);
+  switch (argc) {
+  case 1:
+    x = NUM2DBL(argv[0]);
+    lmax = w->lmax;
+    res = gsl_vector_alloc(alf_array_size(lmax));
+    deriv = gsl_vector_alloc(alf_array_size(lmax));
+    ret1 = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, res);
+    ret2 = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, deriv);
+    break;
+  case 2:
+    lmax = FIX2INT(argv[1]);
+    x = NUM2DBL(argv[1]);
+    res = gsl_vector_alloc(alf_array_size(lmax));
+    deriv = gsl_vector_alloc(alf_array_size(lmax));
+    ret1 = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, res);
+    ret2 = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, deriv);
+    break;
+  case 3:
+    CHECK_VECTOR(argv[1]);
+    CHECK_VECTOR(argv[2]);
+    ret1 = argv[1];
+    ret2 = argv[2];
+    lmax = w->lmax;
+    x = NUM2DBL(argv[0]);
+    break;
+  case 4:
+    lmax = FIX2INT(argv[0]);
+    x = NUM2DBL(argv[1]);
+    CHECK_VECTOR(argv[2]);
+    CHECK_VECTOR(argv[3]);
+    Data_Get_Struct(argv[2], gsl_vector, res);
+    Data_Get_Struct(argv[3], gsl_vector, deriv);
+    if (res->size < alf_array_size(lmax)) {
+      rb_raise(rb_eRuntimeError, "Vector length is too small. (%d for >= %d\n", (int) res->size,
+	       (int) alf_array_size(lmax));
+    }
+    if (deriv->size < alf_array_size(lmax)) {
+      rb_raise(rb_eRuntimeError, "Vector length is too small. (%d for >= %d\n", (int) res->size,
+	       (int) alf_array_size(lmax));
+    }
+    ret1 = argv[2];
+    ret2 = argv[3];
+    break;
+  default:
+    rb_raise(rb_eArgError, "Wrong number of argumentso (%d for 1-4)\n", argc);
+  }
+  alf_Plm_deriv_array(lmax, x, res->data, deriv->data, w);
+  ary = rb_ary_new2(2);
+  rb_ary_store(ary, 0, ret1);
+  rb_ary_store(ary, 1, ret2);
+  return ary;
+}
+
+static VALUE rb_alf_array_size(VALUE module, VALUE lmax)
+{
+  return INT2FIX(alf_array_size(FIX2INT(lmax)));
+
+}
+static VALUE rb_alf_array_index(VALUE module, VALUE l, VALUE m)
+{
+  return INT2FIX(alf_array_index(FIX2INT(l), FIX2INT(m)));
+}
+
+void Init_alf(VALUE module)
+{
+  VALUE mALF;
+  mALF = rb_define_module_under(module, "ALF");
+  cWspace = rb_define_class_under(mALF, "Workspace", cGSL_Object);
+  rb_define_singleton_method(cWspace, "alloc", rb_alf_alloc, 1);
+  rb_define_singleton_method(mALF, "alloc", rb_alf_alloc, 1);
+  rb_define_module_function(module, "alf_alloc", rb_alf_alloc, 1);
+
+  rb_define_method(cWspace, "params", rb_alf_params, 3);
+
+  rb_define_method(cWspace, "Plm_array", rb_alf_Plm_array, -1);
+  rb_define_method(cWspace, "Plm_deriv_array", rb_alf_Plm_deriv_array, -1);
+
+  rb_define_module_function(mALF, "array_size", rb_alf_array_size, 1);
+  rb_define_module_function(mALF, "array_index", rb_alf_array_index, 2);
+
+  define_constants(mALF);
+}
+#endif

data/ext/array.c

@@ -0,0 +1,666 @@
+/*
+  array.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_common.h"
+#include "rb_gsl_array.h"
+#include "rb_gsl_complex.h"
+#ifdef HAVE_NARRAY_H
+#include "rb_gsl_with_narray.h"
+#endif
+
+/* global variables */
+VALUE cgsl_block, cgsl_block_int;
+VALUE cgsl_block_uchar;
+VALUE cgsl_block_complex;
+VALUE cgsl_vector, cgsl_vector_view;
+VALUE cgsl_vector_view_ro;
+VALUE cgsl_vector_col_view_ro;
+VALUE cgsl_matrix_view_ro;
+VALUE cgsl_vector_complex;
+VALUE cgsl_vector_complex_view;
+VALUE cgsl_matrix;
+VALUE cgsl_matrix_view;
+VALUE cgsl_matrix_complex;
+VALUE cgsl_matrix_complex_view;
+VALUE cgsl_vector_complex_view_ro;
+VALUE cgsl_matrix_complex_view_ro;
+VALUE cgsl_permutation;
+VALUE cgsl_index;
+VALUE cgsl_vector_col, cgsl_vector_col_view;
+VALUE cgsl_vector_complex_col, cgsl_vector_complex_col_view;
+
+VALUE cgsl_vector_int, cgsl_vector_int_col;
+VALUE cgsl_vector_int_view, cgsl_vector_int_col_view;
+VALUE cgsl_vector_int_view_ro, cgsl_vector_int_col_view_ro;
+VALUE cgsl_matrix_int, cgsl_matrix_int_view, cgsl_matrix_int_view_ro;
+
+double* get_vector_ptr(VALUE ary, size_t *stride, size_t *n)
+{
+  gsl_vector *v = NULL;
+  gsl_vector_complex *vc = NULL;
+  gsl_matrix *m;
+#ifdef HAVE_NARRAY_H
+  VALUE ary2;
+#endif
+  if (VECTOR_P(ary)) {
+    Data_Get_Struct(ary, gsl_vector, v);
+    *stride = v->stride;
+    *n = v->size;
+    return v->data;
+  } else if (VECTOR_COMPLEX_P(ary)) {
+    Data_Get_Struct(ary, gsl_vector_complex, vc);
+    *stride = vc->stride;
+    *n = vc->size*2;
+    return vc->data;
+  } else if (MATRIX_P(ary)) {
+    Data_Get_Struct(ary, gsl_matrix, m);
+    *stride = 1;
+    *n = m->size1*m->size2;
+    return m->data;
+#ifdef HAVE_NARRAY_H
+  } else if (NA_IsNArray(ary)) {
+    *n = NA_TOTAL(ary);
+    *stride = 1;
+    ary2 = na_change_type(ary, NA_DFLOAT);
+    return NA_PTR_TYPE(ary2,double*);
+#endif
+  } else {
+    rb_raise(rb_eTypeError,
+	     "wrong argument type %s", rb_class2name(CLASS_OF(ary)));
+  }
+}
+
+gsl_vector* get_cvector(VALUE obj)
+{
+  gsl_vector *v = NULL;
+  if (rb_obj_is_kind_of(obj, cgsl_vector)) {
+    Data_Get_Struct(obj, gsl_vector,  v);
+#ifdef HAVE_NARRAY_H
+  } else if (NA_IsArray(obj)) {
+    v = make_cvector_from_rarrays(obj);
+#endif
+  } else {
+    rb_raise(rb_eTypeError,
+             "wrong argument type %s", rb_class2name(CLASS_OF(obj)));
+  }
+  return v; 
+}
+
+VALUE make_rarray_from_cvector(const gsl_vector *v)
+{
+  size_t i;
+  VALUE ary;
+  ary = rb_ary_new2(v->size);
+  for (i = 0; i < v->size; i++) {
+    rb_ary_store(ary, i, rb_float_new(gsl_vector_get(v, i)));
+  }
+  return ary;
+}
+
+VALUE make_rarray_from_cvector_int(const gsl_vector_int *v)
+{
+  size_t i;
+  VALUE ary;
+  ary = rb_ary_new2(v->size);
+  for (i = 0; i < v->size; i++) {
+    rb_ary_store(ary, i, INT2FIX(gsl_vector_int_get(v, i)));
+  }
+  return ary;
+}
+
+VALUE make_rarray_from_cpermutation(const gsl_permutation *v)
+{
+  size_t i;
+  VALUE ary;
+  ary = rb_ary_new2(v->size);
+  for (i = 0; i < v->size; i++) {
+    rb_ary_store(ary, i, rb_float_new(gsl_permutation_get(v, i)));
+  }
+  return ary;
+}
+
+gsl_vector* get_vector(VALUE ary)
+{
+  gsl_vector *v = NULL;
+  if (CLASS_OF(ary) == rb_cRange) ary = rb_gsl_range2ary(ary);
+  if (TYPE(ary) == T_ARRAY) {
+    return make_cvector_from_rarray(ary);
+#ifdef HAVE_NARRAY_H
+  } else if (NA_IsNArray(ary)) {
+    return make_cvector_from_narray(ary);
+#endif
+  } else if (VECTOR_P(ary)) {
+    Data_Get_Struct(ary, gsl_vector, v);
+    return v;
+  } else {
+    rb_raise(rb_eTypeError,
+	     "wrong argument type %s", rb_class2name(CLASS_OF(ary)));
+  }
+}
+
+gsl_vector* make_cvector_from_rarrays(VALUE ary)
+{
+  if (CLASS_OF(ary) == rb_cRange) ary = rb_gsl_range2ary(ary);
+  if (TYPE(ary) == T_ARRAY) {
+    return make_cvector_from_rarray(ary);
+#ifdef HAVE_NARRAY_H
+  } else if (NA_IsNArray(ary)) {
+    return make_cvector_from_narray(ary);
+#endif
+  } else {
+    rb_raise(rb_eTypeError,
+	     "wrong argument type %s", rb_class2name(CLASS_OF(ary)));
+  }
+}
+
+void cvector_set_from_carray(gsl_vector *v, const double *a)
+{
+  size_t i;
+  for (i = 0; i < v->size; i++) gsl_vector_set(v, i, a[i]);
+}
+
+void cvector_set_from_rarrays(gsl_vector *v, VALUE ary)
+{
+  if (CLASS_OF(ary) == rb_cRange) ary = rb_gsl_range2ary(ary);
+  if (TYPE(ary) == T_ARRAY) {
+    return cvector_set_from_rarray(v, ary);
+#ifdef HAVE_NARRAY_H
+  } else if (NA_IsNArray(ary)) {
+    return cvector_set_from_narray(v, ary);
+#endif
+  } else {
+    rb_raise(rb_eTypeError,
+	     "wrong argument type %s", rb_class2name(CLASS_OF(ary)));
+  }
+}
+
+void carray_set_from_cvector(double *a, const gsl_vector *v)
+{
+  size_t i;
+  for (i = 0; i < v->size; i++) a[i] = gsl_vector_get(v, i);
+}
+
+void carray_set_from_rarrays(double *a, VALUE ary)
+{
+  if (CLASS_OF(ary) == rb_cRange) ary = rb_gsl_range2ary(ary);
+  if (TYPE(ary) == T_ARRAY) {
+    return carray_set_from_rarray(a, ary);
+#ifdef HAVE_NARRAY_H
+  } else if (NA_IsNArray(ary)) {
+    return carray_set_from_narray(a, ary);
+#endif
+  } else {
+    rb_raise(rb_eTypeError,
+	     "wrong argument type %s", rb_class2name(CLASS_OF(ary)));
+  }
+}
+
+void carray_set_from_rarray(double *a, VALUE ary)
+{
+  size_t i, size;
+  VALUE val;
+  if (CLASS_OF(ary) == rb_cRange) ary = rb_gsl_range2ary(ary);
+  Check_Type(ary, T_ARRAY);
+  //  size = RARRAY(ary)->len;
+  size = RARRAY_LEN(ary);
+  if (size == 0) return;
+  for (i = 0; i < size; i++) {
+    val = rb_ary_entry(ary, i);
+    Need_Float(val);
+    a[i] = NUM2DBL(val);
+    //    a[i] = RFLOAT(val)->value;
+  }
+}
+
+#ifdef HAVE_NARRAY_H
+/* NArray -> CArray */
+void carray_set_from_narray(double *a, VALUE ary)
+{
+  int size;
+  VALUE ary2;
+  if (!NA_IsNArray(ary))
+    rb_raise(rb_eTypeError,
+             "wrong argument type %s", rb_class2name(CLASS_OF(ary)));
+  size = NA_TOTAL(ary);
+  if (size == 0) return;
+  ary2 = na_change_type(ary, NA_DFLOAT);
+  memcpy(a, NA_PTR_TYPE(ary2,double*), size*sizeof(double));
+}
+
+/* NArray -> GSL::Vector */
+gsl_vector* make_cvector_from_narray(VALUE ary)
+{
+  gsl_vector *v = NULL;
+  size_t size;
+  VALUE ary2;
+  if (!NA_IsNArray(ary))
+    rb_raise(rb_eTypeError,
+             "wrong argument type %s", rb_class2name(CLASS_OF(ary)));
+  size = NA_TOTAL(ary);
+  v = gsl_vector_alloc(size);
+  if (v == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed");
+  ary2 = na_change_type(ary, NA_DFLOAT);
+  memcpy(v->data, NA_PTR_TYPE(ary2,double*), size*sizeof(double));
+  /*  cvector_set_from_narray(v, ary);*/
+  return v;
+}
+
+void cvector_set_from_narray(gsl_vector *v, VALUE ary)
+{
+  int size;
+  if (!NA_IsNArray(ary))
+    rb_raise(rb_eTypeError,
+             "wrong argument type %s", rb_class2name(CLASS_OF(ary)));
+  size = NA_TOTAL(ary);
+  carray_set_from_narray(v->data, ary);
+}
+#endif
+
+gsl_vector_complex* make_vector_complex_clone(const gsl_vector_complex *v)
+{
+  gsl_vector_complex *vnew = NULL;
+  vnew = gsl_vector_complex_alloc(v->size);
+  if (vnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed");
+  gsl_vector_complex_memcpy(vnew, v);
+  return vnew;
+}
+
+gsl_matrix* make_matrix_clone(const gsl_matrix *m)
+{
+  gsl_matrix *mnew = NULL;
+  mnew = gsl_matrix_alloc(m->size1, m->size2);
+  if (mnew == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_alloc failed");
+  gsl_matrix_memcpy(mnew, m);
+  return mnew;
+}
+
+gsl_matrix_int* make_matrix_int_clone(const gsl_matrix_int *m)
+{
+  gsl_matrix_int *mnew = NULL;
+  mnew = gsl_matrix_int_alloc(m->size1, m->size2);
+  if (mnew == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_alloc failed");
+  gsl_matrix_int_memcpy(mnew, m);
+  return mnew;
+}
+
+VALUE make_matrix_clone2(VALUE vm)
+{
+  gsl_matrix *m = NULL, *mnew = NULL;
+  Data_Get_Struct(vm, gsl_matrix, m);
+  mnew = gsl_matrix_alloc(m->size1, m->size2);
+  if (mnew == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_alloc failed");
+  gsl_matrix_memcpy(mnew, m);
+  return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);;
+}
+
+gsl_matrix_complex* make_matrix_complex_clone(const gsl_matrix_complex *m)
+{
+  gsl_matrix_complex *mnew = NULL;
+  mnew = gsl_matrix_complex_alloc(m->size1, m->size2);
+  if (mnew == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed");
+  gsl_matrix_complex_memcpy(mnew, m);
+  return mnew;
+}
+
+gsl_vector_complex* vector_to_complex(const gsl_vector *v)
+{
+  gsl_vector_complex *cv = NULL;
+  gsl_complex z;
+  size_t i;
+  cv = gsl_vector_complex_alloc(v->size);
+  if (cv == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed");
+  for (i = 0; i < v->size; i++) {
+    z = gsl_complex_rect(gsl_vector_get(v, i), 0.0);
+    gsl_vector_complex_set(cv, i, z);
+  }
+  return cv;
+}
+
+gsl_matrix_complex* matrix_to_complex(const gsl_matrix *m)
+{
+  gsl_matrix_complex *cm = NULL;
+  gsl_complex z;
+  size_t i, j;
+  cm = gsl_matrix_complex_alloc(m->size1, m->size2);
+  if (cm == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed");
+  for (i = 0; i < m->size1; i++) {
+    for (j = 0; j < m->size2; j++) {
+      z = gsl_complex_rect(gsl_matrix_get(m, i, j), 0.0);
+      gsl_matrix_complex_set(cm, i, j, z);
+    }
+  }
+  return cm;
+}
+
+void gsl_matrix_complex_mul(gsl_matrix_complex *mnew, const gsl_matrix_complex *m, 
+			    const gsl_matrix_complex *mb)
+{
+  gsl_complex a, b, c, sum;
+  size_t i, j, k;
+  for (i = 0; i < m->size1; i++) {
+    for (j = 0; j < m->size2; j++) {
+      sum = gsl_complex_rect(0.0, 0.0);
+      for (k = 0; k < m->size2; k++) {
+	a = gsl_matrix_complex_get(m, j, k);
+	b = gsl_matrix_complex_get(mb, k, i);
+	c = gsl_complex_mul(a, b);
+	sum = gsl_complex_add(sum, c);
+      }
+      gsl_matrix_complex_set(mnew, j, i, sum);
+    }
+  }
+}
+
+void gsl_matrix_mul_vector(gsl_vector *vnew, 
+			   const gsl_matrix *m, const gsl_vector *v)
+{
+  size_t i, j;
+  double val;
+  for (i = 0; i < m->size1; i++) {
+    val = 0;
+    for (j = 0; j < m->size2; j++) 
+      val += gsl_matrix_get(m, i, j)*gsl_vector_get(v, j);
+    gsl_vector_set(vnew, i, val);
+  }
+}
+
+void gsl_matrix_int_mul_vector(gsl_vector_int *vnew, 
+			       const gsl_matrix_int *m, const gsl_vector_int *v)
+{
+  size_t i, j;
+  int val;
+  for (i = 0; i < m->size1; i++) {
+    val = 0;
+    for (j = 0; j < m->size2; j++) 
+      val += gsl_matrix_int_get(m, i, j)*gsl_vector_int_get(v, j);
+    gsl_vector_int_set(vnew, i, val);
+  }
+}
+
+void gsl_matrix_complex_mul_vector(gsl_vector_complex *vnew, 
+				   const gsl_matrix_complex *m, 
+				   const gsl_vector_complex *v)
+{
+  gsl_complex a, b, c, sum;
+  size_t i, j;
+  for (i = 0; i < m->size1; i++) {
+    sum = gsl_complex_rect(0.0, 0.0);
+    for (j = 0; j < m->size2; j++) {
+      a = gsl_matrix_complex_get(m, i, j);
+      b = gsl_vector_complex_get(v, j);
+      c = gsl_complex_mul(a, b);
+      sum = gsl_complex_add(sum, c);
+    }
+    gsl_vector_complex_set(vnew, i, sum);
+  }
+  
+}
+
+/*****/
+#ifndef GSL_1_12_LATER
+int gsl_vector_complex_add(gsl_vector_complex *cv, const gsl_vector_complex *cv2)
+{
+  size_t i;
+  gsl_complex a, b, c;
+  for (i = 0; i < cv->size; i++) {
+    a = gsl_vector_complex_get(cv, i);
+    b = gsl_vector_complex_get(cv2, i);
+    c = gsl_complex_add(a, b);
+    gsl_vector_complex_set(cv, i, c);
+  }
+  return 0;
+}
+
+int gsl_vector_complex_add_constant(gsl_vector_complex *cv, gsl_complex b)
+{
+  size_t i;
+  gsl_complex a, c;
+  for (i = 0; i < cv->size; i++) {
+    a = gsl_vector_complex_get(cv, i);
+    c = gsl_complex_add(a, b);
+    gsl_vector_complex_set(cv, i, c);
+  }
+  return 0;
+}
+
+int gsl_vector_complex_scale(gsl_vector_complex *cv, gsl_complex b)
+{
+  size_t i;
+  gsl_complex a, c;
+  for (i = 0; i < cv->size; i++) {
+    a = gsl_vector_complex_get(cv, i);
+    c = gsl_complex_mul(a, b);
+    gsl_vector_complex_set(cv, i, c);
+  }
+  return 0;
+}
+
+
+int gsl_vector_complex_sub(gsl_vector_complex *cv, const gsl_vector_complex *cv2)
+{
+  size_t i;
+  gsl_complex a, b, c;
+  for (i = 0; i < cv->size; i++) {
+    a = gsl_vector_complex_get(cv, i);
+    b = gsl_vector_complex_get(cv2, i);
+    c = gsl_complex_sub(a, b);
+    gsl_vector_complex_set(cv, i, c);
+  }
+  return 0;
+}
+
+int gsl_vector_complex_mul(gsl_vector_complex *cv, const gsl_vector_complex *cv2)
+{
+  size_t i;
+  gsl_complex a, b, c;
+  for (i = 0; i < cv->size; i++) {
+    a = gsl_vector_complex_get(cv, i);
+    b = gsl_vector_complex_get(cv2, i);
+    c = gsl_complex_mul(a, b);
+    gsl_vector_complex_set(cv, i, c);
+  }
+  return 0;
+}
+
+int gsl_vector_complex_div(gsl_vector_complex *cv, const gsl_vector_complex *cv2)
+{
+  size_t i;
+  gsl_complex a, b, c;
+  for (i = 0; i < cv->size; i++) {
+    a = gsl_vector_complex_get(cv, i);
+    b = gsl_vector_complex_get(cv2, i);
+    c = gsl_complex_div(a, b);
+    gsl_vector_complex_set(cv, i, c);
+  }
+  return 0;
+}
+#endif
+
+VALUE rb_gsl_range2ary(VALUE obj)
+{
+  //  double beg, en;
+  //  size_t n;
+  //  int step;
+  VALUE ary;
+  if (CLASS_OF(obj) != rb_cRange) 
+    rb_raise(rb_eTypeError, "wrong argument type %s (Range expected)",
+	     rb_class2name(CLASS_OF(obj)));
+  ary = rb_funcall(obj, rb_gsl_id_to_a, 0);
+  return ary;
+}
+
+void get_range_beg_en_n(VALUE range, double *beg, double *en, size_t *n, int *step);
+VALUE rb_gsl_range2vector(VALUE obj)
+{
+  double beg, en;
+  size_t n;
+  int i, step;
+  gsl_vector *v;
+  if (CLASS_OF(obj) != rb_cRange) 
+    rb_raise(rb_eTypeError, "wrong argument type %s (Range expected)",
+	     rb_class2name(CLASS_OF(obj)));
+  get_range_beg_en_n(obj, &beg, &en, &n, &step);
+  v = gsl_vector_alloc(n);
+  for (i = 0; i < n; i++) gsl_vector_set(v, i, (double) (beg+i));
+  return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v);
+}
+
+void get_range_int_beg_en_n(VALUE range, int *beg, int *en, size_t *n, int *step);
+VALUE rb_gsl_range2vector_int(VALUE obj)
+{
+  int beg, en, i, step;
+  size_t n;
+  gsl_vector_int *v;
+  if (CLASS_OF(obj) != rb_cRange) 
+    rb_raise(rb_eTypeError, "wrong argument type %s (Range expected)",
+	     rb_class2name(CLASS_OF(obj)));
+  get_range_int_beg_en_n(obj, &beg, &en, &n, &step);
+  v = gsl_vector_int_alloc(n);
+  for (i = 0; i < n; i++) gsl_vector_int_set(v, i, beg+i);
+  return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, v);
+}
+
+gsl_vector_int_view* rb_gsl_vector_int_view_alloc(size_t n)
+{
+  gsl_vector_int_view *v;
+  v = ALLOC(gsl_vector_int_view);
+  v->vector.size = n;
+  v->vector.stride = 1;
+  v->vector.owner = 0;
+  return v;
+}
+
+void rb_gsl_vector_int_view_free(gsl_vector_int_view *v)
+{
+  free((gsl_vector_int_view *) v);
+}
+
+gsl_matrix_view* rb_gsl_matrix_view_alloc()
+{
+  gsl_matrix_view *mv = NULL;
+  mv = ALLOC(gsl_matrix_view);
+  if (mv == NULL) rb_raise(rb_eRuntimeError, "malloc failed");
+  return mv;
+}
+
+void rb_gsl_matrix_view_free(gsl_matrix_view * mv)
+{
+  free((gsl_matrix_view *) mv);
+}
+
+gsl_matrix_int_view* rb_gsl_matrix_int_view_alloc()
+{
+  gsl_matrix_int_view *mv = NULL;
+  mv = ALLOC(gsl_matrix_int_view);
+  if (mv == NULL) rb_raise(rb_eRuntimeError, "malloc failed");
+  return mv;
+}
+
+void rb_gsl_matrix_int_view_free(gsl_matrix_int_view * mv)
+{
+  free((gsl_matrix_int_view *) mv);
+}
+
+void Init_gsl_array(VALUE module)
+{
+  cgsl_block = rb_define_class_under(module, "Block", 
+					 cGSL_Object);
+  cgsl_block_int = rb_define_class_under(cgsl_block, "Int", 
+					 cGSL_Object);
+  cgsl_block_uchar = rb_define_class_under(cgsl_block, "Byte", 
+					   cGSL_Object);
+
+  cgsl_block_complex = rb_define_class_under(cgsl_block, "Complex", cgsl_block);
+  cgsl_vector = rb_define_class_under(module, "Vector", 
+				      cGSL_Object);
+  cgsl_vector_col = rb_define_class_under(cgsl_vector, "Col", 
+					 cgsl_vector);
+  cgsl_vector_complex = rb_define_class_under(cgsl_vector, "Complex", 
+					      cGSL_Object);
+  cgsl_vector_complex_col = rb_define_class_under(cgsl_vector_complex, "Col",
+					      cgsl_vector_complex);
+  cgsl_matrix = rb_define_class_under(module, "Matrix", cGSL_Object);
+  cgsl_matrix_complex = rb_define_class_under(cgsl_matrix, "Complex", cGSL_Object);
+
+  cgsl_vector_view = rb_define_class_under(cgsl_vector, "View", cgsl_vector);
+  cgsl_vector_col_view = rb_define_class_under(cgsl_vector_col, "View", cgsl_vector_col);
+
+  cgsl_vector_complex_view = rb_define_class_under(cgsl_vector_complex, "View", 
+						   cgsl_vector_complex);
+  cgsl_vector_complex_col_view = rb_define_class_under(cgsl_vector_complex_col, "View", 
+						   cgsl_vector_complex_col);
+
+  cgsl_vector_int = rb_define_class_under(cgsl_vector, "Int", cGSL_Object);
+  cgsl_vector_int_col = rb_define_class_under(cgsl_vector_int, "Col", cgsl_vector_int);  
+  cgsl_vector_int_view = rb_define_class_under(cgsl_vector_int, "View", cgsl_vector_int);
+  cgsl_vector_int_col_view = rb_define_class_under(cgsl_vector_int_col, "View", cgsl_vector_int_col);
+
+
+  /*****/
+
+  cgsl_matrix_view = rb_define_class_under(cgsl_matrix, "View", 
+					   cgsl_matrix);
+  cgsl_matrix_complex_view = rb_define_class_under(cgsl_matrix_complex, "View", 
+						   cgsl_matrix_complex);
+  cgsl_permutation = rb_define_class_under(module, "Permutation", cGSL_Object);  
+  cgsl_index = rb_define_class_under(module, "Index", cgsl_permutation);
+
+  cgsl_vector_view_ro = rb_define_class_under(cgsl_vector_view, "ReadOnly",
+					      cgsl_vector_view);
+  cgsl_vector_col_view_ro = rb_define_class_under(cgsl_vector_col_view, "ReadOnly",
+					      cgsl_vector_col_view);
+  cgsl_vector_int_view_ro = rb_define_class_under(cgsl_vector_int_view, "ReadOnly",
+					      cgsl_vector_int_view);
+  cgsl_vector_int_col_view_ro = rb_define_class_under(cgsl_vector_int_col_view, "ReadOnly",
+					      cgsl_vector_int_col_view);
+  cgsl_matrix_view_ro = rb_define_class_under(cgsl_matrix_view, "ReadOnly",
+					      cgsl_matrix_view);
+
+  cgsl_vector_complex_view_ro = rb_define_class_under(cgsl_vector_complex_view, 
+						      "ReadOnly",
+						      cgsl_vector_complex_view);
+  cgsl_matrix_complex_view_ro = rb_define_class_under(cgsl_matrix_complex_view, 
+						      "ReadOnly",
+						      cgsl_matrix_complex_view);
+
+  /*****/
+  cgsl_matrix_int = rb_define_class_under(cgsl_matrix, "Int", cGSL_Object);
+  cgsl_matrix_int_view = rb_define_class_under(cgsl_matrix_int, "View", cgsl_matrix_int);
+  cgsl_matrix_int_view_ro = rb_define_class_under(cgsl_matrix_int_view, "ReadOnly",
+					      cgsl_matrix_int_view);
+  /*****/
+  Init_gsl_block_init(module);
+  Init_gsl_block_int_init(module);
+  Init_gsl_block_uchar_init(module);
+  Init_gsl_vector(module);
+  Init_gsl_vector_int(module);
+
+  Init_gsl_vector_complex(module);
+  Init_gsl_matrix(module);
+  Init_gsl_matrix_int(module);
+  Init_gsl_matrix_complex(module);
+  Init_gsl_permutation(module);
+#ifdef GSL_1_1_LATER
+  Init_gsl_combination(module);
+#endif
+  Init_gsl_array_complex(module);
+  Init_gsl_matrix_nmf();
+
+  rb_define_method(cgsl_vector_view_ro, "set", rb_gsl_obj_read_only, -1);
+  rb_define_method(cgsl_matrix_view_ro, "set", rb_gsl_obj_read_only, -1);
+  rb_define_method(cgsl_vector_int_view_ro, "set", rb_gsl_obj_read_only, -1);
+  rb_define_method(cgsl_matrix_int_view_ro, "set", rb_gsl_obj_read_only, -1);  
+  rb_define_method(cgsl_vector_complex_view_ro, "set", rb_gsl_obj_read_only, -1);
+  rb_define_method(cgsl_matrix_complex_view_ro, "set", rb_gsl_obj_read_only, -1);
+
+}