gsl 2.1.0.1 → 2.1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 85493b82ee85da11dfbf1cc6f9ebc6ac37ff17cb
-  data.tar.gz: 4349a2eb3e57d33832e67037e2880abec68b2bdc
+  metadata.gz: 867207d0bcbf91b9e09347e0ff88f94e33eb25c0
+  data.tar.gz: 49cb32046c2852fee2d42af5626842a4c9564d86
 SHA512:
-  metadata.gz: b665766b8b3f1a3054b5a7ecffb04244f6307236e2a1c12a5486ce630306f996c3398ddd5f0dd90aafb80ff84e9d3e37ccdeeae9e5f9c09b1db14a727c75f4f1
-  data.tar.gz: 5eae202b5e9565e0199449281b2c1b9dae11cdcd162635652a2d22ce848520c6a9be435bfff4e3970e4713db24a6641be9f05b4d5c653eb229b3179713e0485e
+  metadata.gz: ca492e6d20fd79de8c8f9c902083876f9d987923673a9f8575cad9a9f13ae059785ee84c4af08473b2fdf1eacb17a374fd4e6764f25ece46d0ee0a212182a91a
+  data.tar.gz: ada482645b5ce72b16c27b79915378942599d90b9b7ef18d7636f4da50d7439d7d71fdd9d486430017896be64c802250db8f14f8bbb4c99e760263d8f2ff0874

data/.travis.yml

@@ -5,7 +5,9 @@ rvm:
   - 1.9.3
   - 2.0
   - 2.1
-  - 2.2
+  - 2.2.6
+  - 2.3.3
+  - 2.4.0
 
 before_install:
   - sudo apt-get update -qq

data/ChangeLog

@@ -1,5 +1,13 @@
 # markup: rd
 
+== Mon January 30 2017
+- Enhancements
+  * Support for assigning Ruby Complex types to GSL::Matrix::Complex. (@v0dro)
+  * Support for 2D interpolation by exposing GSLs interp2d and spline2d. (@v0dro)
+  * Support for Ruby 2.4. (@badlamer)
+- Fixes
+  * Fix NArray superclass mismatch problem. (@v0dro)
+
 == Fri March 4 2016
 * Added compatibility for NMatrix interconversion with GSL::Vector and GSL::Matrix
 * Added NMatrix compatibility to various to make them compatible with NMatrix data types.

data/ext/gsl_native/complex.c

@@ -41,6 +41,11 @@ gsl_complex rb_gsl_obj_to_gsl_complex(VALUE obj, gsl_complex *z)
     if (!NIL_P(vre)) GSL_SET_REAL(z, NUM2DBL(vre));
     if (!NIL_P(vim)) GSL_SET_IMAG(z, NUM2DBL(vim));
     break;
+  case T_COMPLEX:
+    vre = rb_funcall(obj, rb_intern("real"), 0);
+    vim = rb_funcall(obj, rb_intern("imag"), 0);
+    *z = gsl_complex_rect(NUM2DBL(vre), NUM2DBL(vim));
+    break;
   case T_FLOAT:
   case T_FIXNUM:
   case T_BIGNUM:
@@ -63,7 +68,7 @@ gsl_complex rb_gsl_obj_to_gsl_complex(VALUE obj, gsl_complex *z)
 static VALUE rb_gsl_complex_new(int argc, VALUE *argv, VALUE klass)
 {
   gsl_complex *c = NULL;
-  VALUE obj;
+  VALUE obj, vre, vim;
   obj = Data_Make_Struct(klass, gsl_complex, 0, free, c);
   switch (argc) {
   case 1:
@@ -71,6 +76,11 @@ static VALUE rb_gsl_complex_new(int argc, VALUE *argv, VALUE klass)
     case T_ARRAY:
       *c = ary2complex(argv[0]);
       break;
+    case T_COMPLEX:
+      vre = rb_funcall(argv[0], rb_intern("real"), 0);
+      vim = rb_funcall(argv[0], rb_intern("imag"), 0);
+      *c = gsl_complex_rect(NUM2DBL(vre), NUM2DBL(vim));
+      break;
     case T_FLOAT:
     case T_FIXNUM:
     case T_BIGNUM:

data/ext/gsl_native/error.c

@@ -80,9 +80,9 @@ static void rb_gsl_define_exceptions(VALUE module)
   VALUE mgsl_error;
   mgsl_error = rb_define_module_under(module, "ERROR");
   pgsl_error = &cgsl_error[2];
-  pgsl_error[-2] = rb_define_class_under(mgsl_error, "CONTINUE", rb_cFixnum);
+  pgsl_error[-2] = rb_define_class_under(mgsl_error, "CONTINUE", rb_cInteger);
   pgsl_error[-1] = rb_define_class_under(mgsl_error, "FAILURE", rb_eRuntimeError);
-  pgsl_error[0] = rb_define_class_under(mgsl_error, "SUCCESS", rb_cFixnum);
+  pgsl_error[0] = rb_define_class_under(mgsl_error, "SUCCESS", rb_cInteger);
   pgsl_error[1] = rb_define_class_under(mgsl_error, "EDOM", rb_eRangeError);
   pgsl_error[2] = rb_define_class_under(mgsl_error, "ERANGE", rb_eRangeError);
   pgsl_error[3] = rb_define_class_under(mgsl_error, "EFAULT", rb_eRuntimeError);

data/ext/gsl_native/gsl.c

@@ -118,6 +118,10 @@ void Init_gsl_native()
 
   Init_gsl_odeiv(mgsl);
   Init_gsl_interp(mgsl);
+  #ifdef GSL_2_0_LATER
+  Init_gsl_interp2d(mgsl);
+  Init_gsl_spline2d(mgsl);
+  #endif
   Init_gsl_spline(mgsl);
   Init_gsl_diff(mgsl);
   Init_gsl_deriv(mgsl);

data/ext/gsl_native/include/rb_gsl.h

@@ -66,6 +66,12 @@ void Init_gsl_siman(VALUE module);
 void Init_gsl_odeiv(VALUE module);
 void Init_gsl_interp(VALUE module);
 void Init_gsl_spline(VALUE module);
+
+#ifdef GSL_2_0_LATER
+void Init_gsl_interp2d(VALUE module);
+void Init_gsl_spline2d(VALUE module);
+#endif
+
 void Init_gsl_diff(VALUE module);
 void Init_gsl_deriv(VALUE module);
 

data/ext/gsl_native/include/rb_gsl_interp2d.h

@@ -0,0 +1,40 @@
+/*
+  rb_gsl_interp2d.h
+  Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library)
+    (C) Copyright 2001-2004 by Yoshiki Tsunesada
+    (C) Copyright 2015 - by Ruby Science Foundation
+
+  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; without even the implied warranty of
+  MERCHANTABILITY or INTERPOLATIONNESS FOR A PARTICULAR PURPOSE.
+*/
+#ifdef GSL_2_0_LATER
+#ifndef ___RB_GSL_INTERP2D_H___
+#define ___RB_GSL_INTERP2D_H___
+
+#include "rb_gsl.h"
+#include <gsl/gsl_interp2d.h>
+#include <gsl/gsl_spline2d.h>
+
+typedef struct {
+  gsl_interp2d *p;
+  gsl_interp_accel *xacc, *yacc;
+} rb_gsl_interp2d;
+
+typedef struct {
+  gsl_spline2d *s;
+  gsl_interp_accel *xacc, *yacc;
+} rb_gsl_spline2d;
+
+enum {
+  GSL_INTERP2D_BICUBIC,
+  GSL_INTERP2D_BILINEAR
+};
+
+const gsl_interp2d_type* get_interp2d_type(VALUE);
+static void rb_gsl_interp2d_free(rb_gsl_interp2d*);
+
+#endif
+#endif

data/ext/gsl_native/interp2d.c

@@ -0,0 +1,266 @@
+/*
+  interp2d.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.
+*/
+#ifdef GSL_2_0_LATER
+#include "include/rb_gsl_interp2d.h"
+
+VALUE cgsl_interp2d_accel; /* this is used also in spline2d.c */
+EXTERN VALUE cgsl_vector, cgsl_matrix;
+
+static VALUE rb_gsl_interp2d_alloc(int argc, VALUE *argv, VALUE self)
+{ 
+  rb_gsl_interp2d *sp = NULL;
+  const gsl_interp2d_type *T = NULL;
+  double *xptr = NULL, *yptr = NULL, *zptr = NULL;
+  size_t sizex = 0, sizey = 0, sizez = 0, stride = 1;
+
+  T = get_interp2d_type(argv[0]);
+  if (argc == 3) { // type, sizex, sizey
+    sizex = FIX2INT(argv[1]);
+    sizey = FIX2INT(argv[2]);
+  }
+  else if (argc == 4) { // type, xarr, yarr, zarr
+    xptr = get_vector_ptr(argv[1], &stride, &sizex);
+    yptr = get_vector_ptr(argv[2], &stride, &sizey);
+    zptr = get_vector_ptr(argv[3], &stride, &sizez);
+  }
+  else {
+    rb_raise(rb_eRuntimeError, "Expected args: (type, xn, yn) \
+      or (type, xarr, yarr, zarr");
+  }
+
+  if (sizex == 0 || sizey == 0) rb_raise(rb_eRuntimeError, "Interp2d size not given.");
+  sp = ALLOC(rb_gsl_interp2d);
+  sp->p = gsl_interp2d_alloc(T, sizex, sizey);
+  sp->xacc = gsl_interp_accel_alloc();
+  sp->yacc = gsl_interp_accel_alloc();
+
+  if (xptr && yptr && zptr) gsl_interp2d_init(sp->p, xptr, yptr, zptr, sizex, sizey);
+
+  return Data_Wrap_Struct(self, 0, rb_gsl_interp2d_free, sp);
+}
+
+static VALUE rb_gsl_interp2d_init(VALUE self, VALUE xarr, VALUE yarr, VALUE zarr)
+{
+  rb_gsl_interp2d *rgi = NULL;
+  double *xptr = NULL, *yptr = NULL, *zptr = NULL;
+  size_t xsize, ysize, zsize, stride;
+  xptr = get_vector_ptr(xarr, &stride, &xsize);
+  yptr = get_vector_ptr(yarr, &stride, &ysize);
+  zptr = get_vector_ptr(zarr, &stride, &zsize);
+
+  Data_Get_Struct(self, rb_gsl_interp2d, rgi);
+  gsl_interp2d_init(rgi->p, xptr, yptr, zptr, xsize, ysize);
+
+  return self;
+}
+
+static VALUE rb_gsl_interp_evaluate(
+  VALUE self, VALUE xarr, VALUE yarr, VALUE zarr, VALUE xx, VALUE yy, 
+    double (*eval)(const gsl_interp2d * interp, 
+      const double xa[], const double ya[], const double za[],
+      const double x, const double y, gsl_interp_accel * xacc,
+      gsl_interp_accel * yacc))
+{
+  VALUE is_swapped = rb_cvar_get(CLASS_OF(self), rb_intern("@@swapped"));
+  VALUE temp;
+
+  if (is_swapped != Qnil && is_swapped == Qtrue) {
+    temp = xx;
+    xx = yy;
+    yy = temp;
+  }
+  
+  rb_gsl_interp2d *rgi = NULL;
+  double *xptr = NULL, *yptr = NULL, *zptr = NULL;
+  gsl_vector *vx = NULL, *vy = NULL, *vnew = NULL;
+  gsl_matrix *mx = NULL, *my = NULL, *mnew = NULL;
+  VALUE ary, x, y;
+  double val;
+  size_t i, j, xsize, ysize, zsize, stridex, stridey, stridez;
+
+  Data_Get_Struct(self, rb_gsl_interp2d, rgi);
+  xptr = get_vector_ptr(xarr, &stridex, &xsize);
+  if (xsize != rgi->p->xsize ) {
+    rb_raise(rb_eTypeError, "size mismatch (xa:%d != %d)",  (int) xsize, 
+      (int) rgi->p->xsize);
+  }
+
+  yptr = get_vector_ptr(yarr, &stridey, &ysize);
+  if (ysize != rgi->p->ysize ) {
+    rb_raise(rb_eTypeError, "size mismatch (ya:%d != %d)", (int) ysize, 
+      (int) rgi->p->ysize);
+  }
+
+  zptr = get_vector_ptr(zarr, &stridez, &zsize);
+  if (zsize != xsize*ysize ) {
+    rb_raise(rb_eTypeError, "size mismatch (za:%d != %d)", (int) zsize, 
+      (int) xsize*ysize);
+  }
+
+  if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
+  if (CLASS_OF(yy) == rb_cRange) yy = rb_gsl_range2ary(yy);
+
+  if (TYPE(xx) != TYPE(yy)) {
+    rb_raise(rb_eTypeError,"xx and yy must be same type. xx = %d yy = %d.",
+      TYPE(xx), TYPE(yy));
+  }
+
+  switch (TYPE(xx)) {
+  case T_FIXNUM:  case T_BIGNUM:  case T_FLOAT:
+    Need_Float(xx);
+    return rb_float_new((*eval)(rgi->p, xptr, yptr, zptr, NUM2DBL(xx), NUM2DBL(yy),
+      rgi->xacc, rgi->yacc));
+  case T_ARRAY:
+    if (RARRAY_LEN(xx) != RARRAY_LEN(yy)) {
+      rb_raise(rb_eRuntimeError, "xx and yy must be same sized Array.");
+    }
+    ary = rb_ary_new2(RARRAY_LEN(xx));
+
+    for (i = 0; i < (unsigned)RARRAY_LEN(xx); i++) {
+      x = rb_ary_entry(xx, i);
+      y = rb_ary_entry(yy, i);
+      Need_Float(x);
+      Need_Float(y);
+
+      val = (*eval)(rgi->p, xptr, yptr, zptr, NUM2DBL(x), NUM2DBL(y), rgi->xacc,
+        rgi->yacc);
+      rb_ary_store(ary, i, rb_float_new(val));
+    }
+    return ary;
+  default:
+    if (VECTOR_P(xx)) {
+      Data_Get_Struct(xx, gsl_vector, vx);
+      Data_Get_Struct(yy, gsl_vector, vy);
+      if (vx->size != vy->size) {
+        rb_raise(rb_eRuntimeError, "xx and yy must be same sized Vectors.");
+      }
+      vnew = gsl_vector_alloc(vx->size);
+
+      for (i = 0; i < vx->size; i++) {
+        val = (*eval)(rgi->p, xptr, yptr, zptr, gsl_vector_get(vx, i), 
+          gsl_vector_get(vy, i), rgi->xacc, rgi->yacc);
+        gsl_vector_set(vnew, i, val);
+      }
+      return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);
+    } else if (MATRIX_P(xx)) {
+      Data_Get_Struct(xx, gsl_matrix, mx);
+      Data_Get_Struct(xx, gsl_matrix, my);
+
+      if ((mx->size1 != my->size1) || (mx->size2 != my->size2)) {
+        rb_raise(rb_eRuntimeError, "xx and yy must be same sized Matrices.");
+      }
+      mnew = gsl_matrix_alloc(mx->size1, mx->size2);
+      for (i = 0; i < mx->size1; i++) {
+        for (j = 0; j < mx->size2; j++) {
+          val = (*eval)(rgi->p, xptr, yptr, zptr, gsl_matrix_get(mx, i, j),
+            gsl_matrix_get(my, i, j), rgi->xacc, rgi->yacc);
+          gsl_matrix_set(mnew, i, j, val);
+        }
+      }
+      return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
+    } else {
+      rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(xx)));
+    }
+  }
+}
+
+static VALUE rb_gsl_interp2d_eval(VALUE self, VALUE xarr, VALUE yarr, VALUE zarr,
+  VALUE xx, VALUE yy)
+{
+  return rb_gsl_interp_evaluate(self, xarr, yarr, zarr, xx, yy, gsl_interp2d_eval);
+}
+
+/*
+  Function that is called by the Ruby GC for cleaning up this structure.
+*/
+static void rb_gsl_interp2d_free(rb_gsl_interp2d *fr)
+{
+  gsl_interp2d_free(fr->p);
+  gsl_interp_accel_free(fr->xacc);
+  gsl_interp_accel_free(fr->yacc);
+  free((rb_gsl_interp2d*) fr);
+}
+
+/*
+  Define constants for deciding type of interpolation.
+*/
+static void rb_gsl_interp2d_define_const(VALUE self)
+{
+  rb_define_const(self, "BICUBIC", INT2FIX(GSL_INTERP2D_BICUBIC));
+  rb_define_const(self, "BILINEAR", INT2FIX(GSL_INTERP2D_BILINEAR));
+}
+
+const gsl_interp2d_type* get_interp2d_type(VALUE t)
+{ 
+  int type;
+  char name[32];
+
+  switch(TYPE(t)) {
+    case T_FIXNUM:
+      type = FIX2INT(t);
+
+      switch (type) {
+        case 0: return gsl_interp2d_bicubic;  break;
+        case 1: return gsl_interp2d_bilinear; break;
+        default:
+          rb_raise(rb_eRuntimeError, "Cannot recognize type %d.\n", type);
+      } 
+    case T_STRING:
+      strcpy(name, STR2CSTR(t));
+
+      if (str_tail_grep("bicubic", name) == 0) {
+        return gsl_interp2d_bicubic;
+      }
+      else if (str_tail_grep("bicubic", name) == 0) {
+        return gsl_interp2d_bilinear;
+      }
+      else {
+        rb_raise(rb_eRuntimeError, "Cannot recognize type %s.\n", name);
+      }
+    default:
+      rb_raise(rb_eRuntimeError, "Unknown type.");
+  }
+}
+
+static VALUE rb_gsl_interp2d_info(VALUE self)
+{
+  rb_gsl_interp2d *p;
+  char buf[256];
+  Data_Get_Struct(self, rb_gsl_interp2d, p);
+  sprintf(buf, "Class:      %s\n", rb_class2name(CLASS_OF(self)));
+  sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS_SUPER(CLASS_OF(self))));
+  sprintf(buf, "%sType:       %s\n", buf, gsl_interp2d_name(p->p));
+  sprintf(buf, "%sxmin:       %f\n", buf, p->p->xmin);
+  sprintf(buf, "%sxmax:       %f\n", buf, p->p->xmax);
+  sprintf(buf, "%symin:       %f\n", buf, p->p->ymin);
+  sprintf(buf, "%symax:       %f\n", buf, p->p->ymax);
+  sprintf(buf, "%sxsize:       %d\n", buf, (int) p->p->xsize);
+  sprintf(buf, "%sysize:       %d\n", buf, (int) p->p->ysize);
+
+  return rb_str_new2(buf);
+}
+
+void Init_gsl_interp2d(VALUE module)
+{
+  VALUE cgsl_interp2d;
+
+  cgsl_interp2d = rb_define_class_under(module, "Interp2d", cGSL_Object);
+  cgsl_interp2d_accel = rb_define_class_under(cgsl_interp2d, "Accel", cGSL_Object);
+
+  rb_define_singleton_method(cgsl_interp2d, "alloc", rb_gsl_interp2d_alloc, -1);
+  rb_gsl_interp2d_define_const(cgsl_interp2d);
+
+  rb_define_method(cgsl_interp2d, "init", rb_gsl_interp2d_init, 3);
+  rb_define_method(cgsl_interp2d, "eval", rb_gsl_interp2d_eval, 5);
+  rb_define_method(cgsl_interp2d, "info", rb_gsl_interp2d_info, 0);
+}
+
+#endif

data/ext/gsl_native/spline2d.c

@@ -0,0 +1,211 @@
+/*
+  spline2d.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.
+*/
+#ifdef GSL_2_0_LATER
+#include "include/rb_gsl_interp2d.h"
+
+EXTERN VALUE cgsl_interp2d_accel;  /* defined in interp2d.c */
+static void rb_gsl_spline2d_free(rb_gsl_spline2d *fr);
+
+static VALUE rb_gsl_spline2d_alloc(int argc, VALUE *argv, VALUE self)
+{
+  rb_gsl_spline2d *sp = NULL;
+  const gsl_interp2d_type *T = NULL;
+  double *xptr = NULL, *yptr = NULL, *zptr = NULL;
+  size_t sizex = 0, sizey = 0, sizez = 0, stride = 1;
+
+  T = get_interp2d_type(argv[0]);
+  if (argc == 3) { // type, sizex, sizey
+    sizex = FIX2INT(argv[1]);
+    sizey = FIX2INT(argv[2]);
+  }
+  else if (argc == 4) { // type, xarr, yarr, zarr
+    xptr = get_vector_ptr(argv[1], &stride, &sizex);
+    yptr = get_vector_ptr(argv[2], &stride, &sizey);
+    zptr = get_vector_ptr(argv[3], &stride, &sizez);
+  }
+  else {
+    rb_raise(rb_eRuntimeError, "Expected args: (interp2d type, xn, yn) \
+      or (interp2d type, xarr, yarr, zarr");
+  }
+
+  if (sizex == 0 || sizey == 0) rb_raise(rb_eRuntimeError, "Spline2d size not given.");
+  sp = ALLOC(rb_gsl_spline2d);
+  sp->s = gsl_spline2d_alloc(T, sizex, sizey);
+  sp->xacc = gsl_interp_accel_alloc();
+  sp->yacc = gsl_interp_accel_alloc();
+
+  if (xptr && yptr && zptr) gsl_spline2d_init(sp->s, xptr, yptr, zptr, sizex, sizey);
+
+  return Data_Wrap_Struct(self, 0, rb_gsl_spline2d_free, sp);
+}
+
+static void rb_gsl_spline2d_free(rb_gsl_spline2d *fr)
+{
+  gsl_spline2d_free(fr->s);
+  gsl_interp_accel_free(fr->xacc);
+  gsl_interp_accel_free(fr->yacc);
+  free((rb_gsl_interp2d*) fr);
+}
+
+static VALUE rb_gsl_spline2d_init(VALUE self, VALUE xarr, VALUE yarr, VALUE zarr)
+{
+  rb_gsl_spline2d *rgs = NULL;
+  double *xptr = NULL, *yptr = NULL, *zptr = NULL;
+  size_t xsize, ysize, zsize, stride;
+  xptr = get_vector_ptr(xarr, &stride, &xsize);
+  yptr = get_vector_ptr(yarr, &stride, &ysize);
+  zptr = get_vector_ptr(zarr, &stride, &zsize);
+
+  Data_Get_Struct(self, rb_gsl_spline2d, rgs);
+  gsl_spline2d_init(rgs->s, xptr, yptr, zptr, xsize, ysize);
+
+  return self;
+}
+
+static VALUE rb_gsl_spline2d_accel(VALUE self)
+{
+  rb_gsl_spline2d *rgs = NULL;
+  VALUE ary = rb_ary_new();
+  Data_Get_Struct(self, rb_gsl_spline2d, rgs);
+
+  rb_ary_push(ary, Data_Wrap_Struct(cgsl_interp2d_accel, 0, NULL, rgs->xacc));
+  rb_ary_push(ary, Data_Wrap_Struct(cgsl_interp2d_accel, 0, NULL, rgs->yacc));
+
+  return ary;
+}
+
+static VALUE rb_gsl_spline2d_evaluate(VALUE self, VALUE xx, VALUE yy,
+  double (*eval)(const gsl_spline2d *, double, double, gsl_interp_accel *, 
+    gsl_interp_accel *))
+{ 
+  VALUE is_swapped = rb_cvar_get(CLASS_OF(self), rb_intern("@@swapped"));
+  VALUE temp;
+
+  if (is_swapped != Qnil && is_swapped == Qtrue) {
+    temp = xx;
+    xx = yy;
+    yy = temp;
+  }
+  
+  rb_gsl_spline2d *rgs = NULL;
+  gsl_vector *vx = NULL, *vy = NULL, *vnew = NULL;
+  gsl_matrix *mx = NULL, *my = NULL, *mnew = NULL;
+  VALUE ary, x, y;
+  double val;
+  size_t i, j;
+
+  Data_Get_Struct(self, rb_gsl_spline2d, rgs);
+
+  if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
+  if (CLASS_OF(yy) == rb_cRange) yy = rb_gsl_range2ary(yy);
+
+  if (TYPE(xx) != TYPE(yy)) {
+    rb_raise(rb_eTypeError,"xx and yy must be same type. xx = %d yy = %d.",
+      TYPE(xx), TYPE(yy));
+  }
+
+  switch (TYPE(xx)) {
+  case T_FIXNUM:  case T_BIGNUM:  case T_FLOAT:
+    Need_Float(xx);
+    return rb_float_new((*eval)(rgs->s, NUM2DBL(xx), NUM2DBL(yy),
+      rgs->xacc, rgs->yacc));
+  case T_ARRAY:
+    if (RARRAY_LEN(xx) != RARRAY_LEN(yy)) {
+      rb_raise(rb_eRuntimeError, "xx and yy must be same sized Array.");
+    }
+    ary = rb_ary_new2(RARRAY_LEN(xx));
+
+    for (i = 0; i < (unsigned)RARRAY_LEN(xx); i++) {
+      x = rb_ary_entry(xx, i);
+      y = rb_ary_entry(yy, i);
+      Need_Float(x);
+      Need_Float(y);
+
+      val = (*eval)(rgs->s, NUM2DBL(x), NUM2DBL(y), rgs->xacc, rgs->yacc);
+      rb_ary_store(ary, i, rb_float_new(val));
+    }
+    return ary;
+  default:
+    if (VECTOR_P(xx)) {
+      Data_Get_Struct(xx, gsl_vector, vx);
+      Data_Get_Struct(yy, gsl_vector, vy);
+      if (vx->size != vy->size) {
+        rb_raise(rb_eRuntimeError, "xx and yy must be same size Vectors.");
+      }
+      vnew = gsl_vector_alloc(vx->size);
+
+      for (i = 0; i < vx->size; i++) {
+        val = (*eval)(rgs->s, gsl_vector_get(vx, i), gsl_vector_get(vy, i), 
+          rgs->xacc, rgs->yacc);
+        gsl_vector_set(vnew, i, val);
+      }
+      return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);
+    } else if (MATRIX_P(xx)) {
+      Data_Get_Struct(xx, gsl_matrix, mx);
+      Data_Get_Struct(xx, gsl_matrix, my);
+
+      if ((mx->size1 != my->size1) || (mx->size2 != my->size2)) {
+        rb_raise(rb_eRuntimeError, "xx and yy must be same sized Matrices.");
+      }
+      mnew = gsl_matrix_alloc(mx->size1, mx->size2);
+      for (i = 0; i < mx->size1; i++) {
+        for (j = 0; j < mx->size2; j++) {
+          val = (*eval)(rgs->s, gsl_matrix_get(mx, i, j),
+            gsl_matrix_get(my, i, j), rgs->xacc, rgs->yacc);
+          gsl_matrix_set(mnew, i, j, val);
+        }
+      }
+      return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
+    } else {
+      rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(xx)));
+    }
+  }
+}
+
+static VALUE rb_gsl_spline2d_eval(VALUE self, VALUE xx, VALUE yy)
+{ 
+  return rb_gsl_spline2d_evaluate(self, xx, yy, gsl_spline2d_eval);
+}
+
+static VALUE rb_gsl_spline2d_info(VALUE self)
+{
+  rb_gsl_spline2d *p = NULL;
+  char buf[256];
+  Data_Get_Struct(self, rb_gsl_spline2d, p);
+  sprintf(buf, "Class:      %s\n", rb_class2name(CLASS_OF(self)));
+  sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS_SUPER(CLASS_OF(self))));
+  sprintf(buf, "%sType:       %s\n", buf, gsl_interp2d_name(&p->s->interp_object));
+  sprintf(buf, "%sxmin:       %f\n", buf, p->s->interp_object.xmin);
+  sprintf(buf, "%sxmax:       %f\n", buf, p->s->interp_object.xmax);
+  sprintf(buf, "%symin:       %f\n", buf, p->s->interp_object.ymin);
+  sprintf(buf, "%symax:       %f\n", buf, p->s->interp_object.ymax);
+  sprintf(buf, "%sxSize:       %d\n", buf, (int) p->s->interp_object.xsize);
+  sprintf(buf, "%sySize:       %d\n", buf, (int) p->s->interp_object.ysize);
+  return rb_str_new2(buf);
+}
+
+void Init_gsl_spline2d(VALUE module)
+{
+  VALUE cgsl_spline2d;
+
+  cgsl_spline2d = rb_define_class_under(module, "Spline2d", cGSL_Object);
+
+  rb_define_singleton_method(cgsl_spline2d, "alloc", rb_gsl_spline2d_alloc, -1);
+
+  /*****/
+
+  rb_define_method(cgsl_spline2d, "init", rb_gsl_spline2d_init, 3);
+  rb_define_method(cgsl_spline2d, "accel", rb_gsl_spline2d_accel, 0);
+  rb_define_method(cgsl_spline2d, "eval", rb_gsl_spline2d_eval, 2);
+  rb_define_alias(cgsl_spline2d, "[]", "eval");
+  rb_define_method(cgsl_spline2d, "info", rb_gsl_spline2d_info, 0);
+}
+#endif