numo-gsl-integration 0.1.0

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

@@ -0,0 +1,75 @@
+#include "integration_internal.h"
+
+typedef struct {
+  gsl_function *function;
+  double a;
+  double b;
+  double c;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  gsl_integration_workspace *workspace;
+  double *result;
+  double *error;
+} integration_qawc_params;
+
+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);
+}
+
+VALUE integration_qawc(int argc, VALUE *argv, VALUE self) {
+  VALUE a;
+  VALUE b;
+  VALUE c;
+  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_qawc_params qawc_params;
+  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;
+
+  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);
+  qawc_params.c = NUM2DBL(c);
+  qawc_params.epsabs = epsabs;
+  qawc_params.epsrel = epsrel;
+  qawc_params.limit = limit;
+  qawc_params.workspace = workspace;
+  qawc_params.result = &result;
+  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

@@ -0,0 +1,107 @@
+#include "integration_internal.h"
+
+typedef struct {
+  gsl_function *function;
+  double a;
+  double omega;
+  enum gsl_integration_qawo_enum sine;
+  double epsabs;
+  size_t limit;
+  gsl_integration_workspace *workspace;
+  gsl_integration_workspace *cycle_workspace;
+  gsl_integration_qawo_table *table;
+  double *result;
+  double *error;
+} integration_qawf_params;
+
+static VALUE integration_free_qawf_resources(VALUE data) {
+  integration_qawf_params *params = (integration_qawf_params *)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);
+  }
+
+  return Qnil;
+}
+
+static VALUE integration_run_qawf(VALUE data) {
+  integration_qawf_params *params = (integration_qawf_params *)data;
+
+  params->table = gsl_integration_qawo_table_alloc(params->omega, 1.0,
+                                                   params->sine, params->limit);
+  params->workspace = gsl_integration_workspace_alloc(params->limit);
+  params->cycle_workspace = gsl_integration_workspace_alloc(params->limit);
+
+  (void)gsl_integration_qawf(params->function, params->a, params->epsabs,
+                             params->limit, params->workspace,
+                             params->cycle_workspace, params->table,
+                             params->result, params->error);
+
+  return Qnil;
+}
+
+static VALUE integration_run_qawf_with_resources(VALUE data) {
+  return rb_ensure(integration_run_qawf, data, integration_free_qawf_resources,
+                   data);
+}
+
+VALUE integration_qawf(int argc, VALUE *argv, VALUE self) {
+  VALUE a;
+  VALUE omega;
+  VALUE sine;
+  VALUE options;
+  VALUE epsabs_value = Qundef;
+  VALUE limit_value = Qundef;
+  ID keywords[] = {rb_intern("epsabs"), rb_intern("limit")};
+  VALUE keyword_values[2];
+  double epsabs;
+  size_t limit;
+  gsl_function function;
+  integration_callback_params params;
+  integration_qawf_params qawf_params;
+  double result;
+  double error;
+  int state = 0;
+
+  (void)self;
+
+  rb_scan_args(argc, argv, "3:", &a, &omega, &sine, &options);
+
+  if (!NIL_P(options)) {
+    rb_get_kwargs(options, keywords, 0, 2, keyword_values);
+    epsabs_value = keyword_values[0];
+    limit_value = keyword_values[1];
+  }
+
+  epsabs = epsabs_value == Qundef ? 1e-10 : NUM2DBL(epsabs_value);
+  limit = limit_value == Qundef ? 1000 : NUM2SIZET(limit_value);
+
+  integration_function_init(&function, &params);
+
+  qawf_params.function = &function;
+  qawf_params.a = NUM2DBL(a);
+  qawf_params.omega = NUM2DBL(omega);
+  qawf_params.sine = (enum gsl_integration_qawo_enum)NUM2INT(sine);
+  qawf_params.epsabs = epsabs;
+  qawf_params.limit = limit;
+  qawf_params.workspace = NULL;
+  qawf_params.cycle_workspace = NULL;
+  qawf_params.table = NULL;
+  qawf_params.result = &result;
+  qawf_params.error = &error;
+
+  rb_protect(integration_run_qawf_with_resources, (VALUE)&qawf_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/qawo.c

@@ -0,0 +1,99 @@
+#include "integration_internal.h"
+
+typedef struct {
+  gsl_function *function;
+  double a;
+  double b;
+  double omega;
+  enum gsl_integration_qawo_enum sine;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  gsl_integration_workspace *workspace;
+  gsl_integration_qawo_table *table;
+  double *result;
+  double *error;
+} integration_qawo_params;
+
+static VALUE integration_free_qawo_resources(VALUE data) {
+  integration_qawo_params *params = (integration_qawo_params *)data;
+
+  if (params->table != NULL) {
+    gsl_integration_qawo_table_free(params->table);
+  }
+  if (params->workspace != NULL) {
+    gsl_integration_workspace_free(params->workspace);
+  }
+
+  return Qnil;
+}
+
+static VALUE integration_run_qawo(VALUE data) {
+  integration_qawo_params *params = (integration_qawo_params *)data;
+
+  params->table = gsl_integration_qawo_table_alloc(
+      params->omega, params->b - params->a, params->sine, params->limit);
+  params->workspace = gsl_integration_workspace_alloc(params->limit);
+
+  (void)gsl_integration_qawo(params->function, params->a, params->epsabs,
+                             params->epsrel, params->limit, params->workspace,
+                             params->table, params->result, params->error);
+
+  return Qnil;
+}
+
+static VALUE integration_run_qawo_with_resources(VALUE data) {
+  return rb_ensure(integration_run_qawo, data, integration_free_qawo_resources,
+                   data);
+}
+
+VALUE integration_qawo(int argc, VALUE *argv, VALUE self) {
+  VALUE a;
+  VALUE b;
+  VALUE omega;
+  VALUE sine;
+  VALUE options;
+  integration_options parsed_options;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  gsl_function function;
+  integration_callback_params params;
+  integration_qawo_params qawo_params;
+  double result;
+  double error;
+  int state = 0;
+
+  (void)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;
+
+  integration_function_init(&function, &params);
+
+  qawo_params.function = &function;
+  qawo_params.a = NUM2DBL(a);
+  qawo_params.b = NUM2DBL(b);
+  qawo_params.omega = NUM2DBL(omega);
+  qawo_params.sine = (enum gsl_integration_qawo_enum)NUM2INT(sine);
+  qawo_params.epsabs = epsabs;
+  qawo_params.epsrel = epsrel;
+  qawo_params.limit = limit;
+  qawo_params.workspace = NULL;
+  qawo_params.table = NULL;
+  qawo_params.result = &result;
+  qawo_params.error = &error;
+
+  rb_protect(integration_run_qawo_with_resources, (VALUE)&qawo_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/qaws.c

@@ -0,0 +1,102 @@
+#include "integration_internal.h"
+
+typedef struct {
+  gsl_function *function;
+  double a;
+  double b;
+  double alpha;
+  double beta;
+  int mu;
+  int nu;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  gsl_integration_workspace *workspace;
+  gsl_integration_qaws_table *table;
+  double *result;
+  double *error;
+} integration_qaws_params;
+
+static VALUE integration_free_qaws_resources(VALUE data) {
+  integration_qaws_params *params = (integration_qaws_params *)data;
+
+  if (params->table != NULL) {
+    gsl_integration_qaws_table_free(params->table);
+  }
+  if (params->workspace != NULL) {
+    gsl_integration_workspace_free(params->workspace);
+  }
+
+  return Qnil;
+}
+
+static VALUE integration_run_qaws(VALUE data) {
+  integration_qaws_params *params = (integration_qaws_params *)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,
+                             params->error);
+
+  return Qnil;
+}
+
+static VALUE integration_run_qaws_with_resources(VALUE data) {
+  return rb_ensure(integration_run_qaws, data, integration_free_qaws_resources,
+                   data);
+}
+
+VALUE integration_qaws(int argc, VALUE *argv, VALUE self) {
+  VALUE a;
+  VALUE b;
+  VALUE alpha;
+  VALUE beta;
+  VALUE mu;
+  VALUE nu;
+  VALUE options;
+  integration_options parsed_options;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  gsl_function function;
+  integration_callback_params params;
+  integration_qaws_params qaws_params;
+  double result;
+  double error;
+  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;
+
+  integration_function_init(&function, &params);
+
+  qaws_params.function = &function;
+  qaws_params.a = NUM2DBL(a);
+  qaws_params.b = NUM2DBL(b);
+  qaws_params.alpha = NUM2DBL(alpha);
+  qaws_params.beta = NUM2DBL(beta);
+  qaws_params.mu = NUM2INT(mu);
+  qaws_params.nu = NUM2INT(nu);
+  qaws_params.epsabs = epsabs;
+  qaws_params.epsrel = epsrel;
+  qaws_params.limit = limit;
+  qaws_params.workspace = NULL;
+  qaws_params.table = NULL;
+  qaws_params.result = &result;
+  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/qng.c

@@ -0,0 +1,75 @@
+#include "integration_internal.h"
+
+typedef struct {
+  gsl_function *function;
+  double a;
+  double b;
+  double epsabs;
+  double epsrel;
+  double *result;
+  double *error;
+  size_t *evaluations;
+} integration_qng_params;
+
+static VALUE integration_run_qng(VALUE data) {
+  integration_qng_params *params = (integration_qng_params *)data;
+
+  (void)gsl_integration_qng(params->function, params->a, params->b,
+                            params->epsabs, params->epsrel, params->result,
+                            params->error, params->evaluations);
+
+  return Qnil;
+}
+
+VALUE integration_qng(int argc, VALUE *argv, VALUE self) {
+  VALUE a;
+  VALUE b;
+  VALUE options;
+  VALUE epsabs_value = Qundef;
+  VALUE epsrel_value = Qundef;
+  ID keywords[] = {rb_intern("epsabs"), rb_intern("epsrel")};
+  VALUE keyword_values[2];
+  double epsabs;
+  double epsrel;
+  gsl_function function;
+  integration_callback_params params;
+  integration_qng_params qng_params;
+  double result;
+  double error;
+  size_t evaluations;
+  int state = 0;
+
+  (void)self;
+
+  rb_scan_args(argc, argv, "2:", &a, &b, &options);
+
+  if (!NIL_P(options)) {
+    rb_get_kwargs(options, keywords, 0, 2, keyword_values);
+    epsabs_value = keyword_values[0];
+    epsrel_value = keyword_values[1];
+  }
+
+  epsabs = epsabs_value == Qundef ? 0.0 : NUM2DBL(epsabs_value);
+  epsrel = epsrel_value == Qundef ? 1e-8 : NUM2DBL(epsrel_value);
+
+  integration_function_init(&function, &params);
+
+  qng_params.function = &function;
+  qng_params.a = NUM2DBL(a);
+  qng_params.b = NUM2DBL(b);
+  qng_params.epsabs = epsabs;
+  qng_params.epsrel = epsrel;
+  qng_params.result = &result;
+  qng_params.error = &error;
+  qng_params.evaluations = &evaluations;
+
+  rb_protect(integration_run_qng, (VALUE)&qng_params, &state);
+
+  RB_GC_GUARD(params.block);
+  RB_GC_GUARD(params.exception);
+
+  integration_finish_callback(&params, state);
+
+  return rb_ary_new_from_args(3, DBL2NUM(result), DBL2NUM(error),
+                              SIZET2NUM(evaluations));
+}

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

@@ -0,0 +1,35 @@
+#include "integration_internal.h"
+
+VALUE integration_free_workspace(VALUE data) {
+  gsl_integration_workspace *workspace = (gsl_integration_workspace *)data;
+
+  gsl_integration_workspace_free(workspace);
+
+  return Qnil;
+}
+
+VALUE integration_free_cquad_workspace(VALUE data) {
+  gsl_integration_cquad_workspace *workspace =
+      (gsl_integration_cquad_workspace *)data;
+
+  gsl_integration_cquad_workspace_free(workspace);
+
+  return Qnil;
+}
+
+VALUE integration_free_romberg_workspace(VALUE data) {
+  gsl_integration_romberg_workspace *workspace =
+      (gsl_integration_romberg_workspace *)data;
+
+  gsl_integration_romberg_free(workspace);
+
+  return Qnil;
+}
+
+VALUE integration_free_glfixed_table(VALUE data) {
+  gsl_integration_glfixed_table *table = (gsl_integration_glfixed_table *)data;
+
+  gsl_integration_glfixed_table_free(table);
+
+  return Qnil;
+}

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

@@ -0,0 +1,79 @@
+#include "integration_internal.h"
+
+typedef struct {
+  gsl_function *function;
+  double a;
+  double b;
+  double epsabs;
+  double epsrel;
+  gsl_integration_romberg_workspace *workspace;
+  double *result;
+  size_t *evaluations;
+} integration_romberg_params;
+
+static VALUE integration_run_romberg(VALUE data) {
+  integration_romberg_params *params = (integration_romberg_params *)data;
+
+  (void)gsl_integration_romberg(params->function, params->a, params->b,
+                                params->epsabs, params->epsrel, params->result,
+                                params->evaluations, params->workspace);
+
+  return Qnil;
+}
+
+static VALUE integration_run_romberg_with_workspace(VALUE data) {
+  integration_romberg_params *params = (integration_romberg_params *)data;
+
+  return rb_ensure(integration_run_romberg, data,
+                   integration_free_romberg_workspace,
+                   (VALUE)params->workspace);
+}
+
+VALUE integration_romberg(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_romberg_workspace *workspace;
+  gsl_function function;
+  integration_callback_params params;
+  integration_romberg_params romberg_params;
+  double result;
+  size_t evaluations;
+  int state = 0;
+
+  (void)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;
+
+  integration_function_init(&function, &params);
+
+  workspace = gsl_integration_romberg_alloc(limit);
+
+  romberg_params.function = &function;
+  romberg_params.a = NUM2DBL(a);
+  romberg_params.b = NUM2DBL(b);
+  romberg_params.epsabs = epsabs;
+  romberg_params.epsrel = epsrel;
+  romberg_params.workspace = workspace;
+  romberg_params.result = &result;
+  romberg_params.evaluations = &evaluations;
+
+  rb_protect(integration_run_romberg_with_workspace, (VALUE)&romberg_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), SIZET2NUM(evaluations));
+}

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Numo
+  module GSL
+    module Integration
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/numo/gsl/integration.rb

@@ -0,0 +1,15 @@
+# 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"