romanbsd-gsl 1.11.2.2

data/ext/const_additional.c

@@ -0,0 +1,120 @@
+/*
+  const_additional.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_const.h"
+
+#ifndef GSL_1_4_9_LATER
+#define MKS_STEFAN_BOLTZMANN_CONSTANT (5.6703993443638e-08)
+#define MKS_THOMSON_CROSS_SECTION (6.65245852869236e-29)
+#define CGS_STEFAN_BOLTZMANN_CONSTANT (5.6703993443638e-05)
+#define CGS_THOMSON_CROSS_SECTION (6.65245852869236e-25)
+#endif
+
+#define MKS_CLASSICAL_ELECTRON_RADIUS (2.81794028310825e-15)
+#define MKS_RADIATION_DENSITY_CONSTANT (7.56576650685962e-16)
+#define MKS_RADIATION_NUMBER_DENSITY_CONSTANT (20.2869161066108e-6)
+#define MKS_SOLAR_TIME (4.925490947e-6)
+#define MKS_SOLAR_GM (1.3271243999e20)
+#define MKS_PLANCK_MASS (2.17664610503472e-08)
+#define MKS_PLANCK_LENGTH (1.61609744261067e-35)
+#define MKS_PLANCK_TIME (5.39072081196475e-44)
+
+#define CGS_CLASSICAL_ELECTRON_RADIUS (2.81794028310825e-13)
+#define CGS_RADIATION_DENSITY_CONSTANT (7.56576650685962e-15)
+#define CGS_RADIATION_NUMBER_DENSITY_CONSTANT (20.2869161066108)
+#define CGS_SOLAR_TIME (4.925490947e-6)
+#define CGS_SOLAR_GM (1.3271243999e26)
+#define CGS_PLANCK_MASS (2.17664610503472e-05)
+#define CGS_PLANCK_LENGTH (1.61609744261067e-33)
+#define CGS_PLANCK_TIME (5.39072081196475e-44)
+
+static void rb_gsl_const_mks(VALUE module);
+static void rb_gsl_const_cgs(VALUE module);
+static void rb_gsl_const_num(VALUE module);
+
+static void rb_gsl_const_mks(VALUE module)
+{
+  rb_define_const(module, "RADIATION_DENSITY_CONSTANT",
+		  rb_float_new(MKS_RADIATION_DENSITY_CONSTANT));
+  rb_define_const(module, "RADIATION_NUMBER_DENSITY_CONSTANT", 
+		  rb_float_new(MKS_RADIATION_NUMBER_DENSITY_CONSTANT));
+  rb_define_const(module, "CLASSICAL_ELECTRON_RADIUS",
+		  rb_float_new(MKS_CLASSICAL_ELECTRON_RADIUS));
+  rb_define_const(module, "SOLAR_TIME", rb_float_new(MKS_SOLAR_TIME));
+  rb_define_const(module, "SOLAR_GM", rb_float_new(MKS_SOLAR_GM));
+
+  rb_define_const(module, "PLANCK_MASS", rb_float_new(MKS_PLANCK_MASS));
+  rb_define_const(module, "PLANCK_LENGTH", rb_float_new(MKS_PLANCK_LENGTH));
+  rb_define_const(module, "PLANCK_TIME", rb_float_new(MKS_PLANCK_TIME));
+
+#ifndef GSL_1_4_9_LATER
+  rb_define_const(module, "STEFAN_BOLTZMANN_CONSTANT", 
+		  rb_float_new(MKS_STEFAN_BOLTZMANN_CONSTANT));
+  rb_define_const(module, "THOMSON_CROSS_SECTION", 
+		  rb_float_new(MKS_THOMSON_CROSS_SECTION));
+#endif
+}
+
+static void rb_gsl_const_cgs(VALUE module)
+{
+  rb_define_const(module, "RADIATION_DENSITY_CONSTANT", 
+		  rb_float_new(CGS_RADIATION_DENSITY_CONSTANT));
+  rb_define_const(module, "RADIATION_NUMBER_DENSITY_CONSTANT", 
+		  rb_float_new(CGS_RADIATION_NUMBER_DENSITY_CONSTANT));
+  rb_define_const(module, "CLASSICAL_ELECTRON_RADIUS", 
+		  rb_float_new(CGS_CLASSICAL_ELECTRON_RADIUS));
+  rb_define_const(module, "SOLAR_TIME", rb_float_new(CGS_SOLAR_TIME));
+  rb_define_const(module, "SOLAR_GM", rb_float_new(CGS_SOLAR_GM));
+
+  rb_define_const(module, "PLANCK_MASS", rb_float_new(CGS_PLANCK_MASS));
+  rb_define_const(module, "PLANCK_LENGTH", rb_float_new(CGS_PLANCK_LENGTH));
+  rb_define_const(module, "PLANCK_TIME", rb_float_new(CGS_PLANCK_TIME));
+
+#ifndef GSL_1_4_9_LATER
+  rb_define_const(module, "STEFAN_BOLTZMANN_CONSTANT", 
+		  rb_float_new(CGS_STEFAN_BOLTZMANN_CONSTANT));
+  rb_define_const(module, "THOMSON_CROSS_SECTION", 
+		  rb_float_new(CGS_THOMSON_CROSS_SECTION));
+#endif
+}
+
+static void rb_gsl_const_num(VALUE module)
+{
+
+}
+
+void Init_gsl_const_additional(VALUE mmks, VALUE mcgs, VALUE mnum)
+{
+  rb_gsl_const_mks(mmks);
+  rb_gsl_const_cgs(mcgs);
+  rb_gsl_const_num(mnum);
+}
+
+#undef MKS_CLASSICAL_ELECTRON_RADIUS
+#undef MKS_STEFAN_BOLTZMANN_CONSTANT
+#undef MKS_RADIATION_DENSITY_CONSTANT
+#undef MKS_RADIATION_NUMBER_DENSITY_CONSTANT
+#undef CGS_CLASSICAL_ELECTRON_RADIUS 
+#undef CGS_STEFAN_BOLTZMANN_CONSTANT 
+#undef CGS_RADIATION_DENSITY_CONSTANT
+#undef CGS_RADIATION_NUMBER_DENSITY_CONSTANT
+#undef CGS_THOMSON_CROSS_SECTION
+#undef MKS_THOMSON_CROSS_SECTION
+#undef MKS_SOLAR_TIME
+#undef CGS_SOLAR_TIME
+#undef MKS_SOLAR_GM
+#undef CGS_SOLAR_GM
+#undef MKS_PLANCK_MASS
+#undef MKS_PLANCK_LENGTH
+#undef MKS_PLANCK_TIME
+#undef CGS_PLANCK_MASS
+#undef CGS_PLANCK_LENGTH
+#undef CGS_PLANCK_TIME

data/ext/cqp.c

@@ -0,0 +1,283 @@
+#ifdef HAVE_GSL_GSL_CQP_H
+
+#include "rb_gsl.h"
+#include "gsl/gsl_cqp.h"
+
+static const gsl_cqpminimizer_type* type_by_string(VALUE t);
+static const gsl_cqpminimizer_type* get_type(VALUE t)
+{
+
+	switch (TYPE(t)) {
+	case T_STRING:
+		return type_by_string(t);
+		break;
+	default:
+		rb_raise(rb_eTypeError, "Wrong argument type %s.", rb_class2name(CLASS_OF(t)));
+	}
+}
+
+static const gsl_cqpminimizer_type* type_by_string(VALUE t)
+{
+	char *name;	
+	name = STR2CSTR(t);
+	if (strcmp(name, "mg_pdip") == 0) {
+		return gsl_cqpminimizer_mg_pdip;
+	} else {
+		rb_raise(rb_eRuntimeError, "Unknown minimizer type %s.", name);
+	}
+	return NULL; /* never reach here */
+}
+
+static VALUE rb_cqpminimizer_alloc(VALUE klass,  VALUE t, VALUE n, VALUE me, VALUE mi)
+{
+	gsl_cqpminimizer *m;
+	m = gsl_cqpminimizer_alloc(get_type(t), (size_t) FIX2INT(n), (size_t) FIX2INT(me), (size_t) FIX2INT(mi));
+	return Data_Wrap_Struct(klass, 0, gsl_cqpminimizer_free, m);
+}
+
+static VALUE rb_cqpminimizer_set(VALUE obj, VALUE data)
+{
+	gsl_cqpminimizer *m;
+	gsl_cqp_data *d;
+	Data_Get_Struct(obj, gsl_cqpminimizer, m);
+	Data_Get_Struct(data, gsl_cqp_data, d);
+	gsl_cqpminimizer_set(m, d);
+	return Qtrue;
+}
+
+static VALUE rb_cqpminimizer_name(VALUE obj)
+{
+	gsl_cqpminimizer *m;
+	Data_Get_Struct(obj, gsl_cqpminimizer, m);
+	return rb_str_new2(gsl_cqpminimizer_name(m));
+}
+
+static VALUE rb_cqpminimizer_iterate(VALUE obj)
+{
+	gsl_cqpminimizer *m;
+	Data_Get_Struct(obj, gsl_cqpminimizer, m);
+	return INT2FIX(gsl_cqpminimizer_iterate(m));
+}
+
+static VALUE rb_cqpminimizer_x(VALUE obj)
+{
+	gsl_cqpminimizer *m;
+	Data_Get_Struct(obj, gsl_cqpminimizer, m);
+	return Data_Wrap_Struct(cgsl_vector_view, 0, NULL, gsl_cqpminimizer_x(m));
+}
+
+static VALUE rb_cqpminimizer_lm_eq(VALUE obj)
+{
+	gsl_cqpminimizer *m;
+	Data_Get_Struct(obj, gsl_cqpminimizer, m);
+	return Data_Wrap_Struct(cgsl_vector_view, 0, NULL, gsl_cqpminimizer_lm_eq(m));
+}
+static VALUE rb_cqpminimizer_lm_ineq(VALUE obj)
+{
+	gsl_cqpminimizer *m;
+	Data_Get_Struct(obj, gsl_cqpminimizer, m);
+	return Data_Wrap_Struct(cgsl_vector_view, 0, NULL, gsl_cqpminimizer_lm_ineq(m));
+}
+static VALUE rb_cqpminimizer_f(VALUE obj)
+{
+	gsl_cqpminimizer *m;
+	Data_Get_Struct(obj, gsl_cqpminimizer, m);
+	return rb_float_new(gsl_cqpminimizer_f(m));
+}
+static VALUE rb_cqpminimizer_gap(VALUE obj)
+{
+	gsl_cqpminimizer *m;
+	Data_Get_Struct(obj, gsl_cqpminimizer, m);
+	return rb_float_new(gsl_cqpminimizer_gap(m));
+}
+static VALUE rb_cqpminimizer_residuals_norm(VALUE obj)
+{
+	gsl_cqpminimizer *m;
+	Data_Get_Struct(obj, gsl_cqpminimizer, m);
+	return rb_float_new(gsl_cqpminimizer_residuals_norm(m));
+}
+/*
+static VALUE rb_cqpminimizer_minimum(VALUE obj)
+{
+	gsl_cqpminimizer *m;
+	Data_Get_Struct(obj, gsl_cqpminimizer, m);
+	return rb_float_new(gsl_cqpminimizer_minimum(m));
+}
+*/
+static VALUE rb_cqpminimizer_test_convergence(VALUE obj, VALUE g, VALUE r)
+{
+	gsl_cqpminimizer *m;
+	Data_Get_Struct(obj, gsl_cqpminimizer, m);
+	return INT2FIX(gsl_cqpminimizer_test_convergence(m, NUM2DBL(g), NUM2DBL(r)));
+}
+static VALUE rb_cqpminimizer_test_infeasibility(VALUE obj, VALUE e)
+{
+	gsl_cqpminimizer *m;
+	Data_Get_Struct(obj, gsl_cqpminimizer, m);
+	return INT2FIX(gsl_cqp_minimizer_test_infeasibility(m, NUM2DBL(e)));
+}
+
+static VALUE rb_cqp_data_alloc(VALUE klass)
+{
+	gsl_cqp_data *d;
+	d = (gsl_cqp_data*) malloc(sizeof(gsl_cqp_data));
+	return Data_Wrap_Struct(klass, 0, free, d);
+}
+
+static VALUE rb_cqp_data_Q(VALUE obj)
+{
+	gsl_cqp_data *d;
+	Data_Get_Struct(obj, gsl_cqp_data, d);
+	return Data_Wrap_Struct(cgsl_matrix_view, 0, NULL, 	d->Q);
+}
+
+static VALUE rb_cqp_data_q(VALUE obj)
+{
+	gsl_cqp_data *d;
+	Data_Get_Struct(obj, gsl_cqp_data, d);
+	return Data_Wrap_Struct(cgsl_vector_view, 0, NULL, 	d->q);
+}
+
+static VALUE rb_cqp_data_A(VALUE obj)
+{
+	gsl_cqp_data *d;
+	Data_Get_Struct(obj, gsl_cqp_data, d);
+	return Data_Wrap_Struct(cgsl_matrix_view, 0, NULL, 	d->A);
+}
+
+static VALUE rb_cqp_data_b(VALUE obj)
+{
+	gsl_cqp_data *d;
+	Data_Get_Struct(obj, gsl_cqp_data, d);
+	return Data_Wrap_Struct(cgsl_vector_view, 0, NULL, 	d->b);
+}
+
+static VALUE rb_cqp_data_C(VALUE obj)
+{
+	gsl_cqp_data *d;
+	Data_Get_Struct(obj, gsl_cqp_data, d);
+	return Data_Wrap_Struct(cgsl_matrix_view, 0, NULL, 	d->C);
+}
+
+static VALUE rb_cqp_data_d(VALUE obj)
+{
+	gsl_cqp_data *d;
+	Data_Get_Struct(obj, gsl_cqp_data, d);
+	return Data_Wrap_Struct(cgsl_vector_view, 0, NULL, 	d->d);
+}
+
+static VALUE rb_cqp_data_set_Q(VALUE obj, VALUE mm)
+{
+	gsl_cqp_data *d;
+	gsl_matrix *m;
+	Data_Get_Struct(obj, gsl_cqp_data, d);
+	CHECK_MATRIX(mm);
+	Data_Get_Struct(mm, gsl_matrix, m);	
+	d->Q = m;
+	return Qtrue;
+}
+
+static VALUE rb_cqp_data_set_q(VALUE obj, VALUE vv)
+{
+	gsl_cqp_data *d;
+	gsl_vector *v;
+	Data_Get_Struct(obj, gsl_cqp_data, d);
+	CHECK_VECTOR(vv);
+	Data_Get_Struct(vv, gsl_vector, v);
+	d->q = v;
+	return Qtrue;
+}
+
+static VALUE rb_cqp_data_set_A(VALUE obj, VALUE mm)
+{
+	gsl_cqp_data *d;
+	gsl_matrix *m;
+	Data_Get_Struct(obj, gsl_cqp_data, d);
+	CHECK_MATRIX(mm);
+	Data_Get_Struct(mm, gsl_matrix, m);
+	d->A = m;
+	return Qtrue;
+}
+
+static VALUE rb_cqp_data_set_b(VALUE obj, VALUE vv)
+{
+	gsl_cqp_data *d;
+	gsl_vector *v;
+	Data_Get_Struct(obj, gsl_cqp_data, d);
+	CHECK_VECTOR(vv);
+	Data_Get_Struct(vv, gsl_vector, v);
+	d->b = v;
+	return Qtrue;
+}
+
+static VALUE rb_cqp_data_set_C(VALUE obj, VALUE mm)
+{
+	gsl_cqp_data *d;
+	gsl_matrix *m;
+	Data_Get_Struct(obj, gsl_cqp_data, d);
+	CHECK_MATRIX(mm);
+	Data_Get_Struct(mm, gsl_matrix, m);
+	d->C = m;
+	return Qtrue;
+}
+
+static VALUE rb_cqp_data_set_d(VALUE obj, VALUE vv)
+{
+	gsl_cqp_data *d;
+	gsl_vector *v;
+	Data_Get_Struct(obj, gsl_cqp_data, d);
+	CHECK_VECTOR(vv);
+	Data_Get_Struct(vv, gsl_vector, v);
+	d->d = v;
+	return Qtrue;
+}
+
+void Init_cqp(VALUE module)
+{
+	VALUE mCQP, cMinimizer, cData;
+	
+	mCQP = rb_define_module_under(module, "CQP");
+	cMinimizer = rb_define_class_under(mCQP, "Minimizer", cGSL_Object);
+	cData = rb_define_class_under(mCQP, "Data", cGSL_Object);	
+
+	rb_define_singleton_method(cMinimizer, "alloc", rb_cqpminimizer_alloc, 4);
+	
+	rb_define_method(cMinimizer, "set", rb_cqpminimizer_set, 1);
+	rb_define_method(cMinimizer, "name", rb_cqpminimizer_name, 0);
+	rb_define_method(cMinimizer, "iterate", rb_cqpminimizer_iterate, 0);	
+	rb_define_method(cMinimizer, "x", rb_cqpminimizer_x, 0);
+	rb_define_method(cMinimizer, "lm_eq", rb_cqpminimizer_lm_eq, 0);
+	rb_define_method(cMinimizer, "lm_ineq", rb_cqpminimizer_lm_ineq, 0);
+	rb_define_method(cMinimizer, "f", rb_cqpminimizer_f, 0);
+	rb_define_method(cMinimizer, "gap", rb_cqpminimizer_gap, 0);
+	rb_define_method(cMinimizer, "residuals_norm", rb_cqpminimizer_residuals_norm, 0);	
+/*	rb_define_method(cMinimizer, "minimum", rb_cqpminimizer_minimum, 0);	*/
+	rb_define_method(cMinimizer, "test_convergence", rb_cqpminimizer_test_convergence, 2);
+	rb_define_method(cMinimizer, "test_infeasibility", rb_cqpminimizer_test_infeasibility, 1);	
+
+	/*****/	
+	rb_define_singleton_method(cData, "alloc", rb_cqp_data_alloc, 0);	
+	
+	rb_define_method(cData, "Q", rb_cqp_data_Q, 0);
+	rb_define_method(cData, "q", rb_cqp_data_q, 0);
+	rb_define_method(cData, "A", rb_cqp_data_A, 0);
+	rb_define_method(cData, "b", rb_cqp_data_b, 0);
+	rb_define_method(cData, "C", rb_cqp_data_C, 0);
+	rb_define_method(cData, "d", rb_cqp_data_d, 0);
+	
+	rb_define_method(cData, "set_Q", rb_cqp_data_set_Q, 1);
+	rb_define_method(cData, "set_q", rb_cqp_data_set_q, 1);
+	rb_define_method(cData, "set_A", rb_cqp_data_set_A, 1);
+	rb_define_method(cData, "set_b", rb_cqp_data_set_b, 1);
+	rb_define_method(cData, "set_C", rb_cqp_data_set_C, 1);
+	rb_define_method(cData, "set_d", rb_cqp_data_set_d, 1);
+	rb_define_alias(cData, "Q=", "set_Q");
+	rb_define_alias(cData, "q=", "set_q");
+	rb_define_alias(cData, "A=", "set_A");
+	rb_define_alias(cData, "b=", "set_b");
+	rb_define_alias(cData, "C=", "set_C");
+	rb_define_alias(cData, "d=", "set_d");	
+}
+
+#endif
+

data/ext/deriv.c

@@ -0,0 +1,194 @@
+/*
+  deriv.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"
+#ifdef GSL_1_4_9_LATER
+#include "rb_gsl_common.h"
+#include "rb_gsl_function.h"
+#include <gsl/gsl_math.h>
+#include <gsl/gsl_deriv.h>
+#define RB_GSL_DERIV_H_DEFAULT (1e-8)
+#ifdef HAVE_NARRAY_H
+#include "narray.h"
+#endif
+
+static int get_func2(int argc, VALUE *argv, VALUE obj, VALUE *ff, VALUE *xx, VALUE *hh)
+{
+  switch (TYPE(obj)) {
+  case T_MODULE:
+  case T_CLASS:
+  case T_OBJECT:
+    if (argc == 3) {
+      CHECK_FUNCTION(argv[0]);
+      Need_Float(argv[2]);
+      *ff = argv[0];
+      *xx = argv[1];
+      *hh = argv[2];
+    } else if (argc == 2) {
+      CHECK_FUNCTION(argv[0]);
+      *ff = argv[0];
+      *xx = argv[1];
+      *hh = rb_float_new(RB_GSL_DERIV_H_DEFAULT);
+    } else {
+      rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc);
+    }
+    break;
+  default:
+    if (argc == 2) {
+      Need_Float(argv[1]);
+      *ff = obj;
+      *xx = argv[0];
+      *hh = argv[1];
+    } else if (argc == 1) {
+      *ff = obj;
+      *xx = argv[0];
+      *hh = rb_float_new(RB_GSL_DERIV_H_DEFAULT);
+    } else {
+      rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc);
+    }
+    break;
+  }
+  return 0;
+}
+
+#ifdef RB_GSL_DERIV_H_DEFAULT
+#undef RB_GSL_DERIV_H_DEFAULT
+#endif
+
+static VALUE rb_gsl_deriv_eval(VALUE obj, VALUE xx, VALUE hh, 
+			       int (*deriv)(const gsl_function *, 
+					    double, double,
+					    double *, double *))
+{
+  gsl_function *f = NULL;
+  double result, abserr, h;
+  VALUE x, ary, aerr;
+  gsl_vector *v = NULL, *vnew = NULL, *verr = NULL;
+  gsl_matrix *m = NULL, *mnew = NULL, *merr = NULL;
+  size_t n, i, j;
+  int status;
+#ifdef HAVE_NARRAY_H
+  struct NARRAY *na;
+  double *ptr1, *ptr2, *ptr3;
+  VALUE ary2, ary3;
+#endif
+  Need_Float(hh);
+  Data_Get_Struct(obj, gsl_function, f);
+  h = NUM2DBL(hh);
+  if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
+  switch (TYPE(xx)) {
+  case T_FIXNUM:
+  case T_BIGNUM:
+  case T_FLOAT:
+    status = (*deriv)(f, NUM2DBL(xx), h, &result, &abserr);
+    return rb_ary_new3(3, rb_float_new(result), rb_float_new(abserr), INT2FIX(status));
+    break;
+  case T_ARRAY:
+    n = RARRAY(xx)->len;
+    ary = rb_ary_new2(n);
+    aerr = rb_ary_new2(n);
+    for (i = 0; i < n; i++) {
+      x = rb_ary_entry(xx, i);
+      Need_Float(x);
+      (*deriv)(f, NUM2DBL(x), h, &result, &abserr);
+      rb_ary_store(ary, i, rb_float_new(result));
+      rb_ary_store(aerr, i, rb_float_new(abserr));
+    }
+    return rb_ary_new3(2, ary, aerr);
+    break;
+  default:
+#ifdef HAVE_NARRAY_H
+    if (NA_IsNArray(xx)) {
+      GetNArray(xx, na);
+      n = na->total;
+      ptr1 = (double*) na->ptr;
+      ary2 = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx));
+      ary3 = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx));
+      ptr2 = NA_PTR_TYPE(ary2, double*);
+      ptr3 = NA_PTR_TYPE(ary3, double*);
+      for (i = 0; i < n; i++) {
+	(*deriv)(f, ptr1[i], h, &result, &abserr);	
+	ptr2[i] = result;
+	ptr3[i] = abserr;
+      }
+      return rb_ary_new3(2, ary2, ary3);
+    }
+#endif
+    if (VECTOR_P(xx)) {
+      Data_Get_Struct(xx, gsl_vector, v);
+      vnew = gsl_vector_alloc(v->size);
+      verr = gsl_vector_alloc(v->size);
+      for (i = 0; i < v->size; i++) {
+	(*deriv)(f, gsl_vector_get(v, i), h, &result, &abserr);	
+	gsl_vector_set(vnew, i, result);
+	gsl_vector_set(verr, i, abserr);
+      }
+      return rb_ary_new3(2,
+			 Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew),
+			 Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, verr));
+    } else if (MATRIX_P(xx)) {
+      Data_Get_Struct(xx, gsl_matrix, m);
+      mnew = gsl_matrix_alloc(m->size1, m->size2);
+      merr = gsl_matrix_alloc(m->size1, m->size2);
+      for (i = 0; i < m->size1; i++) {
+	for (j = 0; j < m->size2; j++) {
+	  (*deriv)(f, gsl_matrix_get(m, i, j), h, &result, &abserr);	
+	  gsl_matrix_set(mnew, i, j, result);
+	  gsl_matrix_set(merr, i, j, abserr);
+	}
+      }
+      return rb_ary_new3(2,
+			 Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew),
+			 Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, merr));
+    } else {
+      rb_raise(rb_eTypeError, "wrong argument type");
+    }
+    break;
+  }
+  return Qnil; /* never reach here */
+}
+
+static VALUE rb_gsl_deriv_central(int argc, VALUE *argv, VALUE obj)
+{
+  VALUE ff, xx, hh;
+  get_func2(argc, argv, obj, &ff, &xx, &hh);
+  return rb_gsl_deriv_eval(ff, xx, hh, gsl_deriv_central);
+}
+
+static VALUE rb_gsl_deriv_forward(int argc, VALUE *argv, VALUE obj)
+{
+  VALUE ff, xx, hh;
+  get_func2(argc, argv, obj, &ff, &xx, &hh);
+  return rb_gsl_deriv_eval(ff, xx, hh, gsl_deriv_forward);
+}
+
+static VALUE rb_gsl_deriv_backward(int argc, VALUE *argv, VALUE obj)
+{
+  VALUE ff, xx, hh;
+  get_func2(argc, argv, obj, &ff, &xx, &hh);
+  return rb_gsl_deriv_eval(ff, xx, hh, gsl_deriv_backward);
+}
+
+void Init_gsl_deriv(VALUE module)
+{
+  VALUE mgsl_deriv;
+
+  mgsl_deriv = rb_define_module_under(module, "Deriv");
+
+  rb_define_method(cgsl_function, "deriv_central", rb_gsl_deriv_central, -1);
+  rb_define_method(cgsl_function, "deriv_forward", rb_gsl_deriv_forward, -1);
+  rb_define_method(cgsl_function, "deriv_backward", rb_gsl_deriv_backward, -1);
+
+  rb_define_singleton_method(mgsl_deriv, "central", rb_gsl_deriv_central, -1);
+  rb_define_singleton_method(mgsl_deriv, "forward", rb_gsl_deriv_forward, -1);
+  rb_define_singleton_method(mgsl_deriv, "backward", rb_gsl_deriv_backward, -1);
+}
+
+#endif