rb-gsl 1.15.3.1

data/ext/gsl.c

@@ -0,0 +1,280 @@
+/*
+  gsl.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.h"
+#include <gsl/gsl_machine.h>
+
+ID rb_gsl_id_beg, rb_gsl_id_end, rb_gsl_id_excl, rb_gsl_id_to_a;
+static ID rb_gsl_id_name, rb_gsl_id_size;
+VALUE cGSL_Object;
+static void rb_gsl_define_intern(VALUE module);
+static void rb_gsl_define_const(VALUE module);
+static void rb_gsl_define_methods(VALUE module);
+
+static VALUE rb_gsl_object_inspect(VALUE obj)
+{
+  char buf[256];
+  sprintf(buf, "%s", rb_class2name(CLASS_OF(obj)));
+  return rb_str_new2(buf);
+}
+
+static VALUE rb_gsl_call_rescue(VALUE obj)
+{
+  return Qfalse;
+}
+
+static VALUE rb_gsl_call_name(VALUE obj)
+{
+  return rb_funcall(obj, rb_gsl_id_name, 0);
+}
+
+static VALUE rb_gsl_call_size(VALUE obj)
+{
+  return rb_funcall(obj, rb_gsl_id_size, 0);
+}
+
+static VALUE rb_gsl_object_info(VALUE obj)
+{
+  char buf[256];
+  VALUE s;
+  sprintf(buf, "Class:      %s\n", rb_class2name(CLASS_OF(obj)));
+#ifdef RUBY_1_9_LATER
+  sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS_SUPER(CLASS_OF(obj))));
+#else
+  sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS(CLASS_OF(obj))->super));
+#endif
+  s = rb_rescue(rb_gsl_call_name, obj, rb_gsl_call_rescue, obj);
+  if (s) sprintf(buf, "%sType:       %s\n", buf, STR2CSTR(s));
+  s = rb_rescue(rb_gsl_call_size, obj, rb_gsl_call_rescue, obj);
+  if (s) sprintf(buf, "%sSize:       %d\n", buf, (int) FIX2INT(s));
+  return rb_str_new2(buf);
+}
+
+static VALUE rb_gsl_not_implemeted(VALUE obj)
+{
+  rb_raise(rb_eNotImpError, "%s#dup is not implemented", rb_class2name(CLASS_OF(obj)));
+  return Qnil;
+}
+
+void Init_rb_gsl()
+{
+  VALUE mgsl;
+
+  mgsl = rb_define_module("GSL");
+  cGSL_Object = rb_define_class_under(mgsl, "Object", rb_cObject);
+  rb_define_method(cGSL_Object, "inspect", rb_gsl_object_inspect, 0);
+  rb_define_method(cGSL_Object, "info", rb_gsl_object_info, 0);
+  // Override Object#dup to prevent invalid dup-ing of GSL_Objects.
+  // Subclasses (e.g. GSL::Vector) must provide their own implementation of
+  // #dup if desired.
+  rb_define_method(cGSL_Object, "dup", rb_gsl_not_implemeted, 0);
+
+  rb_gsl_define_intern(mgsl);
+
+  Init_gsl_error(mgsl);
+
+  Init_gsl_math(mgsl);
+  Init_gsl_complex(mgsl);
+
+  Init_gsl_array(mgsl);
+
+  Init_gsl_blas(mgsl);
+
+  Init_gsl_sort(mgsl);
+
+  Init_gsl_poly(mgsl);  /* this must be called after the Vector class defined */
+  Init_gsl_poly_int(mgsl);
+  Init_gsl_poly2(mgsl);
+  Init_gsl_rational(mgsl);
+
+  Init_gsl_sf(mgsl);
+
+  Init_gsl_linalg(mgsl); /*  Init_gsl_linalg_complex() is called in Init_gsl_linalg() */
+
+  Init_gsl_eigen(mgsl);
+
+  Init_gsl_fft(mgsl);
+    Init_gsl_signal(mgsl);
+  Init_gsl_function(mgsl);
+  Init_gsl_integration(mgsl);
+
+  Init_gsl_rng(mgsl);
+  Init_gsl_qrng(mgsl);
+  Init_gsl_ran(mgsl);
+#ifdef GSL_1_4_LATER
+  Init_gsl_cdf(mgsl);
+#endif
+  Init_gsl_stats(mgsl);
+
+  Init_gsl_histogram(mgsl);
+  Init_gsl_histogram2d(mgsl);
+  Init_gsl_histogram3d(mgsl);
+  Init_gsl_ntuple(mgsl);
+  Init_gsl_monte(mgsl);
+  Init_gsl_siman(mgsl);
+
+  Init_gsl_odeiv(mgsl);
+  Init_gsl_interp(mgsl);
+  Init_gsl_spline(mgsl);
+  Init_gsl_diff(mgsl);
+#ifdef GSL_1_4_9_LATER
+  Init_gsl_deriv(mgsl);
+#endif
+
+  Init_gsl_cheb(mgsl);
+  Init_gsl_sum(mgsl);
+  Init_gsl_dht(mgsl);
+
+  Init_gsl_root(mgsl);
+  Init_gsl_multiroot(mgsl);
+  Init_gsl_min(mgsl);
+  Init_gsl_multimin(mgsl);
+  Init_gsl_fit(mgsl);
+  Init_gsl_multifit(mgsl);
+
+  Init_gsl_const(mgsl);
+
+  Init_gsl_ieee(mgsl);
+
+#ifdef HAVE_NARRAY_H
+  Init_gsl_narray(mgsl);
+#endif
+
+  Init_wavelet(mgsl);
+
+  rb_gsl_define_const(mgsl);
+
+#ifdef HAVE_TENSOR_TENSOR_H
+  Init_tensor_init(mgsl);
+  Init_tensor_int_init(mgsl);
+#endif
+
+  Init_gsl_graph(mgsl);
+  Init_gsl_dirac(mgsl);
+
+#ifdef HAVE_TAMU_ANOVA_TAMU_ANOVA_H
+  Init_tamu_anova(mgsl);
+#endif
+
+#ifdef HAVE_OOL_OOL_VERSION_H
+	Init_ool(mgsl);
+#endif
+
+#ifdef HAVE_JACOBI_H
+	Init_jacobi(mgsl);
+#endif
+
+#ifdef HAVE_GSL_GSL_CQP_H
+	Init_cqp(mgsl);
+#endif
+
+	Init_fresnel(mgsl);
+	
+#ifdef GSL_1_9_LATER
+	Init_bspline(mgsl);
+#endif
+
+#ifdef HAVE_ALF_ALF_H
+	Init_alf(mgsl);
+#endif
+
+	Init_geometry(mgsl);
+
+#ifdef GSL_1_14_LATER
+	Init_multiset(mgsl);
+#endif
+
+  rb_gsl_define_methods(mgsl);
+}
+
+/**********/
+
+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("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");
+}
+
+static void rb_gsl_define_const(VALUE module)
+{
+  rb_define_const(module, "MODE_DEFAULT", INT2FIX(GSL_MODE_DEFAULT));
+  rb_define_const(module, "PREC_DOUBLE", INT2FIX(GSL_PREC_DOUBLE));
+  rb_define_const(module, "PREC_SINGLE", INT2FIX(GSL_PREC_SINGLE));
+  rb_define_const(module, "PREC_APPROX", INT2FIX(GSL_PREC_APPROX));
+#ifdef GSL_VERSION
+  rb_define_const(module, "VERSION", rb_str_new2(GSL_VERSION));
+  rb_define_const(module, "GSL_VERSION", rb_str_new2(GSL_VERSION));
+#endif
+#ifdef RUBY_GSL_VERSION
+  rb_define_const(module, "RUBY_GSL_VERSION", rb_str_new2(RUBY_GSL_VERSION));
+  rb_define_const(module, "RB_GSL_VERSION", rb_str_new2(RUBY_GSL_VERSION));
+#endif
+
+  rb_define_const(module, "DBL_EPSILON", rb_float_new(GSL_DBL_EPSILON));
+  rb_define_const(module, "FLT_EPSILON", rb_float_new(GSL_FLT_EPSILON));
+  rb_define_const(module, "MACH_EPS", rb_float_new(GSL_MACH_EPS));
+  rb_define_const(module, "SQRT_DBL_EPSILON", rb_float_new(GSL_SQRT_DBL_EPSILON));
+  rb_define_const(module, "ROOT3_DBL_EPSILON", rb_float_new(GSL_ROOT3_DBL_EPSILON));
+  rb_define_const(module, "ROOT4_DBL_EPSILON", rb_float_new(GSL_ROOT4_DBL_EPSILON));
+  rb_define_const(module, "ROOT5_DBL_EPSILON", rb_float_new(GSL_ROOT5_DBL_EPSILON));
+  rb_define_const(module, "ROOT6_DBL_EPSILON", rb_float_new(GSL_ROOT6_DBL_EPSILON));
+  rb_define_const(module, "LOG_DBL_EPSILON", rb_float_new(GSL_LOG_DBL_EPSILON));
+
+  rb_define_const(module, "DBL_MAX", rb_float_new(GSL_DBL_MAX));
+  rb_define_const(module, "SQRT_DBL_MAX", rb_float_new(GSL_SQRT_DBL_MAX));
+  rb_define_const(module, "ROOT3_DBL_MAX", rb_float_new(GSL_ROOT3_DBL_MAX));
+  rb_define_const(module, "ROOT4_DBL_MAX", rb_float_new(GSL_ROOT4_DBL_MAX));
+  rb_define_const(module, "ROOT5_DBL_MAX", rb_float_new(GSL_ROOT5_DBL_MAX));
+  rb_define_const(module, "ROOT6_DBL_MAX", rb_float_new(GSL_ROOT6_DBL_MAX));
+  rb_define_const(module, "LOG_DBL_MAX", rb_float_new(GSL_LOG_DBL_MAX));
+
+  rb_define_const(module, "DBL_MIN", rb_float_new(GSL_DBL_MIN));
+  rb_define_const(module, "SQRT_DBL_MIN", rb_float_new(GSL_SQRT_DBL_MIN));
+  rb_define_const(module, "ROOT3_DBL_MIN", rb_float_new(GSL_ROOT3_DBL_MIN));
+  rb_define_const(module, "ROOT4_DBL_MIN", rb_float_new(GSL_ROOT4_DBL_MIN));
+  rb_define_const(module, "ROOT5_DBL_MIN", rb_float_new(GSL_ROOT5_DBL_MIN));
+  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)
+{
+#ifdef HAVE_TENSOR_TENSOR_H
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
+static VALUE rb_gsl_have_narray(VALUE module)
+{
+#ifdef HAVE_NARRAY_H
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
+static void rb_gsl_define_methods(VALUE module)
+{
+  rb_define_singleton_method(module, "have_tensor?", rb_gsl_have_tensor, 0);
+  rb_define_singleton_method(module, "have_narray?", rb_gsl_have_narray, 0);
+}

data/ext/gsl_narray.c

@@ -0,0 +1,804 @@
+/*
+  narray.c
+
+  Written by Yoshiki Tsunesada       Dec/2001
+  Modified by Seiya Nishizawa        14/Apr/2004
+ */
+
+#include "rb_gsl_config.h"
+#ifdef HAVE_NARRAY_H
+#include "rb_gsl_array.h"
+#include "narray.h"
+#include "rb_gsl_with_narray.h"
+
+static VALUE rb_gsl_na_to_gsl_matrix_method(VALUE nna);
+static VALUE rb_gsl_na_to_gsl_matrix_int_method(VALUE nna);
+static VALUE rb_gsl_na_to_gsl_vector_int_method(VALUE na);
+static VALUE rb_gsl_vector_int_to_na(VALUE obj);
+static VALUE rb_gsl_na_to_gsl_vector_int(VALUE obj, VALUE na);
+
+/* GSL::Vector -> NArray */
+
+static VALUE rb_gsl_vector_to_narray(VALUE obj, VALUE klass)
+{
+  gsl_vector *v = NULL;
+  VALUE nary;
+  int shape[1];
+  Data_Get_Struct(obj, gsl_vector, v);
+  shape[0] = v->size;
+  nary = na_make_object(NA_DFLOAT, 1, shape, klass);
+  if (v->stride == 1) {
+    memcpy(NA_PTR_TYPE(nary,double*), v->data, shape[0]*sizeof(double));
+  } else {
+    int i;
+    for(i=0; i < v->size; i++) {
+      (NA_PTR_TYPE(nary,double*))[i] = gsl_vector_get(v, i);
+    }
+  }
+  return nary;
+}
+
+static VALUE rb_gsl_vector_complex_to_narray(VALUE obj, VALUE klass)
+{
+  gsl_vector_complex *v = NULL;
+  VALUE nary;
+  int shape[1];
+  Data_Get_Struct(obj, gsl_vector_complex, v);
+  shape[0] = v->size;
+  nary = na_make_object(NA_DCOMPLEX, 1, shape, klass);
+  if (v->stride == 1) {
+    memcpy(NA_PTR_TYPE(nary,double*), v->data, shape[0]*2*sizeof(double));
+  } else {
+    int i;
+    for(i=0; i < 2*v->size; i++) {
+      (NA_PTR_TYPE(nary,gsl_complex*))[i] = gsl_vector_complex_get(v, i);
+    }
+  }
+  return nary;
+}
+
+static VALUE rb_gsl_vector_to_na(VALUE obj)
+{
+  VALUE na = Qnil;
+
+  if(VECTOR_P(obj))
+    na = rb_gsl_vector_to_narray(obj, cNArray);
+  else if(VECTOR_COMPLEX_P(obj))
+    na = rb_gsl_vector_complex_to_narray(obj, cNArray);
+  else
+    rb_raise(rb_eRuntimeError, "unexpected type '%s'",
+        rb_obj_classname(obj));
+
+  return na;
+}
+
+static VALUE rb_gsl_vector_complex_to_na(VALUE obj)
+{
+  return rb_gsl_vector_complex_to_narray(obj, cNArray);
+}
+
+static VALUE rb_gsl_vector_to_nvector(VALUE obj)
+{
+  return rb_gsl_vector_to_narray(obj, cNVector);
+}
+
+static VALUE rb_gsl_vector_complex_to_nvector(VALUE obj)
+{
+  return rb_gsl_vector_complex_to_narray(obj, cNVector);
+}
+
+/* GSL::Vector -> NArray view */
+
+static struct NARRAY* rb_gsl_na_view_alloc(int rank, int total, int type)
+{
+  struct NARRAY *na;
+  na = (struct NARRAY*) malloc(sizeof(struct NARRAY));
+  na->rank = rank;
+  na->total = total;
+  na->type = type;
+  // TODO Set na->ref to a one element NArray of type NAObject that contains
+  // the GSL::Vector being referenced.
+  na->ref = Qtrue;       /* to initialize */
+  na->shape = (int *) malloc(sizeof(int)*rank);
+  return na;
+}
+
+static void rb_gsl_na_view_free(struct NARRAY *na)
+{
+  free((int *) na->shape);
+  free((struct NARRAY *) na);
+}
+
+static VALUE rb_gsl_vector_to_narray_ref(VALUE obj, VALUE klass)
+{
+  gsl_vector *v = NULL;
+  gsl_vector_complex *vc = NULL;
+  gsl_vector_int *vi = NULL;
+  VALUE nary;
+  struct NARRAY *na;
+  if (VECTOR_P(obj)) {
+    Data_Get_Struct(obj, gsl_vector, v);
+    if (v->stride != 1) {
+      rb_raise(rb_eRuntimeError, "Cannot make a reference obj: stride!=1");
+    }
+    na = rb_gsl_na_view_alloc(1, v->size, NA_DFLOAT);
+    na->shape[0] = v->size;
+    na->ptr = (char *) v->data;
+  } else if (VECTOR_INT_P(obj)) {
+    Data_Get_Struct(obj, gsl_vector_int, vi);
+    if (vi->stride != 1) {
+      rb_raise(rb_eRuntimeError, "Cannot make a reference obj: stride!=1");
+    }
+    na = rb_gsl_na_view_alloc(1, vi->size, NA_LINT);
+    na->shape[0] = vi->size;
+    na->ptr = (char *) vi->data;
+  } else if (VECTOR_COMPLEX_P(obj)) {
+    Data_Get_Struct(obj, gsl_vector_complex, vc);
+    if (vc->stride != 1) {
+      rb_raise(rb_eRuntimeError, "Cannot make a reference obj: stride!=1");
+    }
+    na = rb_gsl_na_view_alloc(1, vc->size, NA_DCOMPLEX);
+    na->shape[0] = vc->size;
+    na->ptr = (char *) vc->data;
+  } else {
+    rb_raise(rb_eRuntimeError, "cannot convert %s to NArray reference object",
+        rb_obj_classname(obj));
+  }
+  nary = Data_Wrap_Struct(klass, 0, rb_gsl_na_view_free, na);
+  return nary;
+}
+
+static VALUE rb_gsl_vector_to_na_ref(VALUE obj)
+{
+  return rb_gsl_vector_to_narray_ref(obj, cNArray);
+}
+
+static VALUE rb_gsl_vector_to_nvector_ref(VALUE obj)
+{
+  return rb_gsl_vector_to_narray_ref(obj, cNVector);
+}
+
+static VALUE rb_gsl_vector_int_to_narray(VALUE obj, VALUE klass)
+{
+  gsl_vector_int *v = NULL;
+  VALUE nary;
+  int shape[1];
+  Data_Get_Struct(obj, gsl_vector_int, v);
+  shape[0] = v->size;
+  nary = na_make_object(NA_LINT, 1, shape, klass);
+  if (v->stride == 1) {
+    memcpy(NA_PTR_TYPE(nary,int*), v->data, shape[0]*sizeof(int));
+  } else {
+    int i;
+    for(i=0; i < v->size; i++) {
+      (NA_PTR_TYPE(nary,int*))[i] = gsl_vector_int_get(v, i);
+    }
+  }
+  return nary;
+}
+
+static VALUE rb_gsl_vector_int_to_na(VALUE obj)
+{
+  return rb_gsl_vector_int_to_narray(obj, cNArray);
+}
+
+static VALUE rb_gsl_vector_int_to_nvector(VALUE obj)
+{
+  return rb_gsl_vector_int_to_narray(obj, cNVector);
+}
+
+/* singleton method */
+static VALUE rb_gsl_na_to_gsl_vector(VALUE obj, VALUE na)
+{
+  return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free,
+                          na_to_gv(na));
+}
+
+static VALUE rb_gsl_na_to_gsl_vector_view(VALUE obj, VALUE na)
+{
+  return Data_Wrap_Struct(cgsl_vector_view, 0, gsl_vector_view_free,
+                          na_to_gv_view(na));
+}
+
+static VALUE rb_gsl_na_to_gsl_vector_complex(VALUE obj, VALUE na)
+{
+  return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free,
+                          na_to_gv_complex(na));
+}
+
+static VALUE rb_gsl_na_to_gsl_vector_complex_view(VALUE obj, VALUE na)
+{
+  return Data_Wrap_Struct(cgsl_vector_complex_view, 0, gsl_vector_complex_view_free,
+                          na_to_gv_complex_view(na));
+}
+
+static VALUE rb_gsl_na_to_gsl_vector_int(VALUE obj, VALUE na)
+{
+  return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free,
+                          na_to_gv_int(na));
+}
+
+static VALUE rb_gsl_na_to_gsl_vector_int_view(VALUE obj, VALUE na)
+{
+  return Data_Wrap_Struct(cgsl_vector_int_view, 0, rb_gsl_vector_int_view_free,
+                          na_to_gv_int_view(na));
+}
+
+static VALUE rb_gsl_na_to_gsl_vector_method(VALUE na)
+{
+  VALUE v;
+
+  if(NA_TYPE(na) == NA_SCOMPLEX || NA_TYPE(na) == NA_DCOMPLEX)
+    v = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free,
+        na_to_gv_complex(na));
+  else
+    v = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free,
+        na_to_gv(na));
+
+  return v;
+}
+
+VALUE rb_gsl_na_to_gsl_vector_view_method(VALUE na)
+{
+  VALUE v;
+
+  if(NA_TYPE(na) == NA_SCOMPLEX || NA_TYPE(na) == NA_DCOMPLEX)
+    v = Data_Wrap_Struct(cgsl_vector_complex_view, 0, gsl_vector_complex_view_free,
+        na_to_gv_complex_view(na));
+  else
+    v = Data_Wrap_Struct(cgsl_vector_view, 0, gsl_vector_view_free,
+        na_to_gv_view(na));
+
+  return v;
+}
+
+static VALUE rb_gsl_na_to_gsl_vector_int_method(VALUE na)
+{
+  return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free,
+                          na_to_gv_int(na));
+}
+
+static VALUE rb_gsl_na_to_gsl_vector_int_view_method(VALUE na)
+{
+  return Data_Wrap_Struct(cgsl_vector_int_view, 0, rb_gsl_vector_int_view_free,
+                          na_to_gv_int_view(na));
+}
+
+gsl_vector* na_to_gv(VALUE na)
+{
+  gsl_vector *v = NULL;
+  VALUE nary = na;
+  v = gsl_vector_alloc(NA_TOTAL(na));
+  if(NA_TYPE(na) != NA_DFLOAT) {
+    nary = na_change_type(na, NA_DFLOAT);
+  }
+  memcpy(v->data, NA_PTR_TYPE(nary,double*), v->size*sizeof(double));
+  return v;
+}
+
+gsl_vector_view* na_to_gv_view(VALUE na)
+{
+  gsl_vector_view *v = NULL;
+
+  // Raise exception if na's type is not NA_DFLOAT.
+  if(NA_TYPE(na) != NA_DFLOAT)
+    rb_raise(rb_eTypeError, "GSL::Vector::View requires NArray be DFLOAT");
+
+  v = gsl_vector_view_alloc();
+  v->vector.data = NA_PTR_TYPE(na,double*);
+  v->vector.size = NA_TOTAL(na);
+  v->vector.stride = 1;
+  v->vector.owner = 0;
+  return v;
+}
+
+gsl_vector_complex* na_to_gv_complex(VALUE na)
+{
+  gsl_vector_complex *v = NULL;
+  VALUE nary = na;
+  v = gsl_vector_complex_alloc(NA_TOTAL(na));
+  if(NA_TYPE(na) != NA_DCOMPLEX) {
+    nary = na_change_type(na, NA_DCOMPLEX);
+  }
+  memcpy(v->data, NA_PTR_TYPE(nary,gsl_complex*), v->size*sizeof(gsl_complex));
+  return v;
+}
+
+gsl_vector_complex_view* na_to_gv_complex_view(VALUE na)
+{
+  gsl_vector_complex_view *v = NULL;
+
+  // Raise exception if na's type is not NA_DCOMPLEX
+  if(NA_TYPE(na) != NA_DCOMPLEX)
+    rb_raise(rb_eTypeError, "GSL::Vector::Complex::View requires NArray be DCOMPLEX");
+
+  v = gsl_vector_complex_view_alloc();
+  v->vector.data = NA_PTR_TYPE(na,double*);
+  v->vector.size = NA_TOTAL(na);
+  v->vector.stride = 1;
+  v->vector.owner = 0;
+  return v;
+}
+
+gsl_vector_int* na_to_gv_int(VALUE na)
+{
+  gsl_vector_int *v = NULL;
+  VALUE nary = na;
+  v = gsl_vector_int_alloc(NA_TOTAL(na));
+  if(NA_TYPE(na) != NA_LINT) {
+    nary = na_change_type(na, NA_LINT);
+  }
+  memcpy(v->data, NA_PTR_TYPE(nary,int*), v->size*sizeof(int));
+  return v;
+}
+
+gsl_vector_int_view* na_to_gv_int_view(VALUE na)
+{
+  gsl_vector_int_view *v = NULL;
+
+  // Raise exception if na's type is not NA_LINT
+  if(NA_TYPE(na) != NA_LINT)
+    rb_raise(rb_eTypeError, "GSL::Vector::Int::View requires NArray be LINT");
+  v = rb_gsl_vector_int_view_alloc(NA_TOTAL(na));
+  v->vector.data = NA_PTR_TYPE(na,int*);
+  v->vector.size = NA_TOTAL(na);
+  v->vector.stride = 1;
+  v->vector.owner = 0;
+  return v;
+}
+
+static VALUE rb_gsl_matrix_to_narray(VALUE obj, VALUE klass)
+{
+  gsl_matrix *m = NULL;
+  VALUE nary;
+  int shape[2];
+  size_t i;
+  Data_Get_Struct(obj, gsl_matrix, m);
+  shape[0] = m->size2;
+  shape[1] = m->size1;
+  nary = na_make_object(NA_DFLOAT, 2, shape, klass);
+  for (i = 0; i < shape[1]; i++) {
+    memcpy(NA_PTR_TYPE(nary,double*)+(i*shape[0]), m->data+(i*m->tda), 
+           shape[0]*sizeof(double));
+  }
+  return nary;
+}
+
+static VALUE rb_gsl_matrix_to_na(VALUE obj, VALUE klass)
+{
+  return rb_gsl_matrix_to_narray(obj, cNArray);
+}
+
+static VALUE rb_gsl_matrix_to_nmatrix(VALUE obj, VALUE klass)
+{
+  return rb_gsl_matrix_to_narray(obj, cNMatrix);
+}
+
+static VALUE rb_gsl_matrix_int_to_narray(VALUE obj, VALUE klass)
+{
+  gsl_matrix_int *m = NULL;
+  VALUE nary;
+  int shape[2];
+  size_t i;
+  Data_Get_Struct(obj, gsl_matrix_int, m);
+  shape[0] = m->size2;
+  shape[1] = m->size1;
+  nary = na_make_object(NA_LINT, 2, shape, klass);
+  for (i = 0; i < shape[1]; i++) {
+    memcpy(NA_PTR_TYPE(nary,int*)+(i*shape[0]), m->data+(i*m->tda), 
+           shape[0]*sizeof(int));
+  }
+  return nary;
+}
+
+static VALUE rb_gsl_matrix_int_to_na(VALUE obj)
+{
+  return rb_gsl_matrix_int_to_narray(obj, cNArray);
+}
+
+static VALUE rb_gsl_matrix_int_to_nmatrix(VALUE obj)
+{
+  return rb_gsl_matrix_int_to_narray(obj, cNMatrix);
+}
+
+static VALUE rb_gsl_matrix_to_narray_ref(VALUE obj, VALUE klass)
+{
+  gsl_matrix *m = NULL;
+  VALUE nary;
+  struct NARRAY *na;
+  Data_Get_Struct(obj, gsl_matrix, m);
+  if (m->tda != m->size2) {
+    rb_raise(rb_eRuntimeError, "Cannot make a reference obj: non-contiguous");
+  }
+  na = rb_gsl_na_view_alloc(2, m->size2 * m->size1, NA_DFLOAT);
+  na->shape[0] = m->size2;
+  na->shape[1] = m->size1;
+  na->ptr = (char *) m->data;
+  nary = Data_Wrap_Struct(klass, 0, rb_gsl_na_view_free, na);
+  return nary;
+}
+
+static VALUE rb_gsl_matrix_to_na_ref(VALUE obj)
+{
+  return rb_gsl_matrix_to_narray_ref(obj, cNArray);
+}
+
+static VALUE rb_gsl_matrix_to_nmatrix_ref(VALUE obj)
+{
+  return rb_gsl_matrix_to_narray_ref(obj, cNMatrix);
+}
+
+static VALUE rb_gsl_matrix_int_to_narray_ref(VALUE obj, VALUE klass)
+{
+  gsl_matrix_int *m = NULL;
+  VALUE nary;
+  struct NARRAY *na;
+  Data_Get_Struct(obj, gsl_matrix_int, m);
+  if (m->tda != m->size2) {
+    rb_raise(rb_eRuntimeError, "Cannot make a reference obj: non-contiguous");
+  }
+  na = rb_gsl_na_view_alloc(2, m->size2 * m->size1, NA_LINT);
+  na->shape[0] = m->size2;
+  na->shape[1] = m->size1;
+  na->ptr = (char *) m->data;
+  nary = Data_Wrap_Struct(klass, 0, rb_gsl_na_view_free, na);
+  return nary;
+}
+
+static VALUE rb_gsl_matrix_int_to_na_ref(VALUE obj)
+{
+  return rb_gsl_matrix_int_to_narray_ref(obj, cNArray);
+}
+
+static VALUE rb_gsl_matrix_int_to_nmatrix_ref(VALUE obj)
+{
+  return rb_gsl_matrix_int_to_narray_ref(obj, cNMatrix);
+}
+
+/* NArray -> GSL::Matrix */
+VALUE rb_gsl_na_to_gsl_matrix(VALUE obj, VALUE nna)
+{
+  gsl_matrix *m = NULL;
+  m = na_to_gm(nna);
+  return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, m);
+}
+
+VALUE rb_gsl_na_to_gsl_matrix_view(VALUE obj, VALUE nna)
+{
+  gsl_matrix_view *m = NULL;
+  m = na_to_gm_view(nna);
+  return Data_Wrap_Struct(cgsl_matrix_view, 0, gsl_matrix_view_free, m);
+}
+
+VALUE rb_gsl_na_to_gsl_matrix_int(VALUE obj, VALUE nna)
+{
+  gsl_matrix_int *m = NULL;
+  m = na_to_gm_int(nna);
+  return Data_Wrap_Struct(cgsl_matrix_int, 0, gsl_matrix_int_free, m);
+}
+
+VALUE rb_gsl_na_to_gsl_matrix_int_view(VALUE obj, VALUE nna)
+{
+  gsl_matrix_int_view *m = NULL;
+  m = na_to_gm_int_view(nna);
+  return Data_Wrap_Struct(cgsl_matrix_int_view, 0, rb_gsl_matrix_int_view_free, m);
+}
+
+static VALUE rb_gsl_na_to_gsl_matrix_method(VALUE nna)
+{
+  gsl_matrix *m = NULL;
+  m = na_to_gm(nna);
+  return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, m);
+}
+
+static VALUE rb_gsl_na_to_gsl_matrix_view_method(VALUE nna)
+{
+  gsl_matrix_view *m = NULL;
+  m = na_to_gm_view(nna);
+  return Data_Wrap_Struct(cgsl_matrix_view, 0, gsl_matrix_view_free, m);
+}
+
+static VALUE rb_gsl_na_to_gsl_matrix_int_method(VALUE nna)
+{
+  gsl_matrix_int *m = NULL;
+  m = na_to_gm_int(nna);
+  return Data_Wrap_Struct(cgsl_matrix_int, 0, gsl_matrix_int_free, m);
+}
+
+static VALUE rb_gsl_na_to_gsl_matrix_int_view_method(VALUE nna)
+{
+  gsl_matrix_int_view *m = NULL;
+  m = na_to_gm_int_view(nna);
+  return Data_Wrap_Struct(cgsl_matrix_int_view, 0, rb_gsl_matrix_int_view_free, m);
+}
+
+gsl_matrix* na_to_gm(VALUE nna)
+{
+  gsl_matrix *m = NULL;
+  VALUE ary2;
+  struct NARRAY *na = NULL;
+  GetNArray(nna, na);
+  m = gsl_matrix_alloc(na->shape[1], na->shape[0]);
+  ary2 = na_change_type(nna, NA_DFLOAT);
+  memcpy(m->data, NA_PTR_TYPE(ary2,double*), m->size1*m->size2*sizeof(double));
+  return m;
+}
+
+gsl_matrix_view* na_to_gm_view(VALUE nna)
+{
+  gsl_matrix_view *m = NULL;
+  VALUE ary2;
+  struct NARRAY *na = NULL;
+
+  // Raise exception if nna's type is not NA_DFLOAT
+  if(NA_TYPE(nna) != NA_DFLOAT)
+    rb_raise(rb_eTypeError, "GSL::Matrix::View requires NArray be DFLOAT");
+  GetNArray(nna, na);
+  m = gsl_matrix_view_alloc();
+  ary2 = na_change_type(nna, NA_DFLOAT);
+  m->matrix.data = NA_PTR_TYPE(ary2,double*);
+  m->matrix.size1 = na->shape[1];
+  m->matrix.size2 = na->shape[0];
+  m->matrix.tda = m->matrix.size2; 
+  m->matrix.owner = 0;
+  return m;
+}
+
+gsl_matrix_int* na_to_gm_int(VALUE nna)
+{
+  gsl_matrix_int *m = NULL;
+  VALUE ary2;
+  struct NARRAY *na = NULL;
+  GetNArray(nna, na);
+  m = gsl_matrix_int_alloc(na->shape[1], na->shape[0]);
+  ary2 = na_change_type(nna, NA_LINT);
+  memcpy(m->data, NA_PTR_TYPE(ary2,int*), m->size1*m->size2*sizeof(int));
+  return m;
+}
+
+gsl_matrix_int_view* na_to_gm_int_view(VALUE nna)
+{
+  gsl_matrix_int_view *m = NULL;
+  VALUE ary2;
+  struct NARRAY *na = NULL;
+
+  // Raise exception if nna's type is not NA_LINT
+  if(NA_TYPE(nna) != NA_LINT)
+    rb_raise(rb_eTypeError, "GSL::Matrix::Int::View requires NArray be LINT");
+  GetNArray(nna, na);
+  m = rb_gsl_matrix_int_view_alloc(na->shape[1], na->shape[0]);
+  ary2 = na_change_type(nna, NA_LINT);
+  m->matrix.data = NA_PTR_TYPE(ary2,int*);
+  m->matrix.size1 = na->shape[1];
+  m->matrix.size2 = na->shape[0];
+  m->matrix.tda = m->matrix.size2; 
+  m->matrix.owner = 0;
+  return m;
+}
+
+#ifdef HAVE_NARRAY_H
+#include "narray.h"
+#include <gsl/gsl_histogram.h>
+EXTERN VALUE cgsl_histogram;
+static VALUE rb_gsl_narray_histogram(int argc, VALUE *argv, VALUE obj)
+{
+  double *ptr, *ptr_range;
+  gsl_histogram *h;
+  gsl_vector *ranges;
+  gsl_vector_view v;
+  double min, max;
+  size_t i, n, size, stride;
+  ptr = get_vector_ptr(obj, &stride, &size);
+  v.vector.data = ptr;
+  v.vector.size = size;
+  v.vector.size = stride;
+  switch (argc) {
+  case 1:
+    if (rb_obj_is_kind_of(argv[0], rb_cRange)) 
+      argv[0] = rb_gsl_range2ary(argv[0]);
+    switch (TYPE(argv[0])) {
+    case T_FIXNUM:
+      n = NUM2INT(argv[0]);
+      min = gsl_vector_min(&v.vector) - 4*GSL_DBL_EPSILON;
+      max = gsl_vector_max(&v.vector) + 4*GSL_DBL_EPSILON;
+      h = gsl_histogram_alloc(n);
+      gsl_histogram_set_ranges_uniform(h, min, max);
+      break;
+    case T_ARRAY:
+      //      n = RARRAY(argv[0])->len - 1;
+      n = RARRAY_LEN(argv[0]) - 1;
+      h = gsl_histogram_alloc(n);
+      for (i = 0; i <= n; i++) h->range[i] = NUM2DBL(rb_ary_entry(argv[0], i));
+      break;
+    default:
+      if (VECTOR_P(argv[0])) {
+        Data_Get_Struct(argv[0], gsl_vector, ranges);
+        n = ranges->size - 1;
+        h = gsl_histogram_alloc(n);
+        gsl_histogram_set_ranges(h, ranges->data, ranges->size);
+      } else if (NA_IsNArray(argv[0])) {
+        ptr_range = get_vector_ptr(argv[0], &stride, &n);
+        h = gsl_histogram_alloc(n);
+        gsl_histogram_set_ranges(h, ptr_range, n);
+      }
+      break;
+    }
+    break;
+  case 2:
+    n = NUM2INT(argv[0]);
+    switch (TYPE(argv[1])) {
+    case T_ARRAY:
+      min = NUM2DBL(rb_ary_entry(argv[1], 0));
+      max = NUM2DBL(rb_ary_entry(argv[1], 1));
+      break;
+    default:
+      rb_raise(rb_eTypeError, "wrong argument type %s (Array expected)",
+               rb_class2name(CLASS_OF(argv[1])));
+      break;
+    }
+    h = gsl_histogram_alloc(n);
+    gsl_histogram_set_ranges_uniform(h, min, max);
+    break;
+  case 3:
+    n = NUM2INT(argv[0]);
+    min = NUM2DBL(argv[1]); max = NUM2DBL(argv[2]);
+    h = gsl_histogram_alloc(n);
+    gsl_histogram_set_ranges_uniform(h, min, max);
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments %d", argc);
+    break;
+  }
+  for (i = 0; i < size; i++)
+    gsl_histogram_increment(h, ptr[i*stride]);
+  return Data_Wrap_Struct(cgsl_histogram, 0, gsl_histogram_free, h);
+}
+#endif
+
+/*void rb_gsl_with_narray_define_methods()*/
+void Init_gsl_narray(VALUE module)
+{
+  rb_define_method(cgsl_vector, "to_na", rb_gsl_vector_to_na, 0);
+  rb_define_alias(cgsl_vector, "to_narray", "to_na");
+  rb_define_method(cgsl_vector, "to_na2", rb_gsl_vector_to_na_ref, 0);
+  rb_define_alias(cgsl_vector, "to_narray_ref", "to_na2");
+  rb_define_alias(cgsl_vector, "to_na_ref", "to_na2");
+
+  rb_define_method(cgsl_vector, "to_nv", rb_gsl_vector_to_nvector, 0);
+  rb_define_alias(cgsl_vector, "to_nvector", "to_nv");
+  rb_define_method(cgsl_vector, "to_nv_ref", rb_gsl_vector_to_nvector_ref, 0);
+  rb_define_alias(cgsl_vector, "to_nvector_ref", "to_nv_ref");
+
+  rb_define_singleton_method(cgsl_vector, "to_gslv", rb_gsl_na_to_gsl_vector, 1);
+  rb_define_singleton_method(cgsl_vector, "to_gv", rb_gsl_na_to_gsl_vector, 1);
+
+  rb_define_singleton_method(cgsl_vector, "na_to_gslv", rb_gsl_na_to_gsl_vector, 1);
+  rb_define_singleton_method(cgsl_vector, "na_to_gv", rb_gsl_na_to_gsl_vector, 1);
+  rb_define_singleton_method(cgsl_vector, "to_gslv_view", rb_gsl_na_to_gsl_vector_view, 1);
+
+  rb_define_singleton_method(cgsl_vector, "to_gv_view", rb_gsl_na_to_gsl_vector_view, 1);
+
+  rb_define_singleton_method(cgsl_vector, "na_to_gslv_view", rb_gsl_na_to_gsl_vector_view, 1);
+  rb_define_singleton_method(cgsl_vector, "na_to_gv_view", rb_gsl_na_to_gsl_vector_view, 1);
+
+  rb_define_method(cNArray, "to_gv", rb_gsl_na_to_gsl_vector_method, 0);
+  rb_define_alias(cNArray, "to_gslv", "to_gv");
+  rb_define_method(cNArray, "to_gv_view", rb_gsl_na_to_gsl_vector_view_method, 0);
+  rb_define_alias(cNArray, "to_gslv_view", "to_gv_view");
+  rb_define_alias(cNArray, "to_gv2", "to_gv_view");
+  rb_define_alias(cNArray, "to_gv_ref", "to_gv_view");
+  /*****/
+  rb_define_method(cgsl_vector_complex, "to_na", rb_gsl_vector_complex_to_na, 0);
+  rb_define_alias(cgsl_vector_complex, "to_narray", "to_na");
+
+  rb_define_method(cgsl_vector_complex, "to_na2", rb_gsl_vector_to_na_ref, 0);
+  rb_define_alias(cgsl_vector_complex, "to_narray_ref", "to_na2");
+  rb_define_alias(cgsl_vector_complex, "to_na_ref", "to_na2");
+
+  rb_define_method(cgsl_vector_complex, "to_nv", rb_gsl_vector_complex_to_nvector, 0);
+  rb_define_alias(cgsl_vector_complex, "to_nvector", "to_nv");
+
+  rb_define_method(cgsl_vector_complex, "to_nv2", rb_gsl_vector_to_nvector_ref, 0);
+  rb_define_alias(cgsl_vector_complex, "to_nv_ref", "to_nv2");
+  rb_define_alias(cgsl_vector_complex, "to_nvector_ref", "to_nv2");
+
+  rb_define_singleton_method(cgsl_vector_complex, "to_gslv", rb_gsl_na_to_gsl_vector_complex, 1);
+  rb_define_singleton_method(cgsl_vector_complex, "to_gv", rb_gsl_na_to_gsl_vector_complex, 1);
+  rb_define_singleton_method(cgsl_vector_complex, "na_to_gslv", rb_gsl_na_to_gsl_vector_complex, 1);
+  rb_define_singleton_method(cgsl_vector_complex, "na_to_gv", rb_gsl_na_to_gsl_vector_complex, 1);
+
+  rb_define_singleton_method(cgsl_vector_complex, "to_gslv_view", rb_gsl_na_to_gsl_vector_complex_view, 1);
+  rb_define_singleton_method(cgsl_vector_complex, "to_gv_view", rb_gsl_na_to_gsl_vector_complex_view, 1);
+  rb_define_singleton_method(cgsl_vector_complex, "na_to_gslv_view", rb_gsl_na_to_gsl_vector_complex_view, 1);
+  rb_define_singleton_method(cgsl_vector_complex, "na_to_gv_view", rb_gsl_na_to_gsl_vector_complex_view, 1);
+
+  /*****/
+  rb_define_method(cgsl_vector_int, "to_na", rb_gsl_vector_int_to_na, 0);
+  rb_define_alias(cgsl_vector_int, "to_narray", "to_na");
+  rb_define_method(cgsl_vector_int, "to_nv", rb_gsl_vector_int_to_nvector, 0);
+  rb_define_alias(cgsl_vector_int, "to_nvector", "to_nv");
+  rb_define_method(cgsl_vector_int, "to_na2", rb_gsl_vector_to_na_ref, 0);
+  rb_define_alias(cgsl_vector_int, "to_na_ref", "to_na2");
+  rb_define_alias(cgsl_vector_int, "to_narray_ref", "to_na2");
+  rb_define_method(cgsl_vector_int, "to_nv_ref", rb_gsl_vector_to_nvector_ref, 0);
+  rb_define_alias(cgsl_vector_int, "to_nvector_ref", "to_nv_ref");
+
+  rb_define_singleton_method(cgsl_vector_int, "to_gslv", rb_gsl_na_to_gsl_vector_int, 1);
+  rb_define_singleton_method(cgsl_vector_int, "to_gv", rb_gsl_na_to_gsl_vector_int, 1);
+
+  rb_define_singleton_method(cgsl_vector_int, "na_to_gslv", rb_gsl_na_to_gsl_vector_int, 1);
+  rb_define_singleton_method(cgsl_vector_int, "na_to_gv", rb_gsl_na_to_gsl_vector_int, 1);
+
+  rb_define_singleton_method(cgsl_vector_int, "to_gslv_view", rb_gsl_na_to_gsl_vector_int_view, 1);
+  rb_define_singleton_method(cgsl_vector_int, "to_gv_view", rb_gsl_na_to_gsl_vector_int_view, 1);
+
+  rb_define_singleton_method(cgsl_vector_int, "na_to_gslv_view", rb_gsl_na_to_gsl_vector_int_view, 1);
+  rb_define_singleton_method(cgsl_vector_int, "na_to_gv_view", rb_gsl_na_to_gsl_vector_int_view, 1);
+
+  rb_define_method(cNArray, "to_gv_int", rb_gsl_na_to_gsl_vector_int_method, 0);
+  rb_define_alias(cNArray, "to_gslv_int", "to_gv_int");
+  rb_define_method(cNArray, "to_gv_int_view", rb_gsl_na_to_gsl_vector_int_view_method, 0);
+  rb_define_alias(cNArray, "to_gslv_int_view", "to_gv_int_view");
+  /*****/
+
+  rb_define_method(cgsl_matrix, "to_na", rb_gsl_matrix_to_na, 0);
+  rb_define_alias(cgsl_matrix, "to_narray", "to_na");
+  rb_define_method(cgsl_matrix, "to_nm", rb_gsl_matrix_to_nmatrix, 0);
+  rb_define_alias(cgsl_matrix, "to_nmatrix", "to_nm");
+  rb_define_method(cgsl_matrix, "to_na2", rb_gsl_matrix_to_na_ref, 0);
+  rb_define_alias(cgsl_matrix, "to_na_ref", "to_na2");
+  rb_define_alias(cgsl_matrix, "to_narray_ref", "to_na2");
+  rb_define_method(cgsl_matrix, "to_nm_ref", rb_gsl_matrix_to_nmatrix_ref, 0);
+  rb_define_alias(cgsl_matrix, "to_nmatrix_ref", "to_nm_ref");
+
+  rb_define_singleton_method(cgsl_matrix, "to_gslm", rb_gsl_na_to_gsl_matrix, 1);
+  rb_define_singleton_method(cgsl_matrix, "to_gm", rb_gsl_na_to_gsl_matrix, 1);
+
+  rb_define_singleton_method(cgsl_matrix, "na_to_gslm", rb_gsl_na_to_gsl_matrix, 1);
+  rb_define_singleton_method(cgsl_matrix, "na_to_gm", rb_gsl_na_to_gsl_matrix, 1);
+
+  rb_define_singleton_method(cgsl_matrix, "to_gslm_view", rb_gsl_na_to_gsl_matrix_view, 1);
+  rb_define_singleton_method(cgsl_matrix, "to_gm_view", rb_gsl_na_to_gsl_matrix_view, 1);
+
+  rb_define_singleton_method(cgsl_matrix, "na_to_gslm_view", rb_gsl_na_to_gsl_matrix_view, 1);
+  rb_define_singleton_method(cgsl_matrix, "na_to_gm_view", rb_gsl_na_to_gsl_matrix_view, 1);
+
+  rb_define_method(cNArray, "to_gslm", rb_gsl_na_to_gsl_matrix_method, 0);
+  rb_define_alias(cNArray, "to_gm", "to_gslm");
+  rb_define_method(cNArray, "to_gslm_view", rb_gsl_na_to_gsl_matrix_view_method, 0);
+  rb_define_alias(cNArray, "to_gm_view", "to_gslm_view");  
+
+  /*****/
+  // TODO Complex matrix
+
+  /*****/
+  rb_define_method(cgsl_matrix_int, "to_na", rb_gsl_matrix_int_to_na, 0);
+  rb_define_alias(cgsl_matrix_int, "to_narray", "to_na");
+  rb_define_method(cgsl_matrix_int, "to_nm", rb_gsl_matrix_int_to_nmatrix, 0);
+  rb_define_alias(cgsl_matrix_int, "to_nmatrix", "to_nm");
+
+  rb_define_method(cgsl_matrix_int, "to_na2", rb_gsl_matrix_int_to_na_ref, 0);
+  rb_define_alias(cgsl_matrix_int, "to_na_ref", "to_na2");
+  rb_define_alias(cgsl_matrix_int, "to_narray_ref", "to_na2");
+  rb_define_method(cgsl_matrix_int, "to_nm_ref", rb_gsl_matrix_int_to_nmatrix_ref, 0);
+  rb_define_alias(cgsl_matrix_int, "to_nmatrix_ref", "to_nm_ref");
+
+  rb_define_singleton_method(cgsl_matrix_int, "to_gslm", rb_gsl_na_to_gsl_matrix_int, 1);
+  rb_define_singleton_method(cgsl_matrix_int, "to_gm", rb_gsl_na_to_gsl_matrix_int, 1);
+  rb_define_singleton_method(cgsl_matrix_int, "na_to_gslm", rb_gsl_na_to_gsl_matrix_int, 1);
+  rb_define_singleton_method(cgsl_matrix_int, "na_to_gm", rb_gsl_na_to_gsl_matrix_int, 1);
+
+  rb_define_singleton_method(cgsl_matrix_int, "to_gslm_view", rb_gsl_na_to_gsl_matrix_int_view, 1);
+  rb_define_singleton_method(cgsl_matrix_int, "to_gm_view", rb_gsl_na_to_gsl_matrix_int_view, 1);
+  rb_define_singleton_method(cgsl_matrix_int, "na_to_gslm_view", rb_gsl_na_to_gsl_matrix_int_view, 1);
+  rb_define_singleton_method(cgsl_matrix_int, "na_to_gm_view", rb_gsl_na_to_gsl_matrix_int_view, 1);
+
+  rb_define_method(cNArray, "to_gm_int", rb_gsl_na_to_gsl_matrix_int_method, 0);
+  rb_define_alias(cNArray, "to_gslm_int", "to_gm_int");
+  rb_define_method(cNArray, "to_gm_int_view", rb_gsl_na_to_gsl_matrix_int_view_method, 0);
+  rb_define_alias(cNArray, "to_gslm_int_view", "to_gm_int_view");
+
+  rb_define_method(cNArray, "histogram", rb_gsl_narray_histogram, -1);
+}
+
+#endif