numo-gsl-integration 0.1.0

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

@@ -0,0 +1,35 @@
+#include "integration_internal.h"
+
+void Init_integration(void) {
+  VALUE mNumo;
+  VALUE mGSL;
+  VALUE mIntegration;
+
+  mNumo = rb_define_module("Numo");
+  mGSL = rb_define_module_under(mNumo, "GSL");
+  mIntegration = rb_define_module_under(mGSL, "Integration");
+
+  rb_define_const(mIntegration, "GAUSS15", INT2NUM(GSL_INTEG_GAUSS15));
+  rb_define_const(mIntegration, "GAUSS21", INT2NUM(GSL_INTEG_GAUSS21));
+  rb_define_const(mIntegration, "GAUSS31", INT2NUM(GSL_INTEG_GAUSS31));
+  rb_define_const(mIntegration, "GAUSS41", INT2NUM(GSL_INTEG_GAUSS41));
+  rb_define_const(mIntegration, "GAUSS51", INT2NUM(GSL_INTEG_GAUSS51));
+  rb_define_const(mIntegration, "GAUSS61", INT2NUM(GSL_INTEG_GAUSS61));
+  rb_define_const(mIntegration, "COSINE", INT2NUM(GSL_INTEG_COSINE));
+  rb_define_const(mIntegration, "SINE", INT2NUM(GSL_INTEG_SINE));
+
+  rb_define_singleton_method(mIntegration, "qag", integration_qag, -1);
+  rb_define_singleton_method(mIntegration, "qng", integration_qng, -1);
+  rb_define_singleton_method(mIntegration, "qags", integration_qags, -1);
+  rb_define_singleton_method(mIntegration, "qagp", integration_qagp, -1);
+  rb_define_singleton_method(mIntegration, "qagi", integration_qagi, -1);
+  rb_define_singleton_method(mIntegration, "qagiu", integration_qagiu, -1);
+  rb_define_singleton_method(mIntegration, "qagil", integration_qagil, -1);
+  rb_define_singleton_method(mIntegration, "qawc", integration_qawc, -1);
+  rb_define_singleton_method(mIntegration, "qaws", integration_qaws, -1);
+  rb_define_singleton_method(mIntegration, "qawo", integration_qawo, -1);
+  rb_define_singleton_method(mIntegration, "qawf", integration_qawf, -1);
+  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);
+}

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

@@ -0,0 +1,52 @@
+#ifndef NUMO_GSL_INTEGRATION_INTERNAL_H
+#define NUMO_GSL_INTEGRATION_INTERNAL_H
+
+#include <gsl/gsl_integration.h>
+#include <ruby.h>
+
+typedef struct {
+  double epsabs;
+  double epsrel;
+  size_t limit;
+} integration_options;
+
+void integration_options_parse(VALUE options, integration_options *parsed,
+                               double default_epsabs, double default_epsrel,
+                               size_t default_limit);
+
+typedef struct {
+  VALUE block;
+  VALUE x;
+  VALUE exception;
+  int state;
+} integration_callback_params;
+
+void integration_callback_params_init(integration_callback_params *params);
+void integration_function_init(gsl_function *function,
+                               integration_callback_params *params);
+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);
+VALUE integration_free_glfixed_table(VALUE data);
+
+VALUE integration_qag(int argc, VALUE *argv, VALUE self);
+VALUE integration_qng(int argc, VALUE *argv, VALUE self);
+VALUE integration_qags(int argc, VALUE *argv, VALUE self);
+VALUE integration_qagp(int argc, VALUE *argv, VALUE self);
+VALUE integration_qagi(int argc, VALUE *argv, VALUE self);
+VALUE integration_qagiu(int argc, VALUE *argv, VALUE self);
+VALUE integration_qagil(int argc, VALUE *argv, VALUE self);
+VALUE integration_qawc(int argc, VALUE *argv, VALUE self);
+VALUE integration_qaws(int argc, VALUE *argv, VALUE self);
+VALUE integration_qawo(int argc, VALUE *argv, VALUE self);
+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);
+
+#endif

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

@@ -0,0 +1,26 @@
+#include "integration_internal.h"
+
+void integration_options_parse(VALUE options, integration_options *parsed,
+                               double default_epsabs, double default_epsrel,
+                               size_t default_limit) {
+  VALUE epsabs_value = Qundef;
+  VALUE epsrel_value = Qundef;
+  VALUE limit_value = Qundef;
+  ID keywords[] = {rb_intern("epsabs"), rb_intern("epsrel"),
+                   rb_intern("limit")};
+  VALUE keyword_values[3];
+
+  if (!NIL_P(options)) {
+    rb_get_kwargs(options, keywords, 0, 3, keyword_values);
+    epsabs_value = keyword_values[0];
+    epsrel_value = keyword_values[1];
+    limit_value = keyword_values[2];
+  }
+
+  parsed->epsabs =
+      epsabs_value == Qundef ? default_epsabs : NUM2DBL(epsabs_value);
+  parsed->epsrel =
+      epsrel_value == Qundef ? default_epsrel : NUM2DBL(epsrel_value);
+  parsed->limit =
+      limit_value == Qundef ? default_limit : NUM2SIZET(limit_value);
+}

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

@@ -0,0 +1,90 @@
+#include "integration_internal.h"
+
+typedef struct {
+  gsl_function *function;
+  double a;
+  double b;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  int key;
+  gsl_integration_workspace *workspace;
+  double *result;
+  double *error;
+} integration_qag_params;
+
+static VALUE integration_run_qag(VALUE data) {
+  integration_qag_params *params = (integration_qag_params *)data;
+
+  (void)gsl_integration_qag(params->function, params->a, params->b,
+                            params->epsabs, params->epsrel, params->limit,
+                            params->key, params->workspace, params->result,
+                            params->error);
+
+  return Qnil;
+}
+
+VALUE integration_qag(int argc, VALUE *argv, VALUE self) {
+  VALUE a;
+  VALUE b;
+  VALUE options;
+  VALUE epsabs_value = Qundef;
+  VALUE epsrel_value = Qundef;
+  VALUE limit_value = Qundef;
+  VALUE key_value = Qundef;
+  ID keywords[] = {rb_intern("epsabs"), rb_intern("epsrel"), rb_intern("limit"),
+                   rb_intern("key")};
+  VALUE keyword_values[4];
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  int key;
+  gsl_integration_workspace *workspace;
+  gsl_function function;
+  integration_callback_params params;
+  integration_qag_params qag_params;
+  double result;
+  double error;
+
+  (void)self;
+
+  rb_scan_args(argc, argv, "2:", &a, &b, &options);
+
+  if (!NIL_P(options)) {
+    rb_get_kwargs(options, keywords, 0, 4, keyword_values);
+    epsabs_value = keyword_values[0];
+    epsrel_value = keyword_values[1];
+    limit_value = keyword_values[2];
+    key_value = keyword_values[3];
+  }
+
+  epsabs = epsabs_value == Qundef ? 0.0 : NUM2DBL(epsabs_value);
+  epsrel = epsrel_value == Qundef ? 1e-8 : NUM2DBL(epsrel_value);
+  limit = limit_value == Qundef ? 1000 : NUM2SIZET(limit_value);
+  key = key_value == Qundef ? GSL_INTEG_GAUSS61 : NUM2INT(key_value);
+
+  integration_function_init(&function, &params);
+
+  workspace = gsl_integration_workspace_alloc(limit);
+
+  qag_params.function = &function;
+  qag_params.a = NUM2DBL(a);
+  qag_params.b = NUM2DBL(b);
+  qag_params.epsabs = epsabs;
+  qag_params.epsrel = epsrel;
+  qag_params.limit = limit;
+  qag_params.key = key;
+  qag_params.workspace = workspace;
+  qag_params.result = &result;
+  qag_params.error = &error;
+
+  rb_ensure(integration_run_qag, (VALUE)&qag_params, integration_free_workspace,
+            (VALUE)workspace);
+
+  RB_GC_GUARD(params.block);
+  RB_GC_GUARD(params.exception);
+
+  integration_finish_callback(&params, 0);
+
+  return rb_ary_new_from_args(2, DBL2NUM(result), DBL2NUM(error));
+}

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

@@ -0,0 +1,73 @@
+#include "integration_internal.h"
+
+typedef struct {
+  gsl_function *function;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  gsl_integration_workspace *workspace;
+  double *result;
+  double *error;
+} integration_qagi_params;
+
+static VALUE integration_run_qagi(VALUE data) {
+  integration_qagi_params *params = (integration_qagi_params *)data;
+
+  (void)gsl_integration_qagi(params->function, params->epsabs, params->epsrel,
+                             params->limit, params->workspace, params->result,
+                             params->error);
+
+  return Qnil;
+}
+
+static VALUE integration_run_qagi_with_workspace(VALUE data) {
+  integration_qagi_params *params = (integration_qagi_params *)data;
+
+  return rb_ensure(integration_run_qagi, data, integration_free_workspace,
+                   (VALUE)params->workspace);
+}
+
+VALUE integration_qagi(int argc, VALUE *argv, VALUE self) {
+  VALUE options;
+  integration_options parsed_options;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  gsl_integration_workspace *workspace;
+  gsl_function function;
+  integration_callback_params params;
+  integration_qagi_params qagi_params;
+  double result;
+  double error;
+  int state = 0;
+
+  (void)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;
+
+  integration_function_init(&function, &params);
+
+  workspace = gsl_integration_workspace_alloc(limit);
+
+  qagi_params.function = &function;
+  qagi_params.epsabs = epsabs;
+  qagi_params.epsrel = epsrel;
+  qagi_params.limit = limit;
+  qagi_params.workspace = workspace;
+  qagi_params.result = &result;
+  qagi_params.error = &error;
+
+  rb_protect(integration_run_qagi_with_workspace, (VALUE)&qagi_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/qagil.c

@@ -0,0 +1,70 @@
+#include "integration_internal.h"
+
+typedef struct {
+  gsl_function *function;
+  double b;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  gsl_integration_workspace *workspace;
+  double *result;
+  double *error;
+} integration_qagil_params;
+
+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);
+}
+
+VALUE integration_qagil(int argc, VALUE *argv, VALUE self) {
+  VALUE b;
+  VALUE options;
+  integration_options parsed_options;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  gsl_integration_workspace *workspace;
+  gsl_function function;
+  integration_callback_params params;
+  integration_qagil_params qagil_params;
+  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;
+
+  integration_function_init(&function, &params);
+
+  workspace = gsl_integration_workspace_alloc(limit);
+  qagil_params.function = &function;
+  qagil_params.b = NUM2DBL(b);
+  qagil_params.epsabs = epsabs;
+  qagil_params.epsrel = epsrel;
+  qagil_params.limit = limit;
+  qagil_params.workspace = workspace;
+  qagil_params.result = &result;
+  qagil_params.error = &error;
+
+  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

@@ -0,0 +1,70 @@
+#include "integration_internal.h"
+
+typedef struct {
+  gsl_function *function;
+  double a;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  gsl_integration_workspace *workspace;
+  double *result;
+  double *error;
+} integration_qagiu_params;
+
+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);
+}
+
+VALUE integration_qagiu(int argc, VALUE *argv, VALUE self) {
+  VALUE a;
+  VALUE options;
+  integration_options parsed_options;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  gsl_integration_workspace *workspace;
+  gsl_function function;
+  integration_callback_params params;
+  integration_qagiu_params qagiu_params;
+  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;
+
+  integration_function_init(&function, &params);
+
+  workspace = gsl_integration_workspace_alloc(limit);
+  qagiu_params.function = &function;
+  qagiu_params.a = NUM2DBL(a);
+  qagiu_params.epsabs = epsabs;
+  qagiu_params.epsrel = epsrel;
+  qagiu_params.limit = limit;
+  qagiu_params.workspace = workspace;
+  qagiu_params.result = &result;
+  qagiu_params.error = &error;
+
+  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

@@ -0,0 +1,130 @@
+#include "integration_internal.h"
+
+#include <math.h>
+
+typedef struct {
+  VALUE points_array;
+  gsl_function *function;
+  double *points;
+  size_t point_count;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  gsl_integration_workspace *workspace;
+  double *result;
+  double *error;
+} integration_qagp_params;
+
+static void integration_validate_qagp_points(VALUE points) {
+  long point_count;
+  long index;
+  double previous = 0.0;
+
+  if (!RB_TYPE_P(points, T_ARRAY)) {
+    rb_raise(integration_error_class(), "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");
+  }
+
+  for (index = 0; index < point_count; index++) {
+    VALUE point = rb_ary_entry(points, index);
+    double current;
+
+    if (!rb_obj_is_kind_of(point, rb_cNumeric)) {
+      rb_raise(integration_error_class(),
+               "points must contain only numeric values");
+    }
+
+    current = NUM2DBL(point);
+    if (!isfinite(current)) {
+      rb_raise(integration_error_class(),
+               "points must contain only finite values");
+    }
+
+    if (index > 0 && !(previous < current)) {
+      rb_raise(integration_error_class(), "points must be strictly increasing");
+    }
+
+    previous = current;
+  }
+}
+
+static VALUE integration_run_qagp(VALUE data) {
+  integration_qagp_params *params = (integration_qagp_params *)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;
+}
+
+static VALUE integration_free_qagp_resources(VALUE data) {
+  integration_qagp_params *params = (integration_qagp_params *)data;
+
+  if (params->workspace != NULL) {
+    gsl_integration_workspace_free(params->workspace);
+  }
+  if (params->points != NULL) {
+    xfree(params->points);
+  }
+  return Qnil;
+}
+
+static VALUE integration_run_qagp_with_resources(VALUE data) {
+  return rb_ensure(integration_run_qagp, data, integration_free_qagp_resources,
+                   data);
+}
+
+VALUE integration_qagp(int argc, VALUE *argv, VALUE self) {
+  VALUE points;
+  VALUE options;
+  integration_options parsed_options;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  gsl_function function;
+  integration_callback_params params;
+  integration_qagp_params qagp_params;
+  double result;
+  double error;
+  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;
+  qagp_params.point_count = (size_t)RARRAY_LEN(points);
+  qagp_params.epsabs = epsabs;
+  qagp_params.epsrel = epsrel;
+  qagp_params.limit = limit;
+  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

@@ -0,0 +1,79 @@
+#include "integration_internal.h"
+
+typedef struct {
+  gsl_function *function;
+  double a;
+  double b;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  gsl_integration_workspace *workspace;
+  double *result;
+  double *error;
+} integration_qags_params;
+
+static VALUE integration_run_qags(VALUE data) {
+  integration_qags_params *params = (integration_qags_params *)data;
+
+  (void)gsl_integration_qags(params->function, params->a, params->b,
+                             params->epsabs, params->epsrel, params->limit,
+                             params->workspace, params->result, params->error);
+
+  return Qnil;
+}
+
+static VALUE integration_run_qags_with_workspace(VALUE data) {
+  integration_qags_params *params = (integration_qags_params *)data;
+
+  return rb_ensure(integration_run_qags, data, integration_free_workspace,
+                   (VALUE)params->workspace);
+}
+
+VALUE integration_qags(int argc, VALUE *argv, VALUE self) {
+  VALUE a;
+  VALUE b;
+  VALUE options;
+  integration_options parsed_options;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  gsl_integration_workspace *workspace;
+  gsl_function function;
+  integration_callback_params params;
+  integration_qags_params qags_params;
+  double result;
+  double error;
+  int state = 0;
+
+  (void)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;
+
+  integration_function_init(&function, &params);
+
+  workspace = gsl_integration_workspace_alloc(limit);
+
+  qags_params.function = &function;
+  qags_params.a = NUM2DBL(a);
+  qags_params.b = NUM2DBL(b);
+  qags_params.epsabs = epsabs;
+  qags_params.epsrel = epsrel;
+  qags_params.limit = limit;
+  qags_params.workspace = workspace;
+  qags_params.result = &result;
+  qags_params.error = &error;
+
+  rb_protect(integration_run_qags_with_workspace, (VALUE)&qags_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));
+}