numo-gsl-integration 0.1.0 → 0.3.0

data/ext/numo/gsl/integration/fixed.c

@@ -0,0 +1,163 @@
+#include "integration_internal.h"
+typedef struct {
+  gsl_function *function;
+  const gsl_integration_fixed_type *type;
+  size_t order;
+  double a;
+  double b;
+  double alpha;
+  double beta;
+  gsl_integration_fixed_workspace *workspace;
+  double *result;
+} integration_fixed_params;
+static const gsl_integration_fixed_type *integration_fixed_type(VALUE type) {
+  ID type_id;
+  if (!RB_TYPE_P(type, T_SYMBOL)) {
+    rb_raise(rb_eTypeError, "type must be a Symbol");
+  }
+  type_id = SYM2ID(type);
+  if (type_id == rb_intern("legendre")) {
+    return gsl_integration_fixed_legendre;
+  }
+  if (type_id == rb_intern("chebyshev")) {
+    return gsl_integration_fixed_chebyshev;
+  }
+  if (type_id == rb_intern("chebyshev2")) {
+    return gsl_integration_fixed_chebyshev2;
+  }
+  if (type_id == rb_intern("gegenbauer")) {
+    return gsl_integration_fixed_gegenbauer;
+  }
+  if (type_id == rb_intern("jacobi")) {
+    return gsl_integration_fixed_jacobi;
+  }
+  if (type_id == rb_intern("laguerre")) {
+    return gsl_integration_fixed_laguerre;
+  }
+  if (type_id == rb_intern("hermite")) {
+    return gsl_integration_fixed_hermite;
+  }
+  if (type_id == rb_intern("exponential")) {
+    return gsl_integration_fixed_exponential;
+  }
+  if (type_id == rb_intern("rational")) {
+    return gsl_integration_fixed_rational;
+  }
+  rb_raise(rb_eArgError, "unsupported fixed quadrature type: %s",
+           rb_id2name(type_id));
+}
+static VALUE integration_free_fixed_workspace(VALUE data) {
+  integration_fixed_params *params = (integration_fixed_params *)data;
+  if (params->workspace != NULL) {
+    gsl_integration_fixed_free(params->workspace);
+  }
+  return Qnil;
+}
+static VALUE integration_run_fixed(VALUE data) {
+  integration_fixed_params *params = (integration_fixed_params *)data;
+  params->workspace =
+      gsl_integration_fixed_alloc(params->type, params->order, params->a,
+                                  params->b, params->alpha, params->beta);
+  if (params->workspace == NULL) {
+    rb_memerror();
+  }
+  (void)gsl_integration_fixed(params->function, params->result,
+                              params->workspace);
+  return Qnil;
+}
+static VALUE integration_run_fixed_with_workspace(VALUE data) {
+  return rb_ensure(integration_run_fixed, data,
+                   integration_free_fixed_workspace, data);
+}
+VALUE integration_fixed(int argc, VALUE *argv, VALUE self) {
+  VALUE type;
+  VALUE options;
+  ID keywords[] = {rb_intern("order"), rb_intern("a"), rb_intern("b"),
+                   rb_intern("alpha"), rb_intern("beta")};
+  VALUE keyword_values[5];
+  VALUE order_value;
+  VALUE alpha_value;
+  VALUE beta_value;
+  size_t order;
+  gsl_function function;
+  integration_callback_params params;
+  integration_fixed_params fixed_params;
+  double result;
+  int state = 0;
+  (void)self;
+  rb_scan_args(argc, argv, "1:", &type, &options);
+  fixed_params.type = integration_fixed_type(type);
+  if (NIL_P(options)) {
+    options = rb_hash_new();
+  }
+  rb_get_kwargs(options, keywords, 3, 2, keyword_values);
+  order_value = keyword_values[0];
+  alpha_value = keyword_values[3];
+  beta_value = keyword_values[4];
+  if (!RB_INTEGER_TYPE_P(order_value)) {
+    rb_raise(rb_eTypeError, "order must be an Integer");
+  }
+  if (RTEST(rb_funcall(order_value, rb_intern("<="), 1, INT2FIX(0)))) {
+    rb_raise(rb_eArgError, "order must be positive");
+  }
+  order = NUM2SIZET(order_value);
+  integration_function_init(&function, &params);
+  fixed_params.function = &function;
+  fixed_params.order = order;
+  fixed_params.a = NUM2DBL(keyword_values[1]);
+  fixed_params.b = NUM2DBL(keyword_values[2]);
+  if (fixed_params.type == gsl_integration_fixed_gegenbauer) {
+    if (alpha_value == Qundef) {
+      rb_raise(rb_eArgError, "alpha is required for gegenbauer");
+    }
+    fixed_params.alpha = NUM2DBL(alpha_value);
+    fixed_params.beta = 0.0;
+  } else if (fixed_params.type == gsl_integration_fixed_jacobi) {
+    if (alpha_value == Qundef) {
+      rb_raise(rb_eArgError, "alpha is required for jacobi");
+    }
+    if (beta_value == Qundef) {
+      rb_raise(rb_eArgError, "beta is required for jacobi");
+    }
+    fixed_params.alpha = NUM2DBL(alpha_value);
+    fixed_params.beta = NUM2DBL(beta_value);
+  } else if (fixed_params.type == gsl_integration_fixed_laguerre) {
+    if (alpha_value == Qundef) {
+      rb_raise(rb_eArgError, "alpha is required for laguerre");
+    }
+    fixed_params.alpha = NUM2DBL(alpha_value);
+    fixed_params.beta = 0.0;
+  } else if (fixed_params.type == gsl_integration_fixed_hermite) {
+    if (alpha_value == Qundef) {
+      rb_raise(rb_eArgError, "alpha is required for hermite");
+    }
+    fixed_params.alpha = NUM2DBL(alpha_value);
+    fixed_params.beta = 0.0;
+  } else if (fixed_params.type == gsl_integration_fixed_exponential) {
+    if (alpha_value == Qundef) {
+      rb_raise(rb_eArgError, "alpha is required for exponential");
+    }
+    fixed_params.alpha = NUM2DBL(alpha_value);
+    fixed_params.beta = 0.0;
+  } else if (fixed_params.type == gsl_integration_fixed_rational) {
+    if (alpha_value == Qundef) {
+      rb_raise(rb_eArgError, "alpha is required for rational");
+    }
+    if (beta_value == Qundef) {
+      rb_raise(rb_eArgError, "beta is required for rational");
+    }
+    fixed_params.alpha = NUM2DBL(alpha_value);
+    fixed_params.beta = NUM2DBL(beta_value);
+  } else {
+    fixed_params.alpha = 0.0;
+    fixed_params.beta = 0.0;
+  }
+  fixed_params.workspace = NULL;
+  fixed_params.result = &result;
+  rb_protect(integration_run_fixed_with_workspace, (VALUE)&fixed_params,
+             &state);
+  RB_GC_GUARD(params.block);
+  RB_GC_GUARD(params.exception);
+  integration_finish_callback(&params, state);
+  return DBL2NUM(result);
+}

data/ext/numo/gsl/integration/glfixed.c

@@ -48,9 +48,18 @@ VALUE integration_glfixed(int argc, VALUE *argv, VALUE self) {
     order_value = keyword_values[0];
   }
 
-  order = order_value == Qundef ? 10 : NUM2SIZET(order_value);
-  if (order == 0) {
-    rb_raise(integration_error_class(), "order must be positive");
+  if (order_value == Qundef) {
+    order = 10;
+  } else {
+    if (!RB_INTEGER_TYPE_P(order_value)) {
+      rb_raise(rb_eTypeError, "order must be an Integer");
+    }
+
+    if (RTEST(rb_funcall(order_value, rb_intern("<="), 1, INT2FIX(0)))) {
+      rb_raise(rb_eArgError, "order must be positive");
+    }
+
+    order = NUM2SIZET(order_value);
   }
 
   integration_function_init(&function, &params);
@@ -59,7 +68,9 @@ VALUE integration_glfixed(int argc, VALUE *argv, VALUE self) {
   glfixed_params.a = NUM2DBL(a);
   glfixed_params.b = NUM2DBL(b);
   glfixed_params.order = order;
+
   glfixed_params.table = gsl_integration_glfixed_table_alloc(order);
+
   glfixed_params.result = &result;
 
   rb_protect(integration_run_glfixed_with_table, (VALUE)&glfixed_params,

data/ext/numo/gsl/integration/integration.c

@@ -1,5 +1,14 @@
 #include "integration_internal.h"
 
+static VALUE numo_eGslError;
+
+static _Noreturn void integration_gsl_error_handler(const char *reason,
+                                                    const char *file, int line,
+                                                    int gsl_errno) {
+  rb_raise(numo_eGslError, "%s:%d: %s (GSL error %d)", file, line, reason,
+           gsl_errno);
+}
+
 void Init_integration(void) {
   VALUE mNumo;
   VALUE mGSL;
@@ -8,6 +17,8 @@ void Init_integration(void) {
   mNumo = rb_define_module("Numo");
   mGSL = rb_define_module_under(mNumo, "GSL");
   mIntegration = rb_define_module_under(mGSL, "Integration");
+  numo_eGslError = rb_define_class_under(mGSL, "GslError", rb_eStandardError);
+  gsl_set_error_handler(&integration_gsl_error_handler);
 
   rb_define_const(mIntegration, "GAUSS15", INT2NUM(GSL_INTEG_GAUSS15));
   rb_define_const(mIntegration, "GAUSS21", INT2NUM(GSL_INTEG_GAUSS21));
@@ -32,4 +43,5 @@ void Init_integration(void) {
   rb_define_singleton_method(mIntegration, "cquad", integration_cquad, -1);
   rb_define_singleton_method(mIntegration, "romberg", integration_romberg, -1);
   rb_define_singleton_method(mIntegration, "glfixed", integration_glfixed, -1);
+  rb_define_singleton_method(mIntegration, "fixed", integration_fixed, -1);
 }

data/ext/numo/gsl/integration/integration_internal.h

@@ -1,6 +1,7 @@
 #ifndef NUMO_GSL_INTEGRATION_INTERNAL_H
 #define NUMO_GSL_INTEGRATION_INTERNAL_H
 
+#include <gsl/gsl_errno.h>
 #include <gsl/gsl_integration.h>
 #include <ruby.h>
 
@@ -28,7 +29,7 @@ double integration_callback(double x, void *data);
 void integration_raise_callback_exception(integration_callback_params *params);
 void integration_finish_callback(integration_callback_params *params,
                                  int state);
-VALUE integration_error_class(void);
+
 VALUE integration_free_workspace(VALUE data);
 VALUE integration_free_cquad_workspace(VALUE data);
 VALUE integration_free_romberg_workspace(VALUE data);
@@ -48,5 +49,6 @@ VALUE integration_qawf(int argc, VALUE *argv, VALUE self);
 VALUE integration_cquad(int argc, VALUE *argv, VALUE self);
 VALUE integration_romberg(int argc, VALUE *argv, VALUE self);
 VALUE integration_glfixed(int argc, VALUE *argv, VALUE self);
+VALUE integration_fixed(int argc, VALUE *argv, VALUE self);
 
 #endif

data/ext/numo/gsl/integration/qagi.c

@@ -46,6 +46,7 @@ VALUE integration_qagi(int argc, VALUE *argv, VALUE self) {
   rb_scan_args(argc, argv, "0:", &options);
 
   integration_options_parse(options, &parsed_options, 0.0, 1e-8, 1000);
+
   epsabs = parsed_options.epsabs;
   epsrel = parsed_options.epsrel;
   limit = parsed_options.limit;

data/ext/numo/gsl/integration/qagil.c

@@ -13,14 +13,17 @@ typedef struct {
 
 static VALUE integration_run_qagil(VALUE data) {
   integration_qagil_params *params = (integration_qagil_params *)data;
+
   (void)gsl_integration_qagil(params->function, params->b, params->epsabs,
                               params->epsrel, params->limit, params->workspace,
                               params->result, params->error);
+
   return Qnil;
 }
 
 static VALUE integration_run_qagil_with_workspace(VALUE data) {
   integration_qagil_params *params = (integration_qagil_params *)data;
+
   return rb_ensure(integration_run_qagil, data, integration_free_workspace,
                    (VALUE)params->workspace);
 }
@@ -39,11 +42,13 @@ VALUE integration_qagil(int argc, VALUE *argv, VALUE self) {
   double result;
   double error;
   int state = 0;
+
   (void)self;
 
   rb_scan_args(argc, argv, "1:", &b, &options);
 
   integration_options_parse(options, &parsed_options, 0.0, 1e-8, 1000);
+
   epsabs = parsed_options.epsabs;
   epsrel = parsed_options.epsrel;
   limit = parsed_options.limit;
@@ -51,6 +56,7 @@ VALUE integration_qagil(int argc, VALUE *argv, VALUE self) {
   integration_function_init(&function, &params);
 
   workspace = gsl_integration_workspace_alloc(limit);
+
   qagil_params.function = &function;
   qagil_params.b = NUM2DBL(b);
   qagil_params.epsabs = epsabs;
@@ -62,8 +68,10 @@ VALUE integration_qagil(int argc, VALUE *argv, VALUE self) {
 
   rb_protect(integration_run_qagil_with_workspace, (VALUE)&qagil_params,
              &state);
+
   RB_GC_GUARD(params.block);
   RB_GC_GUARD(params.exception);
+
   integration_finish_callback(&params, state);
 
   return rb_ary_new_from_args(2, DBL2NUM(result), DBL2NUM(error));

data/ext/numo/gsl/integration/qagiu.c

@@ -13,14 +13,17 @@ typedef struct {
 
 static VALUE integration_run_qagiu(VALUE data) {
   integration_qagiu_params *params = (integration_qagiu_params *)data;
+
   (void)gsl_integration_qagiu(params->function, params->a, params->epsabs,
                               params->epsrel, params->limit, params->workspace,
                               params->result, params->error);
+
   return Qnil;
 }
 
 static VALUE integration_run_qagiu_with_workspace(VALUE data) {
   integration_qagiu_params *params = (integration_qagiu_params *)data;
+
   return rb_ensure(integration_run_qagiu, data, integration_free_workspace,
                    (VALUE)params->workspace);
 }
@@ -39,11 +42,13 @@ VALUE integration_qagiu(int argc, VALUE *argv, VALUE self) {
   double result;
   double error;
   int state = 0;
+
   (void)self;
 
   rb_scan_args(argc, argv, "1:", &a, &options);
 
   integration_options_parse(options, &parsed_options, 0.0, 1e-8, 1000);
+
   epsabs = parsed_options.epsabs;
   epsrel = parsed_options.epsrel;
   limit = parsed_options.limit;
@@ -51,6 +56,7 @@ VALUE integration_qagiu(int argc, VALUE *argv, VALUE self) {
   integration_function_init(&function, &params);
 
   workspace = gsl_integration_workspace_alloc(limit);
+
   qagiu_params.function = &function;
   qagiu_params.a = NUM2DBL(a);
   qagiu_params.epsabs = epsabs;
@@ -62,8 +68,10 @@ VALUE integration_qagiu(int argc, VALUE *argv, VALUE self) {
 
   rb_protect(integration_run_qagiu_with_workspace, (VALUE)&qagiu_params,
              &state);
+
   RB_GC_GUARD(params.block);
   RB_GC_GUARD(params.exception);
+
   integration_finish_callback(&params, state);
 
   return rb_ary_new_from_args(2, DBL2NUM(result), DBL2NUM(error));

data/ext/numo/gsl/integration/qagp.c

@@ -1,5 +1,4 @@
 #include "integration_internal.h"
-
 #include <math.h>
 
 typedef struct {
@@ -21,13 +20,13 @@ static void integration_validate_qagp_points(VALUE points) {
   double previous = 0.0;
 
   if (!RB_TYPE_P(points, T_ARRAY)) {
-    rb_raise(integration_error_class(), "points must be an Array");
+    rb_raise(rb_eTypeError, "points must be an Array");
   }
 
   point_count = RARRAY_LEN(points);
+
   if (point_count < 2) {
-    rb_raise(integration_error_class(),
-             "points must contain at least two values");
+    rb_raise(rb_eArgError, "points must contain at least two values");
   }
 
   for (index = 0; index < point_count; index++) {
@@ -35,18 +34,17 @@ static void integration_validate_qagp_points(VALUE points) {
     double current;
 
     if (!rb_obj_is_kind_of(point, rb_cNumeric)) {
-      rb_raise(integration_error_class(),
-               "points must contain only numeric values");
+      rb_raise(rb_eTypeError, "points must contain only numeric values");
     }
 
     current = NUM2DBL(point);
+
     if (!isfinite(current)) {
-      rb_raise(integration_error_class(),
-               "points must contain only finite values");
+      rb_raise(rb_eArgError, "points must contain only finite values");
     }
 
     if (index > 0 && !(previous < current)) {
-      rb_raise(integration_error_class(), "points must be strictly increasing");
+      rb_raise(rb_eArgError, "points must be strictly increasing");
     }
 
     previous = current;
@@ -58,15 +56,19 @@ static VALUE integration_run_qagp(VALUE data) {
   size_t index;
 
   params->points = ALLOC_N(double, params->point_count);
+
   for (index = 0; index < params->point_count; index++) {
     params->points[index] =
         NUM2DBL(rb_ary_entry(params->points_array, (long)index));
   }
+
   params->workspace = gsl_integration_workspace_alloc(params->limit);
+
   (void)gsl_integration_qagp(params->function, params->points,
                              params->point_count, params->epsabs,
                              params->epsrel, params->limit, params->workspace,
                              params->result, params->error);
+
   return Qnil;
 }
 
@@ -76,9 +78,11 @@ static VALUE integration_free_qagp_resources(VALUE data) {
   if (params->workspace != NULL) {
     gsl_integration_workspace_free(params->workspace);
   }
+
   if (params->points != NULL) {
     xfree(params->points);
   }
+
   return Qnil;
 }
 
@@ -102,14 +106,19 @@ VALUE integration_qagp(int argc, VALUE *argv, VALUE self) {
   int state = 0;
 
   (void)self;
+
   rb_scan_args(argc, argv, "1:", &points, &options);
 
   integration_validate_qagp_points(points);
+
   integration_options_parse(options, &parsed_options, 0.0, 1e-8, 1000);
+
   epsabs = parsed_options.epsabs;
   epsrel = parsed_options.epsrel;
   limit = parsed_options.limit;
+
   integration_function_init(&function, &params);
+
   qagp_params.points_array = points;
   qagp_params.function = &function;
   qagp_params.points = NULL;
@@ -120,10 +129,13 @@ VALUE integration_qagp(int argc, VALUE *argv, VALUE self) {
   qagp_params.workspace = NULL;
   qagp_params.result = &result;
   qagp_params.error = &error;
+
   rb_protect(integration_run_qagp_with_resources, (VALUE)&qagp_params, &state);
+
   RB_GC_GUARD(points);
   RB_GC_GUARD(params.block);
   RB_GC_GUARD(params.exception);
+
   integration_finish_callback(&params, state);
 
   return rb_ary_new_from_args(2, DBL2NUM(result), DBL2NUM(error));

data/ext/numo/gsl/integration/qags.c

@@ -50,6 +50,7 @@ VALUE integration_qags(int argc, VALUE *argv, VALUE self) {
   rb_scan_args(argc, argv, "2:", &a, &b, &options);
 
   integration_options_parse(options, &parsed_options, 0.0, 1e-8, 1000);
+
   epsabs = parsed_options.epsabs;
   epsrel = parsed_options.epsrel;
   limit = parsed_options.limit;

data/ext/numo/gsl/integration/qawc.c

@@ -15,14 +15,17 @@ typedef struct {
 
 static VALUE integration_run_qawc(VALUE data) {
   integration_qawc_params *params = (integration_qawc_params *)data;
+
   (void)gsl_integration_qawc(params->function, params->a, params->b, params->c,
                              params->epsabs, params->epsrel, params->limit,
                              params->workspace, params->result, params->error);
+
   return Qnil;
 }
 
 static VALUE integration_run_qawc_with_workspace(VALUE data) {
   integration_qawc_params *params = (integration_qawc_params *)data;
+
   return rb_ensure(integration_run_qawc, data, integration_free_workspace,
                    (VALUE)params->workspace);
 }
@@ -43,11 +46,13 @@ VALUE integration_qawc(int argc, VALUE *argv, VALUE self) {
   double result;
   double error;
   int state = 0;
+
   (void)self;
 
   rb_scan_args(argc, argv, "3:", &a, &b, &c, &options);
 
   integration_options_parse(options, &parsed_options, 0.0, 1e-8, 1000);
+
   epsabs = parsed_options.epsabs;
   epsrel = parsed_options.epsrel;
   limit = parsed_options.limit;
@@ -55,6 +60,7 @@ VALUE integration_qawc(int argc, VALUE *argv, VALUE self) {
   integration_function_init(&function, &params);
 
   workspace = gsl_integration_workspace_alloc(limit);
+
   qawc_params.function = &function;
   qawc_params.a = NUM2DBL(a);
   qawc_params.b = NUM2DBL(b);
@@ -67,8 +73,10 @@ VALUE integration_qawc(int argc, VALUE *argv, VALUE self) {
   qawc_params.error = &error;
 
   rb_protect(integration_run_qawc_with_workspace, (VALUE)&qawc_params, &state);
+
   RB_GC_GUARD(params.block);
   RB_GC_GUARD(params.exception);
+
   integration_finish_callback(&params, state);
 
   return rb_ary_new_from_args(2, DBL2NUM(result), DBL2NUM(error));

data/ext/numo/gsl/integration/qawf.c

@@ -4,6 +4,7 @@ typedef struct {
   gsl_function *function;
   double a;
   double omega;
+
   enum gsl_integration_qawo_enum sine;
   double epsabs;
   size_t limit;
@@ -20,9 +21,11 @@ static VALUE integration_free_qawf_resources(VALUE data) {
   if (params->table != NULL) {
     gsl_integration_qawo_table_free(params->table);
   }
+
   if (params->cycle_workspace != NULL) {
     gsl_integration_workspace_free(params->cycle_workspace);
   }
+
   if (params->workspace != NULL) {
     gsl_integration_workspace_free(params->workspace);
   }

data/ext/numo/gsl/integration/qawo.c

@@ -5,6 +5,7 @@ typedef struct {
   double a;
   double b;
   double omega;
+
   enum gsl_integration_qawo_enum sine;
   double epsabs;
   double epsrel;
@@ -21,6 +22,7 @@ static VALUE integration_free_qawo_resources(VALUE data) {
   if (params->table != NULL) {
     gsl_integration_qawo_table_free(params->table);
   }
+
   if (params->workspace != NULL) {
     gsl_integration_workspace_free(params->workspace);
   }
@@ -69,6 +71,7 @@ VALUE integration_qawo(int argc, VALUE *argv, VALUE self) {
   rb_scan_args(argc, argv, "4:", &a, &b, &omega, &sine, &options);
 
   integration_options_parse(options, &parsed_options, 0.0, 1e-8, 1000);
+
   epsabs = parsed_options.epsabs;
   epsrel = parsed_options.epsrel;
   limit = parsed_options.limit;

data/ext/numo/gsl/integration/qaws.c

@@ -23,6 +23,7 @@ static VALUE integration_free_qaws_resources(VALUE data) {
   if (params->table != NULL) {
     gsl_integration_qaws_table_free(params->table);
   }
+
   if (params->workspace != NULL) {
     gsl_integration_workspace_free(params->workspace);
   }
@@ -36,6 +37,7 @@ static VALUE integration_run_qaws(VALUE data) {
   params->table = gsl_integration_qaws_table_alloc(params->alpha, params->beta,
                                                    params->mu, params->nu);
   params->workspace = gsl_integration_workspace_alloc(params->limit);
+
   (void)gsl_integration_qaws(params->function, params->a, params->b,
                              params->table, params->epsabs, params->epsrel,
                              params->limit, params->workspace, params->result,
@@ -69,9 +71,11 @@ VALUE integration_qaws(int argc, VALUE *argv, VALUE self) {
   int state = 0;
 
   (void)self;
+
   rb_scan_args(argc, argv, "6:", &a, &b, &alpha, &beta, &mu, &nu, &options);
 
   integration_options_parse(options, &parsed_options, 0.0, 1e-8, 1000);
+
   epsabs = parsed_options.epsabs;
   epsrel = parsed_options.epsrel;
   limit = parsed_options.limit;
@@ -94,8 +98,10 @@ VALUE integration_qaws(int argc, VALUE *argv, VALUE self) {
   qaws_params.error = &error;
 
   rb_protect(integration_run_qaws_with_resources, (VALUE)&qaws_params, &state);
+
   RB_GC_GUARD(params.block);
   RB_GC_GUARD(params.exception);
+
   integration_finish_callback(&params, state);
 
   return rb_ary_new_from_args(2, DBL2NUM(result), DBL2NUM(error));

data/ext/numo/gsl/integration/romberg.c

@@ -50,6 +50,7 @@ VALUE integration_romberg(int argc, VALUE *argv, VALUE self) {
   rb_scan_args(argc, argv, "2:", &a, &b, &options);
 
   integration_options_parse(options, &parsed_options, 0.0, 1e-8, 20);
+
   epsabs = parsed_options.epsabs;
   epsrel = parsed_options.epsrel;
   limit = parsed_options.limit;

data/lib/numo/gsl/integration/version.rb

@@ -3,7 +3,7 @@
 module Numo
   module GSL
     module Integration
-      VERSION = "0.1.0"
+      VERSION = "0.3.0"
     end
   end
 end

data/lib/numo/gsl/integration.rb

@@ -1,15 +1,3 @@
 # frozen_string_literal: true
-
 require_relative "integration/version"
-require "numo/gsl"
-
-module Numo
-  module GSL
-    module Integration
-      class Error < Numo::GSL::GslError
-      end
-    end
-  end
-end
-
 require "numo/gsl/integration/integration"