implement integrator_coeffs using module.__getattr__

Author: basnijholt

adaptive/learner/integrator_coeffs.py

@@ -2,15 +2,11 @@
 
 from collections import defaultdict
 from fractions import Fraction
+from functools import lru_cache
 
 import numpy as np
 import scipy.linalg
 
-try:
-    from functools import cached_property
-except ImportError:
-    from adaptive.utils import cached_property
-
 
 def legendre(n):
     """Return the first n Legendre polynomials.
@@ -146,72 +142,48 @@ def calc_V(x, n):
     return np.array(V).T
 
 
-class Coefficients:
-    def __init__(self) -> None:
-        # The nodes
-        self.ns = (5, 9, 17, 33)
-
-        # If the relative difference between two consecutive approximations is
-        # lower than this value, the error estimate is considered reliable.
-        # See section 6.2 of Pedro Gonnet's thesis.
-        self.hint = 0.1
-
-        # Smallest acceptable relative difference of points in a rule.  This was chosen
-        # such that no artifacts are apparent in plots of (i, log(a_i)), where a_i is
-        # the sequence of estimates of the integral value of an interval and all its
-        # ancestors..
-        self.eps = np.spacing(1)
-        self.min_sep = 16 * self.eps
-
-        # Maximum amount of subdivisions
-        self.ndiv_max = 20
-
-    @cached_property
-    def xi(self):
-        # The Newton polynomials
-        xi = [-np.cos(np.linspace(0, np.pi, n)) for n in self.ns]
-        # Make `xi` perfectly anti-symmetric, important for splitting the intervals
-        return [(row - row[::-1]) / 2 for row in xi]
-
-    @cached_property
-    def V(self):
-        # Compute the Vandermonde-like matrix and its inverse.
-        return [calc_V(x, n) for x, n in zip(self.xi, self.ns)]
-
-    @cached_property
-    def V_inv(self):
-        # Compute the inverse Vandermonde-like matrix
-        return list(map(scipy.linalg.inv, self.V))
-
-    @cached_property
-    def Vcond(self):
-        return [
-            scipy.linalg.norm(a, 2) * scipy.linalg.norm(b, 2)
-            for a, b in zip(self.V, self.V_inv)
-        ]
-
-    @cached_property
-    def k(self):
-        return np.arange(self.ns[3])
-
-    @cached_property
-    def T_right(self):
-        return self.V_inv[3] @ calc_V((self.xi[3] + 1) / 2, self.ns[3])
-
-    @cached_property
-    def T_left(self):
-        return self.V_inv[3] @ calc_V((self.xi[3] - 1) / 2, self.ns[3])
-
-    @cached_property
-    def alpha(self):
-        return np.sqrt((self.k + 1) ** 2 / (2 * self.k + 1) / (2 * self.k + 3))
-
-    @cached_property
-    def gamma(self):
-        return np.concatenate(
-            [[0, 0], np.sqrt(self.k[2:] ** 2 / (4 * self.k[2:] ** 2 - 1))]
-        )
-
-    @cached_property
-    def b_def(self):
-        return calc_bdef(self.ns)
+@lru_cache(maxsize=None)
+def _coefficients():
+    eps = np.spacing(1)
+
+    # the nodes and Newton polynomials
+    ns = (5, 9, 17, 33)
+    xi = [-np.cos(np.linspace(0, np.pi, n)) for n in ns]
+
+    # Make `xi` perfectly anti-symmetric, important for splitting the intervals
+    xi = [(row - row[::-1]) / 2 for row in xi]
+
+    # Compute the Vandermonde-like matrix and its inverse.
+    V = [calc_V(x, n) for x, n in zip(xi, ns)]
+    V_inv = list(map(scipy.linalg.inv, V))
+    Vcond = [
+        scipy.linalg.norm(a, 2) * scipy.linalg.norm(b, 2) for a, b in zip(V, V_inv)
+    ]
+
+    # Compute the shift matrices.
+    T_left, T_right = [V_inv[3] @ calc_V((xi[3] + a) / 2, ns[3]) for a in [-1, 1]]
+
+    # If the relative difference between two consecutive approximations is
+    # lower than this value, the error estimate is considered reliable.
+    # See section 6.2 of Pedro Gonnet's thesis.
+    hint = 0.1
+
+    # Smallest acceptable relative difference of points in a rule.  This was chosen
+    # such that no artifacts are apparent in plots of (i, log(a_i)), where a_i is
+    # the sequence of estimates of the integral value of an interval and all its
+    # ancestors..
+    min_sep = 16 * eps
+
+    ndiv_max = 20
+
+    # set-up the downdate matrix
+    k = np.arange(ns[3])
+    alpha = np.sqrt((k + 1) ** 2 / (2 * k + 1) / (2 * k + 3))
+    gamma = np.concatenate([[0, 0], np.sqrt(k[2:] ** 2 / (4 * k[2:] ** 2 - 1))])
+
+    b_def = calc_bdef(ns)
+    return locals()
+
+
+def __getattr__(attr):
+    return _coefficients()[attr]

adaptive/learner/integrator_learner.py

@@ -10,14 +10,11 @@
 from scipy.linalg import norm
 from sortedcontainers import SortedSet
 
+import adaptive.learner.integrator_coeffs as coeff
 from adaptive.learner.base_learner import BaseLearner
 from adaptive.notebook_integration import ensure_holoviews
 from adaptive.utils import cache_latest, restore
 
-from .integrator_coeffs import Coefficients
-
-coeff = Coefficients()
-
 
 def _downdate(c, nans, depth):
     # This is algorithm 5 from the thesis of Pedro Gonnet.

adaptive/tests/test_cquad.py

@@ -4,17 +4,15 @@
 import numpy as np
 import pytest
 
+import adaptive.learner.integrator_coeffs as coeff
 from adaptive.learner import IntegratorLearner
-from adaptive.learner.integrator_coeffs import Coefficients
 from adaptive.learner.integrator_learner import DivergentIntegralError
 
 from .algorithm_4 import DivergentIntegralError as A4DivergentIntegralError
 from .algorithm_4 import algorithm_4, f0, f7, f21, f24, f63, fdiv
 
 eps = np.spacing(1)
 
-ns = Coefficients().ns
-
 
 def run_integrator_learner(f, a, b, tol, n):
     learner = IntegratorLearner(f, bounds=(a, b), tol=tol)
@@ -247,7 +245,7 @@ def test_removed_choose_mutiple_points_at_once():
     we should use the high-precision interval.
     """
     learner = IntegratorLearner(np.exp, bounds=(0, 1), tol=1e-15)
-    n = ns[-1] + 2 * (ns[0] - 2)  # first + two children (33+6=39)
+    n = coeff.ns[-1] + 2 * (coeff.ns[0] - 2)  # first + two children (33+6=39)
     xs, _ = learner.ask(n)
     for x in xs:
         learner.tell(x, learner.function(x))
@@ -259,7 +257,7 @@ def test_removed_ask_one_by_one():
         # This test should raise because integrating np.exp should be done
         # after the 33th point
         learner = IntegratorLearner(np.exp, bounds=(0, 1), tol=1e-15)
-        n = ns[-1] + 2 * (ns[0] - 2)  # first + two children (33+6=39)
+        n = coeff.ns[-1] + 2 * (coeff.ns[0] - 2)  # first + two children (33+6=39)
         for _ in range(n):
             xs, _ = learner.ask(1)
             for x in xs:

adaptive/utils.py

@@ -83,7 +83,3 @@ def __call__(self, *args, **kwargs):
                     msg = f"The attribute '{name}' should be of type {type_}, not {type(x)}."
                     raise TypeError(msg)
         return obj
-
-
-def cached_property(f):
-    return property(functools.lru_cache(None)(f))