numo-gsl-integration 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ed1ccbd179314a5925c135faa809ff255bb9acf626c475af39237c8e397f89a
-  data.tar.gz: 891a0e74db19f6d5c5b40aeff66a2610dbf063c5d2ccd3b9dfdae0a730a880fd
+  metadata.gz: 24601b3a87462ee4bc6077999599478d3c08776b8da2caa648e56dbfaacec731
+  data.tar.gz: 97d7fe3772e374a35ab108ea0a4238fbbceb04598fc2637c3f4d76285cc17f66
 SHA512:
-  metadata.gz: 86207b0346bcff38a8892e36c8721d2327010b7367a74b91344db9c799ae2ea0390203572ce275efad201a47bc480f66e26b1daad753cfd63c878c7b78575793
-  data.tar.gz: 532c33c4e35c701e901cf10d771a9c982533b927353dbbe0d53173684dc2ab66a90231e617906a10cc3d530aa05f364ea83735982e3721b421e06e1cbb2b983a
+  metadata.gz: 86447bf3974787c1067ceecacf700b3583fc2365fb0699f7fac10ed33c54b03c83a9ea5467598c0f9f687222d8ad6fed5c14feeca617d61d7ad39f01accb9ea1
+  data.tar.gz: 682f48569710825aac5fd2905dcfcab621abe47cea6f48f332b367d6da1747afe38512d08a6e84e1911b6ccd331d88fdb329b714bfa5619534ed8cea41227708

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [0.3.1] - 2026-11-06
+
+### Changed in 0.3.1
+
+- Simplified the internal handling of fixed quadrature rules without changing the public API.
+
 ## [0.3.0] - 2026-11-05
 
 ### Added in 0.3.0

data/docs/routines.md

@@ -181,14 +181,7 @@ 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
-=
-\\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)
+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.
@@ -220,15 +213,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`.
 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`:

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

@@ -1,4 +1,17 @@
 #include "integration_internal.h"
+
+enum {
+  INTEGRATION_FIXED_REQUIRES_ALPHA = 1 << 0,
+  INTEGRATION_FIXED_REQUIRES_BETA = 1 << 1
+};
+
+typedef struct {
+  ID id;
+  const char *name;
+  const gsl_integration_fixed_type **type;
+  unsigned int requirements;
+} integration_fixed_type_info;
+
 typedef struct {
   gsl_function *function;
   const gsl_integration_fixed_type *type;
@@ -10,150 +23,164 @@ typedef struct {
   gsl_integration_fixed_workspace *workspace;
   double *result;
 } integration_fixed_params;
-static const gsl_integration_fixed_type *integration_fixed_type(VALUE type) {
+
+static integration_fixed_type_info integration_fixed_types[] = {
+    {0, "legendre", &gsl_integration_fixed_legendre, 0},
+    {0, "chebyshev", &gsl_integration_fixed_chebyshev, 0},
+    {0, "chebyshev2", &gsl_integration_fixed_chebyshev2, 0},
+    {0, "gegenbauer", &gsl_integration_fixed_gegenbauer,
+     INTEGRATION_FIXED_REQUIRES_ALPHA},
+    {0, "jacobi", &gsl_integration_fixed_jacobi,
+     INTEGRATION_FIXED_REQUIRES_ALPHA | INTEGRATION_FIXED_REQUIRES_BETA},
+    {0, "laguerre", &gsl_integration_fixed_laguerre,
+     INTEGRATION_FIXED_REQUIRES_ALPHA},
+    {0, "hermite", &gsl_integration_fixed_hermite,
+     INTEGRATION_FIXED_REQUIRES_ALPHA},
+    {0, "exponential", &gsl_integration_fixed_exponential,
+     INTEGRATION_FIXED_REQUIRES_ALPHA},
+    {0, "rational", &gsl_integration_fixed_rational,
+     INTEGRATION_FIXED_REQUIRES_ALPHA | INTEGRATION_FIXED_REQUIRES_BETA},
+};
+
+static ID integration_fixed_id_order;
+static ID integration_fixed_id_a;
+static ID integration_fixed_id_b;
+static ID integration_fixed_id_alpha;
+static ID integration_fixed_id_beta;
+static ID integration_fixed_id_less_than_or_equal;
+
+void integration_fixed_init(void) {
+  size_t i;
+
+  for (i = 0;
+       i < sizeof(integration_fixed_types) / sizeof(integration_fixed_types[0]);
+       ++i) {
+    integration_fixed_types[i].id = rb_intern(integration_fixed_types[i].name);
+  }
+
+  integration_fixed_id_order = rb_intern("order");
+  integration_fixed_id_a = rb_intern("a");
+  integration_fixed_id_b = rb_intern("b");
+  integration_fixed_id_alpha = rb_intern("alpha");
+  integration_fixed_id_beta = rb_intern("beta");
+  integration_fixed_id_less_than_or_equal = rb_intern("<=");
+}
+
+static const integration_fixed_type_info *integration_fixed_type(VALUE type) {
   ID type_id;
+  size_t i;
+
   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;
+  for (i = 0;
+       i < sizeof(integration_fixed_types) / sizeof(integration_fixed_types[0]);
+       ++i) {
+    if (integration_fixed_types[i].id == type_id) {
+      return &integration_fixed_types[i];
+    }
   }
+
   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")};
+  ID keywords[] = {integration_fixed_id_order, integration_fixed_id_a,
+                   integration_fixed_id_b, integration_fixed_id_alpha,
+                   integration_fixed_id_beta};
   VALUE keyword_values[5];
   VALUE order_value;
   VALUE alpha_value;
   VALUE beta_value;
+  const integration_fixed_type_info *type_info;
   size_t order;
   gsl_function function;
   integration_callback_params params;
-  integration_fixed_params fixed_params;
+  integration_fixed_params fixed_params = {0};
   double result;
   int state = 0;
+
   (void)self;
   rb_scan_args(argc, argv, "1:", &type, &options);
-  fixed_params.type = integration_fixed_type(type);
+  type_info = 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)))) {
+  if (RTEST(rb_funcall(order_value, integration_fixed_id_less_than_or_equal, 1,
+                       INT2FIX(0)))) {
     rb_raise(rb_eArgError, "order must be positive");
   }
   order = NUM2SIZET(order_value);
+
+  if ((type_info->requirements & INTEGRATION_FIXED_REQUIRES_ALPHA) != 0 &&
+      alpha_value == Qundef) {
+    rb_raise(rb_eArgError, "alpha is required for %s", type_info->name);
+  }
+  if ((type_info->requirements & INTEGRATION_FIXED_REQUIRES_BETA) != 0 &&
+      beta_value == Qundef) {
+    rb_raise(rb_eArgError, "beta is required for %s", type_info->name);
+  }
+
   integration_function_init(&function, &params);
   fixed_params.function = &function;
+  fixed_params.type = *type_info->type;
   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.alpha =
+      (type_info->requirements & INTEGRATION_FIXED_REQUIRES_ALPHA) != 0
+          ? NUM2DBL(alpha_value)
+          : 0.0;
+  fixed_params.beta =
+      (type_info->requirements & INTEGRATION_FIXED_REQUIRES_BETA) != 0
+          ? NUM2DBL(beta_value)
+          : 0.0;
   fixed_params.result = &result;
+
   rb_protect(integration_run_fixed_with_workspace, (VALUE)&fixed_params,
              &state);
   RB_GC_GUARD(params.block);

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

@@ -19,6 +19,7 @@ void Init_integration(void) {
   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);
+  integration_fixed_init();
 
   rb_define_const(mIntegration, "GAUSS15", INT2NUM(GSL_INTEG_GAUSS15));
   rb_define_const(mIntegration, "GAUSS21", INT2NUM(GSL_INTEG_GAUSS21));

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

@@ -35,6 +35,8 @@ VALUE integration_free_cquad_workspace(VALUE data);
 VALUE integration_free_romberg_workspace(VALUE data);
 VALUE integration_free_glfixed_table(VALUE data);
 
+void integration_fixed_init(void);
+
 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);

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

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: numo-gsl-integration
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Takahiro SATOH