executable-engineering 0.1.35__py3-none-any.whl → 0.1.38__py3-none-any.whl

executable_engineering/__init__.py

@@ -5,9 +5,11 @@ from .closedoptimization_module import OptimizerClosed
 from .openoptimization_module import OptimizerOpen
 from .gradientoptimization_module import OptimizerGrad
 from .numerical_error_module import python_internal_binary, decimal_to_binary
-from .linearsystems_module import visual_solve_2d, visualize_conditioning, visualize_matrix_norms, jacobi_step, gauss_seidel_step, sor_step, visualize_convergence_2d, create_diagonally_dominant_matrix, iter_solve, steepest_descent, conjugate_gradient, IterationTracker
+from .linearsystems_module import visual_solve_2d, visualize_conditioning, visualize_matrix_norms, jacobi_step, gauss_seidel_step, sor_step, visualize_convergence_2d, create_diagonally_dominant_matrix, iter_solve, steepest_descent, conjugate_gradient, IterationTracker, discretise_poisson, spai
 
 __all__ = [
+  "discretise_poisson",
+  "spai",
   "visual_solve_2d",
   "visualize_conditioning",
   "visualize_matrix_norms",

executable_engineering/linearsystems_module.py

@@ -430,13 +430,105 @@ class IterationTracker:
     """
     A clean callback tracker for native SciPy solvers (cg, gmres, etc.).
     """
-    def __init__(self, x0=None):
+    def __init__(self, x0=None, A=None, b=None, print_residual=False):
         import numpy as np
         if x0 is not None:
             self.iterations = [np.array(x0).copy()]
         else:
             self.iterations = []
+            
+        self.residuals = []
+        self.A = A
+        self.b = b
+        self.print_residual = print_residual
+        self.step = 0
+        
+        if A is not None and b is not None and x0 is not None:
+            x_arr = np.array(x0)
+            res = np.linalg.norm(A @ x_arr - b)
+            self.residuals.append(res)
+            if self.print_residual:
+                guess_str = np.array2string(x_arr, precision=4, separator=', ', suppress_small=True)
+                print(f"Step {self.step}: Guess = {guess_str}, Residual = {res:.4e}")
 
     def __call__(self, xk):
         import numpy as np
-        self.iterations.append(np.array(xk).copy())
+        self.step += 1
+        
+        # Check if xk is a scalar (i.e. callback_type='pr_norm' in GMRES)
+        if np.isscalar(xk) or (isinstance(xk, np.ndarray) and xk.size == 1):
+            res = float(np.squeeze(xk))
+            self.residuals.append(res)
+            if self.print_residual:
+                print(f"Step {self.step}: Residual = {res:.4e} (Guess vector xk not computed by SciPy GMRES)")
+        else:
+            # xk is a vector (i.e. from CG)
+            x = np.array(xk).copy()
+            self.iterations.append(x)
+            if self.A is not None and self.b is not None:
+                res = np.linalg.norm(self.A @ x - self.b)
+                self.residuals.append(res)
+                if self.print_residual:
+                    guess_str = np.array2string(x, precision=4, separator=', ', suppress_small=True)
+                    print(f"Step {self.step}: Guess = {guess_str}, Residual = {res:.4e}")
+
+
+def discretise_poisson(N, Q):
+    """Generate the matrix and rhs associated with the discrete Poisson operator."""
+    import numpy as np
+    from scipy.sparse import coo_matrix
+
+    nelements = 5 * N**2 - 16 * N + 16
+
+    row_ind = np.empty(nelements, dtype=np.float64)
+    col_ind = np.empty(nelements, dtype=np.float64)
+    data = np.empty(nelements, dtype=np.float64)
+
+    f = np.empty(N * N, dtype=np.float64)
+
+    count = 0
+    for j in range(N):
+        for i in range(N):
+            if i == 0 or i == N - 1 or j == 0 or j == N - 1:
+                row_ind[count] = col_ind[count] = j * N + i
+                data[count] =  1
+                f[j * N + i] = 0
+                count += 1
+
+            else:
+                row_ind[count : count + 5] = j * N + i
+                col_ind[count] = j * N + i
+                col_ind[count + 1] = j * N + i + 1
+                col_ind[count + 2] = j * N + i - 1
+                col_ind[count + 3] = (j + 1) * N + i
+                col_ind[count + 4] = (j - 1) * N + i
+
+                data[count] = 4 * (N - 1)**2
+                data[count + 1 : count + 5] = - (N - 1)**2
+                f[j * N + i] = Q
+
+                count += 5
+
+    return coo_matrix((data, (row_ind, col_ind)), shape=(N**2, N**2)).tocsr(), f
+
+def spai(A, m):
+    """Perform m step of the SPAI iteration."""
+    import numpy as np
+    from scipy.sparse import identity
+    from scipy.sparse.linalg import onenormest
+
+    n = A.shape[0]
+
+    ident = identity(n, format='csr')
+    alpha = 2 / onenormest(A @ A.T)
+    M = alpha * A
+
+    for index in range(m):
+        C = A @ M
+        G = ident - C
+        AG = A @ G
+        trace = (G.T @ AG).diagonal().sum()
+        alpha = trace / np.linalg.norm(AG.data)**2
+        M = M + alpha * G
+
+    return M

{executable_engineering-0.1.35.dist-info → executable_engineering-0.1.38.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: executable_engineering
-Version: 0.1.35
+Version: 0.1.38
 Summary: Demonstrative tools for the Executable Engineering textbook
 Home-page: https://github.com/themintlab/ExecutableEngineering/tree/main/executable_engineering
 Author: Michael Welland

{executable_engineering-0.1.35.dist-info → executable_engineering-0.1.38.dist-info}/RECORD

@@ -1,14 +1,14 @@
-executable_engineering/__init__.py,sha256=GiYYijxAfiee44SRLXjMsFCa3xOPWtUx0tnlWm4G6TM,1596
+executable_engineering/__init__.py,sha256=TbE18BDMSDAqyHnJI0XQXMIcM6bXQv8ebV3rWijyVP0,1656
 executable_engineering/closedoptimization_module.py,sha256=i9KkdulyCZmriYKlx0CuUetjoMmxJm9ADWgStU3w85w,9273
 executable_engineering/closedrootfinder_module.py,sha256=ozccVABOrTiqcdkkqwAWRNo04MsDC0Z_f_tfukl3q20,5706
 executable_engineering/gradientoptimization_module.py,sha256=-2fErE9cemSEPeV9PlWOf4cF7Tr6DjilEw_NxvE-JYw,6601
-executable_engineering/linearsystems_module.py,sha256=4fJyuFGUdm2FKiydDD-_vAh1O9XEH8f0puBKWkGtlqM,15101
+executable_engineering/linearsystems_module.py,sha256=w6UkwZu80gUz5bAIWY47xJbwaEVzR9tCcIBkMsKjIRk,18356
 executable_engineering/neuralnet_module.py,sha256=Hu9QFoMyODg4RCEpHmT9zTwzjcVFYM8ZLYtbB3CbrsA,10102
 executable_engineering/numerical_error_module.py,sha256=wxfYP8u29c19I2D6MxpQV3zDMV0DpS1QUqFpp3f6eGE,1204
 executable_engineering/openoptimization_module.py,sha256=OCPyrynkTo1It50RoT7irnL72aQn6FexE_R1SfFYxlg,8590
 executable_engineering/openrootfinder_module.py,sha256=rmXDi0XdrDYdLZdPFgYCihMg_4NF1D71i6kh8Kx-V2w,5802
-executable_engineering-0.1.35.dist-info/licenses/LICENSE,sha256=Tg4nrt8rFhgpkPbIA8SWoCR3MlGLw0NufB8AE6-TH_o,1074
-executable_engineering-0.1.35.dist-info/METADATA,sha256=g6kHizAHnhfStOWrQIt53yY59SAdmTmiojVJ2hTvA1I,1648
-executable_engineering-0.1.35.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-executable_engineering-0.1.35.dist-info/top_level.txt,sha256=0U5ATV5WGTLvN9rRSjQ54TyL-ztTyXaN3FzZ_QMq4HM,23
-executable_engineering-0.1.35.dist-info/RECORD,,
+executable_engineering-0.1.38.dist-info/licenses/LICENSE,sha256=Tg4nrt8rFhgpkPbIA8SWoCR3MlGLw0NufB8AE6-TH_o,1074
+executable_engineering-0.1.38.dist-info/METADATA,sha256=541f1AVAklhM94uez2A7obug_jOUPVS5eZMdGoQrWlI,1648
+executable_engineering-0.1.38.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+executable_engineering-0.1.38.dist-info/top_level.txt,sha256=0U5ATV5WGTLvN9rRSjQ54TyL-ztTyXaN3FzZ_QMq4HM,23
+executable_engineering-0.1.38.dist-info/RECORD,,