numo-gsl-integration 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c42681d508010807cd1ef98568ddcbd6f8d2de8a59e812b5161aac0caf70f72
-  data.tar.gz: '0048c5a0902c526f7b34c015b6bbdcc5372d4f2fc57623aeec06ce70c10fe8dc'
+  metadata.gz: 01ba50fbaebaceaa6e5d4151c60a5cda604fbdb45cb78fe0cdbce009916d0028
+  data.tar.gz: 50080c206cf316e836e6e36c7a33492665a1eaa6a832704d98046aa090c2d70b
 SHA512:
-  metadata.gz: b01f0b964db92305a9a9bbaf884a600217aaa84ad6b4970c91327881f8bf3088ad8d0150ca3af505624f6beabd2645bafe3ea99e27ca9ec0987fe21056d8acf3
-  data.tar.gz: 5c5afeda8c3d6bb2e1c512c37c7e5957d27fa9bc3b2f1290a341664f48398a570d36610491c05848daa6064bd160e0b477891114d8751e0590a96a118e37ebb0
+  metadata.gz: 52e2c27c1aa5bec02da2afb0c737eb607f8517f2c4ce55d2fdf26ce8ab72c5003d3ce79ff755b8430bae7479864ea90ad7b1340454e99b9b133cd0223be943df
+  data.tar.gz: 45e2d49aaa8c374e8e4591965d71dc91468fa855bd73779363ab71dbf997e1484a0ff2bb33e4925ecfa2b05c5d90533d943ea97f89efd25bb733b982d631f4e4

data/CHANGELOG.md

@@ -2,9 +2,25 @@
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-11-05
+
+### Changed in 0.2.0
+
+- Removed the runtime dependency on `numo-gsl-alt`.
+- Defined `Numo::GSL::GslError` and installed the process-wide GSL error handler in the native extension.
+- Added the numeric GSL error code to messages raised by the integration GSL error handler.
+- Replaced wrapper-side validation errors with `TypeError` and `ArgumentError`.
+- Changed Markdown formatting from `markdownlint-cli2 --fix` to Prettier while retaining `markdownlint-cli2` for linting.
+- Extended Markdown formatting and linting to all Markdown files under the project root and `docs`.
+- Added Prettier installation to the CI workflow.
+
+### Removed in 0.2.0
+
+- Removed `Numo::GSL::Integration::Error`.
+
 ## [0.1.0] - 2026-11-04
 
-### Added
+### Added in 0.1.0
 
 - Added fixed-order Gauss–Legendre integration for smooth functions.
 - Added Romberg integration for smooth functions with function-evaluation counts.
@@ -24,8 +40,8 @@
 - Added RBS declarations for the public integration API and RBS validation to the default Rake task.
 - Added automated rubyfmt, clang-format, and Markdown checks, with `format:check` and `format:apply` tasks.
 
-### Changed
+### Changed in 0.1.0
 
-- Load `numo/gsl` before the integration native extension and make `Numo::GSL::Integration::Error` inherit from `Numo::GSL::GslError`.
-- Delegate GSL-reported integration errors to the process-wide handler installed by `numo-gsl-alt` instead of converting return statuses to `Integration::Error`.
-- Ensure integration workspaces, weight tables, and temporary arrays are released when integration completes normally or raises an exception.
+- Loaded `numo/gsl` before the integration native extension and made `Numo::GSL::Integration::Error` inherit from `Numo::GSL::GslError`.
+- Delegated GSL-reported integration errors to the process-wide handler installed by `numo-gsl-alt` instead of converting return statuses to `Integration::Error`.
+- Ensured integration workspaces, weight tables, and temporary arrays are released when integration completes normally or raises an exception.

data/README.md

@@ -1,18 +1,13 @@
 # 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.
+`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 can be installed and loaded without `numo-gsl` or `numo-gsl-alt`.
 
 ## 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.
+- `gsl-config` available in `PATH`  
+  GSL itself must be installed separately.
 
 ## Installation
 
@@ -38,8 +33,7 @@ Load the library:
 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.
-
+The native extension defines `Numo::GSL::GslError` and installs a process-wide GSL error handler when it is loaded.  
 For example, use `qag` to integrate a function over a finite interval:
 
 ```ruby
@@ -50,22 +44,22 @@ 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 |
+| Method    | Interval      | Intended use                                               |
+| --------- | ------------- | ---------------------------------------------------------- |
+| `qng`     | Finite        | Non-adaptive integration of smooth functions               |
+| `qag`     | Finite        | General-purpose adaptive integration                       |
+| `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.
 

data/docs/error-handling.md

@@ -1,19 +1,13 @@
 # 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.
+`numo-gsl-integration` defines `Numo::GSL::GslError` as a subclass of `StandardError` and installs a process-wide GSL error handler when the native extension is loaded.  
+Errors reported by GSL are raised directly as `Numo::GSL::GslError`. The message contains the GSL source file, line number, reason, and numeric error code:
 
-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
+```text
+file:line: reason (GSL error code)
 ```
 
-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.
+`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.  
+Invalid argument types raise `TypeError`. Invalid values, counts, or ordering raise `ArgumentError`. Exceptions raised by the integrand are propagated unchanged.  
+The GSL error handler is shared by the entire process. Loading this gem replaces the previously registered handler. If another GSL binding is loaded afterward, that binding may replace this gem's handler in turn.

data/docs/routines.md

@@ -1,213 +1,269 @@
-# 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)  
-```  
+# 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`.
+
+## 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
+```
+
+## 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`.
+
+## 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. A non-array argument or a non-numeric element raises `TypeError`. Too few points, non-finite values, or values that are not strictly increasing raise `ArgumentError` 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).  
-```  
+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  
-```  
+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
@@ -265,8 +321,7 @@ result, evaluations = Numo::GSL::Integration.romberg(0.0, Math::PI) do |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.
-
+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
@@ -283,6 +338,5 @@ result = Numo::GSL::Integration.glfixed(
 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.
-
+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

@@ -1,53 +1,41 @@
 #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);
@@ -55,7 +43,3 @@ void integration_finish_callback(integration_callback_params *params,
     rb_jump_tag(state);
   }
 }
-
-VALUE integration_error_class(void) {
-  return rb_path2class("Numo::GSL::Integration::Error");
-}

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

@@ -1,5 +1,4 @@
 #include "integration_internal.h"
-
 typedef struct {
   gsl_function *function;
   double a;
@@ -8,23 +7,17 @@ typedef struct {
   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;
@@ -38,37 +31,34 @@ VALUE integration_glfixed(int argc, VALUE *argv, VALUE self) {
   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");
+  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);
-
   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);
 }

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

@@ -1,14 +1,20 @@
 #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;
   VALUE mIntegration;
-
   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));
   rb_define_const(mIntegration, "GAUSS31", INT2NUM(GSL_INTEG_GAUSS31));
@@ -17,7 +23,6 @@ void Init_integration(void) {
   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);

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

@@ -1,26 +1,22 @@
 #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>
-
 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);
@@ -28,12 +24,10 @@ 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);
@@ -48,5 +42,4 @@ 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/qagp.c

@@ -1,7 +1,5 @@
 #include "integration_internal.h"
-
 #include <math.h>
-
 typedef struct {
   VALUE points_array;
   gsl_function *function;
@@ -14,49 +12,36 @@ typedef struct {
   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");
+    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++) {
     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");
+      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;
   }
 }
-
 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] =
@@ -69,10 +54,8 @@ static VALUE integration_run_qagp(VALUE data) {
                              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);
   }
@@ -81,12 +64,10 @@ static VALUE integration_free_qagp_resources(VALUE data) {
   }
   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;
@@ -100,10 +81,8 @@ VALUE integration_qagp(int argc, VALUE *argv, VALUE self) {
   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;
@@ -125,6 +104,5 @@ VALUE integration_qagp(int argc, VALUE *argv, VALUE self) {
   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/lib/numo/gsl/integration/version.rb

@@ -3,7 +3,7 @@
 module Numo
   module GSL
     module Integration
-      VERSION = "0.1.0"
+      VERSION = "0.2.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"

data/sig/numo/gsl/integration.rbs

@@ -2,10 +2,6 @@ module Numo
   module GSL
     module Integration
       VERSION: String
-
-      class Error < ::Numo::GSL::GslError
-      end
-
       GAUSS15: Integer
       GAUSS21: Integer
       GAUSS31: Integer
@@ -14,7 +10,6 @@ module Numo
       GAUSS61: Integer
       COSINE: Integer
       SINE: Integer
-
       def self.qag: (
         Numeric a,
         Numeric b,
@@ -23,14 +18,12 @@ module Numo
         ?limit: Integer,
         ?key: Integer
       ) { (Float) -> Numeric } -> [Float, Float]
-
       def self.qng: (
         Numeric a,
         Numeric b,
         ?epsabs: Numeric,
         ?epsrel: Numeric
       ) { (Float) -> Numeric } -> [Float, Float, Integer]
-
       def self.qags: (
         Numeric a,
         Numeric b,
@@ -38,34 +31,29 @@ module Numo
         ?epsrel: Numeric,
         ?limit: Integer
       ) { (Float) -> Numeric } -> [Float, Float]
-
       def self.qagp: (
         Array[Numeric] points,
         ?epsabs: Numeric,
         ?epsrel: Numeric,
         ?limit: Integer
       ) { (Float) -> Numeric } -> [Float, Float]
-
       def self.qagi: (
         ?epsabs: Numeric,
         ?epsrel: Numeric,
         ?limit: Integer
       ) { (Float) -> Numeric } -> [Float, Float]
-
       def self.qagiu: (
         Numeric a,
         ?epsabs: Numeric,
         ?epsrel: Numeric,
         ?limit: Integer
       ) { (Float) -> Numeric } -> [Float, Float]
-
       def self.qagil: (
         Numeric b,
         ?epsabs: Numeric,
         ?epsrel: Numeric,
         ?limit: Integer
       ) { (Float) -> Numeric } -> [Float, Float]
-
       def self.qawc: (
         Numeric a,
         Numeric b,
@@ -74,7 +62,6 @@ module Numo
         ?epsrel: Numeric,
         ?limit: Integer
       ) { (Float) -> Numeric } -> [Float, Float]
-
       def self.qaws: (
         Numeric a,
         Numeric b,
@@ -86,7 +73,6 @@ module Numo
         ?epsrel: Numeric,
         ?limit: Integer
       ) { (Float) -> Numeric } -> [Float, Float]
-
       def self.qawo: (
         Numeric a,
         Numeric b,
@@ -96,7 +82,6 @@ module Numo
         ?epsrel: Numeric,
         ?limit: Integer
       ) { (Float) -> Numeric } -> [Float, Float]
-
       def self.qawf: (
         Numeric a,
         Numeric omega,
@@ -104,7 +89,6 @@ module Numo
         ?epsabs: Numeric,
         ?limit: Integer
       ) { (Float) -> Numeric } -> [Float, Float]
-
       def self.cquad: (
         Numeric a,
         Numeric b,
@@ -112,7 +96,6 @@ module Numo
         ?epsrel: Numeric,
         ?limit: Integer
       ) { (Float) -> Numeric } -> [Float, Float, Integer]
-
       def self.romberg: (
         Numeric a,
         Numeric b,
@@ -120,7 +103,6 @@ module Numo
         ?epsrel: Numeric,
         ?limit: Integer
       ) { (Float) -> Numeric } -> [Float, Integer]
-
       def self.glfixed: (
         Numeric a,
         Numeric b,

data/sig/numo/gsl.rbs

@@ -1,6 +1,6 @@
 module Numo
   module GSL
-    class GslError <::StandardError
+    class GslError < ::StandardError
     end
   end
 end

metadata

@@ -1,34 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: numo-gsl-integration
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Takahiro SATOH
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: numo-gsl-alt
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.3
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.3
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '0.2'
+dependencies: []
 description: Provides GNU Scientific Library numerical integration routines under
   Numo::GSL::Integration.
 email: