numo-gsl-integration 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01ba50fbaebaceaa6e5d4151c60a5cda604fbdb45cb78fe0cdbce009916d0028
-  data.tar.gz: 50080c206cf316e836e6e36c7a33492665a1eaa6a832704d98046aa090c2d70b
+  metadata.gz: 0ed1ccbd179314a5925c135faa809ff255bb9acf626c475af39237c8e397f89a
+  data.tar.gz: 891a0e74db19f6d5c5b40aeff66a2610dbf063c5d2ccd3b9dfdae0a730a880fd
 SHA512:
-  metadata.gz: 52e2c27c1aa5bec02da2afb0c737eb607f8517f2c4ce55d2fdf26ce8ab72c5003d3ce79ff755b8430bae7479864ea90ad7b1340454e99b9b133cd0223be943df
-  data.tar.gz: 45e2d49aaa8c374e8e4591965d71dc91468fa855bd73779363ab71dbf997e1484a0ff2bb33e4925ecfa2b05c5d90533d943ea97f89efd25bb733b982d631f4e4
+  metadata.gz: 86207b0346bcff38a8892e36c8721d2327010b7367a74b91344db9c799ae2ea0390203572ce275efad201a47bc480f66e26b1daad753cfd63c878c7b78575793
+  data.tar.gz: 532c33c4e35c701e901cf10d771a9c982533b927353dbbe0d53173684dc2ab66a90231e617906a10cc3d530aa05f364ea83735982e3721b421e06e1cbb2b983a

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-11-05
+
+### Added in 0.3.0
+
+- Added fixed point quadrature with Legendre, first- and second-kind Chebyshev, Gegenbauer, Jacobi, Laguerre, Hermite, exponential, and rational rules.
+
 ## [0.2.0] - 2026-11-05
 
 ### Changed in 0.2.0
@@ -22,7 +28,7 @@
 
 ### Added in 0.1.0
 
-- Added fixed-order Gauss–Legendre integration for smooth functions.
+- Added fixed-order Gauss-Legendre integration for smooth functions.
 - Added Romberg integration for smooth functions with function-evaluation counts.
 - Added CQUAD doubly-adaptive integration with function-evaluation counts.
 - Added QAWF adaptive integration for sine- and cosine-weighted Fourier integrals over a semi-infinite interval.

data/README.md

@@ -1,12 +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 can be installed and loaded without `numo-gsl` or `numo-gsl-alt`.
+`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`](https://github.com/ruby-numo/numo-gsl) or [`numo-gsl-alt`](https://github.com/mvz/numo-gsl-alt).
 
 ## Requirements
 
 - [Ruby](https://www.ruby-lang.org/) 3.2 or later
 - GNU Scientific Library (GSL)
-- `gsl-config` available in `PATH`  
+- `gsl-config` available in `PATH`
+
   GSL itself must be installed separately.
 
 ## Installation
@@ -33,7 +34,6 @@ Load the library:
 require "numo/gsl/integration"
 ```
 
-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
@@ -44,22 +44,23 @@ end
 
 ## Supported routines
 
-| 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 |
+| 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       |
+| `fixed`   | Rule-dependent | Fixed-order Gaussian quadrature with selectable weight functions |
 
 See [Integration routines](docs/routines.md) for parameters and examples.
 

data/docs/routines.md

@@ -94,7 +94,7 @@ result, error = Numo::GSL::Integration.qagp(
 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 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
@@ -181,17 +181,17 @@ end
 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
+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)
+\\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 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
@@ -220,15 +220,15 @@ end
 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).
+(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`.  
+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)}}
+\\frac{1}{\\sqrt{x(1-x)}}
 ```
 
 over the interval from `0.0` to `1.0`. Its exact value is `Math::PI`:
@@ -321,12 +321,12 @@ 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
 
-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.
+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(
@@ -338,5 +338,55 @@ 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.
+
+## Fixed point quadratures
+
+GSL [fixed point quadratures](https://www.gnu.org/software/gsl/doc/html/integration.html#fixed-point-quadratures) provide fixed-order Gaussian quadrature rules for several weight functions. `Numo::GSL::Integration.fixed` takes a quadrature type, the number of points, and the GSL rule parameters:
+
+```ruby
+result = Numo::GSL::Integration.fixed(
+  :legendre,
+  order: 3,
+  a: 0.0,
+  b: 1.0
+) do |x|
+  x ** 4
+end
+```
+
+The example has an exact value of `1.0 / 5.0`. The block returns the unweighted function. For weighted rules, GSL applies the selected weight internally.
+
+The supported types and required keyword arguments are:
+
+| Type           | Required rule parameters | Description                                                  |
+| -------------- | ------------------------ | ------------------------------------------------------------ |
+| `:legendre`    | —                        | Gauss-Legendre rule over the finite interval from `a` to `b` |
+| `:chebyshev`   | —                        | First-kind Chebyshev rule over the finite interval           |
+| `:chebyshev2`  | —                        | Second-kind Chebyshev rule over the finite interval          |
+| `:gegenbauer`  | `alpha`                  | Gegenbauer rule                                              |
+| `:jacobi`      | `alpha`, `beta`          | Jacobi rule                                                  |
+| `:laguerre`    | `alpha`                  | Generalized Laguerre rule                                    |
+| `:hermite`     | `alpha`                  | Generalized Hermite rule                                     |
+| `:exponential` | `alpha`                  | Exponential rule over a finite interval                      |
+| `:rational`    | `alpha`, `beta`          | Rational rule                                                |
+
+`order` must be a positive integer. The keywords `a` and `b` are required for every type because they are passed to `gsl_integration_fixed_alloc`; their exact role and valid range depend on the selected GSL rule. The `alpha` and `beta` values must also satisfy the constraints imposed by that rule. Invalid numerical parameters are reported as `Numo::GSL::GslError` by GSL.
+
+The following example uses the rational rule. Its parameters satisfy the rule's order-dependent constraints for `order: 3`:
+
+```ruby
+result = Numo::GSL::Integration.fixed(
+  :rational,
+  order: 3,
+  a: 0.0,
+  b: 1.0,
+  alpha: 0.0,
+  beta: -7.0
+) do |_x|
+  1.0
+end
+```
+
+The example result is `1.0 / 6.0`. Fixed point quadratures return only the integral. They do not accept absolute or relative error bounds and do not return an error estimate. Use an adaptive routine when the required order is not known in advance.

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

@@ -1,44 +1,59 @@
 #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);
   }

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

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

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

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

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

@@ -1,4 +1,5 @@
 #include "integration_internal.h"
+
 typedef struct {
   gsl_function *function;
   double a;
@@ -7,17 +8,23 @@ 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;
@@ -31,34 +38,48 @@ 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];
   }
+
   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,20 +1,25 @@
 #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));
@@ -23,6 +28,7 @@ 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);
@@ -37,4 +43,5 @@ void Init_integration(void) {
   rb_define_singleton_method(mIntegration, "cquad", integration_cquad, -1);
   rb_define_singleton_method(mIntegration, "romberg", integration_romberg, -1);
   rb_define_singleton_method(mIntegration, "glfixed", integration_glfixed, -1);
+  rb_define_singleton_method(mIntegration, "fixed", integration_fixed, -1);
 }

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

@@ -1,22 +1,27 @@
 #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);
@@ -24,10 +29,12 @@ 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_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);
@@ -42,4 +49,6 @@ VALUE integration_qawf(int argc, VALUE *argv, VALUE self);
 VALUE integration_cquad(int argc, VALUE *argv, VALUE self);
 VALUE integration_romberg(int argc, VALUE *argv, VALUE self);
 VALUE integration_glfixed(int argc, VALUE *argv, VALUE self);
+VALUE integration_fixed(int argc, VALUE *argv, VALUE self);
+
 #endif

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

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

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

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

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

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

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

@@ -1,5 +1,6 @@
 #include "integration_internal.h"
 #include <math.h>
+
 typedef struct {
   VALUE points_array;
   gsl_function *function;
@@ -12,62 +13,84 @@ 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(rb_eTypeError, "points must be an Array");
   }
+
   point_count = RARRAY_LEN(points);
+
   if (point_count < 2) {
     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(rb_eTypeError, "points must contain only numeric values");
     }
+
     current = NUM2DBL(point);
+
     if (!isfinite(current)) {
       rb_raise(rb_eArgError, "points must contain only finite values");
     }
+
     if (index > 0 && !(previous < current)) {
       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] =
         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;
@@ -81,14 +104,21 @@ 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;
   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;
@@ -99,10 +129,14 @@ VALUE integration_qagp(int argc, VALUE *argv, VALUE self) {
   qagp_params.workspace = NULL;
   qagp_params.result = &result;
   qagp_params.error = &error;
+
   rb_protect(integration_run_qagp_with_resources, (VALUE)&qagp_params, &state);
+
   RB_GC_GUARD(points);
   RB_GC_GUARD(params.block);
   RB_GC_GUARD(params.exception);
+
   integration_finish_callback(&params, state);
+
   return rb_ary_new_from_args(2, DBL2NUM(result), DBL2NUM(error));
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

data/sig/numo/gsl/integration.rbs

@@ -108,6 +108,14 @@ module Numo
         Numeric b,
         ?order: Integer
       ) { (Float) -> Numeric } -> Float
+      def self.fixed: (
+        (:legendre | :chebyshev | :chebyshev2 | :gegenbauer | :jacobi | :laguerre | :hermite | :exponential | :rational) type,
+        order: Integer,
+        a: Numeric,
+        b: Numeric,
+        ?alpha: Numeric,
+        ?beta: Numeric
+      ) { (Float) -> Numeric } -> Float
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: numo-gsl-integration
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Takahiro SATOH
@@ -27,6 +27,7 @@ files:
 - ext/numo/gsl/integration/callback.c
 - ext/numo/gsl/integration/cquad.c
 - ext/numo/gsl/integration/extconf.rb
+- ext/numo/gsl/integration/fixed.c
 - ext/numo/gsl/integration/glfixed.c
 - ext/numo/gsl/integration/integration.c
 - ext/numo/gsl/integration/integration_internal.h