NRSAI: An Adaptive and Efficient Preconditioner for Large Sparse Linear Systems

Abstract

This paper presents a new Residual-based Sparse Approximate Inverse algorithm, designed to be automatic, computationally efficient, and highly parallelizable. After briefly reviewing Frobenius-norm-based preconditioning techniques and identifying two key challenges in this class of methods, we introduce an improved approach that integrates adaptive strategies from the Power Sparse Approximate Inverse algorithm and incomplete LU factorization. The method leverages the Hamilton–Cayley theorem for effective sparsity pattern construction and employs LU decomposition for efficient implementation. Theoretical analysis establishes the convergence properties and computational features of the proposed algorithm. Numerical experiments using real-world data demonstrate that the proposed algorithm significantly outperforms established methods—including the Sparse Approximate Inverse, Power Sparse Approximate Inverse and Residual-based Sparse Approximate Inverse algorithms—with a Generalized Minimal Residual iterative solver, confirming its superior efficiency and practical applicability.

1. Introduction

Most practical challenges encountered in industrial production and daily life can be formulated as problems within the realm of scientific computing. Among these, the solution to the following large sparse linear systems constitutes a core issue that our research focuses on:

$$\begin{array}{c}\hfill Ax=b,\end{array}$$

(1)

where $A\in {\mathbb{R}}^{n\times n}$ is a nonsymmetric coefficient matrix and $b\in {\mathbb{R}}^n$ is a given vector. The primary approaches for solving linear systems fall into two categories: direct methods and iterative methods. In most practical scenarios, the matrix A arises from the linearized discretization of partial differential equations, where the dimension n can be exceedingly large. Under such conditions, direct solution methods become infeasible due to excessive memory requirements and computational costs. Consequently, the use of iterative methods is often unavoidable [1,2,3,4,5,6,7,8].

Currently, the most widely used iterative methods can be broadly divided into two main categories. The first consists of stationary iterative methods based on matrix splitting. Among these, the most fundamental are the Jacobi, Gauss–Seidel, and Successive Over-Relaxation (SOR) iterations. More advanced variants include multigrid-like techniques, the Symmetric Successive Over-Relaxation (SSOR) iteration, Uzawa iteration, and the well-known Hermitian and Skew-Hermitian Splitting (HSS) iteration [9,10]—which have attracted significant scholarly attention—along with their various improvements and extensions. While these methods are straightforward in form and relatively easy to implement, their performance often depends critically on the choice of parameters; however, this dependency has been largely mitigated for the HSS method through effective preconditioning strategies. Notably, the work in [11] showed that, with a proper preconditioner, the parameter $\alpha$ can be set to 1 optimally for a broad class of problems. The second major category comprises Krylov subspace methods. Among these, the most commonly applied are the Generalized Minimal Residual (GMRES) method [12], the Quasi-Minimal Residual (QMR) method [13], and the Biconjugate Gradient Stabilized (BICGSTAB) method [14]. However, Krylov iterative solvers often suffer from slow convergence when the coefficient matrix A exhibits unfavorable spectral properties or is ill-conditioned [10]. To accelerate their convergence, it is essential to incorporate preconditioning techniques designed to improve the conditioning of the system—ideally reducing the condition number of the matrix to close to one. At present, widely used preconditioning strategies encompass several major classes. These include general algebraic methods like incomplete LU (ILU) factorization and sparse approximate inverses. For structured problems, particularly those derived from partial differential equations, highly efficient alternatives are available, such as multigrid methods and structured preconditioners based on matrix algebras (e.g., [15,16,17,18]). The latter are defined by seeking an approximate inverse within a specific matrix algebra characterized by $O\left(n\right)$ free parameters, rather than a prescribed sparsity pattern, offering a powerful compromise between accuracy and computational cost.

The rapid advancement of parallel computing highlights a fundamental principle: algorithms with high parallel efficiency are more likely to prevail in the future [19]. Fortunately, Krylov subspace-based iterative methods align well with this requirement, as key operations such as matrix–vector products, dot products, and vector updates can be efficiently parallelized in theory [6]. It should be acknowledged that conventional preconditioners, exemplified by ILU factorization, demonstrate excellent performance in iterative computation. Nevertheless, these methods often suffer from inherent limitations in parallelizability or require highly complex implementations to achieve parallel execution for specific problems [19,20].

The foundation of the most straightforward sparse approximate inverse approach rests on the assumption that a sparse matrix M can effectively approximate the inverse of the matrix A, denoted as $A^{-1}$ [21]. This preconditioning matrix M is then employed either to reduce the condition number of the original system or to distribute the spectrum in a favourable way [22,23], thereby accelerating the convergence of iterative solvers for the linear equations. The core challenge involves constructing such a matrix M and efficiently solving the resulting right- or left-preconditioned system through iterative methods

$$AMy=b,x=My,\mathrm{or}MAx=Mb.$$

(2)

It is evident that sparse approximate inverse preconditioners participate in the iterative solution process by constructing an explicit approximation M of $A^{-1}$. This implies that M operates via matrix–vector products throughout the computation, endowing the method with inherent parallelizability [5,24,25]. Moreover, in parallel computing environments, the overall performance of such preconditioners is highly dependent on the sparsity pattern and quality of M [6].

Another significant advantage of sparse approximate inverse preconditioners is their robustness [26]. Although incomplete factorization preconditioners often demonstrate strong performance, they are prone to various forms of numerical instability [27,28]. For example, even when applied to well-behaved symmetric positive definite matrices, standard incomplete Cholesky factorization may fail unless specific conditions are met—such as when the matrix is an H-matrix [29,30]. In contrast, sparse approximate inverse techniques are generally free from such limitations, contributing to their broader applicability [26].

Owing to the considerable advantages of sparse approximate inverse techniques [31], significant research attention has been attracted in recent years, supported by rigorous theoretical analyses that substantiate these benefits [5,25,32,33,34,35,36,37,38,39,40]. Currently, two main methodologies prevail for implementing sparse approximate inverse preconditioners: one relies on preprocessing through matrix factorization, while the other seeks preconditioners by minimizing the Frobenius norm, as in the case of the structurted preconditioning [15,16,18]. When matrix factorization is efficiently organized via an incomplete Gram–Schmidt procedure, the classic approximate inverse algorithm algorithm [33,34] emerges as a prominent representative of the first category. The second approach depends critically on two factors: predefined sparsity patterns and adaptive iterative algorithms, with the SParse Approximate Inverse (SPAI) algorithm [5] serving as the archetype in this class.

This paper introduces more effective algorithms designed to address specific challenges in the modeling of estuarine and coastal environments. Unlike the open ocean and continental shelf seas, these regions are characterized by complex shorelines, islands, and shoals, which introduce substantial dynamical and geometric complications. Practical limitations often hinder comprehensive empirical observation and data collection in such areas, making full reliance on measurements infeasible. Furthermore, since theoretical models are inherently simplified representations of reality, they alone cannot fully capture the complex physical processes occurring in coastal waters. In light of these constraints, numerical simulation becomes an essential tool for studying estuary and coastal dynamics.

Two primary types of numerical ocean models are widely used: those based on structured quadrilateral grids and those employing unstructured triangular grids. To achieve high resolution without prohibitive computational cost, we have developed an ocean model that utilizes two-way nested quadrilateral grids. By incorporating both hydrostatic and non-hydrostatic approximations, this model supports the simulation of multi-scale processes within a unified framework.

Following the model development, the emphasis shifts to its efficient numerical solution. The bidirectionally nested quadrilateral grid ocean model is specifically designed to capture the unique hydrodynamic features of estuaries and coastal zones, employing locally refined nested grids to enhance resolution. While this approach improves accuracy, it imposes stringent constraints on the time step and substantially increases computational cost. The resulting discretized linear systems are both large-scale and highly sparse [41,42]. Therefore, a key objective of this paper is to develop efficient parallel algorithms tailored to such systems, addressing the specific numerical challenges posed by this model.

We propose customized algorithms for the effective solution of these discretized linear equations. The coefficient matrices and right-hand side vectors used in our numerical experiments are derived from discretizations of the model at various resolutions. Specifically, four test cases are considered, with coefficient matrix dimensions of $2565 \times 2565$, $15,601 \times 15,601$, $20,785 \times 20,785$, and $34,737 \times 34,737$, respectively.

In this work, we introduce a new variant of the Residual-based Sparse Approximate Inverse (RSAI [43]) algorithm, designated the New RSAI (NRSAI) algorithm, which is designed to be automatic, computationally efficient, and highly parallelizable. Section 2 provides a concise overview of the original RSAI method, highlighting its ability to adaptively construct preconditioning matrices using residual-based information. In Section 3, we refine the RSAI approach by incorporating strategies inspired by the Power Sparse Approximate Inverse (PSAI [44]) algorithm and ILU factorization, tailoring it to the specific structure of our problem. These modifications improve the adaptive capabilities during iteration, leading to the proposed NRSAI algorithm. Section 4 presents its theoretical analysis, establishing its convergence properties and computational characteristics. Numerical experiments are conducted in Section 5 using real-world data to demonstrate the performance advantages of the NRSAI algorithm over the RSAI, SPAI, and PSAI algorithms. Finally, Section 6 summarizes the main contributions and findings of this study.

2. The RSAI Procedure

This section begins by presenting the conceptual foundation of our methodology, followed by a concise review of the Residual-based Sparse Approximate Inverse (RSAI [43]) algorithm.

The central objective of preconditioning is to construct a matrix M that serves as an efficient approximation to $A^{-1}$. This leads to the fundamental problem formulation:

$$AM\approx E,$$

where A is a known nonsingular coefficient matrix, M is the preconditioner to be solved, and E is the identity matrix.

Methods based on sparse approximate inverse preconditioners commonly reformulate this problem through Frobenius norm minimization:

$$\begin{array}{c}\hfill \underset{M\in \mathcal{S}}{min}{\parallel AM-E\parallel }_F,\end{array}$$

(3)

over a space of matrices $\mathcal{S}$ with a prescribed sparsity pattern, where ${\parallel ·\parallel }_F$ is the Frobenius norm.

Owing to the separability and unitary invariance properties of the Frobenius norm, the global minimization problem decouples into n independent least-squares subproblems

$$\begin{array}{c}\hfill {min\parallel AM-E\parallel }_F=min\sum _{k=1}^n{\parallel A{m}_k-e_k\parallel }_2\end{array}$$

(4)

with certain sparsity constraints on M, where $m_k$ is the k-th column of M and $e_k$ is the k-th column of E, $k=1,2,\dots ,n$.

This leads to the formulation of n independent least-squares problems that can be solved in parallel:

$$\begin{array}{c}\hfill \underset{m_k\in \mathcal{S}}{min}{\parallel A{m}_k-e_k\parallel }_2.\end{array}$$

(5)

Let J denote the set of nonzero positions in $m_k$, and define I as the set of row indices corresponding to nonzero rows in the submatrix $A(:,J)$. Due to the sparsity inherent in all components of (5), and by leveraging matrix-vector operation principles, the original large-scale least-squares problem is effectively reduced to a small-scale one:

$$\begin{array}{c}\hfill \underset{m_k\left(J\right)\in \mathcal{S}}{min}{\parallel A(I,J)m_k\left(J\right)-e_k\left(I\right)\parallel }_2.\end{array}$$

(6)

This transformation substantially improves computational efficiency without compromising numerical accuracy. Further elaboration can be found in [5].

In general, determining an appropriate sparsity pattern for the preconditioner M of matrix A a priori is challenging without adequate structural information. Consequently, it is often necessary to adapt the sparsity structure of M dynamically during the iteration. Different algorithms employ distinct strategies to address this issue: the SPAI algorithm introduces an auxiliary least-squares problem; the PSAI algorithm adopts a theory-guided approach; whereas the RSAI algorithm utilizes residual information directly. The RSAI method is detailed as follows.

Consider, for instance, the solution process for the column vector $m_k$, beginning with an initial sparsity pattern $J_k^0$. Let $I_k^l$ and $J_k^l$ denote the sets of nonzero row and column indices, respectively, after l iterations. The problem solved at this stage can be expressed as:

$$\begin{array}{c}\hfill \underset{m_k\left(J_k^l\right)\in \mathcal{S}}{min}{\parallel A(I_k^l,J_k^l)m_k\left(J_k^l\right)-e_k\left(I_k^l\right)\parallel }_2,\end{array}$$

(7)

and its complete residual

$$\begin{array}{c}\hfill r_k=A{m}_k-e_k.\end{array}$$

(8)

The residual corresponding to the local problem (7) is:

$$\begin{array}{c}\hfill {\widehat{r}}_k=A(I_k^l,J_k^l)m_k\left(J_k^l\right)-e_k\left(I_k^l\right)\end{array}$$

(9)

and it satisfies $\left|\right|r_k{\left|\right|}_2=\left|\right|{\widehat{r}}_k{\left|\right|}_2$. If the convergence criterion is not met—i.e., $\left|\right|{\widehat{r}}_k{\left|\right|}_2>\epsilon$—the current approximation $m_k$ is insufficient and requires refinement.

The RSAI algorithm leverages the residual itself to guide this process. Components of $r_k$ with larger magnitudes contribute more significantly to the residual norm. Therefore, prioritizing the reduction of these dominant entries accelerates convergence.

At each iteration, the algorithm examines the residual vector $r_k$. Let $L_k$ contain the indices of all nonzero entries in $r_k$. To avoid redundant updates, a set $R_k^l$ is maintained to track indices used in previous iterations. The entries of $r_k\left(L_k\right)$ are sorted in descending order of absolute value, and the top $c_k^l$ entries not already in $R_k^l$, are selected to form a new set ${\widehat{R}}_k^l$. Then, update $R_k^{l+1}=R_k^l\cup {\widehat{R}}_k^l$.

To reduce the residual components corresponding to ${\widehat{R}}_k^l$, this set is used to identify new nonzero columns in $A({\widehat{R}}_k^l,:)$, forming a column index set $\widehat{J}$. If $\widehat{J}=\varnothing$, the algorithm proceeds to the next iteration. Otherwise, the corresponding nonzero rows are identified, yielding a row index set $\widehat{I}$. The index sets are updated as:

$$I_k^{l+1}=I_k^l\cup \widehat{I},J_k^{l+1}=J_k^l\cup \widehat{J}.$$

Further details on the solution procedure can be found in [43].

3. A New Residual-Based Sparse Approximate Inverse (NRSAI) Procedure

This section presents the proposed NRSAI algorithm (Algorithm 1) in detail.

Algorithm 1 NRSAI

Require:  the matrix A, the tolerance $\epsilon$, the column index k, the criterion $\delta$ and the parameter c. Ensure:  the k-th column $m_k$ of preconditioner M.    1: Compute the initial sparsity pattern $J_k$ of $m_k$, the set of non-zero indices in column k of E, A and $A^2$. Then compute $I_k$ from (11). Solve (12). Compute the initial residual ${\widehat{r}}_k$ via (14). $\left|\right|r_k{\left|\right|}_2=\left|\right|{\widehat{r}}_k{\left|\right|}_2$. Initialize set $\widehat{R_k}$ as an empty set.    2: while  $\left|\right|r_k{\left|\right|}_2>\epsilon$  do    3:      Compute $D=I\setminus \widehat{R_k}$. sort $|r_k\left(D\right)|$ in decreasing order. Compute $\widehat{D}$ by combining $\delta$       and c.    4:      if $\widehat{D}=\varnothing$,break.    5:      Compute $\widehat{J}=\left\{j\right|A(\widehat{D},j)\ne 0,j\notin J_k\}$.    6:      Compute $\widehat{I}=\left\{i\right|A(i,\widehat{J})\ne 0,i\notin I_k\}$.    7:      Update $I_k,J_k,\widehat{R_k}$.    8:      Solve (19).    9:      Compute the residual ${\widehat{r}}_k$ and $\left|\right|r_k{\left|\right|}_2$.  10: end while

We begin by describing the construction of the initial sparsity pattern for the sparse approximate inverse preconditioner M, adapted to the specific structure of the coefficient matrix A. As indicated in Section 2, the sparsity pattern J of each column vector $m_k$ significantly influences the resulting residual $r_k$ after solving the corresponding subproblem. A well-chosen pattern J that incorporates “high-quality” non-zero indices leads to a smaller ${\mathsf{\ell }}_2$-norm of the residual, thereby reducing the number of iterations required and improving overall computational efficiency. It is therefore essential to tailor the initial sparsity structure to the particular matrix A, rather than relying on generic templates.

Inspired by the PSAI algorithm, the sparsity pattern of M can be progressively refined using the Cayley–Hamilton theorem. According to [44], this theorem allows the inverse of A to be expressed as a matrix polynomial:

$$\begin{array}{c}\hfill A^{-1}=\sum _{i=0}^{m-1}{c}_i{A}^i,\end{array}$$

(10)

where $A^0=E$ denotes the identity matrix, and $c_i$ is a scalar coefficient for $i=0,1,\dots ,m-1$ coming from those of the characteristic polynomial of A.

In essence, the non-zero pattern of the preconditioner M can be inferred from the union of non-zero patterns across various powers of the matrix A. For most non-singular sparse matrices, the sparsity structure of M generally differs from that of A. However, directly using high powers of A leads to prohibitive computational costs. Drawing inspiration from the extension from ILU(0) to ILU(1), and to balance computational expense with effectiveness, we construct the sparsity pattern for our preconditioner by taking the union of the inherently sparse non-zero patterns of the matrices E, A and $A^2$. This approach allows us to capture more of the system’s connectivity while leveraging the naturally occurring sparsity of these operator matrices.

Since the columns of M are computed independently, we describe the procedure for a generic column $m_k$. Based on the aforementioned strategy, an initial non-zero pattern $J_k^0$ for $m_k$ is constructed. The corresponding initial row index set $I_k^0$ is then defined as:

$$\begin{array}{c}\hfill I_k^0=\left\{i\right|A(i,J_k^0)\ne 0\}.\end{array}$$

(11)

This allows the original problem to be reduced to an equivalent smaller-scale least-squares problem. Denoting $\widehat{A}=A(I_k^0,J_k^0)$, ${\widehat{m}}_k=m_k\left(J_k^0\right)$, and $\widehat{e}k=e_k\left(I_k^0\right)$, the problem becomes:

$$\begin{array}{c}\hfill \underset{{\widehat{m}}_k}{min}\parallel \widehat{A}{\widehat{m}}_k-{\widehat{e}}_k\parallel .\end{array}$$

(12)

Due to the moderate size and well-posed nature of this subproblem, it can be efficiently solved via LU decomposition in MATLAB. Once ${\widehat{m}}_k$ is obtained, the initial approximation to $m_k$ is constructed, and the full residual is computed as:

$$\begin{array}{c}\hfill r_k=A{m}_k-e_k=A(:,J_k^0)m_k\left(J_k^0\right)-e_k.\end{array}$$

(13)

Moreover, if we define the reduced residual:

$$\begin{array}{c}\hfill {\widehat{r}}_k=A(I_k^0,J_k^0)m_k\left(J_k^0\right)-e_k\left(I_k^0\right),\end{array}$$

(14)

then it follows that $\parallel {\widehat{r}}_k\parallel = \parallel r_k\parallel$.

We have established a well-defined initial problem and obtained its solution. The subsequent phase involves an adaptive iterative procedure, which focuses on the residual vector $r_k$.

Under the initial configuration, let $m_k$ denote the current approximation produced by the NRSAI algorithm after a certain number of iterations, with corresponding row and column index sets I and J. Given a predefined tolerance $\epsilon$, if $\parallel r_k\parallel ⩽ \epsilon$, the current $m_k$ is considered acceptable; otherwise, further updates are performed iteratively until the residual condition is satisfied. To avoid introducing singularity in the preconditioner, the non-zero pattern of $m_k$ is gradually expanded during this process.

Similar to the RSAI algorithm, we extract key information from the individual entries $r_k\left(i\right)$ of the residual. However, a fundamental distinction of our approach is that we consider not only the entries with the largest magnitudes, but also incorporate a dynamic threshold to identify multiple influential components.

The primary goal of the iteration is to reduce $\parallel r_k\parallel$ below $\epsilon$. Thus, the residual itself guides the index selection. It is intuitively beneficial to prioritize reducing the components of $r_k$ with larger magnitudes, as they contribute more significantly to the norm. However, as the iteration progresses, the relative importance of these components may change. Therefore, we introduce an adaptive threshold parameter to systematically identify which residual entries are considered “large” at each step.

The iterative workflow of the NRSAI algorithm is as follows. Starting from the initial index sets $I_k^0$ and $J_k^0$, suppose that after l iterations, the current approximation $m_k$ does not yet satisfy the tolerance condition. Denote the corresponding index sets as $I_k^l$ and $J_k^l$, the residual as $r_k$, and the set of already utilized indices as $R_k^l$.

Given the identity

$$\begin{array}{c}\hfill \parallel r_k\parallel = \parallel A{m}_k-e_k\parallel =∥A(I_k^l,J_k^l)m_k\left(J_k^l\right)-e_k\left(I_k^l\right)∥ =\parallel {\widehat{r}}_k\parallel ,\end{array}$$

(15)

we may restrict our attention to the reduced residual vector ${\widehat{r}}_k$. Its entries are sorted in descending order of absolute value. As in the RSAI algorithm, selected indices from ${\widehat{r}}_k$ are used to identify new column indices. To avoid redundant selections, previously chosen indices are excluded via the set $R_k^l$, whose role is thus essential.

Define the candidate set

$$\begin{array}{c}\hfill D_k^l=\left\{i\right|i\in I_k^l,i\notin R_k^l\},\end{array}$$

(16)

on which subsequent operations are performed.

In contrast to the RSAI method, we introduce a threshold parameter $\delta$ to guide the selection. An entry $r_k\left(i\right)$ is considered significant only if its magnitude relative to the residual norm satisfies

$$|r_k\left(i\right)|\ge \delta \parallel r_k\parallel .$$

If no such entry exists in a given iteration, the process terminates.

For example, suppose the indices corresponding to the c largest-magnitude entries in $r_k\left(D_k^l\right)$ are $i_1,i_2,\dots ,i_c$. If $|r_k\left(i_1\right)| <\delta \parallel r_k\parallel$, then no index is selected. If $|r_k\left(i_2\right)| \ge \delta \parallel r_k\parallel$ but $|r_k\left(i_3\right)| <\delta \parallel r_k\parallel$, then the selected index set is $i_1,i_2$.

Let $\widehat{D}$ denote the set of selected indices. Then, the new column indices are obtained as:

$$\begin{array}{c}\hfill \widehat{J}=\left\{j\right|A(\widehat{D},j)\ne 0,j\notin J_k^l\}.\end{array}$$

(17)

Correspondingly, the new row indices are given by:

$$\begin{array}{c}\hfill \widehat{I}=\left\{i\right|A(i,\widehat{J})\ne 0,i\notin I_k^l\}.\end{array}$$

(18)

The index sets are then updated as:

$$I_k^{l+1}=I_k^l\cup \widehat{I},J_k^{l+1}=J_k^l\cup \widehat{J},$$

and the preconditioner column is refined by solving the enlarged least-squares problem:

$$\begin{array}{c}\hfill min∥A(I_k^{l+1},J_k^{l+1})m_k\left(J_k^{l+1}\right)-e_k\left(I_k^{l+1}\right)∥.\end{array}$$

(19)

Finally, the set of used indices is updated to $R_k^{l+1}=R_k^l\cup \widehat{D}$.

Typically, the solution of problem (19) is achieved through QR decomposition. When leveraging the solution from the previous iteration, the computation can be accelerated using efficient updating techniques. For a comprehensive discussion, we refer the reader to [5,44]. Nevertheless, for certain structured matrices, problem (19) can be solved more effectively using LU decomposition within the MATLAB environment.

4. Theoretical Analysis

We now analyze the theoretical properties of the NRSAI algorithm described in the previous section.

As a method based on Frobenius-norm minimization, the columns of the preconditioner M in NRSAI are computed independently; thus, a direct guarantee of its nonsingularity is not available. Despite this, the general theory developed by Grote and Huckle [5], which connects the nonsingularity of M to the stopping tolerance $\epsilon$ and justifies its effectiveness—applies directly to our proposed algorithm.

Furthermore, according to [5], the sparsity pattern of the preconditioner M generated by the SPAI algorithm is bounded above. The analysis in [43] indicates that, due to the fundamental similarity in the iterative logic, the RSAI algorithm also produces a preconditioner M with bounded sparsity. This ensures that the sparsity constraint is maintained throughout the computation. Given the analogous iterative structure between the NRSAI and RSAI algorithms, the preconditioner M computed by the NRSAI algorithm is likewise sparse.

We now recall a result from [43] regarding the sparsity of M. Let $\mathrm{nnz}(·)$ denote the number of non-zero elements in a vector or matrix.

Theorem 1

([43]). Let $M=(m_1,m_2,\dots ,m_n)$ be a preconditioner generated by the RSAI algorithm after $l_{max}$ iterations, and define $g_i=\mathrm{nnz}\left(A(i,:)\right)$ for $1⩽i⩽n$. For a specific column $m_k$, let $g_k^l={max}_{i\in \widehat{R}{k}^l}{g}_i$, $g=max1⩽k⩽n{g}_k$, $c_k^l=\left|{\widehat{R}}_k^l\right|$, $c_k=max1⩽l⩽l_{max}{c}_k^l$, and $c={max}_{1⩽k⩽n}{c}_k$. If the initial sparsity pattern is $J_k^0=k$,

$$nnz\left(m_k\right)⩽min\left\{\sum _{l=1}^{l_{max}}{g}_k^l{c}_k^l+1,n\right\},k=1,2,\dots ,n.$$

(20)

Furthermore, there are

$$nnz\left(M\right)⩽min\{(gc{l}_{max}+1)n,n^2\}.$$

(21)

Similarly, we can discuss the relationship between the matrix M generated by the NRSAI algorithm and the various quantities in the algorithm.

Theorem 2.

Let $M=(m_1,m_2,\dots ,m_n)$ be a preconditioner generated by the NRSAI algorithm after $l_{max}$ iterations, and define $g_i=\mathrm{nnz}\left(A(i,:)\right)$ for $1⩽i⩽n$. For a specific column $m_k$, let $g_k^l={max}_{i\in \widehat{D}}{g}_i$, $g={max}_{1⩽k⩽n}{g}_k$, and let c denote the maximum number of elements in the set $\widehat{D}$ across all iterations. If the initial sparsity pattern $J_k^0$ satisfies $|J_k^0| =s$, then

$$nnz\left(m_k\right)⩽min\left\{c\sum _{l=1}^{l_{max}}{g}_k^l+s,n\right\},k=1,2,\dots ,n.$$

(22)

Moreover, the total number of nonzero entries in M is bounded by

$$nnz\left(M\right)⩽min\{(cg{l}_{max}+s)n,n^2\}.$$

(23)

Proof. 

For most sparse matrices requiring preconditioning, the initial sparsity pattern $J_k^0$ proposed in our method is non-empty and typically contains multiple elements. Although the size of this set influences computational efficiency and problem scale, it does not alter the underlying iterative process. Following a reasoning analogous to Theorem 1, we observe that each iteration adds at most $c{g}_k^l$ non-zero entries to the sparsity pattern of $m_k$. Hence,

$$\mathrm{nnz}\left(m_k\right)⩽c\sum _{l=1}^{l_{max}}{g}_k^l+s,$$

(24)

while also $\mathrm{nnz}\left(m_k\right)⩽n$, which together yield inequality (22). Combining (24) with the identity

$$\mathrm{nnz}\left(M\right)=\sum _{k=1}^n\mathrm{nnz}\left(m_k\right),$$

(25)

we obtain the bound (23). □

5. Numerical Results

In this section we apply the proposed NRSAI algorithm to compute the preconditioner M for matrix A, which is then used within the preconditioned GMRES method [12]. Here, “IT” and “CPU” denote the arithmetic averages of the iteration counts and CPU times (in seconds) over 10 runs of the preconditioned GMRES solver, respectively. The ratio refers to the proportion of nonzeros between M and A. All numerical experiments in this section were conducted using MATLAB R2023a on a Dell R740 2U server equipped with dual Gold 6250 CPUs (16 cores, 32 threads per CPU, base frequency 3.9 GHz, maximum turbo frequency 4.5 GHz) and 128 GB of RAM.

The methodology for extracting the linear systems in this section begins with the spatial discretization of the underlying partial differential equations (governing estuarine and coastal dynamics) via finite differencing on unstructured quadrilateral grids. A critical aspect of the approach is the treatment of the two-way nesting interfaces, where high-order interpolation schemes are employed to couple solutions between grids of different resolutions. This entire discretization and grid-coupling process transforms the continuous problem into a large, sparse system of linear equations; see [45,46].

In the initial numerical tests, the dimension of the sparse linear systems is set to $2565\times 2565$. Although this matrix size is relatively small from a practical standpoint, the underlying model remains consistent, allowing this lower-dimensional example to effectively validate the efficiency of the preconditioner constructed via the NRSAI algorithm; that is, we first validate the core functionality and robustness of the proposed preconditioner on a set of representative medium-scale problems (with $2565\times 2565$) under various conditions. This initial step is crucial for verifying the correctness and basic performance characteristics of our algorithm before progressing to large-scale tests that demonstrate its scalability.

Table 1 presents the numerical results of the NRSAI preconditioner combined with GMRES under different tolerance values $\epsilon =0.1,0.2,0.3,0.4$ and $0.5$, respectively, with a maximum of 5 outer iterations. The results indicate that the NRSAI preconditioner significantly accelerates the convergence of GMRES in both iteration count and computation time compared to the unpreconditioned case. Moreover, variations in $\epsilon$ have negligible impact on the iteration count unless a very strict tolerance is used, while only slightly affecting the total runtime.

It is noteworthy that the purpose of this initial test (see Table 1 and Table 2) is to validate the core functionality and robustness of the proposed preconditioner. Therefore, we report the total CPU time to facilitate a clear, high-level comparison. A more detailed profiling of the computational cost, breaking down the time into preconditioner construction and GMRES solution, will be presented and discussed in the subsequent large-scale tests (see Table 3, Table 4 and Table 5).

Figure 1 illustrates the eigenvalue distributions of the original matrix A and the preconditioned matrix $AM$. Clearly, the preconditioner M effectively clusters the eigenvalues of A near 1.

Table 1. Numerical results of GMRES under different $\epsilon$ for a 2565× 2565 system.

	IT	CPU (Seconds)
$M=I$	28	$0.1081$
$\epsilon =0.5$	12	$0.0252$
$\epsilon =0.4$	12	$0.0214$
$\epsilon =0.3$	12	$0.0215$
$\epsilon =0.2$	12	$0.0229$
$\epsilon =0.1$	9	$0.0177$

Table 1. Numerical results of GMRES under different $\epsilon$ for a 2565× 2565 system.

	IT	CPU (Seconds)
$M=I$	28	$0.1081$
$\epsilon =0.5$	12	$0.0252$
$\epsilon =0.4$	12	$0.0214$
$\epsilon =0.3$	12	$0.0215$
$\epsilon =0.2$	12	$0.0229$
$\epsilon =0.1$	9	$0.0177$

Figure 2 further compares the eigenvalue distributions of $AM$ for $\epsilon =0.1$ and $\epsilon =0.5$ under a magnified scale. The top and bottom subfigures correspond to $\epsilon =0.1$ and $\epsilon =0.5$, respectively. It is evident that the eigenvalues are more tightly clustered when $\epsilon =0.1$, which aligns with the superior performance observed in Table 1.

For a quantitative assessment, Table 2 lists the values of $\parallel AM-I\parallel$ under various norms, the spectral condition numbers of $AM$, and the density ratio for different $\epsilon$. The results show that the values are very close for $\epsilon =0.2,0.3,0.4$ and $0.5$, while a noticeable improvement occurs at $\epsilon =0.1$, consistent with the earlier observations.

Table 2. Quantitative measures under different $\epsilon$, with problem dimension $2565\times 2565$.

	${\mathbf{\parallel }\mathit{AM}\mathbf{-}\mathit{I}\mathbf{\parallel }}_{\mathbf{1}}$	${\mathbf{\parallel }\mathit{AM}\mathbf{-}\mathit{I}\mathbf{\parallel }}_{\mathbf{2}}$	${\mathbf{\parallel }\mathit{AM}\mathbf{-}\mathit{I}\mathbf{\parallel }}_{\mathit{F}}$	${\mathbf{cond}}_{\mathbf{2}}\mathbf{\left(}\mathit{AM}\mathbf{\right)}$	Ratio
$M=I$	$3738.5$	$3223.1$	82422	$3224.1$	$0.1963$
$\epsilon =0.5$	$0.8732$	$0.7368$	$6.7967$	$4.6167$	$2.6447$
$\epsilon =0.4$	$0.8732$	$0.7368$	$6.7967$	$4.6167$	$2.6447$
$\epsilon =0.3$	$0.8732$	$0.7368$	$6.7967$	$4.6167$	$2.6447$
$\epsilon =0.2$	$0.8732$	$0.7368$	$6.7863$	$4.6165$	$2.6478$
$\epsilon =0.1$	$0.6852$	$0.5345$	$3.6427$	$2.4359$	$5.8765$

Table 2. Quantitative measures under different $\epsilon$, with problem dimension $2565\times 2565$.

	${\mathbf{\parallel }\mathit{AM}\mathbf{-}\mathit{I}\mathbf{\parallel }}_{\mathbf{1}}$	${\mathbf{\parallel }\mathit{AM}\mathbf{-}\mathit{I}\mathbf{\parallel }}_{\mathbf{2}}$	${\mathbf{\parallel }\mathit{AM}\mathbf{-}\mathit{I}\mathbf{\parallel }}_{\mathit{F}}$	${\mathbf{cond}}_{\mathbf{2}}\mathbf{\left(}\mathit{AM}\mathbf{\right)}$	Ratio
$M=I$	$3738.5$	$3223.1$	82422	$3224.1$	$0.1963$
$\epsilon =0.5$	$0.8732$	$0.7368$	$6.7967$	$4.6167$	$2.6447$
$\epsilon =0.4$	$0.8732$	$0.7368$	$6.7967$	$4.6167$	$2.6447$
$\epsilon =0.3$	$0.8732$	$0.7368$	$6.7967$	$4.6167$	$2.6447$
$\epsilon =0.2$	$0.8732$	$0.7368$	$6.7863$	$4.6165$	$2.6478$
$\epsilon =0.1$	$0.6852$	$0.5345$	$3.6427$	$2.4359$	$5.8765$

Finally, Figure 3 compares the sparsity patterns of the original matrix A, $A+A^2$ and the preconditioner M for $\epsilon =0.1$ and $0.5$. It is clear that the sparsity pattern of $A+A^2$ effectively captures that of M.

We further compare the NRSAI algorithm with other preconditioning methods. Here, $T_p$ denotes the time to construct the preconditioner, $T_s$ and $ITer$ are the solution time and iteration count of preconditioned GMRES, and $T_t=T_p+T_s$. All results are averaged over 10 runs. GMRES is limited to 1000 iterations with a tolerance of ${10}^{-6}$.

Table 3 shows the results for a 15,601 × 15,601 matrix. The PSAI preconditioner leads to divergence, and SPAI increases total time despite reducing iterations. RSAI shows good speed in preconditioner construction and accelerates convergence effectively. The proposed NRSAI algorithm outperforms others, requiring only one-fourth of preconditioning time for the RSAI algorithm and achieving the shortest total solution time.

Table 3. Results for a 15,601 × 15,601 matrix.

Preconditioner	None	SPAI	PSAI	RSAI	NRSAI
$T_p\left(seconds\right)$	0	0.7094	0.0488	0.0157	0.0038
$T_s\left(seconds\right)$	0.3564	1.1469	86.4312	0.0137	0.0112
$T_t\left(seconds\right)$	0.3564	1.8563	86.4800	0.0294	0.0150
$Iter$	42	10	1001	10	10

Table 3. Results for a 15,601 × 15,601 matrix.

Preconditioner	None	SPAI	PSAI	RSAI	NRSAI
$T_p\left(seconds\right)$	0	0.7094	0.0488	0.0157	0.0038
$T_s\left(seconds\right)$	0.3564	1.1469	86.4312	0.0137	0.0112
$T_t\left(seconds\right)$	0.3564	1.8563	86.4800	0.0294	0.0150
$Iter$	42	10	1001	10	10

For a 20,785 × 20,785 matrix (Table 4), the PSAI algorithm again causes non-convergence, and the SPAI algorithm degrades further. The RSAI algorithm remains stable, while the NRSAI algorithm continues to excel in both preconditioning time and total solution time.

Table 4. Results for a 20,785 × 20,785 matrix.

Preconditioner	None	SPAI	PSAI	RSAI	NRSAI
$T_p\left(seconds\right)$	0	9.0689	0.0661	0.0753	0.0094
$T_s\left(seconds\right)$	1.4831	5.1409	137.3696	0.0926	0.0712
$T_t\left(seconds\right)$	1.4831	14.2098	137.4357	0.1679	0.0806
$Iter$	109	24	1001	26	31

Table 4. Results for a 20,785 × 20,785 matrix.

Preconditioner	None	SPAI	PSAI	RSAI	NRSAI
$T_p\left(seconds\right)$	0	9.0689	0.0661	0.0753	0.0094
$T_s\left(seconds\right)$	1.4831	5.1409	137.3696	0.0926	0.0712
$T_t\left(seconds\right)$	1.4831	14.2098	137.4357	0.1679	0.0806
$Iter$	109	24	1001	26	31

Finally, Table 5 presents results for the largest matrix, of size 34,737 × 34,737. Both PSAI and SPAI fail to yield effective preconditioning. The NRSAI algorithm consistently outperforms the RSAI algorithm in preconditioner construction time and solution efficiency.

Table 5. Results for a 34,737 × 34,737 matrix.

Preconditioner	None	SPAI	PSAI	RSAI	NRSAI
$T_p\left(seconds\right)$	0	4.4485	0.9641	0.2031	0.0617
$T_s\left(seconds\right)$	1.4286	7.4078	632.3594	0.1462	0.0426
$T_t\left(seconds\right)$	1.4286	11.8563	633.3235	0.3493	0.1043
$Iter$	42	10	1001	10	10

Table 5. Results for a 34,737 × 34,737 matrix.

Preconditioner	None	SPAI	PSAI	RSAI	NRSAI
$T_p\left(seconds\right)$	0	4.4485	0.9641	0.2031	0.0617
$T_s\left(seconds\right)$	1.4286	7.4078	632.3594	0.1462	0.0426
$T_t\left(seconds\right)$	1.4286	11.8563	633.3235	0.3493	0.1043
$Iter$	42	10	1001	10	10

6. Findings, Limitations, and Future Work

6.1. Key Findings

This work introduced the NRSAI preconditioner and demonstrated its efficacy through theoretical analysis and numerical experiments. The key findings are summarized as follows.

First, the proposed adaptive pattern selection strategy, underpinned by the Hamilton–Cayley theorem, was shown to be effective in capturing the essential non-zero structure of the inverse with low computational cost.

Second, the integration of techniques from the PSAI algorithm and ILU led to an algorithm that is both automatic and robust, eliminating the need for manual parameter tuning.

Third, extensive numerical tests on real-world problems confirmed that the NRSAI algorithm consistently outperforms established methods, including the SPAI, PSAI, and RSAI algorithms, in terms of iteration count and CPU time within a GMRES solver, underscoring its practical utility.

6.2. Limitations and Future Work

A limitation of the present numerical experiments is that they were conducted primarily on problems of a fixed dimension. A comprehensive analysis of the algorithm’s scalability and computational complexity across a wide range of problem sizes will be a central focus of our future work. Despite its promising performance, a limitation of the NRSAI algorithm is that the new algorithm only takes into account the specific characteristics of the rows and columns of the matrix during computation, without considering the overall structure of the matrix. Future work will focus on combining the overall structure with the specific structure of the rows and columns to propose a better algorithm.

7. Conclusions

This study opens with a concise overview of sparse approximate inverse preconditioning methods grounded in Frobenius norm minimization, outlining two central challenges common to such approaches.

Building on the PSAI algorithm, we emphasize the importance of the Hamilton–Cayley theorem in constructing effective sparsity patterns for the preconditioner. Motivated by techniques from incomplete LU factorization, a computationally efficient implementation of this theorem is developed, offering a solution to the first challenge.

Further examination of the RSAI algorithm reveals specific limitations, which are mitigated through an adaptive enhancement, thereby addressing the second challenge. By synergistically combining both solutions, we introduce a novel algorithm: NRSAI, an LU decomposition-based variant optimized for the class of problems considered in this work.

Numerical experiments were performed in two stages: initial tests confirmed the feasibility of the NRSAI algorithm, and subsequent comparative evaluations against the SPAI, PSAI, and RSAI algorithms within a GMRES framework demonstrated the significantly higher efficiency of the NRSAI algorithm.