gsl 1.16.0.6 → 2.1.0

data/ext/gsl_native/dht.c

@@ -72,6 +72,15 @@ static VALUE rb_gsl_dht_apply(int argc, VALUE *argv, VALUE obj)
       ptr1 = (double*)na->ptr;
       ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv[0]));
       ptr2 = NA_PTR_TYPE(ary, double*);
+#endif
+#ifdef HAVE_NMATRIX_H
+    } else if (NM_IsNMatrix(argv[0])) {
+      NM_DENSE_STORAGE *nm;
+      nm = NM_STORAGE_DENSE(argv[0]);
+      ptr1 = (double*)nm->elements;
+      ary = rb_nmatrix_dense_create(FLOAT64, nm->shape, nm->dim, nm->elements, 
+        NM_DENSE_COUNT(argv[0]));
+      ptr2 = (double*)NM_DENSE_ELEMENTS(ary);
 #endif
     } else {
       rb_raise(rb_eTypeError, "wrong argument type %s (Vector expected)",
@@ -139,6 +148,23 @@ static VALUE rb_gsl_dht_xk_sample(VALUE obj, VALUE n,
       }
       return ary;
 #endif
+#ifdef HAVE_NARRAY_H
+    } else if (NM_IsNMatrix(n)) {
+      NM_DENSE_STORAGE *nm;
+      int *ptr;
+      double *ptr2;
+      nm = NM_STORAGE_DENSE(n);
+      ptr = (int*) nm->elements;
+      size = NM_DENSE_COUNT(n);
+      ary = rb_nmatrix_dense_create(FLOAT64, nm->shape, nm->dim, nm->elements, 
+        NM_DENSE_COUNT(n));
+      ptr2 = (double*)NM_DENSE_ELEMENTS(ary);
+      for (i = 0; i < size; i++) {
+        ptr2[i] = (*sample)(t, ptr[i]);
+      }
+      return ary;
+#endif
+
     } else {
       rb_raise(rb_eTypeError, "wrong argument type %s (Vector::Int expected)",
                rb_class2name(CLASS_OF(n)));

data/ext/gsl_native/eigen.c

@@ -19,6 +19,10 @@
 #include <gsl/gsl_math.h>
 #include <gsl/gsl_eigen.h>
 
+#ifdef HAVE_NMATRIX_H
+#include "include/rb_gsl_with_nmatrix.h"
+#endif
+
 static VALUE cgsl_eigen_symm_workspace;
 static VALUE cgsl_eigen_symmv_workspace;
 static VALUE cgsl_eigen_herm_workspace;
@@ -135,6 +139,54 @@ static VALUE rb_gsl_eigen_symm_narray(int argc, VALUE *argv, VALUE obj)
 }
 #endif
 
+#ifdef HAVE_NMATRIX_H
+static VALUE rb_gsl_eigen_symm_nmatrix(int argc, VALUE *argv, VALUE obj)
+{
+  NM_DENSE_STORAGE *nm;
+  VALUE nmatrix;
+  gsl_matrix *A = NULL;
+  gsl_eigen_symm_workspace *w = NULL;
+  gsl_vector_view vv;
+  unsigned int shape[1];
+  int flagw = 0;
+
+  if (!NM_IsNMatrix(argv[0]))
+    rb_raise(rb_eTypeError, "wrong argument type %s (NMatrix expected)",
+             rb_class2name(CLASS_OF(argv[0])));
+  nm = NM_STORAGE_DENSE(argv[0]);
+  if (nm->shape[0] != nm->shape[1])
+    rb_raise(rb_eRuntimeError, "square matrix required");
+  A = gsl_matrix_alloc(nm->shape[0], nm->shape[1]);
+  memcpy(A->data, (double*) nm->elements, sizeof(double)*A->size1*A->size2);
+
+  switch (argc) {
+  case 2:
+    if (CLASS_OF(argv[1]) != cgsl_eigen_symm_workspace)
+      rb_raise(rb_eTypeError,
+               "argv[1]:  wrong argument type %s (Eigen::Symm::Workspace expected",
+               rb_class2name(CLASS_OF(argv[1])));
+    Data_Get_Struct(argv[1], gsl_eigen_symm_workspace, w);
+    flagw = 0;
+    break;
+  case 1:
+    w = gsl_eigen_symm_alloc(A->size1);
+    flagw = 1;
+    break;
+  default:
+    rb_raise(rb_eArgError, "matrix not given");
+    break;
+  }
+  shape[0] = A->size1;
+  nmatrix = rb_nvector_dense_create(FLOAT64, nm->elements, shape[0]);
+  vv = gsl_vector_view_array((double*)NM_DENSE_ELEMENTS(nmatrix), A->size1);
+  gsl_eigen_symm(A, &vv.vector, w);
+  /*  gsl_sort_vector(v);*/
+  gsl_matrix_free(A);
+  if (flagw == 1) gsl_eigen_symm_free(w);
+  return nmatrix;
+}
+#endif
+
 static VALUE rb_gsl_eigen_symm(int argc, VALUE *argv, VALUE obj)
 {
   gsl_matrix *Atmp = NULL, *A = NULL;
@@ -150,6 +202,10 @@ static VALUE rb_gsl_eigen_symm(int argc, VALUE *argv, VALUE obj)
 #ifdef HAVE_NARRAY_H
       if (NA_IsNArray(argv[0])) return rb_gsl_eigen_symm_narray(argc, argv, obj);
 #endif
+
+#ifdef HAVE_NMATRIX_H
+      if (NM_IsNMatrix(argv[0])) return rb_gsl_eigen_symm_nmatrix(argc, argv, obj);
+#endif
       CHECK_MATRIX(argv[0]);
       Data_Get_Struct(argv[0], gsl_matrix, Atmp);
       if (CLASS_OF(argv[1]) != cgsl_eigen_symm_workspace)
@@ -162,6 +218,10 @@ static VALUE rb_gsl_eigen_symm(int argc, VALUE *argv, VALUE obj)
 #ifdef HAVE_NARRAY_H
       if (NA_IsNArray(argv[0])) return rb_gsl_eigen_symm_narray(argc, argv, obj);
 #endif
+
+#ifdef HAVE_NMATRIX_H
+      if (NM_IsNMatrix(argv[0])) return rb_gsl_eigen_symm_nmatrix(argc, argv, obj);
+#endif
       CHECK_MATRIX(argv[0]);
       Data_Get_Struct(argv[0], gsl_matrix, Atmp);
       w = gsl_eigen_symm_alloc(Atmp->size1);
@@ -261,6 +321,67 @@ static VALUE rb_gsl_eigen_symmv_narray(int argc, VALUE *argv, VALUE obj)
 }
 #endif
 
+#ifdef HAVE_NMATRIX_H
+static VALUE rb_gsl_eigen_symmv_nmatrix(int argc, VALUE *argv, VALUE obj)
+{
+  NM_DENSE_STORAGE *nm;
+  VALUE eval, evec;
+  gsl_matrix *A = NULL;
+  gsl_eigen_symmv_workspace *w = NULL;
+  gsl_matrix_view mv;
+  gsl_vector_view vv;
+  unsigned int shape1[1], shape2[2];
+  int flagw = 0;
+  switch (argc) {
+  case 2:
+    if (!NM_IsNMatrix(argv[0]))
+      rb_raise(rb_eTypeError, "wrong argument type %s (NMatrix expected)",
+               rb_class2name(CLASS_OF(argv[0])));
+    nm = NM_STORAGE_DENSE(argv[0]);
+    if (nm->dim < 2) rb_raise(rb_eRuntimeError, "dim >= 2 required");
+    if (nm->shape[0] != nm->shape[1])
+      rb_raise(rb_eRuntimeError, "square matrix required");
+    A = gsl_matrix_alloc(nm->shape[1], nm->shape[0]);
+    memcpy(A->data, (double*) nm->elements, sizeof(double)*A->size1*A->size2);
+    if (CLASS_OF(argv[1]) != cgsl_eigen_symmv_workspace)
+      rb_raise(rb_eTypeError,
+               "argv[1]:  wrong argument type %s (Eigen::Symm::Workspace expected",
+               rb_class2name(CLASS_OF(argv[1])));
+    Data_Get_Struct(argv[1], gsl_eigen_symmv_workspace, w);
+    flagw = 0;
+    break;
+  case 1:
+    if (!NM_IsNMatrix(argv[0]))
+      rb_raise(rb_eTypeError, "wrong argument type %s (NArray expected)",
+               rb_class2name(CLASS_OF(argv[0])));
+    nm = NM_STORAGE_DENSE(argv[0]);
+    if (nm->dim < 2) rb_raise(rb_eRuntimeError, "rank >= 2 required");
+    if (nm->shape[0] != nm->shape[1])
+      rb_raise(rb_eRuntimeError, "square matrix required");
+    A = gsl_matrix_alloc(nm->shape[1], nm->shape[0]);
+    memcpy(A->data, (double*) nm->elements, sizeof(double)*A->size1*A->size2);
+    w = gsl_eigen_symmv_alloc(A->size1);
+    flagw = 1;
+    break;
+  default:
+    rb_raise(rb_eArgError, "matrix not given");
+    break;
+  }
+  shape1[0] = A->size1;
+  shape2[0] = A->size1;
+  shape2[1] = A->size1;
+  eval = rb_nvector_dense_create(FLOAT64, nm->elements, shape1[0]);
+  evec = rb_nmatrix_dense_create(FLOAT64, shape2, 2, nm->elements, shape2[0]*shape2[1]);
+  vv = gsl_vector_view_array((double*)NM_DENSE_ELEMENTS(eval), A->size1);
+  mv = gsl_matrix_view_array((double*)NM_DENSE_ELEMENTS(evec), A->size1, A->size2);
+  gsl_eigen_symmv(A, &vv.vector, &mv.matrix, w);
+  /*  gsl_sort_vector(v);*/
+  gsl_matrix_free(A);
+  if (flagw == 1) gsl_eigen_symmv_free(w);
+  return rb_ary_new3(2, eval, evec);
+}
+#endif
+
 static VALUE rb_gsl_eigen_symmv(int argc, VALUE *argv, VALUE obj)
 {
   gsl_matrix *Atmp = NULL, *A = NULL, *em = NULL;
@@ -277,6 +398,10 @@ static VALUE rb_gsl_eigen_symmv(int argc, VALUE *argv, VALUE obj)
 #ifdef HAVE_NARRAY_H
       if (NA_IsNArray(argv[0])) return rb_gsl_eigen_symmv_narray(argc, argv, obj);
 #endif
+
+#ifdef HAVE_NMATRIX_H
+      if (NM_IsNMatrix(argv[0])) return rb_gsl_eigen_symmv_nmatrix(argc, argv, obj);
+#endif
       CHECK_MATRIX(argv[0]);
       Data_Get_Struct(argv[0], gsl_matrix, Atmp);
       if (CLASS_OF(argv[1]) != cgsl_eigen_symmv_workspace)
@@ -289,6 +414,10 @@ static VALUE rb_gsl_eigen_symmv(int argc, VALUE *argv, VALUE obj)
 #ifdef HAVE_NARRAY_H
       if (NA_IsNArray(argv[0])) return rb_gsl_eigen_symmv_narray(argc, argv, obj);
 #endif
+
+#ifdef HAVE_NMATRIX_H
+      if (NM_IsNMatrix(argv[0])) return rb_gsl_eigen_symmv_nmatrix(argc, argv, obj);
+#endif
       CHECK_MATRIX(argv[0]);
       Data_Get_Struct(argv[0], gsl_matrix, Atmp);
       w = gsl_eigen_symmv_alloc(Atmp->size1);

data/ext/gsl_native/extconf.rb

@@ -9,6 +9,35 @@ rescue => err
   abort "*** ERROR: missing required library to compile this module: #{err}"
 end
 
+# Function derived from NArray's extconf.rb.
+def create_conf_h(file) #:nodoc:
+  print "creating #{file}\n"
+  File.open(file, 'w') do |hfile|
+    header_guard = file.upcase.sub(/\s|\./, '_')
+
+    hfile.puts "#ifndef #{header_guard}"
+    hfile.puts "#define #{header_guard}"
+    hfile.puts
+
+    # FIXME: Find a better way to do this:
+    hfile.puts "#define RUBY_2 1" if RUBY_VERSION >= '2.0'
+
+    for line in $defs
+      line =~ /^-D(.*)/
+      match_data = $1.dup
+
+      if match_data.match(/GSL_VERSION*/)
+        hfile.printf "#define #{match_data.to_s.split('=').join(' ')}\n"
+      else
+        hfile.printf "#define %s 1\n", match_data
+      end
+    end
+
+    hfile.puts
+    hfile.puts "#endif"
+  end
+end
+
 def gsl_def(const, value = nil)
   value = "=#{value}" if value
   $defs << "-D#{const}#{value}"
@@ -30,8 +59,19 @@ def gsl_gem_config(target, dir = 'ext')
   path = begin
     require 'rubygems'
 
-    spec = Gem::Specification.find_by_path("#{target}.h")
-    File.join(spec.full_gem_path, dir) if spec
+    # For some weird reason finding narray and nmatrix headers works with specific
+    # functions only. Might need to fix nmatrix/narray to place headers in correct
+    # locations?
+    if target == 'narray'
+      gem 'narray'
+      spec = Gem::Specification.find_by_path("#{target}")
+      File.join(spec.full_gem_path, dir) if spec
+    else
+      gem 'nmatrix'
+      spec = Gem::Specification.find_all_by_name("#{target}").compact
+      File.join(spec[0].require_path)
+    end
+
   rescue LoadError
   end
 
@@ -66,7 +106,7 @@ gsl_config_arg(:version) { |version, check|
 
   raise 'Ruby/GSL requires gsl-1.15 or later.' unless later['1.15']
 
-  %w[1.15 1.16].each { |v| later[v] }
+  %w[1.15 1.16 2.0 2.1].each { |v| later[v] }
 }
 
 gsl_config_arg(:cflags) { |cflags, check|
@@ -105,14 +145,28 @@ gsl_have_library('gsl_poly_solve_quartic')
 
 gsl_def(:HAVE_GNU_GRAPH) if find_executable('graph')
 
-gsl_gem_config('narray', 'src')
+external_libs = []
+external_libs << 'narray' if ENV['NARRAY']
+external_libs << 'nmatrix' if ENV['NMATRIX']
 
-have_header('narray.h')
-have_library('narray') if RUBY_PLATFORM =~ /cygwin|mingw/
+external_libs.each do |library|
+  gsl_gem_config(library)
+  have_header("#{library}.h")
+  have_library(library) if RUBY_PLATFORM =~ /cygwin|mingw/  
+end
 
 unless arg_config('--disable-tamu-anova')
   gsl_dir_config('tamu_anova')
   gsl_have_header('tamuanova', 'tamu_anova/tamu_anova.h')
 end
 
+have_struct_member('gsl_multifit_fdfsolver', 'J', 'gsl/gsl_multifit_nlin.h')
+have_func('gsl_sf_mathieu_a_e',  'gsl/gsl_sf_mathieu.h');
+have_func('gsl_sf_mathieu_b_e',  'gsl/gsl_sf_mathieu.h');
+have_func('gsl_sf_mathieu_ce_e', 'gsl/gsl_sf_mathieu.h');
+have_func('gsl_sf_mathieu_se_e', 'gsl/gsl_sf_mathieu.h');
+have_func('gsl_sf_mathieu_Mc_e', 'gsl/gsl_sf_mathieu.h');
+have_func('gsl_sf_mathieu_Ms_e', 'gsl/gsl_sf_mathieu.h');
+
+create_conf_h('gsl_config.h')
 create_makefile('gsl_native')

data/ext/gsl_native/fft.c

@@ -618,6 +618,20 @@ static VALUE rb_fft_radix2(VALUE obj,
       ptr2 = NA_PTR_TYPE(ary, double*);
     }
 #endif
+
+#ifdef HAVE_NMATRIX_H
+  } else if (flag == 1) {
+    if (sss == RB_GSL_FFT_COPY) {
+      int shape[1];
+      shape[0] = n;
+      ary = rb_nvector_dense_create(FLOAT64, ptr1, shape[0]);
+      ptr2 = (double*)NM_DENSE_ELEMENTS(ary);
+      stride = 1;
+    } else {
+      ary = obj;
+      ptr2 = (double*)NM_DENSE_ELEMENTS(ary);
+    }
+#endif
   } else {
     rb_raise(rb_eRuntimeError, "something wrong");
   }
@@ -708,6 +722,20 @@ static VALUE rb_fft_real_trans(int argc, VALUE *argv, VALUE obj,
       ary = obj;
     }
 #endif
+
+#ifdef HAVE_NMATRIX_H
+  } else if (naflag == 1) {
+    if (sss == RB_GSL_FFT_COPY) {
+      int shape[1];
+      shape[0] = n;
+      ary = rb_nvector_dense_create(FLOAT64, ptr1, shape[0]);
+      ptr2 = (double*)NM_DENSE_ELEMENTS(ary);
+      stride = 1;
+    } else {
+      ptr2 = ptr1;
+      ary = obj;
+    }
+#endif
   } else {
     rb_raise(rb_eRuntimeError, "something wrong");
   }
@@ -773,6 +801,20 @@ static VALUE rb_fft_halfcomplex_trans(int argc, VALUE *argv, VALUE obj,
       ary = obj;
     }
 #endif
+
+#ifdef HAVE_NMATRIX_H
+  } else if (naflag == 1) {
+    if (sss == RB_GSL_FFT_COPY) {
+      int shape[1];
+      shape[0] = n;
+      ary = rb_nvector_dense_create(FLOAT64, ptr1, shape[0]);
+      ptr2 = (double*)NM_DENSE_ELEMENTS(ary);
+      stride = 1;
+    } else {
+      ptr2 = ptr1;
+      ary = obj;
+    }
+#endif
   } else {
     rb_raise(rb_eRuntimeError, "something wrong");
   }

data/ext/gsl_native/function.c

@@ -149,6 +149,24 @@ static VALUE rb_gsl_function_eval(VALUE obj, VALUE x)
       }
       return ary;
     }
+#endif
+#ifdef HAVE_NMATRIX_H
+    if (NM_IsNMatrix(x)) {
+      double *ptr1, *ptr2;
+      NM_DENSE_STORAGE *nm;
+      nm = NM_STORAGE_DENSE(x);
+      ptr1 = (double *) nm->elements;
+      n = NM_DENSE_COUNT(x);
+      ary = rb_nmatrix_dense_create(FLOAT64, nm->shape, nm->dim, nm->elements, n);
+      ptr2 = (double*)NM_DENSE_ELEMENTS(ary);
+      for (i = 0; i < n; i++) {
+        x2 = rb_float_new(ptr1[i]);
+        if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2);
+        else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params);
+        ptr2[i] = NUM2DBL(result);
+      }
+      return ary;
+    }
 #endif
     if (VECTOR_P(x)) {
       Data_Get_Struct(x, gsl_vector, v);

data/ext/gsl_native/gsl.c

@@ -9,6 +9,7 @@
   WITHOUT ANY WARRANTY.
 */
 
+#include "gsl_config.h"
 #include "include/rb_gsl.h"
 #include <gsl/gsl_machine.h>
 
@@ -140,6 +141,10 @@ void Init_gsl_native()
   Init_gsl_narray(mgsl);
 #endif
 
+#ifdef HAVE_NMATRIX_H
+  Init_gsl_nmatrix(mgsl);
+#endif
+
   Init_wavelet(mgsl);
 
   rb_gsl_define_const(mgsl);

data/ext/gsl_native/gsl_nmatrix.c

@@ -0,0 +1,204 @@
+/*
+  gsl_nmatrix.c
+
+  Written by Sameer Deshmukh (@v0dro)      feb/2016
+ */
+#ifdef HAVE_NMATRIX_H
+
+#include "include/rb_gsl_with_nmatrix.h"
+
+// functions to convert GSL::Vectors to 1D NMatrix
+static VALUE rb_gsl_vector_to_nmatrix(VALUE obj);
+static VALUE rb_gsl_vector_int_to_nmatrix(VALUE obj);
+static VALUE rb_gsl_vector_complex_to_nmatrix(VALUE obj);
+
+// functions to convert GSL::Matrix to 2D NMatrix
+static VALUE rb_gsl_matrix_to_nmatrix(VALUE obj);
+static VALUE rb_gsl_matrix_int_to_nmatrix(VALUE obj);
+static VALUE rb_gsl_matrix_complex_to_nmatrix(VALUE obj);
+
+/* GSL::Vector -> NMatrix */
+static VALUE rb_gsl_vector_to_nmatrix(VALUE obj) {
+  gsl_vector *v = NULL;
+  Data_Get_Struct(obj, gsl_vector, v);
+
+  return rb_nvector_dense_create(FLOAT64, v->data, v->size);
+}
+
+static VALUE rb_gsl_vector_int_to_nmatrix(VALUE obj) {
+  gsl_vector_int *v = NULL;
+  Data_Get_Struct(obj, gsl_vector_int, v);
+
+  return rb_nvector_dense_create(INT32, v->data, v->size);
+}
+
+static VALUE rb_gsl_vector_complex_to_nmatrix(VALUE obj) {
+  gsl_vector_complex *v = NULL;
+  Data_Get_Struct(obj, gsl_vector_complex, v);
+
+  return rb_nvector_dense_create(COMPLEX128, v->data, v->size);
+}
+
+static VALUE rb_gsl_matrix_to_nmatrix(VALUE obj) {
+  gsl_matrix *m = NULL;
+  Data_Get_Struct(obj, gsl_matrix, m);
+
+  return rb_nmatrix_dense_create(FLOAT64, &(m->size1), 2, m->data, m->size1 * m->size2);
+}
+
+static VALUE rb_gsl_matrix_int_to_nmatrix(VALUE obj) {
+  gsl_matrix_int *m = NULL;
+  Data_Get_Struct(obj, gsl_matrix_int, m);
+
+  return rb_nmatrix_dense_create(INT32, &(m->size1), 2, m->data, m->size1 * m->size2);
+}
+
+static VALUE rb_gsl_matrix_complex_to_nmatrix(VALUE obj) {
+  gsl_matrix_complex *m = NULL;
+  Data_Get_Struct(obj, gsl_matrix_complex, m);
+
+  return rb_nmatrix_dense_create(COMPLEX128, &(m->size1), 2, m->data, m->size1 * m->size2);
+}
+
+// functions called on NMatrix objects. 'nm' is of type NMatrix.
+gsl_vector* rb_gsl_nmatrix_to_gv(VALUE nm) {
+  NM_DENSE_STORAGE* s = NM_STORAGE_DENSE(nm);
+  // TODO: change this once nmatrix is fixed
+  gsl_vector* v = gsl_vector_alloc( FIX2INT(rb_funcall(nm, rb_intern("count"), 0, NULL)) );
+
+  if (s->dtype != FLOAT64) {
+    rb_raise(rb_eStandardError, "requires dtype of :float64 to convert to a GSL vector");
+  }
+
+  memcpy(v->data, s->elements, v->size*sizeof(double));
+
+  return v;
+}
+
+gsl_vector_int* rb_gsl_nmatrix_to_gv_int(VALUE nm) {
+  NM_DENSE_STORAGE* s = NM_STORAGE_DENSE(nm);
+  gsl_vector_int* v = gsl_vector_int_alloc(
+    FIX2INT(rb_funcall(nm, rb_intern("count"), 0, NULL)));
+
+  if (s->dtype != INT32) {
+    rb_raise(rb_eStandardError, "requires dtype of :int32 to convert to a GSL int vector");
+  }
+
+  memcpy(v->data, s->elements, v->size*sizeof(int32_t));
+
+  return v;
+}
+
+gsl_vector_complex* rb_gsl_nmatrix_to_gv_complex(VALUE nm) {
+  NM_DENSE_STORAGE* s = NM_STORAGE_DENSE(nm);
+  gsl_vector_complex* v = gsl_vector_complex_alloc(
+    FIX2INT(rb_funcall(nm, rb_intern("count"), 0, NULL)) );
+
+  if (s->dtype != COMPLEX128) {
+    rb_raise(rb_eStandardError, "requires dtype of :complex128 to convert to a GSL complex vector");
+  }
+
+  memcpy(v->data, s->elements, v->size*sizeof(double)*2);
+
+  return v;
+}
+
+// NMatrix function to convert NMatrix to GSL::Vector object depending on dtype
+VALUE rb_gsl_nmatrix_to_gsl_vector_method(VALUE nm) {
+  if (NM_DTYPE(nm) == COMPLEX64 || NM_DTYPE(nm) == COMPLEX128) {
+    return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, 
+      rb_gsl_nmatrix_to_gv_complex(nm));
+  } 
+  else if (NM_DTYPE(nm) == INT32) {
+    return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free,
+      rb_gsl_nmatrix_to_gv_int(nm));
+  }
+  else if (NM_DTYPE(nm) == FLOAT64) {
+    return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free,
+      rb_gsl_nmatrix_to_gv(nm));
+  }
+  else {
+    rb_raise(rb_eStandardError, 
+      "NMatrix should be either :complex64, :complex128, :int32 or :float64 type."); 
+  }
+}
+
+gsl_matrix* rb_gsl_nmatrix_to_gm(VALUE nm) {
+  NM_DENSE_STORAGE* s = NM_STORAGE_DENSE(nm);
+  gsl_matrix* m = gsl_matrix_alloc( s->shape[0], s->shape[1] );
+
+  if (s->dtype != FLOAT64) {
+    rb_raise(rb_eStandardError, "requires dtype of :float64 to convert from a GSL double vector");
+  }
+
+  memcpy(m->data, s->elements, s->shape[0]*s->shape[1]*sizeof(double)); // double is nm :float64
+  return m;
+}
+
+gsl_matrix_int* rb_gsl_nmatrix_to_gm_int(VALUE nm) {
+  NM_DENSE_STORAGE* s = NM_STORAGE_DENSE(nm);
+  gsl_matrix_int* m = gsl_matrix_int_alloc( s->shape[0], s->shape[1] );
+
+  if (s->dtype != INT32) {
+    rb_raise(rb_eStandardError, "requires dtype of :int32 to convert from a GSL int vector");
+  }
+
+  memcpy(m->data, s->elements, s->shape[0]*s->shape[1]*sizeof(int32_t)); // int32_t is nm :int32
+  return m;
+}
+
+gsl_matrix_complex* rb_gsl_nmatrix_to_gm_complex(VALUE nm) {
+  NM_DENSE_STORAGE* s = NM_STORAGE_DENSE(nm);
+  gsl_matrix_complex* m = gsl_matrix_complex_alloc( s->shape[0], s->shape[1]);
+
+  if (s->dtype != COMPLEX128) {
+    rb_raise(rb_eStandardError, "requires dtype of :complex128 to convert from a GSL complex vector");
+  }
+
+  memcpy(m->data, s->elements, s->shape[0]*s->shape[1]*sizeof(double)*2);
+  return m;
+}
+
+// NMatrix to GSL::Matrix conversion based on dtype
+VALUE rb_gsl_nmatrix_to_gsl_matrix_method(VALUE nmatrix) {
+  if (NM_DIM(nmatrix) > 2) {
+    rb_raise(rb_eStandardError,
+      "NMatrix must not have greater than 2 dimensions.");
+  }
+
+  if (NM_DTYPE(nmatrix) == COMPLEX64 || NM_DTYPE(nmatrix) == COMPLEX128) {
+    return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, 
+      rb_gsl_nmatrix_to_gm_complex(nmatrix));
+  } 
+  else if (NM_DTYPE(nmatrix) == INT32) {
+    return Data_Wrap_Struct(cgsl_matrix_int, 0, gsl_matrix_int_free,
+      rb_gsl_nmatrix_to_gm_int(nmatrix));
+  }
+  else if (NM_DTYPE(nmatrix) == FLOAT64) {
+    return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free,
+      rb_gsl_nmatrix_to_gm(nmatrix));
+  }
+  else {
+    rb_raise(rb_eStandardError, 
+      "NMatrix should be either :complex64, :complex128, :int32 or :float64 type."); 
+  }
+}
+
+void Init_gsl_nmatrix(VALUE module)
+{
+  // functions to convert GSL::Vector to 1D NMatrix.
+  rb_define_method(cgsl_vector, "to_nm", rb_gsl_vector_to_nmatrix, 0);
+  rb_define_method(cgsl_vector_int, "to_nm", rb_gsl_vector_int_to_nmatrix, 0);
+  rb_define_method(cgsl_vector_complex, "to_nm", rb_gsl_vector_complex_to_nmatrix, 0);
+
+  // functions to convert GSL::Matrix to 2D Nmatrix.
+  rb_define_method(cgsl_matrix, "to_nm", rb_gsl_matrix_to_nmatrix, 0);
+  rb_define_method(cgsl_matrix_int, "to_nm", rb_gsl_matrix_int_to_nmatrix, 0);
+  rb_define_method(cgsl_matrix_complex, "to_nm", rb_gsl_matrix_complex_to_nmatrix, 0);
+
+  // functions on NMatrix to convert to GSL::Vector and GSL::Matrix
+  rb_define_method(cNMatrix, "to_gslv", rb_gsl_nmatrix_to_gsl_vector_method, 0);
+  rb_define_method(cNMatrix, "to_gslm", rb_gsl_nmatrix_to_gsl_matrix_method, 0);
+}
+
+#endif