pyrestoolbox 3.8.5__tar.gz → 3.8.6__tar.gz

{pyrestoolbox-3.8.5 → pyrestoolbox-3.8.6}/Cargo.lock

@@ -152,7 +152,7 @@ dependencies = [
 
 [[package]]
 name = "pyrestoolbox-native"
-version = "3.8.5"
+version = "3.8.6"
 dependencies = [
  "pyo3",
  "rug",

{pyrestoolbox-3.8.5 → pyrestoolbox-3.8.6}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pyrestoolbox-native"
-version = "3.8.5"
+version = "3.8.6"
 edition = "2021"
 license = "GPL-3.0-or-later"
 description = "Rust acceleration extensions for pyResToolbox"

{pyrestoolbox-3.8.5 → pyrestoolbox-3.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrestoolbox
-Version: 3.8.5
+Version: 3.8.6
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
@@ -9,10 +9,11 @@ Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: pandas
 Requires-Dist: tabulate
-Requires-Dist: ilt-inversion
-Requires-Dist: mpmath
-Requires-Dist: gmpy2
 Requires-Dist: openpyxl
+Requires-Dist: ilt-inversion ; extra == 'aquifer'
+Requires-Dist: mpmath ; extra == 'aquifer'
+Requires-Dist: gmpy2 ; extra == 'aquifer'
+Provides-Extra: aquifer
 License-File: LICENSE
 Summary: pyResToolbox - A collection of Reservoir Engineering Utilities
 Keywords: restoolbox,petroleum,reservoir
@@ -64,7 +65,7 @@ All public PVT, flow rate, and simulation table functions support both oilfield
 Rust Acceleration (Optional)
 ----------------------------
 
-pyResToolbox includes optional Rust-compiled extensions that accelerate computationally intensive algorithms. When the compiled extension is present and loadable, these functions run automatically through Rust with no API changes. When the extension is unavailable, all functions fall back silently to the pure Python implementation.
+pyResToolbox includes optional Rust-compiled extensions that accelerate computationally intensive algorithms. When the compiled extension is present and loadable, these functions run automatically through Rust with no API changes. When the extension is unavailable, all functions fall back silently to the pure Python implementation. The one exception is ``simtools.influence_tables``, whose pure-Python fallback needs the optional ``aquifer`` extra (``pip install 'pyrestoolbox[aquifer]'``).
 
 **Accelerated functions:**
 

{pyrestoolbox-3.8.5 → pyrestoolbox-3.8.6}/README.rst

@@ -39,7 +39,7 @@ All public PVT, flow rate, and simulation table functions support both oilfield
 Rust Acceleration (Optional)
 ----------------------------
 
-pyResToolbox includes optional Rust-compiled extensions that accelerate computationally intensive algorithms. When the compiled extension is present and loadable, these functions run automatically through Rust with no API changes. When the extension is unavailable, all functions fall back silently to the pure Python implementation.
+pyResToolbox includes optional Rust-compiled extensions that accelerate computationally intensive algorithms. When the compiled extension is present and loadable, these functions run automatically through Rust with no API changes. When the extension is unavailable, all functions fall back silently to the pure Python implementation. The one exception is ``simtools.influence_tables``, whose pure-Python fallback needs the optional ``aquifer`` extra (``pip install 'pyrestoolbox[aquifer]'``).
 
 **Accelerated functions:**
 

{pyrestoolbox-3.8.5 → pyrestoolbox-3.8.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "pyrestoolbox"
-version = "3.8.5"
+version = "3.8.6"
 description = "pyResToolbox - A collection of Reservoir Engineering Utilities"
 license = {text = "GPL-3.0-or-later"}
 authors = [{name = "Mark W. Burgoyne", email = "mark.w.burgoyne@gmail.com"}]
@@ -21,13 +21,14 @@ dependencies = [
     "scipy",
     "pandas",
     "tabulate",
-    "ilt-inversion",
-    "mpmath",
-    "gmpy2",
     "openpyxl",
 ]
 readme = "README.rst"
 
+[project.optional-dependencies]
+# Pure-Python fallback for simtools.influence_tables (the Rust extension needs none of these)
+aquifer = ["ilt-inversion", "mpmath", "gmpy2"]
+
 [project.urls]
 Homepage = "https://github.com/mwburgoyne/pyResToolbox"
 

{pyrestoolbox-3.8.5 → pyrestoolbox-3.8.6}/pyrestoolbox/docs/changelist.rst

@@ -1,3 +1,9 @@
+Changelist in 3.8.6:
+
+- **SIMTOOLS: ``influence_tables`` Rust path now holds the precision the inversion needs (results move).** The Rust Gaver-Wynn-Rho inversion evaluates the Van Everdingen-Hurst transform with its own MPFR Bessel functions, and those carried less precision than GWR needs (about 2.1M digits). The series-to-asymptotic switch was fixed at x = 25, where the asymptotic expansion is good to only about 22 digits; the K-series ran with half the guard bits its cancellation needs; pi in the asymptotic prefactors and Euler's constant in the K0 series were f64 or 50-digit constants; and the I1 asymptotic expansion had a sign error. The switch now depends on the working precision, the guard bits match the cancellation, all constants are MPFR, and the I1 sign is corrected. Against a reference converged to 1e-14, the worst point on a 126-point table (ReD 1.5-20, tD 0.01-200) is now 2.2e-5 at M=7 (was 4.5e-5), 1.4e-8 at M=12 (was 1.6e-4), 3.2e-11 at M=18 (was 6.7e-3) and 2e-16 at M=32 (ReD 1.5 at tD 0.044 returned 20.07 against 0.2175), the same convergence as the pure-Python path. At the default M=7 the README example table (ReD 1.5-1000) moves by up to 4.6e-5 relative (ReD 1.5, tD 0.027: 0.172801 to 0.172809), 6e-7 on average. Run time is unchanged or a little shorter (121 against 138 ms for that table at M=7).
+
+- **PACKAGING: ``ilt-inversion``, ``mpmath`` and ``gmpy2`` are now an optional extra (``pip install 'pyrestoolbox[aquifer]'``).** Only ``simtools.influence_tables`` uses them, and only on its pure-Python path; the Rust extension in every prebuilt wheel does the inverse Laplace transform and Bessel functions itself in MPFR. ``import pyrestoolbox.simtools`` no longer loads ``ilt`` or ``mpmath``. Without the Rust extension and without the extra, ``influence_tables`` raises ``ImportError`` naming the extra; every other function is unaffected. Existing environments keep working, since upgrading does not uninstall the three packages.
+
 Changelist in 3.8.5:
 
 - **NODAL: gas VLP uses the ``gas_pvt`` Z-factor and viscosity methods (results move when a GasPVT is passed).** ``fbhp``, ``fthp``, ``outflow_curve``, ``operating_point`` and the simtools VFP tables took only the gas SG and Sutton/Wichert-Aziz pseudo-criticals from a ``GasPVT``; the march always ran Hall-Yarborough Z with Lee-Gonzalez-Eakin viscosity, so ``zmethod='BNS'`` (or the GasPVT default, DAK with PMC) was silently ignored, as were H2 and He (which raised a warning). The march now evaluates Z and viscosity exactly as ``gas_pvt.z()`` and ``gas_pvt.viscosity()`` do, at every step and in the zero-rate static column, in Python and Rust (the Rust march builds the same Z/viscosity evaluator as ``gas_dmp``, so every method stays accelerated; the two paths agree to 1e-9 relative). Calls without ``gas_pvt`` are bit-identical. Example (THP 1000 psia, 5 MMscf/d, 100 bbl/d water, 5000 ft of 2.441 in tubing, 80-200 degF, SG 0.65), Beggs-Brill BHP: 1475.3 psia before, 1459.3 with ``GasPVT(sg=0.65)`` (DAK/PMC), 1508.2 with ``zmethod='BNS'``; WG 1444.8, 1444.1, 1446.2. Beggs-Brill moves most because the distributed-to-segregated boundary sits mid-well here and the gradient steps 27% across it. The pure-Python fallback is about 15 times slower with a ``gas_pvt`` (about 40 ms per ``fbhp``), since each step calls ``gas_z`` and ``gas_ug``. No documented example passes a ``gas_pvt`` to the VLP functions, so none moves; one nodal test that asserted a sweet ``GasPVT`` equals the ``gsg``-only answer now compares an HY/SUT ``GasPVT`` (within 4e-5).

{pyrestoolbox-3.8.5 → pyrestoolbox-3.8.6}/pyrestoolbox/docs/simtools.rst

@@ -152,6 +152,8 @@ pyrestoolbox.simtools.influence_tables
 
 Solves Van Everdingin & Hurst Constant Terminal Rate solution via inverse Laplace transform and optionally writes out ECLIPSE styled AQUTAB include file.
 
+The Rust extension (in every prebuilt wheel) does the inversion with no extra packages. Without it, the pure-Python fallback needs the optional ``aquifer`` extra (``ilt-inversion``, ``mpmath``, ``gmpy2``): ``pip install 'pyrestoolbox[aquifer]'``. Calling ``influence_tables`` on the pure-Python path without them raises ``ImportError``.
+
 Returns a tuple of;
     1. Dimensionless time list
     2. list of lists of dimensionless pressures at each dimensionless time for each dimensionless radius

{pyrestoolbox-3.8.5 → pyrestoolbox-3.8.6}/pyrestoolbox/simtools/_aquifer.py

@@ -30,8 +30,6 @@ from typing import Union, Tuple
 import numpy as np
 import numpy.typing as npt
 from tabulate import tabulate
-from ilt import gwr
-from mpmath import mp
 
 from pyrestoolbox._accelerator import RUST_AVAILABLE, _rust_module
 
@@ -74,7 +72,17 @@ def influence_tables(
     if RUST_AVAILABLE:
         pDs = _rust_module.influence_tables_rust(tD.tolist(), list(ReDs), M)
     else:
-        # Python fallback via ilt library
+        # Python fallback via ilt library (optional extra: pyrestoolbox[aquifer])
+        try:
+            from ilt import gwr
+            from mpmath import mp
+        except ImportError as e:
+            raise ImportError(
+                "influence_tables needs the Rust extension or the optional "
+                "inverse-Laplace dependencies; install them with "
+                "pip install 'pyrestoolbox[aquifer]'"
+            ) from e
+
         def laplace_Ps(s: float, ReD: float):
             x = mp.sqrt(s)
             # pre-calculate duplicated bessel function for greater efficiency

{pyrestoolbox-3.8.5 → pyrestoolbox-3.8.6}/setup.cfg

@@ -17,10 +17,13 @@ install_requires =
     scipy
     pandas
     tabulate
+    openpyxl
+
+[options.extras_require]
+aquifer =
     ilt-inversion
     mpmath
     gmpy2
-    openpyxl
 
 [options.packages.find]
 exclude =

{pyrestoolbox-3.8.5 → pyrestoolbox-3.8.6}/setup.py

@@ -32,9 +32,9 @@ setup(
         'scipy',
         'pandas',
         'tabulate',
-        'ilt-inversion',
-        'mpmath',
-        'gmpy2',
         'openpyxl'
-    ]
+    ],
+    extras_require={
+        'aquifer': ['ilt-inversion', 'mpmath', 'gmpy2'],
+    }
 )

{pyrestoolbox-3.8.5 → pyrestoolbox-3.8.6}/src/gwr.rs

@@ -13,7 +13,7 @@
 
 use pyo3::prelude::*;
 use rug::Float;
-use rug::float::Round;
+use rug::float::{Constant, Round};
 use rug::ops::AssignRound;
 
 // =========================================================================
@@ -46,10 +46,39 @@ fn float_from_f64(val: f64, prec: u32) -> Float {
 // Small x: power series for I_n(x), then multiply by exp(-x) / exp(x).
 // Large x: asymptotic expansion gives scaled forms directly.
 //
-// Threshold: x > 20 uses asymptotic. Series converges for all x but
-// K_n series has catastrophic cancellation for large x.
+// The switch point depends on the working precision. The asymptotic series,
+// optimally truncated, is only good to a relative e^(-2x), so it is used only
+// once that is below 2^-prec (with a margin). Below the switch the K_n series
+// cancels terms of size e^x down to a result of size e^-x, so the series runs
+// with 2x*log2(e) guard bits. A fixed x > 25 switch with x*log2(e) guard bits
+// limited the transform to about 22 digits; GWR needs about 2.1*M digits.
+
+const ASYMP_MARGIN_BITS: f64 = 16.0;
+const SERIES_EXTRA_GUARD_BITS: u32 = 20;
+
+/// True when the asymptotic expansion reaches `prec` bits at `x`.
+fn use_asymptotic(x: &Float, prec: u32) -> bool {
+    2.0 * x.to_f64() * std::f64::consts::LOG2_E > prec as f64 + ASYMP_MARGIN_BITS
+}
+
+/// True when `term` no longer changes `sum` at `prec` bits.
+fn series_negligible(term: &Float, sum: &Float, prec: u32) -> bool {
+    match (term.get_exp(), sum.get_exp()) {
+        (Some(te), Some(se)) => te < se - prec as i32,
+        _ => term.is_zero(),
+    }
+}
 
-const BESSEL_THRESHOLD: f64 = 25.0;
+/// Scaled Bessel value from a power series: series(x) * exp(exp_sign * x),
+/// evaluated with enough guard bits to absorb the K_n cancellation.
+fn scaled_series(x: &Float, prec: u32, series: fn(&Float, u32) -> Float, exp_sign: i32) -> Float {
+    let guard = (2.0 * x.to_f64() * std::f64::consts::LOG2_E).ceil() as u32 + SERIES_EXTRA_GUARD_BITS;
+    let hp = prec + guard;
+    let xhp = Float::with_val(hp, x);
+    let val = series(&xhp, hp);
+    let scale = Float::with_val(hp, &xhp * exp_sign).exp();
+    Float::with_val(prec, Float::with_val(hp, &val * &scale))
+}
 
 // --- Asymptotic expansion for large x ---
 // I_ν(x) ~ e^x / sqrt(2πx) * sum_{k=0}^K (-1)^k * a_k(ν) / x^k
@@ -98,7 +127,7 @@ fn mpfr_besseli0e_asymp(x: &Float, prec: u32) -> Float {
     }
 
     // I_0e(x) = sum / sqrt(2*pi*x)
-    let two_pi_x = Float::with_val(prec, x * std::f64::consts::TAU);
+    let two_pi_x = Float::with_val(prec, x * Float::with_val(prec, Constant::Pi)) * 2u32;
     Float::with_val(prec, &sum / two_pi_x.sqrt())
 }
 
@@ -112,8 +141,10 @@ fn mpfr_besseli1e_asymp(x: &Float, prec: u32) -> Float {
 
     for k in 1u64..200 {
         let sq = (2 * k - 1) * (2 * k - 1);
-        // factor for nu=1: (4 - (2k-1)^2) / (8*k*x)
-        let numer = 4i64 - sq as i64;
+        // factor for nu=1: -(4 - (2k-1)^2) / (8*k*x), the minus being the (-1)^k
+        // of the I expansion (I_0 folds it in the same way, as +(2k-1)^2):
+        // 1 - 3/(8x) - 15/(128x^2) - ..., A&S 9.7.1
+        let numer = sq as i64 - 4i64;
         a_k *= Float::with_val(prec, numer);
         a_k /= 8u32 * k as u32;
         a_k *= &one_over_x;
@@ -126,7 +157,7 @@ fn mpfr_besseli1e_asymp(x: &Float, prec: u32) -> Float {
         sum += &a_k;
     }
 
-    let two_pi_x = Float::with_val(prec, x * std::f64::consts::TAU);
+    let two_pi_x = Float::with_val(prec, x * Float::with_val(prec, Constant::Pi)) * 2u32;
     Float::with_val(prec, &sum / two_pi_x.sqrt())
 }
 
@@ -181,7 +212,7 @@ fn mpfr_besselk0e_asymp(x: &Float, prec: u32) -> Float {
         sum += &a_k;
     }
 
-    let pi_over_2x = Float::with_val(prec, std::f64::consts::FRAC_PI_2) / x;
+    let pi_over_2x = Float::with_val(prec, Float::with_val(prec, Constant::Pi) / x) / 2u32;
     Float::with_val(prec, &sum * pi_over_2x.sqrt())
 }
 
@@ -208,7 +239,7 @@ fn mpfr_besselk1e_asymp(x: &Float, prec: u32) -> Float {
         sum += &a_k;
     }
 
-    let pi_over_2x = Float::with_val(prec, std::f64::consts::FRAC_PI_2) / x;
+    let pi_over_2x = Float::with_val(prec, Float::with_val(prec, Constant::Pi) / x) / 2u32;
     Float::with_val(prec, &sum * pi_over_2x.sqrt())
 }
 
@@ -224,7 +255,7 @@ fn mpfr_besseli0_series(x: &Float, prec: u32) -> Float {
         term *= &x2_over4;
         term /= k * k;
         result += &term;
-        if term.is_zero() || (k > 10 && Float::with_val(prec, &term / &result).to_f64().abs() < 1e-50) {
+        if k > 10 && series_negligible(&term, &result, prec) {
             break;
         }
     }
@@ -241,7 +272,7 @@ fn mpfr_besseli1_series(x: &Float, prec: u32) -> Float {
         term *= &x2_over4;
         term /= k * (k + 1);
         sum += &term;
-        if term.is_zero() || (k > 10 && Float::with_val(prec, &term / &sum).to_f64().abs() < 1e-50) {
+        if k > 10 && series_negligible(&term, &sum, prec) {
             break;
         }
     }
@@ -252,8 +283,7 @@ fn mpfr_besseli1_series(x: &Float, prec: u32) -> Float {
 /// K_0(x) = -(ln(x/2) + gamma) * I_0(x) + sum_{k=1}^inf H_k * (x^2/4)^k / (k!)^2
 fn mpfr_besselk0_series(x: &Float, prec: u32) -> Float {
     let i0 = mpfr_besseli0_series(x, prec);
-    let gamma = Float::with_val(prec,
-        Float::parse("0.57721566490153286060651209008240243104215933593992").unwrap());
+    let gamma = Float::with_val(prec, Constant::Euler);
     let ln_x_over_2 = Float::with_val(prec, x / 2u32).ln();
 
     let mut result = Float::with_val(prec, &ln_x_over_2 + &gamma);
@@ -270,7 +300,7 @@ fn mpfr_besselk0_series(x: &Float, prec: u32) -> Float {
         h_k += Float::with_val(prec, 1) / Float::with_val(prec, k);
         let contribution = Float::with_val(prec, &h_k * &term);
         result += &contribution;
-        if contribution.is_zero() || (k > 10 && Float::with_val(prec, &contribution / &result).to_f64().abs() < 1e-50) {
+        if k > 10 && series_negligible(&contribution, &result, prec) {
             break;
         }
     }
@@ -289,59 +319,19 @@ fn mpfr_besselk1_series(x: &Float, prec: u32) -> Float {
 // --- Dispatch: series or asymptotic ---
 
 fn mpfr_besseli0e(x: &Float, prec: u32) -> Float {
-    if x.to_f64() < BESSEL_THRESHOLD {
-        // I_0(x)*exp(-x): I_0 ~ exp(x)/sqrt(2πx), so product ~ 1/sqrt(2πx).
-        // Need guard bits ≈ x*log2(e) to preserve precision in I_0 before scaling.
-        let guard = (x.to_f64() * std::f64::consts::LOG2_E).ceil() as u32 + 20;
-        let hp = prec + guard;
-        let xhp = Float::with_val(hp, x);
-        let i0 = mpfr_besseli0_series(&xhp, hp);
-        let result = Float::with_val(hp, &i0 * Float::with_val(hp, -&xhp).exp());
-        Float::with_val(prec, &result)
-    } else {
-        mpfr_besseli0e_asymp(x, prec)
-    }
+    if use_asymptotic(x, prec) { mpfr_besseli0e_asymp(x, prec) } else { scaled_series(x, prec, mpfr_besseli0_series, -1) }
 }
 
 fn mpfr_besseli1e(x: &Float, prec: u32) -> Float {
-    if x.to_f64() < BESSEL_THRESHOLD {
-        let guard = (x.to_f64() * std::f64::consts::LOG2_E).ceil() as u32 + 20;
-        let hp = prec + guard;
-        let xhp = Float::with_val(hp, x);
-        let i1 = mpfr_besseli1_series(&xhp, hp);
-        let result = Float::with_val(hp, &i1 * Float::with_val(hp, -&xhp).exp());
-        Float::with_val(prec, &result)
-    } else {
-        mpfr_besseli1e_asymp(x, prec)
-    }
+    if use_asymptotic(x, prec) { mpfr_besseli1e_asymp(x, prec) } else { scaled_series(x, prec, mpfr_besseli1_series, -1) }
 }
 
 fn mpfr_besselk0e(x: &Float, prec: u32) -> Float {
-    if x.to_f64() < BESSEL_THRESHOLD {
-        // Guard bits to compensate for cancellation in K_0 series.
-        // Cancellation is O(e^x), needing ~x*log2(e) extra bits.
-        let guard = (x.to_f64() * std::f64::consts::LOG2_E).ceil() as u32 + 20;
-        let hp = prec + guard;
-        let xhp = Float::with_val(hp, x);
-        let k0 = mpfr_besselk0_series(&xhp, hp);
-        let result = Float::with_val(hp, &k0 * xhp.exp());
-        Float::with_val(prec, &result)
-    } else {
-        mpfr_besselk0e_asymp(x, prec)
-    }
+    if use_asymptotic(x, prec) { mpfr_besselk0e_asymp(x, prec) } else { scaled_series(x, prec, mpfr_besselk0_series, 1) }
 }
 
 fn mpfr_besselk1e(x: &Float, prec: u32) -> Float {
-    if x.to_f64() < BESSEL_THRESHOLD {
-        let guard = (x.to_f64() * std::f64::consts::LOG2_E).ceil() as u32 + 20;
-        let hp = prec + guard;
-        let xhp = Float::with_val(hp, x);
-        let k1 = mpfr_besselk1_series(&xhp, hp);
-        let result = Float::with_val(hp, &k1 * xhp.exp());
-        Float::with_val(prec, &result)
-    } else {
-        mpfr_besselk1e_asymp(x, prec)
-    }
+    if use_asymptotic(x, prec) { mpfr_besselk1e_asymp(x, prec) } else { scaled_series(x, prec, mpfr_besselk1_series, 1) }
 }
 
 // =========================================================================
@@ -620,6 +610,40 @@ mod tests {
         assert!(k0e.to_f64() > 0.0);
     }
 
+    /// Series and asymptotic paths agree to the working precision just past
+    /// the switch point, at the precisions GWR uses for M = 12 and M = 32.
+    #[test]
+    fn test_bessel_series_asymptotic_overlap() {
+        type Pair = (fn(&Float, u32) -> Float, fn(&Float, u32) -> Float, i32);
+        let pairs: [Pair; 4] = [
+            (mpfr_besseli0_series, mpfr_besseli0e_asymp, -1),
+            (mpfr_besseli1_series, mpfr_besseli1e_asymp, -1),
+            (mpfr_besselk0_series, mpfr_besselk0e_asymp, 1),
+            (mpfr_besselk1_series, mpfr_besselk1e_asymp, 1),
+        ];
+        for prec in [dec_to_bits(25), dec_to_bits(67)] {
+            let x_switch = (prec as f64 + ASYMP_MARGIN_BITS) / (2.0 * std::f64::consts::LOG2_E);
+            let x = Float::with_val(prec, x_switch + 0.5);
+            for (series, asymp, sign) in pairs {
+                let a = scaled_series(&x, prec, series, sign);
+                let b = asymp(&x, prec);
+                let rel = Float::with_val(prec, Float::with_val(prec, &a - &b) / &b).abs();
+                let bits = -rel.to_f64().log2();
+                assert!(bits > prec as f64 - 12.0, "prec {}: only {:.0} bits agree", prec, bits);
+            }
+        }
+    }
+
+    /// K_0 at the GWR abscissa where a 60-bit evaluation loses every digit
+    /// (mpmath: K_0(23.548200450309494) = 1.52394442662604e-11).
+    #[test]
+    fn test_besselk0_mid_argument() {
+        let prec = dec_to_bits(15);
+        let x = Float::with_val(prec, 23.548200450309494);
+        let k0 = mpfr_besselk0e(&x, prec).to_f64() * (-23.548200450309494_f64).exp();
+        assert!((k0 / 1.52394442662604e-11 - 1.0).abs() < 1e-13, "K_0 = {}", k0);
+    }
+
     #[test]
     fn test_gwr_coefficients_m4() {
         let coeffs = GwrCoefficients::new(4, 20);