numo-gsl-integration 0.1.0

data/README.md

@@ -0,0 +1,80 @@
+# Numo::GSL::Integration
+
+`numo-gsl-integration` provides numerical integration routines from the [GNU Scientific Library (GSL)](https://www.gnu.org/software/gsl/) under the `Numo::GSL::Integration` namespace. It depends on [`numo-gsl-alt`](https://github.com/mvz/numo-gsl-alt) for the `Numo::GSL` namespace and GSL error handling.
+
+## Requirements
+
+- [Ruby](https://www.ruby-lang.org/) 3.2 or later
+- GNU Scientific Library (GSL)
+- `gsl-config` available in `PATH`
+
+The `numo-gsl-alt` Ruby gem is installed as a runtime dependency. GSL itself must be installed separately.
+
+## Why numo-gsl-alt?
+
+This gem intentionally depends on [`numo-gsl-alt`](https://github.com/mvz/numo-gsl-alt) rather than [`numo-gsl`](https://github.com/ruby-numo/numo-gsl). The main reason is Ruby compatibility: `numo-gsl` 0.1.2 does not build with Ruby 4.0 because its generated native extension registers a three-argument C function as a one-argument Ruby method. Ruby 4.0 rejects that incompatible function-pointer type during compilation. `numo-gsl-integration` targets Ruby 3.2 or later and is developed and tested with `numo-gsl-alt` 0.1.x, including Ruby 4.0.
+
+## Installation
+
+Add the gem to your Gemfile:
+
+```ruby
+gem "numo-gsl-integration"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+The native extension uses `gsl-config` to locate the GSL headers and libraries.
+
+## Usage
+
+Load the library:
+
+```ruby
+require "numo/gsl/integration"
+```
+
+The entry point loads `numo/gsl` before the integration native extension. This ensures that `numo-gsl-alt` initializes the `Numo::GSL` namespace and installs its GSL error handler before integration routines are loaded.
+
+For example, use `qag` to integrate a function over a finite interval:
+
+```ruby
+result, error = Numo::GSL::Integration.qag(0.0, 1.0) do |x|
+  x * x
+end
+```
+
+## Supported routines
+
+| Method | Interval | Intended use |
+| --- | --- | --- |
+| `qag` | Finite | General-purpose adaptive integration |
+| `qng` | Finite | Non-adaptive integration of smooth functions |
+| `qags` | Finite | Functions with integrable singularities or discontinuities |
+| `qagp` | Finite | Known singular or discontinuity points |
+| `qagi` | Infinite | Integration over the entire real line |
+| `qagiu` | Semi-infinite | Integration from a finite lower bound to positive infinity |
+| `qagil` | Semi-infinite | Integration from negative infinity to a finite upper bound |
+| `qawc` | Finite | Cauchy principal value with a known singular point |
+| `qaws` | Finite | Algebraic and logarithmic endpoint singularities |
+| `qawo` | Finite | Sine- or cosine-weighted oscillatory integrals |
+| `qawf` | Semi-infinite | Sine- or cosine-weighted Fourier integrals |
+| `cquad` | Finite | Difficult integrands and endpoint singularities |
+| `romberg` | Finite | Smooth functions with extrapolated trapezoidal integration |
+| `glfixed` | Finite | Fixed-order Gauss–Legendre integration of smooth functions |
+
+See [Integration routines](docs/routines.md) for parameters and examples.
+
+## Documentation
+
+- [Integration routines](docs/routines.md)
+- [GSL error handling](docs/error-handling.md)
+- [Development](docs/development.md)
+
+## License
+
+This project is licensed under the [GNU General Public License version 3 or later](https://www.gnu.org/licenses/gpl-3.0.html). See the [LICENSE](LICENSE) file for the full license text.

data/docs/development.md

@@ -0,0 +1,49 @@
+# Development
+
+After checking out the repository, install the dependencies:
+
+```bash
+bundle install
+```
+
+Build the native extension and run the complete verification suite:
+
+```bash
+bundle exec rake
+```
+
+The default Rake task performs the following checks:
+
+- compiles the native extension;
+- runs the [RSpec](https://rspec.info/) suite;
+- runs [RuboCop](https://rubocop.org/);
+- validates RBS signatures;
+- checks Ruby files with [rubyfmt](https://github.com/fables-tales/rubyfmt);
+- checks C source files with `clang-format` using the LLVM style; and
+- checks `README.md` and `CHANGELOG.md` with `markdownlint-cli2`.
+
+Check source formatting without applying changes:
+
+```bash
+bundle exec rake format:check
+```
+
+Format the Ruby and C source files:
+
+```bash
+bundle exec rake format:apply
+```
+
+RuboCop is configured with `rubocop-rake`, `rubocop-rspec`, and `rubocop-rubyfmt`.
+
+## clangd
+
+To enable accurate code completion, navigation, and diagnostics when editing the native extension, generate a compilation database with [Bear](https://rizsotto.github.io/Bear/):
+
+```bash
+bear -- bundle exec rake clean compile
+```
+
+The compilation database provides `clangd` with the compiler options and Ruby and GSL header paths used to build each C source file. See the [clangd documentation](https://clangd.llvm.org/design/compile-commands) for details.
+
+The generated `compile_commands.json` contains paths specific to the local build environment and should not be committed. Regenerate it after changing the Ruby or GSL installation or other build settings.

data/docs/error-handling.md

@@ -0,0 +1,19 @@
+# GSL error handling
+
+`numo-gsl-alt` installs the process-wide GSL error handler that converts GSL errors to `Numo::GSL::GslError`. `numo-gsl-integration` neither replaces nor temporarily disables that handler.
+
+Errors reported by GSL are raised directly as `Numo::GSL::GslError` by the handler installed by `numo-gsl-alt`. `numo-gsl-integration` does not convert integration return statuses into separate exceptions.
+
+The workspaces used by QAG, QAGS, QAGP, QAGI, QAGIU, QAGIL, QAWC, QAWS, QAWO, QAWF, CQUAD, and Romberg are released when a call completes normally or raises an exception. QAWS, QAWO, and QAWF also release their weight tables, GLFIXED releases its Gauss–Legendre table, and QAGP releases its temporary copy of the point array.
+
+`Numo::GSL::Integration::Error` is reserved for validation or state errors detected by `numo-gsl-integration` itself. It inherits from `Numo::GSL::GslError`:
+
+```mermaid
+flowchart BT
+  IntegrationError["Numo::GSL::Integration::Error"] -->|inherits from| GslError["Numo::GSL::GslError"]
+  GslError -->|inherits from| StandardError
+```
+
+Code can rescue all GSL-related errors with `Numo::GSL::GslError`, or rescue `Numo::GSL::Integration::Error` when it needs to handle only errors detected by the integration wrapper.
+
+The GSL error handler is shared by the entire process. This gem leaves its ownership with `numo-gsl-alt` and does not switch the handler around individual integration calls.

data/docs/routines.md

@@ -0,0 +1,288 @@
+# Integration routines  
+Load the library before calling an integration routine:  
+```ruby  
+require "numo/gsl/integration"  
+```  
+Exceptions raised by an integrand are propagated to the caller. A non-numeric return value from an integrand raises `TypeError`.  
+## QAG integration  
+GSL [QAG](https://www.gnu.org/software/gsl/doc/html/integration.html#qag-adaptive-integration) provides adaptive integration over a finite interval. `Numo::GSL::Integration.qag` exposes this routine to Ruby and returns the integral and its estimated absolute error.  
+```ruby  
+result, error = Numo::GSL::Integration.qag(0.0, 1.0) do |x|  
+  x * x  
+end  
+```  
+Integration parameters can be specified with the `epsabs`, `epsrel`, `limit`, and `key` keyword arguments:  
+```ruby  
+result, error = Numo::GSL::Integration.qag(  
+  0.0,  
+  1.0,  
+  epsabs: 1e-12,  
+  epsrel: 1e-12,  
+  limit: 100,  
+  key: Numo::GSL::Integration::GAUSS21,  
+) do |x|  
+  x * x  
+end  
+```  
+The `key` keyword selects the Gauss-Kronrod integration rule and defaults to `GAUSS61`. The available values are `GAUSS15`, `GAUSS21`, `GAUSS31`, `GAUSS41`, `GAUSS51`, and `GAUSS61`.  
+## QNG integration  
+GSL [QNG](https://www.gnu.org/software/gsl/doc/html/integration.html#qng-non-adaptive-gauss-kronrod-integration) provides non-adaptive integration for smooth functions over a finite interval. It applies increasingly accurate Gauss-Kronrod-Patterson rules and evaluates the integrand at up to 87 points.  
+```ruby  
+result, error, evaluations = Numo::GSL::Integration.qng(0.0, 1.0) do |x|  
+  x * x  
+end  
+```  
+The return value contains the integral, its estimated absolute error, and the number of integrand evaluations. The `epsabs` and `epsrel` keyword arguments control the requested absolute and relative error limits:  
+```ruby  
+result, error, evaluations = Numo::GSL::Integration.qng(  
+  0.0,  
+  1.0,  
+  epsabs: 1e-12,  
+  epsrel: 1e-12  
+) do |x|  
+  x * x  
+end  
+```  
+## QAGS integration  
+GSL [QAGS](https://www.gnu.org/software/gsl/doc/html/integration.html#qags-adaptive-integration-with-singularities) combines adaptive subdivision with extrapolation to integrate functions with integrable singularities or discontinuities over a finite interval.  
+```ruby  
+result, error = Numo::GSL::Integration.qags(0.0, 1.0) do |x|  
+  Math.log(x) / Math.sqrt(x)  
+end  
+```  
+The example integral has an endpoint singularity and an exact value of `-4.0`. The `epsabs`, `epsrel`, and `limit` keyword arguments control the requested error limits and maximum number of subintervals:  
+```ruby  
+result, error = Numo::GSL::Integration.qags(  
+  0.0,  
+  1.0,  
+  epsabs: 1e-12,  
+  epsrel: 1e-12,  
+  limit: 100  
+) do |x|  
+  x * x  
+end  
+```  
+## QAGP integration  
+GSL [QAGP](https://www.gnu.org/software/gsl/doc/html/integration.html#qagp-adaptive-integration-with-known-singular-points) applies adaptive integration when the locations of interior singularities or discontinuities are known. Pass an array containing the left endpoint, zero or more known interior singularity or discontinuity points, and the right endpoint:  
+```ruby  
+result, error = Numo::GSL::Integration.qagp(  
+  [0.0, 0.5, 1.0]  
+) do |x|  
+  1.0 / Math.sqrt((x - 0.5).abs)  
+end  
+```  
+The points must be finite numeric values in strictly increasing order. The array must contain at least two values. Invalid point arrays raise `Numo::GSL::Integration::Error` before GSL is called.  
+The `epsabs`, `epsrel`, and `limit` keyword arguments control the requested error limits and maximum number of subintervals:  
+```ruby  
+result, error = Numo::GSL::Integration.qagp(  
+  [0.0, 0.25, 0.75, 1.0],  
+  epsabs: 1e-12,  
+  epsrel: 1e-12,  
+  limit: 100  
+) do |x|  
+  x * x  
+end  
+```  
+## QAGI integration  
+GSL [QAGI](https://www.gnu.org/software/gsl/doc/html/integration.html#qagi-adaptive-integration-on-infinite-intervals) provides adaptive integration over the infinite interval from negative infinity to positive infinity. `Numo::GSL::Integration.qagi` takes no interval endpoints and returns the integral and its estimated absolute error.  
+```ruby  
+result, error = Numo::GSL::Integration.qagi do |x|  
+  Math.exp(-(x * x))  
+end  
+```  
+The example integrates the Gaussian function, whose exact value is `Math.sqrt(Math::PI)`. The `epsabs`, `epsrel`, and `limit` keyword arguments control the requested error limits and maximum number of subintervals:  
+```ruby  
+result, error = Numo::GSL::Integration.qagi(  
+  epsabs: 1e-12,  
+  epsrel: 1e-12,  
+  limit: 100  
+) do |x|  
+  1.0 / (1.0 + (x * x))  
+end  
+```  
+## QAGIU integration  
+GSL [QAGIU](https://www.gnu.org/software/gsl/doc/html/integration.html#qagi-adaptive-integration-on-infinite-intervals) provides adaptive integration from a finite lower bound to positive infinity. `Numo::GSL::Integration.qagiu` takes the lower bound and returns the integral and its estimated absolute error.  
+```ruby  
+result, error = Numo::GSL::Integration.qagiu(0.0) do |x|  
+  Math.exp(-x)  
+end  
+```  
+The example integral has an exact value of `1.0`. The `epsabs`, `epsrel`, and `limit` keyword arguments control the requested error limits and maximum number of subintervals:  
+```ruby  
+result, error = Numo::GSL::Integration.qagiu(  
+  1.0,  
+  epsabs: 1e-12,  
+  epsrel: 1e-12,  
+  limit: 100  
+) do |x|  
+  Math.exp(-x)  
+end  
+```  
+## QAGIL integration  
+GSL [QAGIL](https://www.gnu.org/software/gsl/doc/html/integration.html#qagi-adaptive-integration-on-infinite-intervals) provides adaptive integration from negative infinity to a finite upper bound. `Numo::GSL::Integration.qagil` takes the upper bound and returns the integral and its estimated absolute error.  
+```ruby  
+result, error = Numo::GSL::Integration.qagil(0.0) do |x|  
+  Math.exp(x)  
+end  
+```  
+The example integral has an exact value of `1.0`. The `epsabs`, `epsrel`, and `limit` keyword arguments control the requested error limits and maximum number of subintervals:  
+```ruby  
+result, error = Numo::GSL::Integration.qagil(  
+  -1.0,  
+  epsabs: 1e-12,  
+  epsrel: 1e-12,  
+  limit: 100  
+) do |x|  
+  Math.exp(x)  
+end  
+```  
+## QAWC integration  
+GSL [QAWC](https://www.gnu.org/software/gsl/doc/html/integration.html#qawc-adaptive-integration-for-cauchy-principal-values) computes the Cauchy principal value (PV) of an integral over a finite interval with a singularity at $c$:  
+```math  
+PV \int_a^b \frac{f(x)}{x-c}\,dx  
+=  
+\lim_{\varepsilon\to 0^+}  
+\left(  
+\int_a^{c-\varepsilon}\frac{f(x)}{x-c}\,dx  
++  
+\int_{c+\varepsilon}^b\frac{f(x)}{x-c}\,dx  
+\right)  
+```  
+The block passed to `Numo::GSL::Integration.qawc` returns $f(x)$. Do not divide the block result by $x - c$; QAWC applies that weight internally.  
+The following example uses the default integration options and computes the principal value of `x / (x - 1.0)` over the interval from `0.0` to `2.0`, whose exact value is `2.0`:  
+```ruby  
+result, error = Numo::GSL::Integration.qawc(0.0, 2.0, 1.0) do |x|  
+  x  
+end  
+```  
+The `epsabs`, `epsrel`, and `limit` keyword arguments control the requested error limits and maximum number of subintervals. The following example computes the principal value of `1.0 / x` over the symmetric interval from `-1.0` to `1.0`, whose exact value is `0.0`. It specifies a positive `epsabs` because a relative error bound alone is not suitable when the expected result is zero:  
+```ruby  
+result, error = Numo::GSL::Integration.qawc(  
+  -1.0,  
+  1.0,  
+  0.0,  
+  epsabs: 1e-12,  
+  epsrel: 1e-12,  
+  limit: 100  
+) do |_x|  
+  1.0  
+end  
+```  
+## QAWS integration  
+GSL [QAWS](https://www.gnu.org/software/gsl/doc/html/integration.html#qaws-adaptive-integration-for-singular-functions) provides adaptive integration for functions with algebraic or logarithmic singularities at the endpoints of a finite interval. It computes an integral with the weight  
+```math  
+(x-a)^\alpha (b-x)^\beta  
+\log^\mu(x-a) \log^\nu(b-x).  
+```  
+Call `Numo::GSL::Integration.qaws` with the endpoints `a` and `b`, followed by `alpha`, `beta`, `mu`, and `nu`. The exponents `alpha` and `beta` must be greater than `-1.0`. The logarithmic powers `mu` and `nu` must each be `0` or `1`.  
+The block returns the unweighted function $f(x)$. QAWS applies the endpoint weight internally. The following example integrates  
+```math  
+\frac{1}{\sqrt{x(1-x)}}  
+```  
+over the interval from `0.0` to `1.0`. Its exact value is `Math::PI`:  
+```ruby  
+result, error = Numo::GSL::Integration.qaws(  
+  0.0,  
+  1.0,  
+  -0.5,  
+  -0.5,  
+  0,  
+  0  
+) do |_x|  
+  1.0  
+end  
+```  
+Set `mu` to `1` to include `log(x - a)`, and set `nu` to `1` to include `log(b - x)`. The `epsabs`, `epsrel`, and `limit` keyword arguments control the requested error limits and maximum number of subintervals:  
+```ruby  
+result, error = Numo::GSL::Integration.qaws(  
+  0.0,  
+  1.0,  
+  0.0,  
+  0.0,  
+  1,  
+  0,  
+  epsabs: 1e-12,  
+  epsrel: 1e-12,  
+  limit: 100  
+) do |_x|  
+  1.0  
+end  
+```  
+This example computes the integral of `log(x)` from `0.0` to `1.0`, whose exact value is `-1.0`.
+
+## QAWO integration
+
+GSL [QAWO](https://www.gnu.org/software/gsl/doc/html/integration.html#qawo-adaptive-integration-for-oscillatory-functions) provides adaptive integration for finite-interval integrals with a sine or cosine weight. The block returns the unweighted function; QAWO applies the oscillatory weight internally.
+
+```ruby
+result, error = Numo::GSL::Integration.qawo(
+  0.0,
+  Math::PI,
+  1.0,
+  Numo::GSL::Integration::SINE
+) do |_x|
+  1.0
+end
+```
+
+The `epsabs`, `epsrel`, and `limit` keyword arguments control the requested error limits and workspace capacity.
+
+## QAWF integration
+
+GSL [QAWF](https://www.gnu.org/software/gsl/doc/html/integration.html#qawf-adaptive-integration-for-fourier-integrals) provides adaptive integration for sine- or cosine-weighted Fourier integrals over a semi-infinite interval.
+
+```ruby
+result, error = Numo::GSL::Integration.qawf(
+  0.0,
+  1.0,
+  Numo::GSL::Integration::COSINE
+) do |x|
+  Math.exp(-x)
+end
+```
+
+The `epsabs` keyword controls the requested absolute error. The `limit` keyword controls the maximum number of Fourier cycles and the allocated workspace capacity.
+
+## CQUAD integration
+
+GSL [CQUAD](https://www.gnu.org/software/gsl/doc/html/integration.html#cquad-doubly-adaptive-integration) provides doubly-adaptive integration over a finite interval. It is intended for difficult integrands, including functions with integrable singularities. The return value contains the integral, its estimated absolute error, and the number of integrand evaluations.
+
+```ruby
+result, error, evaluations = Numo::GSL::Integration.cquad(0.0, 1.0) do |x|
+  Math.log(x) / Math.sqrt(x)
+end
+```
+
+The example integral has an endpoint singularity and an exact value of `-4.0`. The `epsabs` and `epsrel` keyword arguments control the requested error limits. The `limit` keyword controls the number of intervals retained in the CQUAD workspace and defaults to `100`; GSL requires at least `3`.
+
+## Romberg integration
+
+GSL [Romberg integration](https://www.gnu.org/software/gsl/doc/html/integration.html#romberg-integration) applies Richardson extrapolation to successive trapezoidal approximations. It is intended for smooth functions over a finite interval. The return value contains the integral and the number of integrand evaluations.
+
+```ruby
+result, evaluations = Numo::GSL::Integration.romberg(0.0, Math::PI) do |x|
+  Math.sin(x)
+end
+```
+
+The example integral has an exact value of `2.0`. The `epsabs` and `epsrel` keyword arguments control the requested error limits. The `limit` keyword controls the maximum number of Romberg levels and defaults to `20`. GSL requires at least one level and limits the effective workspace to 30 levels.
+
+Romberg integration does not return an estimated absolute error. Use CQUAD, QAG, QAGS, or another routine that returns an error estimate when the caller needs one.
+
+## GLFIXED integration
+
+GSL [fixed-order Gauss–Legendre integration](https://www.gnu.org/software/gsl/doc/html/integration.html#gauss-legendre-integration) provides fast integration of smooth functions when an appropriate polynomial order is known. An `n`-point rule integrates polynomials of degree `2 * n - 1` or less exactly, subject to floating-point precision.
+
+```ruby
+result = Numo::GSL::Integration.glfixed(
+  0.0,
+  1.0,
+  order: 3
+) do |x|
+  x**4
+end
+```
+
+The example integral has an exact value of `1.0 / 5.0`. The `order` keyword controls the number of Gauss–Legendre points and defaults to `10`. It must be a positive integer.
+
+GLFIXED returns only the integral. It does not accept absolute or relative error bounds and does not return an error estimate. Use an adaptive routine when the required fixed order is not known in advance.

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

@@ -0,0 +1,61 @@
+#include "integration_internal.h"
+
+static VALUE integration_call_block(VALUE data) {
+  integration_callback_params *params = (integration_callback_params *)data;
+  VALUE value;
+
+  value = rb_funcall(params->block, rb_intern("call"), 1, params->x);
+
+  return rb_Float(value);
+}
+
+void integration_callback_params_init(integration_callback_params *params) {
+  params->block = rb_block_proc();
+  params->x = Qnil;
+  params->exception = Qnil;
+  params->state = 0;
+}
+
+void integration_function_init(gsl_function *function,
+                               integration_callback_params *params) {
+  integration_callback_params_init(params);
+  function->function = integration_callback;
+  function->params = params;
+}
+
+double integration_callback(double x, void *data) {
+  integration_callback_params *params = data;
+  VALUE value;
+
+  if (params->state != 0) {
+    return 0.0;
+  }
+
+  params->x = DBL2NUM(x);
+  value = rb_protect(integration_call_block, (VALUE)params, &params->state);
+
+  if (params->state != 0) {
+    params->exception = rb_errinfo();
+    return 0.0;
+  }
+
+  return NUM2DBL(value);
+}
+
+void integration_raise_callback_exception(integration_callback_params *params) {
+  if (params->state != 0) {
+    rb_exc_raise(params->exception);
+  }
+}
+
+void integration_finish_callback(integration_callback_params *params,
+                                 int state) {
+  integration_raise_callback_exception(params);
+  if (state != 0) {
+    rb_jump_tag(state);
+  }
+}
+
+VALUE integration_error_class(void) {
+  return rb_path2class("Numo::GSL::Integration::Error");
+}

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

@@ -0,0 +1,84 @@
+#include "integration_internal.h"
+
+typedef struct {
+  gsl_function *function;
+  double a;
+  double b;
+  double epsabs;
+  double epsrel;
+  size_t limit;
+  gsl_integration_cquad_workspace *workspace;
+  double *result;
+  double *error;
+  size_t *evaluations;
+} integration_cquad_params;
+
+static VALUE integration_run_cquad(VALUE data) {
+  integration_cquad_params *params = (integration_cquad_params *)data;
+
+  (void)gsl_integration_cquad(
+      params->function, params->a, params->b, params->epsabs, params->epsrel,
+      params->workspace, params->result, params->error, params->evaluations);
+
+  return Qnil;
+}
+
+static VALUE integration_run_cquad_with_workspace(VALUE data) {
+  integration_cquad_params *params = (integration_cquad_params *)data;
+
+  return rb_ensure(integration_run_cquad, data,
+                   integration_free_cquad_workspace, (VALUE)params->workspace);
+}
+
+VALUE integration_cquad(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_cquad_workspace *workspace;
+  gsl_function function;
+  integration_callback_params params;
+  integration_cquad_params cquad_params;
+  double result;
+  double error;
+  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, 100);
+  epsabs = parsed_options.epsabs;
+  epsrel = parsed_options.epsrel;
+  limit = parsed_options.limit;
+
+  integration_function_init(&function, &params);
+
+  workspace = gsl_integration_cquad_workspace_alloc(limit);
+
+  cquad_params.function = &function;
+  cquad_params.a = NUM2DBL(a);
+  cquad_params.b = NUM2DBL(b);
+  cquad_params.epsabs = epsabs;
+  cquad_params.epsrel = epsrel;
+  cquad_params.limit = limit;
+  cquad_params.workspace = workspace;
+  cquad_params.result = &result;
+  cquad_params.error = &error;
+  cquad_params.evaluations = &evaluations;
+
+  rb_protect(integration_run_cquad_with_workspace, (VALUE)&cquad_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/extconf.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+gsl_config = find_executable("gsl-config")
+abort("gsl-config is required") unless gsl_config
+
+$CFLAGS << " #{`#{gsl_config} --cflags`.strip}"
+$libs = "#{`#{gsl_config} --libs`.strip} #{$libs}"
+
+abort("gsl/gsl_integration.h is required") unless have_header("gsl/gsl_integration.h")
+
+create_makefile("numo/gsl/integration/integration")

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

@@ -0,0 +1,74 @@
+#include "integration_internal.h"
+
+typedef struct {
+  gsl_function *function;
+  double a;
+  double b;
+  size_t order;
+  gsl_integration_glfixed_table *table;
+  double *result;
+} integration_glfixed_params;
+
+static VALUE integration_run_glfixed(VALUE data) {
+  integration_glfixed_params *params = (integration_glfixed_params *)data;
+
+  *(params->result) = gsl_integration_glfixed(params->function, params->a,
+                                              params->b, params->table);
+
+  return Qnil;
+}
+
+static VALUE integration_run_glfixed_with_table(VALUE data) {
+  integration_glfixed_params *params = (integration_glfixed_params *)data;
+
+  return rb_ensure(integration_run_glfixed, data,
+                   integration_free_glfixed_table, (VALUE)params->table);
+}
+
+VALUE integration_glfixed(int argc, VALUE *argv, VALUE self) {
+  VALUE a;
+  VALUE b;
+  VALUE options;
+  VALUE order_value = Qundef;
+  ID keywords[] = {rb_intern("order")};
+  VALUE keyword_values[1];
+  size_t order;
+  gsl_function function;
+  integration_callback_params params;
+  integration_glfixed_params glfixed_params;
+  double result;
+  int state = 0;
+
+  (void)self;
+
+  rb_scan_args(argc, argv, "2:", &a, &b, &options);
+
+  if (!NIL_P(options)) {
+    rb_get_kwargs(options, keywords, 0, 1, keyword_values);
+    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");
+  }
+
+  integration_function_init(&function, &params);
+
+  glfixed_params.function = &function;
+  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,
+             &state);
+
+  RB_GC_GUARD(params.block);
+  RB_GC_GUARD(params.exception);
+
+  integration_finish_callback(&params, state);
+
+  return DBL2NUM(result);
+}