ε-Algorithm Accelerated Fixed-Point Iteration for the Three-Way GIPSCAL Problem in Asymmetric MDS

Abstract

The Generalized Inner Product SCALing (GIPSCAL) model is a specialized tool for analyzing square asymmetric tables within asymmetric multidimensional scaling (MDS), with applications in sociology (e.g., social mobility tables) and marketing (e.g., brand switching data). This paper presents the development of an efficient numerical algorithm for solving the three-way GIPSCAL problem. We focus on vector $\epsilon$-algorithm-accelerated fixed-point iterations, detailing the underlying acceleration principles. Extensive numerical experiments show that the proposed method achieves acceleration performance comparable to polynomial extrapolation and Anderson acceleration. Furthermore, compared to continuous-time projected gradient flow methods and first- and second-order Riemannian optimization algorithms from the Manopt toolbox, our approach demonstrates superior computational efficiency and scalability.

1. Introduction

Asymmetric square matrices naturally arise in numerous scientific domains, including sociology (e.g., social mobility matrices), marketing (e.g., brand-switching data), and psychology (e.g., stimulus identification experiments) [1,2]. To facilitate the analysis of such data, Harshman [3] introduced the DEcomposition into DIrectional COMponents (DEDICOM) model, which approximates an asymmetric matrix $X\in {\mathbb{R}}^{n\times n}$ as

$$X=QR{Q}^T+E,$$

(1)

where $Q\in {\mathbb{R}}^{n\times r}$ (with $r\ll n$) is typically assumed to be column-orthonormal and encodes object coordinates in a latent space, $R\in {\mathbb{R}}^{r\times r}$ represents the (possibly asymmetric) inter-dimensional relationships, and E denotes the residual matrix. While DEDICOM offers interpretability in modeling asymmetric relationships, it lacks capabilities for effective visualization. To address this limitation, Chino [4] introduced the GIPSCAL (Generalized Inner Product SCALing) model, which not only handles asymmetric data but also provides a framework for graphical representation. However, the original GIPSCAL formulation may exhibit inadequate fit to empirical data. A generalized variant, introduced by Kiers and Takane [5], improves model flexibility via the decomposition

$$X=A(I_r+K)A^T+E,$$

(2)

where $A\in {\mathbb{R}}^{n\times r}$ is a weight matrix, $I_r$ is the $r\times r$ identity matrix, $K\in {\mathbb{R}}^{r\times r}$ is skew-symmetric, and E denotes the error matrix. The symmetric part $A{A}^T$ may be visualized using Classical Multidimensional Scaling (MDS) techniques [6,7], while the asymmetric component $AK{A}^T$ is treated using Gower’s method [7,8]. The model parameters are typically estimated by minimizing the least-squares objective, as outlined in Kiers and Takane [5]. Subsequent developments by Trendafilov and Gallo [9], Trendafilov [10] recast the GIPSCAL framework into the following constrained optimization problem:

$$\begin{array}{cc}\hfill \mathrm{Minimize}& {\displaystyle \frac{1}{2}}\left|\right|X-Q(D+K)Q^T{\left|\right|}^2,\hfill \\ \hfill \mathrm{subject}\mathrm{to}& (Q,D,K)\in \mathcal{O}(n,r)\times {\mathcal{D}}_{+}\left(r\right)\times \mathcal{K}\left(r\right).\hfill \end{array}$$

(3)

Here, $\parallel ·\parallel$ denotes the Frobenius norm, $\mathcal{O}(n,r):=\{Q\in {\mathbb{R}}^{n\times r}:Q^{T}Q=I_r\}$ is the Stiefel manifold of orthonormal matrices, ${\mathcal{D}}_{+}\left(r\right)$ is the set of $r\times r$ diagonal matrices with nonnegative entries, and $\mathcal{K}\left(r\right)$ denotes the set of skew-symmetric $r\times r$ matrices.

This reformulation clarifies the connection between GIPSCAL and the DEDICOM model in (1), revealing that GIPSCAL constitutes a special case of DEDICOM in which the symmetric part of R is constrained to lie in the nonnegative diagonal cone. Additionally, this formulation can be interpreted as a natural asymmetric extension of the INdividual Differences SCALing (INDSCAL) model [7,11]. The GIPSCAL methodology has further been generalized to handle three-way data arrays comprising N asymmetric slices $X_i\in {\mathbb{R}}^{n\times n}$, analogous to three-way extensions of INDSCAL. In this setting, each slice is modeled as [9,10,12,13]

$$X_i=Q(D_i+K_i)Q^T+E_i,$$

(4)

where $Q\in {\mathbb{R}}^{n\times r}$ is a common loading matrix shared across all slices, $D_i\in {\mathbb{R}}^{r\times r}$ are slice-specific nonnegative diagonal matrices, and $K_i\in {\mathbb{R}}^{r\times r}$ are slice-specific skew-symmetric matrices. Consequently, the three-way GIPSCAL seeks to determine $(Q,D_1,\dots ,D_N,K_1,\dots ,K_N)$ by fitting the model to the $n\times n$ asymmetric data matrices $X_i$ in a least-squares sense [9,10,12,13,14]

$$\begin{array}{cc}\hfill \mathrm{Minimize}& {\displaystyle \frac{1}{2}}\sum _{i=1}^N\left|\right|X_i-Q(D_i+K_i)Q^T{\left|\right|}^2,\hfill \\ \hfill \mathrm{subject}\mathrm{to}& (Q,D_1,\dots ,D_N,K_1,\dots ,K_N)\in \mathcal{O}(n,r)\times \mathcal{D}{\left(r\right)}_{+}^N\times \mathcal{K}{\left(r\right)}^N.\hfill \end{array}$$

(5)

where ${\mathcal{D}}_{+}{\left(r\right)}^N$ and $\mathcal{K}{\left(r\right)}^N$ denote N independent copies of the nonnegative diagonal cone and skew-symmetric matrix space, respectively.

In this work, we revisit the numerical challenge of fitting the three-way GIPSCAL model (5), a problem characterized by nonlinear coupling among variables and the need for scalable, efficient algorithms. Despite its relevance in multivariate data analysis, the literature on this topic remains relatively sparse. Early contributions by Trendafilov [10,13] reformulated problem (5) as a constrained gradient dynamical system and proposed a continuous-time projected gradient flow algorithm. This method guarantees global convergence and has shown strong empirical performance across various applications in multivariate analysis [9,15,16,17,18]. Nevertheless, its scalability may be limited in large-scale settings due to computational inefficiencies. To accelerate the inherently slow convergence of alternating least squares (ALS) methods, Loisel and Takane [19] proposed a minimal polynomial extrapolation (MPE) scheme, leveraging vector sequence fixed-point iteration. Empirical results indicate that this approach can substantially speed up convergence. However, in practical implementations, selecting an appropriate backtracking step size often relies on heuristic tuning rather than principled criteria. More recently, Trendafilov and Gallo [9] explored optimization-based reformulations of multivariate models on matrix manifolds and demonstrated the effectiveness of the Manopt toolbox [20] in addressing such problems through Riemannian optimization techniques. Motivated by these developments, this paper builds upon the fixed-point acceleration strategy of Loisel and Takane [19], extending its application to problem (5). We propose a new algorithmic framework that interprets approximate ALS iterations as a matrix-valued fixed-point iteration. Furthermore, we develop acceleration schemes based on the vector $\epsilon$-algorithm (VEA), the topological $\epsilon$-algorithm (TEA), and its simplified variant (STEA) [21,22], incorporating recent advances in numerical extrapolation and available algorithmic toolboxes. Extensive numerical experiments show that, compared to the original matrix sequences generated by fixed-point iteration, the matrix sequence extrapolation acceleration significantly improves convergence. Furthermore, when compared with existing solvers for Problem (5), such as the continuous-time projection gradient flow algorithm and the Riemannian optimization-based Manopt toolbox solvers, the $\epsilon$-algorithms accelerated fixed-point iteration demonstrates a notable reduction in iteration time.

The remainder of the paper is organized as follows: In Section 2, we present the fixed-point iteration framework for solving the three-way GIPSCAL problem in (5). Section 3 introduces the core acceleration principles and describes the implementation of the VEA, TEA, and STEA within this context. Section 4 reports a comprehensive set of numerical experiments, benchmarking the proposed acceleration schemes against the continuous-time projected gradient flow method and several first- and second-order Riemannian optimization algorithms implemented in Manopt. Finally, Section 5 concludes the paper.

2. Fixed-Point Iteration Framework for Problem (5)

Building on the conditional minimization strategy introduced by Loisel and Takane [19], the three-way GIPSCAL problem in (5) can be reformulated as a fixed-point iteration scheme. Their original framework also incorporates minimal polynomial extrapolation (MPE) to accelerate convergence. For the sake of completeness, we revisit and extend this approach by developing an alternating least squares (ALS) framework, which naturally leads to a fixed-point iteration formulation.

Let $\mathcal{S}\left(r\right)$ denote the space of symmetric $r\times r$ matrices. For a point $Z:=(Q,D_1,\dots ,D_N,K_1,\dots ,K_N)$ in the product space ${\mathbb{R}}^{n\times r}\times \mathcal{S}{\left(r\right)}^N\times \mathcal{K}{\left(r\right)}^N$, we define the residual mapping

$$F_i(Q,D_i,K_i)=X_i-Q(D_i+K_i)Q^T,i=1,\dots ,N,$$

(6)

which allows us to express the objective function of problem (5) as $f\left(Z\right)={\displaystyle \frac{1}{2}}{\sum }_{i=1}^N{\parallel F_i\parallel }^2.$ Since the variables $D_i$ and $K_i$ are independent for each slice i, through straightforward algebraic derivation, the Euclidean gradient of $f\left(Z\right)$ can be decomposed component-wise as follows:

$$\nabla f\left(Z\right)=({\nabla }_{Q}f,{\nabla }_{D_1}f,\dots ,{\nabla }_{D_N}f,{\nabla }_{K_1}f,\dots ,{\nabla }_{K_N}f).$$

(7)

Here,

$$\begin{array}{cc}\hfill {\nabla }_{Q}f& =-2\sum _{i=1}^N\mathrm{sym}\left(X_i\right)Q{D}_i-\mathrm{skew}\left(X_i\right)Q{K}_i-Q(D_i^2-K_i^2),\hfill \\ \hfill {\nabla }_{D_i}f& =D_i-Q^T\mathrm{sym}\left(X_i\right)Q,i=1,\dots ,N,\hfill \\ \hfill {\nabla }_{K_i}f& =K_i-Q^T\mathrm{skew}\left(X_i\right)Q,i=1,\dots ,N.\hfill \end{array}$$

Additionally, $sym\left(A\right)={\displaystyle \frac{1}{2}}(A+A^T)$ and $skew\left(A\right)={\displaystyle \frac{1}{2}}(A-A^T)$ denote the symmetric and skew-symmetric parts of matrix A, respectively.

Given a current iterate $Z^{\left(j\right)}=(Q^{\left(j\right)},D_1^{\left(j\right)},\dots ,D_N^{\left(j\right)},K_1^{\left(j\right)},\dots ,K_N^{\left(j\right)})\in \mathcal{O}(n,r)\times {\mathcal{D}}_{+}{\left(r\right)}^N\times \mathcal{K}{\left(r\right)}^N$, the ALS-based iterative scheme for solving (5) is defined by the following update rules:

$$\left\{\begin{array}{cc}\hfill D_i^{(j+1)}=& \underset{D_i}{\mathrm{argmin}}{f}_i(Q^{\left(j\right)},D_i,K_i^{\left(j\right)}),D_i\in {\mathcal{D}}_{+}\left(r\right),i=1,\cdots ,N;\hfill \\ \hfill K_i^{(j+1)}=& \underset{K_i}{\mathrm{argmin}}{f}_i(Q^{\left(j\right)},D_i^{(j+1)},K_i),K_i\in \mathcal{K}\left(r\right),i=1,\cdots ,N;\hfill \\ \hfill Q^{(j+1)}=& \underset{Q}{\mathrm{argmin}}f(Q,D_1^{(j+1)},\cdots ,D_N^{(j+1)},K_1^{(j+1)},\cdots ,K_N^{(j+1)}),Q\in \mathcal{O}(n,r).\hfill \end{array}\right.$$

(8)

The update for $D_i$ involves solving a convex constrained matrix optimization problem:

$$\underset{D_i\in {\mathcal{D}}_{+}\left(r\right)}{min}{f}_i(Q^{\left(j\right)},D_i,K_i^{\left(j\right)})={\displaystyle \frac{1}{2}}{∥X_i-Q^{\left(j\right)}(D_i+K_i^{\left(j\right)}){Q^{\left(j\right)}}^T∥}^2.$$

(9)

By deriving the first-order optimality condition, we obtain the variational inequality

$$\langle D_i-D_i^{(j+1)},{\nabla }_{D_i}{f}_i(Q^{\left(j\right)},D_i,K_i^{\left(j\right)})\rangle \ge 0,\forall D_i\in {\mathcal{D}}_{+}\left(r\right).$$

(10)

According to Theorem 3.1.1 of Hiriart-Urruty and Lemaréchal [23], this is equivalent to solving the implicit projection equation:

$$D_i^{(j+1)}-{\mathcal{P}}_{{\mathcal{D}}_{+}\left(r\right)}\left\{D_i^{(j+1)}-{\nabla }_{D_i}{f}_i(Q^{\left(j\right)},D_i^{(j+1)},K_i^{\left(j\right)})\right\}=0,D_i^{(j+1)}\in {\mathcal{D}}_{+}\left(r\right).$$

(11)

Here, the projection ${\mathcal{P}}_{{\mathcal{D}}_{+}\left(r\right)}:{\mathbb{R}}^{r\times r}\to {\mathcal{D}}_{+}\left(r\right)$ is defined element-wise via

$${\mathcal{P}}_{{\mathcal{D}}_{+}\left(r\right)}\left(M\right)=max\{0,I_r\odot M\},\forall M\in {\mathbb{R}}^{r\times r},$$

(12)

where ⊙ denotes the Hadamard (element-wise) product. The closed-form solution is thus

$$\begin{array}{c}\hfill D_i^{(j+1)}=max\left\{0,I_r\odot \left({Q^{\left(j\right)}}^T\mathrm{sym}\left(X_i\right)Q^{\left(j\right)}\right)\right\},i=1,\cdots ,N.\end{array}$$

(13)

Since $\mathcal{K}\left(r\right)$ is a linear subspace, the optimal $K_i$ satisfies the projected gradient condition

$$\begin{array}{c}\hfill {\mathcal{P}}_{\mathcal{K}\left(r\right)}\left({\nabla }_{K_i}{f}_i\left(Q^{\left(j\right)},D_i^{(j+1)},K_i^{(j+1)}\right)\right)=0,\end{array}$$

where ${\mathcal{P}}_{\mathcal{K}\left(r\right)}\left(M\right)=skew\left(M\right)$. Hence, the solution is explicitly given by

$$\begin{array}{c}\hfill K_i^{(j+1)}={Q^{\left(j\right)}}^T\mathrm{skew}\left(X_i\right)Q^{\left(j\right)},i=1,\cdots ,N.\end{array}$$

(14)

The update for Q entails solving the following orthogonally constrained, nonconvex optimization problem

$$\underset{Q\in \mathcal{O}(n,r)}{min}{\displaystyle \frac{1}{2}}\sum _{i=1}^N{∥X_i-Q\left(D_i^{(j+1)}+K_i^{(j+1)}\right)Q^T∥}^2.$$

(15)

The associated Lagrangian, incorporating the constraint $Q^{T}Q=I_r$, is given by

$$\mathcal{L}(Q,\mathrm{\Lambda })={\displaystyle \frac{1}{2}}\sum _{i=1}^N{∥X_i-Q\left(D_i^{(j+1)}+K_i^{(j+1)}\right)Q^T∥}^2+\langle \mathrm{\Lambda },Q^{T}Q-I_r\rangle ,$$

where $\mathrm{\Lambda }$ is a symmetric Lagrange multiplier matrix. The first-order optimality condition yields

$$\begin{array}{c}\hfill (I_r-Q{Q}^T)\sum _{i=1}^N\left(\mathrm{sym}\left(X_i\right)Q{D}_i^{(j+1)}-\mathrm{skew}\left(X_i\right)Q{K}_i^{(j+1)}\right)=0.\end{array}$$

(16)

Although solving (16) analytically is challenging, we follow the strategy of Loisel and Takane [19] and approximate the solution as follows:

• Compute the matrix

  $$G^{\left(j\right)}:=\sum _{i=1}^N\left(\mathrm{sym}\left(X_i\right)Q^{\left(j\right)}{D}_i^{(j+1)}-\mathrm{skew}\left(X_i\right)Q^{\left(j\right)}{K}_i^{(j+1)}\right);$$

  (17)
• Compute the thin singular value decomposition $G^{\left(j\right)}=U\Sigma V^T$, and set

  $$Q^{(j+1)}:=U{V}^T.$$

  (18)

By integrating the subproblem updates (13), (14), and (18) within the ALS scheme from (8), we obtain the following iterative sequence:

$$Q^{\left(j\right)}⟶(D_1^{(j+1)},\dots ,D_N^{(j+1)},K_1^{(j+1)},\dots ,K_N^{(j+1)})⟶G^{\left(j\right)}⟶Q^{(j+1)}.$$

This iterative process naturally defines a fixed-point iteration:

$$Q^{(j+1)}={\mathcal{H}}_{\mathrm{GIPSCAL}}\left(Q^{\left(j\right)}\right),$$

(19)

Here, ${\mathcal{H}}_{\mathrm{GIPSCAL}}:{\mathbb{R}}^{n\times r}\to {\mathbb{R}}^{n\times r}$ denotes the nonlinear mapping associated with one complete ALS update.

To further analyze the convergence of problem (5) and iteration (19), we present the following theoretical results:

Theorem 1. 

Problem (5) has a global optimal solution.

Proof. 

The feasible set $\mathcal{M}:=\mathcal{O}(n,r)\times {\mathcal{D}}_{+}{\left(r\right)}^N\times \mathcal{K}{\left(r\right)}^N$ is compact under the Frobenius norm topology. The objective function $f\left(Z\right)={\displaystyle \frac{1}{2}}{\displaystyle \sum _{i=1}^N}{\parallel X_i-Q(D_i+K_i)Q^T\parallel }^2$ is continuous. Therefore, by the Weierstrass extreme value theorem, f achieves its minimum value on $\mathcal{M}$.    □

Theorem 2. 

The problem (5) does not have a closed-form analytical solution. This conclusion holds even in special cases where $N=1$ or $r=1$.

Proof. 

(i) The non-convex feasible set induced by the orthogonal constraint $Q^{\top }Q=I_r$ and the quartic complexity of the objective function with respect to Q results in the Hessian matrix being indefinite at the critical points.

(ii) When $D_i,K_i$ are fixed, the Q-subproblem degenerates into a generalized orthogonal Procrustes problem

$$\underset{Q\in \mathcal{O}(n,r)}{min}\sum _{i=1}^N{\parallel X_i-Q{A}_i{Q}^{\top }\parallel }_F^2,(A_i=D_i+K_i),$$

where the asymmetry of $A_i$ (due to $K_i\ne 0$) causes this subproblem to have no analytical solution (unlike the case when $A_i$ is symmetric and can be solved by eigenvalue decomposition);

(iii) The coupling between the slices induced by the summation ${\sum }_{i=1}^N$ in the objective function.

(i)–(iii) together exclude the possibility of a closed-form solution, so numerical iterative methods must be used to approximate the solution.    □

Theorem 3. 

The iterative sequence ${Z^{\left(j\right)}}_{j=0}^{\infty }$, where $Z^{\left(j\right)}=(Q^{\left(j\right)},D_i^{\left(j\right)},K_i^{\left(j\right)})$, generated by alternating least squares to solve problem (5), has its objective function value sequence $f\left(Z^{\left(j\right)}\right)$ converge to a non-negative limit L.

Proof. 

The objective function $f\left(Z\right)={\displaystyle \frac{1}{2}}{\displaystyle \sum _{i=1}^N}{\parallel X_i-Q(D_i+K_i)Q^T\parallel }^2$ is a sum of squared Frobenius norms, and its value is always non-negative. Thus, the sequence $f\left(Z^{\left(j\right)}\right)$ is bounded below by 0. In the alternating update process,

• Fixing $Q^{\left(j\right)},K_i^{\left(j\right)}$ and updating $D_i^{(j+1)}$, the global optimality of the convex subproblem (13) ensures that $f_i(Q^{\left(j\right)},D_i^{(j+1)},K_i^{\left(j\right)})\le f_i(Q^{\left(j\right)},D_i^{\left(j\right)},K_i^{\left(j\right)})$
• Fixing $Q^{\left(j\right)},D_i^{(j+1)}$ and updating $K_i^{(j+1)}$, the closed-form solution in (14) guarantees that $f_i(Q^{\left(j\right)},D_i^{(j+1)},K_i^{(j+1)})\le f_i(Q^{\left(j\right)},D_i^{(j+1)},K_i^{\left(j\right)})$
• Fixing $D_i^{(j+1)},K_i^{(j+1)}$ and updating $Q^{(j+1)}$, the orthogonal Procrustes projection in (18) as a contraction mapping ensures that $f(Q^{(j+1)},·)\le f(Q^{\left(j\right)},·)$

Thus, $f\left(Z^{(j+1)}\right)\le f\left(Z^{\left(j\right)}\right)$. By the monotonicity and boundedness convergence theorem, the sequence $f\left(Z^{\left(j\right)}\right)$ converges to $L\ge 0$.    □

3. $\epsilon$-Algorithms Acceleration for the Fixed-Point Problem (19)

In numerical analysis and applied mathematics, sequences arise naturally across a broad range of computational problems. When a sequence converges slowly, acceleration techniques are often employed to improve the convergence rate. A common strategy involves transforming the original sequence into another that converges more rapidly to the same limit, assuming appropriate regularity conditions. One of the most influential transformations in this context is the Shanks transformation [24], originally derived by Schmidt [25] for iterative solutions of linear systems. It was later implemented algorithmically through the scalar $\epsilon$-algorithm introduced by Wynn [26]. In a subsequent extension, Wynn [27] generalized the scalar $\epsilon$-algorithm to handle vector-valued sequences. However, the algebraic structure underlying the vector version does not follow directly from the scalar case. To address this gap, Brezinski [28] proposed two distinct generalizations of the Shanks transformation and its associated algorithms to sequences in vector spaces. This led to the formulation of the topological Shanks transformation and the development of two corresponding topological $\epsilon$-algorithms (TEA1 and TEA2). These algorithms operate using elements from both a vector space E and its dual space $E^{*}$, enabling a rigorous extension to infinite-dimensional settings. Recognizing the computational overhead associated with dual space operations, Brezinski [29] introduced the simplified topological $\epsilon$-algorithms (STEA1 and STEA2). These variants avoid direct manipulation of dual space elements by substituting scalar $\epsilon$-algorithm outputs, thereby reducing memory usage and enhancing numerical stability. In parallel, the Shanks transformation has inspired a family of vector extrapolation methods, including minimal polynomial extrapolation (MPE), modified minimal polynomial extrapolation (MMPE), and reduced-rank extrapolation (RRE). These techniques—collectively referred to as vector extrapolation methods—share the advantages of simple iterative structure and avoidance of explicit matrix decompositions. Owing to their general applicability and efficiency, $\epsilon$-type and vector extrapolation algorithms have found widespread use in the numerical solution of linear and nonlinear systems, eigenvalue computations, Padé-type approximations, matrix functions, matrix equations, and Krylov subspace methods such as Lanczos iterations [28,30,31,32,33].

In this section, we introduce the principles and specific implementation processes of three $\epsilon$ algorithms: VEA, TEA and STEA. We then explain how each of these methods can be systematically integrated into our fixed-point iteration scheme (introduced in the previous section) to accelerate convergence in the context of solving the three-way GIPSCAL problem.

3.1. Scalar Shanks Transform and Scalar $\epsilon$-Algorithm

Let $S_n$ be a sequence of scalars in the field K, where K is either $\mathbb{R}$ or $\mathbb{C}$. If $\underset{n\to \infty }{lim}{S}_n=S$, under certain conditions, then the sequence $S_n$ can be transformed into a new sequence $T_n$ that converges to the same limit more efficiently, as described by

$$\underset{n\to \infty }{lim}{\displaystyle \frac{T_n-S}{S_n-S}}=0.$$

(20)

Shanks [24] introduced a transformation technique in his 1955 study, which can be used to determine the anticipated limiting value of a sequence of $k+1$ terms. The Shanks transformation assumes that the sequence satisfies the following relation:

$${\alpha }_0(S_n-S)+\cdots +{\alpha }_k(S_{n+k}-S)=0,n=0,1,\dots$$

(21)

Here, the coefficient ${\alpha }_i$ is an arbitrary constant independent of n and satisfies the condition ${\alpha }_0{\alpha }_k\ne 0$. Assuming that the equation ${\alpha }_0+\cdots +{\alpha }_k\ne 0$ holds for all n, we can expand and rearrange it to derive the difference form

$$\Delta S_n{\alpha }_0+\cdots +\Delta S_{n+k}{\alpha }_k=0,$$

(22)

where the forward difference operator $\Delta$ is defined as $\Delta S_i=S_{i+1}-S_i$. To determine the $k+1$ coefficients ${\alpha }_0,\dots ,{\alpha }_k$, we further require that ${\alpha }_0+\cdots +{\alpha }_k=1$, leading to a linear system consisting of k scalar equations derived from (22):

$$\left\{\begin{array}{c}{\alpha }_0+\cdots +{\alpha }_k=1,\hfill \\ \Delta S_{n+i}{\alpha }_0+\cdots +\Delta S_{n+k+i}{\alpha }_k=0,i=0,\dots ,k-1.\hfill \end{array}\right.$$

(23)

The coefficients ${\alpha }_i$ can then be linearly combined to obtain S:

$$S={\alpha }_0{S}_n+{\alpha }_1{S}_{n+1}+\cdots +{\alpha }_k{S}_{n+k}.$$

(24)

Even if the sequence $\left\{S_n\right\}$ does not satisfy the relation in Equation (21), the coefficients ${\alpha }_i$ can still be determined by solving the linear system in Equation (23) using a similar approach. Consequently, an approximate solution for the limit of the sequence S can be obtained via the linear combination outlined in Equation (24). It is important to note that these coefficients and the approximate solution now depend on the current starting index n and the depth k of the acceleration window. These dependencies are denoted as ${\alpha }_i^{(n,k)}$ and $e_k\left(S_n\right)$, respectively. Therefore, we have

$$e_k\left(S_n\right)={\alpha }_0^{(n,k)}{S}_n+\cdots +{\alpha }_k^{(n,k)}{S}_{n+k},k,n=0,1,\dots ,$$

where ${\alpha }_i^{(n,k)}$ satisfies the following linear system:

$$\left\{\begin{array}{c}{\alpha }_0^{(n,k)}+\cdots +{\alpha }_k^{(n,k)}=1,\hfill \\ {\alpha }_0^{(n,k)}\Delta S_n+\cdots +{\alpha }_k^{(n,k)}\Delta S_{n+k}=0,\hfill \\ ⋮\hfill \\ {\alpha }_0^{(n,k)}\Delta S_{n+k-1}+\cdots +{\alpha }_k^{(n,k)}\Delta S_{n+2k-1}=0.\hfill \end{array}\right.$$

(25)

The original sequence $\left\{S_n\right\}$ is transformed into a new sequence $\left\{e_k\left(S_n\right)\right\}$, and this transformation, $\left\{S_n\right\}\to \left\{e_k\left(S_n\right)\right\}$, is known as the Shanks transform. By applying Cramer’s rule for solving systems of linear equations, $e_k\left(S_n\right)$ can be written as the ratio of determinants, as shown below:

$$e_k\left(S_n\right)={\displaystyle \frac{\left|\begin{array}{cccc}{S}_n& S_{n+1}& \cdots & S_{n+k}\\ \Delta S_n& \Delta S_{n+1}& \cdots & \Delta S_{n+k}\\ ⋮& ⋮& & ⋮\\ \Delta S_{n+k-1}& \Delta S_{n+k}& \cdots & \Delta S_{n+2k-1}\end{array}\right|}{\left|\begin{array}{cccc}1& 1& \cdots & 1\\ \Delta S_n& \Delta S_{n+1}& \cdots & \Delta S_{n+k}\\ ⋮& ⋮& & ⋮\\ \Delta S_{n+k-1}& \Delta S_{n+k}& \cdots & \Delta S_{n+2k-1}\end{array}\right|}},k,n=0,1,\dots .$$

(26)

Since directly computing the determinant in Equation (26) is relatively complex, Wynn [26] proposed the scalar $\epsilon$-algorithm (SEA), which implements the Shanks transform using a straightforward recursive procedure. The computational rules for the SEA are given by

$$\left\{\begin{array}{c}{\epsilon }_{-1}^{\left(n\right)}=0,n=0,1,\dots ,\hfill \\ {\epsilon }_0^{\left(n\right)}=S_n,n=0,1,\dots ,\hfill \\ {\epsilon }_{k+1}^{\left(n\right)}={\epsilon }_{k-1}^{(n+1)}+{({\epsilon }_k^{(n+1)}-{\epsilon }_k^{\left(n\right)})}^{-1},k,n=0,1,....\hfill \end{array}\right.$$

(27)

These elements are typically organized into a two-dimensional array, as shown in Figure 1, which is referred to as the $\epsilon$-table. Rule (27) establishes a connection between the four vertices of a diamond in the $\epsilon$-table, where the column index k remains constant across each column, and the row index n remains constant along the descending diagonals. Furthermore, Wynn [26] demonstrated the relationship between the Shanks transformation and the $\epsilon$-algorithm by applying Sylvester’s and Schweins’ determinant identities

$${\epsilon }_{2k}^{\left(n\right)}=e_k\left(S_n\right),{\epsilon }_{2k+1}^{\left(n\right)}={\displaystyle \frac{1}{e_k(\Delta S_n)}}.$$

(28)

3.2. Topological Shanks Transformation and Topological $\epsilon$-Algorithm

Assume that the sequence $S_n$ is a sequence of vectors. The Samelson inverse of a nonzero vector in the vector space E is defined by the following formula:

$$z^{-1}={\displaystyle \frac{z}{(z,z)}},\forall z\in E,$$

(29)

let $(·,·)$ denote the standard inner product on the vector space E. Wynn [27] proposed the vector $\epsilon$-algorithm (VEA) by “vectorizing” the scalar version of the $\epsilon$-algorithm. However, the Shanks transformation cannot be directly extended to vector spaces. To address this, Brezinski et al. [34] introduced the algebraic dual space $E^{*}$ of the vector space E, along with an auxiliary vector $\mathbf{y}\in E^{*}$, and used the duality product $\langle ·,·\rangle$ to derive two types of topological Shanks transformations. The first topological Shanks transformation is defined by the formula

$${\widehat{e}}_k\left(S_n\right)={\alpha }_0^{(n,k)}{S}_n+\cdots +{\alpha }_k^{(n,k)}{S}_{n+k},k,n=0,1,\dots ,$$

(30)

where the coefficients ${\alpha }_i^{(n,k)}$ satisfy the following system of linear equations:

$$\left\{\begin{array}{c}{\alpha }_0^{(n,k)}+\cdots +{\alpha }_k^{(n,k)}=1,\hfill \\ {\alpha }_0^{(n,k)}\langle \mathbf{y},\Delta S_n\rangle +\cdots +{\alpha }_k^{(n,k)}\langle \mathbf{y},\Delta S_{n+k}\rangle =0,\hfill \\ ⋮\hfill \\ {\alpha }_0^{(n,k)}\langle \mathbf{y},\Delta S_{n+k-1}\rangle +\cdots +{\alpha }_k^{(n,k)}\langle \mathbf{y},\Delta S_{n+2k-1}\rangle =0.\hfill \end{array}\right.$$

(31)

Similar to the scalar Shanks transformation, ${\widehat{e}}_k\left(S_n\right)$ can be expressed as a ratio of determinants as follows:

$${\widehat{e}}_k\left(S_n\right)={\displaystyle \frac{\left|\begin{array}{cccc}{S}_n& S_{n+1}& \cdots & S_{n+k}\\ \langle \mathbf{y},\Delta S_n\rangle & \langle \mathbf{y},\Delta S_{n+1}\rangle & \cdots & \langle \mathbf{y},\Delta S_{n+k}\rangle \\ ⋮& ⋮& & ⋮\\ \langle \mathbf{y},\Delta S_{n+k-1}\rangle & \langle \mathbf{y},\Delta S_{n+k}\rangle & \cdots & \langle \mathbf{y},\Delta S_{n+2k-1}\rangle \end{array}\right|}{\left|\begin{array}{cccc}1& 1& \cdots & 1\\ \langle \mathbf{y},\Delta S_n\rangle & \langle \mathbf{y},\Delta S_{n+1}\rangle & \cdots & \langle \mathbf{y},\Delta S_{n+k}\rangle \\ ⋮& ⋮& & ⋮\\ \langle \mathbf{y},\Delta S_{n+k-1}\rangle & \langle \mathbf{y},\Delta S_{n+k}\rangle & \cdots & \langle \mathbf{y},\Delta S_{n+2k-1}\rangle \end{array}\right|}},k,n=0,1,\dots$$

(32)

Here, $\mathbf{y}\in E^{*}$. Furthermore, the second topological Shanks transformation can be obtained by replacing $S_n,\dots ,S_{n+k}$ with $S_{n+k},\dots ,S_{n+2k}$ in (30).

We then introduce a new ordered vector pair $\{u,\mathbf{y}\}\in E\times E^{*}$ and define the inverse of the ordered vector pair as follows:

$$u^{-1}={\displaystyle \frac{\mathbf{y}}{\langle \mathbf{y},u\rangle }}\in E^{*},{\mathbf{y}}^{-1}={\displaystyle \frac{u}{\langle \mathbf{y},u\rangle }}\in E.$$

(33)

Based on this definition, Brezinski and Redivo-Zaglia [21] derived two distinct forms of topological $\epsilon$-algorithms, denoted as TEA1 and TEA2. The recursive rule for the first topological $\epsilon$-algorithm (TEA1) to compute ${\widehat{e}}_k\left(S_n\right)$ is given by:

$$\left\{\begin{array}{cc}{\widehat{\epsilon }}_{-1}^{\left(n\right)}=0\in E^{*},\hfill & n=0,1,\dots ,\hfill \\ {\widehat{\epsilon }}_0^{\left(n\right)}=S_n\in E,\hfill & n=0,1,\dots ,\hfill \\ {\widehat{\epsilon }}_{2k+1}^{\left(n\right)}={\widehat{\epsilon }}_{2k-1}^{(n+1)}+{({\widehat{\epsilon }}_{2k}^{(n+1)}-{\widehat{\epsilon }}_{2k}^{\left(n\right)})}^{-1}\in E^{*},\hfill & k,n=0,1,\dots ,\hfill \\ {\widehat{\epsilon }}_{2k+2}^{\left(n\right)}={\widehat{\epsilon }}_{2k}^{(n+1)}+{({\widehat{\epsilon }}_{2k+1}^{(n+1)}-{\widehat{\epsilon }}_{2k+1}^{\left(n\right)})}^{-1}\in E,\hfill & k,n=0,1,....\hfill \end{array}\right.$$

(34)

Due to the different inversion rules for elements in E and its algebraic dual space $E^{*}$, as stated in Equation (33), and the dependence on the ordered vector pair, the calculation rules for the odd-indexed and even-indexed sequences in TEA1 differ from those in SEA and VEA. Specifically, for the odd-indexed sequence in TEA1, corresponding to the calculation rule in SEA (27), we have ${\widehat{\epsilon }}_{2k+1}^{\left(n\right)}={\widehat{\epsilon }}_{2k-1}^{(n+1)}+{({\widehat{\epsilon }}_{2k}^{(n+1)}-{\widehat{\epsilon }}_{2k}^{\left(n\right)})}^{-1},$ where ${\widehat{\epsilon }}_{2k}^{(n+1)}-{\widehat{\epsilon }}_{2k}^{\left(n\right)}\in E^{*}$, and the inversion corresponds to the ordered vector pair $({\widehat{\epsilon }}_{2k}^{(n+1)}-{\widehat{\epsilon }}_{2k}^{\left(n\right)},\mathbf{y})\in E\times E^{*}$, where $\mathbf{y}\in E^{*}$, i.e.,

$${({\widehat{\epsilon }}_{2k}^{(n+1)}-{\widehat{\epsilon }}_{2k}^{\left(n\right)})}^{-1}={\displaystyle \frac{\mathbf{y}}{\langle \mathbf{y},{\widehat{\epsilon }}_{2k}^{(n+1)}-{\widehat{\epsilon }}_{2k}^{\left(n\right)}\rangle }}\in E^{*}.$$

Similarly, corresponding to (27), for the even-indexed sequence in TEA1, we have ${\widehat{\epsilon }}_{2k+2}^{\left(n\right)}={\widehat{\epsilon }}_{2k}^{(n+1)}+{({\widehat{\epsilon }}_{2k+1}^{(n+1)}-{\widehat{\epsilon }}_{2k+1}^{\left(n\right)})}^{-1},$ where ${\widehat{\epsilon }}_{2k+1}^{(n+1)}-{\widehat{\epsilon }}_{2k+1}^{\left(n\right)}\in E$, and the inversion corresponds to the ordered vector pair $({\widehat{\epsilon }}_{2k}^{(n+1)}-{\widehat{\epsilon }}_{2k}^{\left(n\right)},{\widehat{\epsilon }}_{2k+1}^{(n+1)}-{\widehat{\epsilon }}_{2k+1}^{\left(n\right)})\in E\times E^{*}$, i.e.,

$${({\widehat{\epsilon }}_{2k+1}^{(n+1)}-{\widehat{\epsilon }}_{2k+1}^{\left(n\right)})}^{-1}={\displaystyle \frac{{\widehat{\epsilon }}_{2k}^{(n+1)}-{\widehat{\epsilon }}_{2k}^{\left(n\right)}}{\langle {\widehat{\epsilon }}_{2k+1}^{(n+1)}-{\widehat{\epsilon }}_{2k+1}^{\left(n\right)},{\widehat{\epsilon }}_{2k}^{(n+1)}-{\widehat{\epsilon }}_{2k}^{\left(n\right)}\rangle }}\in E.$$

The recursive rule for computing ${\tilde{e}}_k\left(S_n\right)$ using the second topological $\epsilon$-algorithm (TEA2) is given by

$$\left\{\begin{array}{cc}{\tilde{\epsilon }}_{-1}^{\left(n\right)}=0\in E^{*},\hfill & n=0,1,\dots ,\hfill \\ {\tilde{\epsilon }}_0^{\left(n\right)}=S_n\in E,\hfill & n=0,1,\dots ,\hfill \\ {\tilde{\epsilon }}_{2k+1}^{\left(n\right)}={\tilde{\epsilon }}_{2k-1}^{(n+1)}+{({\tilde{\epsilon }}_{2k}^{(n+1)}-{\tilde{\epsilon }}_{2k}^{\left(n\right)})}^{-1}\in E^{*},\hfill & k,n=0,1,\dots ,\hfill \\ {\tilde{\epsilon }}_{2k+2}^{\left(n\right)}={\tilde{\epsilon }}_{2k}^{(n+1)}+{({\tilde{\epsilon }}_{2k+1}^{(n+1)}-{\tilde{\epsilon }}_{2k+1}^{\left(n\right)})}^{-1}\in E,\hfill & k,n=0,1,....\hfill \end{array}\right.$$

The computation of the odd-indexed sequence in TEA2 follows the same rule as ${\widehat{\epsilon }}_{2k+1}^{\left(n\right)}$ in TEA1. For the even-indexed sequence, corresponding to (27), we have ${\tilde{\epsilon }}_{2k+2}^{\left(n\right)}={\tilde{\epsilon }}_{2k}^{(n+1)}+{({\tilde{\epsilon }}_{2k+1}^{(n+1)}-{\tilde{\epsilon }}_{2k+1}^{\left(n\right)})}^{-1},$ and, unlike TEA1, the inversion in TEA2 for ${\tilde{\epsilon }}_{2k+1}^{(n+1)}-{\tilde{\epsilon }}_{2k+1}^{\left(n\right)}\in E$ corresponds to the ordered vector pair $({\tilde{\epsilon }}_{2k}^{(n+2)}-{\tilde{\epsilon }}_{2k}^{(n+1)},{\tilde{\epsilon }}_{2k+1}^{(n+1)}-{\tilde{\epsilon }}_{2k+1}^{\left(n\right)})\in E\times E^{*}$, i.e.,

$${({\tilde{\epsilon }}_{2k+1}^{(n+1)}-{\tilde{\epsilon }}_{2k+1}^{\left(n\right)})}^{-1}={\displaystyle \frac{{\tilde{\epsilon }}_{2k}^{(n+2)}-{\tilde{\epsilon }}_{2k}^{(n+1)}}{\langle {\tilde{\epsilon }}_{2k+1}^{(n+1)}-{\tilde{\epsilon }}_{2k+1}^{\left(n\right)},{\tilde{\epsilon }}_{2k}^{(n+2)}-{\tilde{\epsilon }}_{2k}^{(n+1)}\rangle }}\in E.$$

Note the connection between the topological Shanks transformation and the topological $\epsilon$-algorithm. For the first topological Shanks transformation, ${\widehat{e}}_k\left(S_n\right)$, and ${\widehat{\epsilon }}_k^{\left(n\right)}$ in TEA1, the following holds:

$$\begin{array}{cccc}\hfill {\widehat{\epsilon }}_{2k}^{\left(n\right)}& ={\widehat{e}}_k\left(S_n\right),\hfill & \hfill \langle \mathbf{y},{\widehat{\epsilon }}_{2k}^{\left(n\right)}\rangle & =e_k\left(\langle \mathbf{y},S_n\rangle \right),\hfill \\ \hfill {\widehat{\epsilon }}_{2k+1}^{\left(n\right)}& ={\displaystyle \frac{\mathbf{y}}{\langle \mathbf{y},{\widehat{e}}_k(\Delta S_n)\rangle }},\hfill & \hfill {\widehat{\epsilon }}_{2k+1}^{\left(n\right)}& ={\displaystyle \frac{\mathbf{y}}{e_k\left(\langle \mathbf{y},\Delta S_n\rangle \right)}},k,n=0,1,....\hfill \end{array}$$

(35)

For the second topological Shanks transformation ${\tilde{e}}_k\left(S_n\right)$ and ${\tilde{\epsilon }}_k^{\left(n\right)}$ in TEA2, the following holds:

$$\begin{array}{cccc}\hfill {\tilde{\epsilon }}_{2k}^{\left(n\right)}& ={\tilde{e}}_k\left(S_n\right),\hfill & \hfill \langle \mathbf{y},{\tilde{\epsilon }}_{2k}^{\left(n\right)}\rangle & =e_k\left(\langle \mathbf{y},S_n\rangle \right),\hfill \\ \hfill {\tilde{\epsilon }}_{2k+1}^{\left(n\right)}& ={\displaystyle \frac{\mathbf{y}}{\langle \mathbf{y},{\tilde{e}}_k(\Delta S_n)\rangle }},\hfill & \hfill {\tilde{\epsilon }}_{2k+1}^{\left(n\right)}& ={\displaystyle \frac{\mathbf{y}}{e_k\left(\langle \mathbf{y},\Delta S_n\rangle \right)}},k,n=0,1,....\hfill \end{array}$$

(36)

The computational rules for the odd-indexed and even-indexed sequences in TEA1 and TEA2 are summarized in the Figure 2. For odd indices, the computational rules for the two types of topological $\epsilon$-algorithms are identical and consistent with those of the scalar $\epsilon$-algorithm (SEA). The computation of ${\epsilon }_{2k+1}^{\left(n\right)}$ requires only the three elements located at the vertices of the diamond structure table: ${\epsilon }_{2k-1}^{(n+1)}$, ${\epsilon }_{2k}^{\left(n\right)}$, and ${\epsilon }_{2k}^{(n+1)}$. However, for even-indexed sequences, both TEA1 and TEA2 require additional elements beyond these three. Moreover, during the recursion process, both topological $\epsilon$-algorithms must simultaneously store information about the odd-indexed sequence in E and the even-indexed sequence in the algebraic dual space $E^{*}$, thereby significantly increasing the storage burden in large-scale computations. Furthermore, both TEA1 and TEA2 require dual product calculations during the recursion process, which further increases the computational complexity.

3.3. Simplified Topological $\epsilon$-Algorithm

To optimize the computational rules of the two topological $\epsilon$-algorithms, Brezinski and Redivo-Zaglia [21] proposed simplified versions of the these algorithms (STEA1 and STEA2) for TEA1 and TEA2. These algorithms combine the odd and even recursive rules of TEA into a single unified rule, thereby requiring the storage of only the even-indexed column vectors. This streamlined computational process not only reduces storage requirements and algorithmic complexity but also enhances overall efficiency, leading to improved performance in large-scale data processing.

For the scalar sequence $\left\{\langle \mathbf{y},S_n\rangle \right\}$, based on the relationship in Equation (28) between the scalar Shanks transformation and SEA, the following holds:

$${\epsilon }_{2k}^{\left(n\right)}=e_k\left(\langle \mathbf{y},S_n\rangle \right),{\epsilon }_{2k+1}^{\left(n\right)}={\displaystyle \frac{1}{e_k\left(\langle \mathbf{y},\Delta S_n\rangle \right)}}.$$

(37)

From Equations (35) and (37), the following holds:

$${\widehat{\epsilon }}_{2k+1}^{(n+1)}-{\widehat{\epsilon }}_{2k+1}^{\left(n\right)}={\displaystyle \frac{\mathbf{y}}{e_k\left(\langle \mathbf{y},\Delta S_{n+1}\rangle \right)}}-{\displaystyle \frac{\mathbf{y}}{e_k\left(\langle \mathbf{y},\Delta S_n\rangle \right)}}=\mathbf{y}({\epsilon }_{2k+1}^{(n+1)}-{\epsilon }_{2k+1}^{\left(n\right)}).$$

(38)

Therefore, the recursive rule for the even-indexed sequence in TEA1 can be rewritten as

$${\widehat{\epsilon }}_{2k+2}^{\left(n\right)}={\widehat{\epsilon }}_{2k}^{(n+1)}+{\displaystyle \frac{{\widehat{\epsilon }}_{2k}^{(n+1)}-{\widehat{\epsilon }}_{2k}^{\left(n\right)}}{\langle \mathbf{y},{\widehat{\epsilon }}_{2k}^{(n+1)}-{\widehat{\epsilon }}_{2k}^{\left(n\right)}\rangle ({\epsilon }_{2k+1}^{(n+1)}-{\epsilon }_{2k+1}^{\left(n\right)})}},k,n=0,1,\cdots .$$

Then, by combining the recursive rules in Equations (27) and (34), the following four equivalent forms for the even indices of the TEA1 algorithm can be derived:

$$\begin{array}{cc}\hfill & \mathrm{STEA}1\text{-}1:{\widehat{\epsilon }}_{2k+2}^{\left(n\right)}={\widehat{\epsilon }}_{2k}^{(n+1)}+{\displaystyle \frac{1}{({\epsilon }_{2k+1}^{(n+1)}-{\epsilon }_{2k+1}^{\left(n\right)})({\epsilon }_{2k}^{(n+1)}-{\epsilon }_{2k}^{\left(n\right)})}}({\widehat{\epsilon }}_{2k}^{(n+1)}-{\widehat{\epsilon }}_{2k}^{\left(n\right)}),\hfill \\ \hfill & \mathrm{STEA}1\text{-}2:{\widehat{\epsilon }}_{2k+2}^{\left(n\right)}={\widehat{\epsilon }}_{2k}^{(n+1)}+{\displaystyle \frac{{\epsilon }_{2k+1}^{\left(n\right)}-{\epsilon }_{2k-1}^{(n+1)}}{{\epsilon }_{2k+1}^{(n+1)}-{\epsilon }_{2k+1}^{\left(n\right)}}}({\widehat{\epsilon }}_{2k}^{(n+1)}-{\widehat{\epsilon }}_{2k}^{\left(n\right)}),\hfill \\ \hfill & \mathrm{STEA}1\text{-}3:{\widehat{\epsilon }}_{2k+2}^{\left(n\right)}={\widehat{\epsilon }}_{2k}^{(n+1)}+{\displaystyle \frac{{\epsilon }_{2k+2}^{\left(n\right)}-{\epsilon }_{2k}^{(n+1)}}{{\epsilon }_{2k}^{(n+1)}-{\epsilon }_{2k}^{\left(n\right)}}}({\widehat{\epsilon }}_{2k}^{(n+1)}-{\widehat{\epsilon }}_{2k}^{\left(n\right)}),\hfill \\ \hfill & \mathrm{STEA}1\text{-}4:{\widehat{\epsilon }}_{2k+2}^{\left(n\right)}={\widehat{\epsilon }}_{2k}^{(n+1)}+({\epsilon }_{2k+1}^{\left(n\right)}-{\epsilon }_{2k-1}^{(n+1)})({\epsilon }_{2k+2}^{\left(n\right)}-{\epsilon }_{2k}^{(n+1)})({\widehat{\epsilon }}_{2k}^{(n+1)}-{\widehat{\epsilon }}_{2k}^{\left(n\right)}).\hfill \end{array}$$

Here, ${\widehat{\epsilon }}_0^{\left(n\right)}=S_n\in E,n=0,1,\dots$. Similarly, the following four mutually equivalent recursive formulas for the even-indexed sequences in TEA2 can be derived:

$$\begin{array}{cc}\hfill & \mathrm{STEA}2\text{-}1:{\tilde{\epsilon }}_{2k+2}^{\left(n\right)}={\tilde{\epsilon }}_{2k}^{(n+1)}+{\displaystyle \frac{1}{({\epsilon }_{2k+1}^{(n+1)}-{\epsilon }_{2k+1}^{\left(n\right)})({\epsilon }_{2k}^{(n+2)}-{\epsilon }_{2k}^{(n+1)})}}({\tilde{\epsilon }}_{2k}^{(n+2)}-{\tilde{\epsilon }}_{2k}^{(n+1)}),\hfill \\ \hfill & \mathrm{STEA}2\text{-}2:{\tilde{\epsilon }}_{2k+2}^{\left(n\right)}={\tilde{\epsilon }}_{2k}^{(n+1)}+{\displaystyle \frac{{\epsilon }_{2k+1}^{(n+1)}-{\epsilon }_{2k-1}^{(n+2)}}{{\epsilon }_{2k+1}^{(n+1)}-{\epsilon }_{2k+1}^{\left(n\right)}}}({\tilde{\epsilon }}_{2k}^{(n+2)}-{\tilde{\epsilon }}_{2k}^{(n+1)}),\hfill \\ \hfill & \mathrm{STEA}2\text{-}3:{\tilde{\epsilon }}_{2k+2}^{\left(n\right)}={\tilde{\epsilon }}_{2k}^{(n+1)}+{\displaystyle \frac{{\epsilon }_{2k+2}^{\left(n\right)}-{\epsilon }_{2k}^{(n+1)}}{{\epsilon }_{2k}^{(n+2)}-{\epsilon }_{2k}^{(n+1)}}}({\tilde{\epsilon }}_{2k}^{(n+2)}-{\tilde{\epsilon }}_{2k}^{(n+1)}),\hfill \\ \hfill & \mathrm{STEA}2\text{-}4:{\tilde{\epsilon }}_{2k+2}^{\left(n\right)}={\tilde{\epsilon }}_{2k}^{(n+1)}+({\epsilon }_{2k+1}^{(n+1)}-{\epsilon }_{2k-1}^{(n+2)})({\epsilon }_{2k+2}^{\left(n\right)}-{\epsilon }_{2k}^{(n+1)})({\tilde{\epsilon }}_{2k}^{(n+2)}-{\tilde{\epsilon }}_{2k}^{(n+1)}).\hfill \end{array}$$

Here, ${\tilde{\epsilon }}_0^{\left(n\right)}=S_n\in E,n=0,1,\dots$.

From the above calculation, it is evident that the generation of $e_k\left(S_n\right)$ in both STEA1 and STEA2 depends solely on the even-indexed sequence, with the odd-indexed sequence serving only as an auxiliary sequence. As a result, during the recursive processes of both simplified topological $\epsilon$-algorithms, only the information of the even-indexed sequences needs to be stored, eliminating the need to store the odd-indexed sequences. Additionally, in STEA1 and STEA2, the number of pairwise product operations is reduced during recursion. The linear functional $\mathbf{y}$ in $E^{*}$ is involved solely in the duality product operation with the initial sequence $S_n$ in E, generating a scalar sequence $\langle \mathbf{y},S_n\rangle$. Furthermore, the recursion of this scalar sequence $\langle \mathbf{y},S_n\rangle$ can be performed using SEA, as shown in Equation (27).

3.4. Implementation of the $\epsilon$-Algorithms

The core principle of the $\epsilon$-algorithms is founded on the Shanks transformation, which leverages the linear difference structure of the sequence by forming specific linear combinations aimed at eliminating the dominant error terms during the convergence process. The algorithm calculates these constructed linear combinations following explicit recursive rules, thus facilitating the acceleration of the sequence’s convergence.

The implementation of $\epsilon$-algorithms (SEA, VEA, TEA, and STEA) and the construction of the associated $\epsilon$-number table are most directly achieved by storing all elements corresponding to each pair of indices k and n. This process begins with a prescribed number of terms in the first two columns and proceeds recursively, computing subsequent entries column by column. As each successive column contains one fewer element than the previous, the resulting structure forms the lower triangular part of the $\epsilon$-table. However, this approach requires retaining all elements within the triangular region, which can lead to considerable memory overhead, especially in the case of vector- or matrix-valued sequences.

To address this limitation, a more memory-efficient strategy computes the terms of the original sequence incrementally and constructs the $\epsilon$-table along ascending diagonals [21,22]. Specifically, after generating an initial triangular portion of the table and retaining only the last row along its ascending diagonal, a new element from the original sequence $S_n$ is introduced, and the next ascending diagonal is computed iteratively. This approach requires storing only a single ascending diagonal $\left(e_i\right)$ and three auxiliary temporary variables, thereby significantly reducing the storage demands.

$$\begin{array}{cc}Stepi|& 0e_i=S_i{e}_{i-1}{e}_{i-2}\cdots e_2{e}_1\hfill \\ Stepi+1|& 0e_{i+1}=S_{i+1}{e}_i{e}_{i-1}\cdots e_3{e}_2{e}_1\hfill \end{array}$$

The implementations of the SEA, VEA, TEA, and STEA algorithms were previously provided in the MATLAB toolbox EPSfun [22]. In this paper, we present a more intuitive and transparent implementation of these algorithms. Specifically, Algorithms 1 and 2 illustrate the procedures for SEA and VEA, respectively. Although both algorithms share the same fundamental computational structure, they differ in how the inverse operation is treated. In particular, the inverse operation in VEA is defined as shown in Equation (29).

For a fixed acceleration window of width k, both SEA and VEA compute new elements incrementally along the rising diagonals until the $2k$-th column is completed. In Algorithm 2, the inner product in ${\mathbb{R}}^m$ is defined using the standard Euclidean inner product, namely, $(x,y)=x^{T}y$, for all $x,y\in {\mathbb{R}}^m$.

Algorithm 1 Scalar $\epsilon$-algorithm (SEA)

Require:  $2k+1$ elements of the scalar sequence $\left\{S_n\right\}$: $S_0,S_1,\dots ,S_{2k}$, where k is the acceleration window width. Ensure:  Return the values W and e 1: $e\left(1\right)=S_1$ 2: for   $i=2:2k+1$ do 3:    $N=0;e\left(i\right)=S_i$ 4:    for $j=i:-1:2$ do 5:      $d=e\left(j\right)-e(j-1);W=N+1/d$ 6:      $N=e(j-1);e(j-1)=W$ 7:    end for 8: end for

Algorithm 2 Vector $\epsilon$-algorithm (VEA)

Require:  $2k+1$ elements of the vector sequence $\left\{S_n\right\}$: $S_0,S_1,\dots ,S_{2k}$, where k is the acceleration window width. Ensure:  Return the values W and e 1: $e(:,1)=S_1$ 2: for   $i=2:2k+1$ do 3:    $N=\mathrm{zeros}(\mathrm{n},1)$    % Initialize a zero vector of the same size as $S_i$. 4:    $e(:,i)=S_i$ 5:    for $j=i:-1:2$ do 6:      $d=e(:,j)-e(:,j-1);W=N+d/\left(d^{T}d\right)$ 7:      $N=e(:,j-1);e(:,j-1)=W$ 8:    end for 9: end for

Algorithm 3 presents the implementation of the TEA algorithm. It is important to note that TEA applies distinct computational rules to subsequences with odd and even indices. Specifically, the computational rules for odd-indexed terms are identical to those used in SEA and VEA, whereas the computation of even-indexed terms requires the introduction of additional elements. Since the construction of the $\epsilon$-table proceeds in a top-down manner, it is sufficient to store only the elements along a single ascending diagonal. In TEA2, the additional elements required for computing even-indexed terms correspond to the newly introduced elements from the initial sequence, and therefore, no extra storage is required. In contrast, in TEA1, the additional elements required for computing the even-indexed terms are not located on the current ascending diagonal. Therefore, TEA1 must additionally store the even-indexed elements from the previous ascending diagonal.

Algorithm 3 Topological $\epsilon$-algorithm (TEA)

Require:  $2k+1$ elements of sequence $\left\{S_n\right\}$: $S_0,S_1,\dots ,S_{2k}$, where k is the acceleration window width. Ensure:  Return the values W and e 1: Select the appropriate duality pairing between the linear generalized function $\mathbf{y}$ and the ordered vector pair $\{u,\mathbf{y}\}\in E\times E^{*}$, where $E^{*}$ denotes the algebraic dual space of E. 2: $e(:,1)=S_1$ 3: for   $i=2:2k+1$ do 4:    $N=\mathrm{zeros}(\mathrm{n},1);e(:,i)=S_i;\mathrm{counter}=1$ 5:    for $j=i:-1:2$ do 6:      $d=e(:,j)-e(:,j-1)$ 7:      if mod(counter, 2) == 1 then 8:         $W=N+\mathbf{y}/\langle \mathbf{y},d\rangle$ 9:      else 10:         $W=N+\left(e\right(:,j+1)-N)/\langle e(:,j+1)-N,d\rangle$ 11:      end if 12:      $N=e(:,j-1);e(:,j-1)=W;\mathrm{counter}=\mathrm{counter}+1$ 13:    end for 14: end for

Algorithm 4 presents the implementation of the STEA method. Notably, the structure of STEA consists of two components: a scalar part and a vector component. The scalar component retains a diamond-shaped structure, while the computational rules for the vector component are adapted to a triangular form. In the scalar part, each new scalar value is obtained by computing the duality product between the newly introduced elements of the sequence $S_n$ and the vector $\mathbf{y}$ while preserving the entire ascending diagonal during computation. In contrast, the vector component retains only the even-indexed elements along the ascending diagonal. As a result, the algorithm requires storing only k vectors. The distinction between STEA1 and STEA2 is analogous to that between TEA1 and TEA2: STEA1 requires storing additional even-indexed elements from the previous ascending diagonal, while STEA2 avoids this, making it generally more memory-efficient. In the implementation provided in the literature [22], the scalar component of STEA is computed first using SEA, and the resulting scalar values are then incorporated into the STEA algorithm. In this paper, we integrate these two procedures into a unified approach. Algorithm 4 provides the detailed implementation of STEA2-3, while the other three equivalent variants can be obtained by modifying the index variable j within the algorithm.

Algorithm 4 The simplified topological $\epsilon$-algorithms (STEA)

Require:  $2k+1$ elements of sequence $\left\{S_n\right\}$: $S_0,S_1,\dots ,S_{2k}$, where k is the acceleration window width. Ensure:  Return the values W and e 1: Select the appropriate duality pairing between the linear generalized function $\mathbf{y}$ and the ordered vector pair $\{u,\mathbf{y}\}\in E\times E^{*}$, where $E^{*}$ denotes the algebraic dual space of E. 2: $e_1\left\{1\right\}=S_1;$    $e_2\left(1\right)=\langle \mathbf{y},e_1\left\{1\right\}\rangle ;$    $iter=0;$ 3: for   $i=2:2k+1$ do 4:    if mod(i, 2) == 0 then 5:      $e_1\left(1\right)=\left[\right];$    % Deletes the first element of the table and shifts the subsequent elements forward. 6:      $iter=iter+1;$ 7:    end if 8:    $N=0;$    $e_1\{i-iter\}=S_i;$    $e_2\left(i\right)=\langle \mathbf{y},e_1\{i-iter\}\rangle ;$    $\mathrm{counter}=1;$ 9:    for $j=i:-1:2$ do 10:      $d=e_2\left(j\right)-e_2(j-1);W=N+1/d;$ 11:      if mod(counter, 2) == 0 then 12:         $J=(W-N)/\left(e\right(j+1)-N);$ 13:         $\mathrm{index}=j-iter+0.5\ast (\mathrm{counter}-2);$ 14:         $e_1\left\{\mathrm{index}\right\}=e_1\left\{\mathrm{index}\right\}+J\ast (e_1\{\mathrm{index}+1\}-e_1\left\{\mathrm{index}\right\});$ 15:      end if 16:      $N=e_2(j-1);e_2(j-1)=W;\mathrm{counter}=\mathrm{counter}+1;$ 17:    end for 18: end for

Remark 1. 

The ε-acceleration algorithms (SEA, VEA, TEA, and STEA) do not require matrix decomposition or subproblem solving, which gives them a significant advantage over polynomial extrapolation methods (such as MPE, MMPE, and RRE) and Anderson acceleration.

Remark 2.

In the algebraic dual space $E^{*}$ of E, the selection of linear functionals $\mathbf{y}$ and the corresponding dual product are detailed in the literature [21,22] for common selection methods. If the original sequence is a vector sequence $\left\{S_n\right\}\subset {\mathbb{R}}^m$ or a matrix sequence $\left\{S_n\right\}\subset {\mathbb{R}}^{m\times n}$, and considering that the vector space ${\mathbb{R}}^m$ and the matrix space ${\mathbb{R}}^{m\times n}$ are algebraically self-dual, the following selections are made:

• $E={\mathbb{R}}^m$, typically $\mathbf{y}=\mathit{ones}(m,1)$, i.e., the m-dimensional vector with all elements equal to 1, and the dual product is defined as $\langle \mathbf{y},S_n\rangle =(\mathbf{y},S_n)={\mathbf{y}}^T{S}_n$;
• $E={\mathbb{R}}^{n\times n}$, typically $\mathbf{y}=I_n$, and the dual product is defined as $\langle \mathbf{y},S_n\rangle =\mathrm{trace}\left(S_n\right)$;
• $E={\mathbb{R}}^{m\times n}$, typically $\mathbf{y}=\mathit{ones}(m,n)$, and the dual product is defined as $\langle \mathbf{y},S_n\rangle =\mathrm{trace}\left({\mathbf{y}}^T{S}_n\right)$.

3.5. Combining $\epsilon$-Algorithms with Fixed-Point Iterations to Solve the Problem (5)

Given that the sequence generated by the fixed-point iteration in Equation (19) for solving the GIPSCAL problem is a matrix sequence, and that the operator ${\mathcal{H}}_{\mathrm{GIPSCAL}}:{\mathbb{R}}^{n\times r}\to {\mathbb{R}}^{n\times r}$ is a nonlinear mapping, we adopt a restart-based acceleration strategy for applying the $\epsilon$-algorithm. This approach follows the vector sequence polynomial extrapolation acceleration framework proposed in [35].

In practical implementations of the acceleration algorithm, a delayed start strategy is commonly employed to prevent premature acceleration and improve overall performance. Specifically, the basic fixed-point iteration (19) is first executed for a fixed number of steps, or until the matrix sequence $\left\{(Q^{\left(k\right)},D_1^{\left(k\right)},\cdots ,D_N^{\left(k\right)},K_1^{\left(k\right)},\cdots ,K_N^{\left(k\right)})\right\}$ a specified level of initial accuracy. Only after this preliminary phase is the acceleration algorithm applied. The detailed implementation steps of the iterative acceleration algorithm based on the $\epsilon$-algorithm for solving the three-way GIPSCAL problem (5) are presented in Algorithm 5.

Algorithm 5 VEA, TEA, and STEA accelerated fixed-point iterations for solving the three-way GIPSCAL problem (5)

Require:  N asymmetric n -order matrices $X_1,\dots ,X_N$, the initial iteration $Q^{\left(0\right)}\in \mathcal{O}(n,r)$, and the window width parameter k. 1: Basic Iteration: Initialize the iteration matrix $S_0^{\left(0\right)}$ to $Q^{\left(0\right)}$ , such that $Z_0^{\left(0\right)}$ = $S_0^{\left(0\right)}$ and perform $\kappa$ iterations through the nonlinear map ${\mathcal{H}}_{\mathrm{GIPSCAL}}$ to get $Z_1,Z_2,\cdots ,Z_{\kappa }$. 2: Perform extrapolation acceleration: Use $Z_{\kappa }$ as the initial value of acceleration $S_0$, carry out $2k$ iterations to obtain $S_0,S_1,S_2,\cdots ,S_{2k}$, and use this $2k+1$ sequence as the sequence of history iterations required for extrapolating the acceleration. Perform the VEA, TEA, or STEA algorithms to generate $S_{2k}^{\left(0\right)}$, which is denoted as $Q^{*}$ after re-orthogonalization by the “economic” SVD decomposition. 3: Convergence judgment and iterative update: Calculate $D_i^{*}$ and $K_i^{*}$ according to Equations (13) and (14) check whether $[Q^{*},D_1^{*},\cdots ,D_N^{*},K_1^{*},\cdots ,K_N^{*}]$ satisfies the termination condition, and if it doesn’t, update $Q^{\left(0\right)}=Q^{*}$, and return to Step 1 to continue iterating until convergence. 4: return $Q^{*}$, $D_1^{*},\cdots ,D_N^{*}$, $K_1^{*},\cdots ,K_N^{*}$.

The termination criterion of Algorithm 5 refers to the first-order optimality conditions of problem (5) as presented in [10]. Note also that the Stiefel manifold $\mathcal{O}(n,p)$ is an embedded submanifold in the Euclidean space ${\mathbb{R}}^{n\times p}$, as discussed in [36], while ${\mathrm{\Omega }}_{+}\left(p\right)$ is a convex set, and $\mathcal{K}\left(r\right)$ is a linear subspace. The termination criterion can be formulated as follows:

$$\begin{array}{cc}\hfill \mathrm{Error}=(& {∥{\mathcal{P}}_{{\mathbf{T}}_{Q^{\left(k\right)}}\mathcal{O}(n,r)}\left({\nabla }_{Q}f\left(Z^{\left(k\right)}\right)\right)∥}^2+\sum _{i=1}^N{∥{\mathcal{P}}_{\mathcal{K}\left(r\right)}\left({\nabla }_{K_i}{f}_i\left(Q^{\left(k\right)},D_i^{\left(k\right)},K_i^{\left(k\right)}\right)\right)∥}^2\hfill \\ \hfill & +\sum _{i=1}^N{∥{\mathcal{P}}_{{\mathcal{D}}_{+}\left(r\right)}\left(D_i^{\left(k\right)}-{\nabla }_{D_i}{f}_i\left(Q^{\left(k\right)},D_i^{\left(k\right)},K_i^{\left(k\right)}\right)\right)-D_i^{\left(k\right)}∥}^2{)}^{{\displaystyle \frac{1}{2}}}\le ϵ.\hfill \end{array}$$

(39)

Here, $ϵ$ is a predefined accuracy threshold, and ${\mathcal{P}}_{{\mathbf{T}}_{Q^{\left(k\right)}}\mathcal{O}(n,r)}$ denotes the orthogonal projection onto the tangent space ${\mathbf{T}}_{Q^{\left(k\right)}}\mathcal{O}(n,r)$ at the point $Q^{\left(k\right)}$. As shown in [9,36], for any matrix $M\in {\mathbb{R}}^{n\times r}$ and any $Q\in \mathcal{O}(n,r)$, the projection is given by

$${\mathcal{P}}_{{\mathbf{T}}_Q\mathcal{O}(n,r)}\left(M\right)=M-Q\mathrm{sym}\left(Q^{T}M\right),$$

(40)

where $\mathrm{sym}\left(A\right)={\displaystyle \frac{1}{2}}(A+A^T)$ denotes the symmetric part of the matrix A. For the implementation of Algorithm 5, the following notation is introduced:

Remark 3. 

The selection of the linear generalized functional $\mathbf{y}$ and the corresponding duality product in the dual space $E^{*}$ should follow the approach outlined in Remark 2.

Remark 4. 

The TEA and STEA methods presented in Algorithm 5 can be applied directly to the matrix sequence generated by the fixed-point iteration in Equation (19). However, if Algorithm 5 employs VEA for sequence acceleration, a combination of matrix vectorization (straightening) and inverse vectorization (inverse straightening) operators is needed. Specifically, for the $2k+1$ matrices $S_0,S_1,\dots ,S_{2k}$ involved in each single-step acceleration loop, the matrix straightening operator is applied to obtain the corresponding $2k+1$ vectors $s_0,s_1,\dots ,s_{2k}$. VEA is then applied to these vectors to calculate the accelerated vector $s_{2k}^{\left(0\right)}$, which is subsequently converted back to matrix form via the inverse straightening operator, resulting in the matrix $S_{2k}^{\left(0\right)}$. An “economy-size” singular value decomposition (SVD) is performed on $S_{2k}^{\left(0\right)}$ to reorthogonalize it, producing the updated matrix $Q^{*}$. Finally, Step 3 of Algorithm 5 is executed to proceed the iterative process.

4. Numerical Experiments

In this section, we present a comprehensive numerical evaluation of the proposed $\epsilon$-algorithm accelerated fixed-point iterations for solving the three-way GIPSCAL problem in Equation (5). We begin by comparing the original fixed-point iteration with its accelerated variants. Additionally, we benchmark these methods against the continuous-time projected gradient flow algorithm introduced by Trendafilov [10,13] as well as several state-of-the-art first- and second-order Riemannian optimization algorithms from the MATLAB toolbox Manopt [9,20]. All experiments were conducted on a standard desktop computer equipped with an Intel(R) Core(TM)i7-13620H CPU (2.40 GHz) and 16.00 GB of RAM and running MATLAB R202b.

To enable controlled and diverse benchmarking, we generated a collection of N square, asymmetric data matrices $X_i\in {\mathbb{R}}^{n\times n}$$(i=1,\dots ,N)$ using a factorial design approach inspired by Takane et al. [37], originally developed for orthogonal INDSCAL problems [9,17]. This setup includes three types of datasets: one purely random and two structured variants. In the random setting, each entry of $X_i$ is drawn independently from a standard normal distribution, i.e., $X_i=\mathtt{randn}(n,n)$. Such unstructured randomness often leads to large fit errors in the objective function of the problem (5). For the structured datasets, we construct each slice as $X_i=Q({\check{D}}_i+K_i)Q^T+E_i,$ where $Q\in {\mathbb{R}}^{n\times r}$, ${\check{D}}_i\in {\mathbb{R}}^{r\times r}$, and $K_i\in {\mathbb{R}}^{r\times r}$ are randomly generated, and $E_i$ denotes an additive noise matrix. The matrix Q is populated with uniformly distributed random entries from $[0,1]$ via rand(n, r) and column-orthogonalized using singular value decomposition (SVD). The diagonal entries of ${\check{D}}_i$ are sampled from a standard normal distribution. Each $K_i$ is drawn from the uniform distribution on $[0,1]$ and skew-symmetrized as $K_i\leftarrow {\displaystyle \frac{1}{2}}(K_i-K_i^T).$ To evaluate robustness under varying structural assumptions, we consider two structured variants: one allowing potentially negative diagonal elements in ${\check{D}}_i$ (indefinite case), and the other enforcing nonnegativity by taking element-wise absolute values (nonnegative definite or nnd case). The disturbance terms $E_i$ are sampled from a normal distribution with zero mean and variance ${\sigma }^2$, where $\sigma$ is set to 10% of the standard deviation of the structural term $Q({\check{D}}_i+K_i)Q^T$. To better reflect practical scenarios, the number of “subjects” N varies between 20 and 50, while the number of “stimuli” n is capped at 200. For effective visualization in multidimensional scaling (MDS), the target dimensionality r is set to three representative levels: $r=2,3,$ and 5.

The initial iterate $Q^{\left(0\right)}\in \mathcal{O}(n,r)$, used in both the original and accelerated fixed-point iterations, is computed using a structured initialization strategy consistent with the recommendations of [10,17]. Specifically, we perform an eigenvalue decomposition (EVD) on the symmetric component of the aggregated data ${\sum }_{i=1}^N{\displaystyle \frac{1}{2}}(X_i+X_i^T)=P\mathrm{\Lambda }{P}^T,$ where the eigenvalues in $\mathrm{\Lambda }$ are sorted in descending order. The first r eigenvectors, denoted $P_r$, are used to initialize $Q^{\left(0\right)}:=P_r$. The corresponding initial values of ${\tilde{D}}_i^{\left(0\right)}$ and $K_i^{\left(0\right)}$, required by both the Riemannian optimization framework and the projected gradient flow method used to solve the equivalent product-manifold-constrained optimization problem in Equation (42), are given by

$$\begin{array}{cc}\hfill {\tilde{D}}_i^{\left(0\right)}& ={\left\{max\left(\mathrm{diag}\left({\displaystyle \frac{1}{2}}{Q^{\left(0\right)}}^T(X_i+X_i^T)Q^{\left(0\right)}\right),0\right)\right\}}^{1/2},i=1,\dots ,N;\hfill \\ \hfill K_i^{\left(0\right)}& ={\displaystyle \frac{1}{2}}{Q^{\left(0\right)}}^T(X_i-X_i^T)Q^{\left(0\right)},i=1,\dots ,N.\hfill \end{array}$$

Due to the matrix-valued nature of the fixed-point sequence, storage constraints require relatively small window sizes k for $\epsilon$-algorithm acceleration. To evaluate the impact of window width on acceleration performance, we experiment with $k=4,5,$ and 6, selecting the value that produces the best empirical performance. To further enhance the reliability of the acceleration, particularly in cases where the base fixed-point iteration converges slowly, we adopt a delayed-start strategy. Under this scheme, the fixed-point algorithm is executed until an intermediate solution $[Q^{\left(j\right)},D_1^{\left(j\right)},\dots ,D_N^{\left(j\right)},K_1^{\left(j\right)},\dots ,K_N^{\left(j\right)}]$ satisfies a specified error threshold, $\mathrm{Error}\le {10}^{-1}$. Only then is the $\epsilon$-algorithm-based acceleration activated. In our experiment, the core implementations of various $\epsilon$-algorithms (including SEA, VEA, TEA, and STEA) are provided by the MATLAB toolbox EPSfun, as described in [22]. The specific code can be downloaded from the following website: http://www.netlib.org/numeralgo/. In this experiment, the topological $\epsilon$-algorithm uses the TEA2 version, while the simplified topological $\epsilon$-algorithm uses the STEA2-3 version. For both the original fixed-point iteration and each of the acceleration algorithms, different termination thresholds are applied based on the data generation method for $X_i$. In the case of RAND-generated data, convergence is relatively slow; therefore, the termination tolerance is set to ${10}^{-6}$. For the NND and IND cases, which typically converge faster, a tighter tolerance of ${10}^{-8}$ is used. The computation of $\mathrm{Error}$ follows the definition given in Equation (39). In all subsequent numerical results, the reported $\mathrm{Error}$ values are consistently calculated using this formula.

4.1. Numerical Comparison of Fixed-Point Acceleration Methods

This section presents a comprehensive numerical comparison between the original fixed-point iteration (denoted FPI) and several accelerated variants. These include $\epsilon$-algorithm-based methods (FPI-VEA, FPI-TEA, and FPI-STEA), polynomial extrapolation techniques (FPI-MPE, FPI-RRE, and FPI-MMPE), and Anderson acceleration (FPI-Anderson). The experimental results, summarized in

Table 1. Numerical comparison of the accelerated fixed-point iterations with the original method across various problem settings.

Partially structured with nnd weight matrices (NND)
N, [n,r]			FPI					FPI-VEA									FPI-TEA
			IT	CPU	Error	Fvalue		$k=4$			$k=5$			$k=6$			$k=4$			$k=5$			$k=6$
								IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU
$50,[45,3]$			50	0.059	$8.98\times {10}^{-9}$	0.660		19	0.024		17	0.020		15	0.021		25	0.029		30	0.037		36	0.040
$50,[45,5]$			75	0.094	$8.75\times {10}^{-9}$	1.363		19	0.026		23	0.035		27	0.037		36	0.052		34	0.052		40	0.053
$50,[100,3]$			44	0.247	$7.66\times {10}^{-9}$	0.666		15	0.091		13	0.072		14	0.079		19	0.105		21	0.116		19	0.106
$50,[100,5]$			77	0.444	$9.33\times {10}^{-9}$	1.380		19	0.111		23	0.135		27	0.157		30	0.169		41	0.233		35	0.199
$50,[200,3]$			47	0.880	$7.38\times {10}^{-9}$	0.665		18	0.338		16	0.290		14	0.245		19	0.327		23	0.408		24	0.439
$50,[200,5]$			76	1.449	$9.47\times {10}^{-9}$	1.375		19	0.364		23	0.435		27	0.505		36	0.672		32	0.609		31	0.577
FPI-STEA										FPI-MPE									FPI-RRE
$k=4$				$k=5$			$k=6$			$k=4$			$k=5$			$k=6$			$k=4$			$k=5$			$k=6$
IT	CPU			IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU
32	0.043			28	0.031		37	0.045		16	0.019		13	0.019		15	0.017		15	0.016		13	0.016		15	0.019
34	0.045			31	0.040		35	0.043		24	0.032		19	0.023		22	0.030		26	0.032		19	0.027		22	0.027
19	0.106			21	0.120		19	0.109		12	0.067		13	0.082		12	0.076		13	0.072		13	0.072		14	0.078
33	0.187			32	0.183		38	0.219		21	0.121		19	0.110		17	0.097		21	0.121		19	0.110		19	0.108
19	0.339			23	0.419		24	0.428		14	0.251		13	0.234		15	0.273		13	0.233		13	0.240		15	0.269
41	0.759			32	0.586		30	0.554		22	0.420		19	0.353		20	0.376		21	0.401		19	0.353		19	0.354
FPI-MMPE										FPI-Anderson
$k=4$				$k=5$			$k=6$			$k=4$			$k=5$			$k=6$
IT	CPU			IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU
16	0.021			13	0.016		15	0.018		9	0.016		9	0.012		9	0.010
21	0.027			19	0.026		22	0.028		22	0.040		16	0.020		17	0.025
16	0.088			13	0.072		15	0.083		8	0.048		8	0.045		8	0.043
21	0.123			19	0.110		21	0.121		16	0.091		15	0.085		15	0.087
16	0.293			13	0.238		15	0.269		8	0.146		8	0.138		8	0.143
19	0.370			19	0.350		20	0.369		17	0.319		15	0.271		15	0.292
Partially structured with indefinite weight matrices (IND)
N, [n,r]			FPI					FPI-VEA									FPI-TEA
			IT	CPU	Error	Fvalue		$k=4$			$k=5$			$k=6$			$k=4$			$k=5$			$k=6$
								IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU
$30,[30,3]$			23	0.013	$5.73\times {10}^{-9}$	20.719		13	0.010		12	0.009		14	0.009		18	0.011		13	0.008		14	0.007
$50,[30,5]$			29	0.026	$9.80\times {10}^{-9}$	64.644		14	0.014		13	0.016		14	0.014		17	0.016		14	0.012		14	0.014
$50,[150,3]$			22	0.312	$6.75\times {10}^{-9}$	31.572		10	0.148		12	0.162		14	0.189		10	0.137		12	0.161		14	0.200
$50,[150,5]$			25	0.351	$6.93\times {10}^{-9}$	64.621		12	0.161		12	0.167		14	0.189		14	0.190		14	0.205		14	0.197
$50,[300,3]$			22	0.768	$4.78\times {10}^{-9}$	31.578		10	0.358		12	0.431		14	0.501		10	0.351		12	0.428		14	0.490
$50,[300,5]$			27	0.955	$5.84\times {10}^{-9}$	64.629		12	0.436		12	0.425		14	0.486		14	0.491		12	0.428		14	0.494
FPI-STEA										FPI-MPE									FPI-RRE
$k=4$				$k=5$			$k=6$			$k=4$			$k=5$			$k=6$			$k=4$			$k=5$			$k=6$
IT	CPU			IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU
18	0.014			13	0.010		14	0.009		12	0.008		13	0.007		11	0.005		12	0.006		13	0.007		12	0.006
17	0.019			14	0.014		14	0.014		16	0.016		14	0.016		15	0.015		16	0.014		14	0.013		15	0.016
10	0.147			12	0.157		14	0.196		10	0.137		8	0.110		8	0.107		11	0.151		8	0.109		8	0.111
14	0.197			14	0.193		14	0.195		15	0.201		13	0.186		14	0.186		15	0.213		13	0.183		14	0.197
10	0.358			12	0.424		14	0.498		11	0.389		8	0.288		8	0.284		11	0.387		8	0.274		8	0.281
14	0.521			12	0.423		14	0.499		15	0.550		13	0.459		13	0.473		15	0.550		13	0.468		13	0.470
FPI-MMPE										FPI-Anderson
$k=4$				$k=5$			$k=6$			$k=4$			$k=5$			$k=6$
IT	CPU			IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU
11	0.007			13	0.009		11	0.008		8	0.008		8	0.006		8	0.004
16	0.017			14	0.013		15	0.014		12	0.011		12	0.012		11	0.010
11	0.148			11	0.153		8	0.106		7	0.097		7	0.090		7	0.094
15	0.208			13	0.183		15	0.210		11	0.149		11	0.147		10	0.138
11	0.390			8	0.279		8	0.292		7	0.248		7	0.251		7	0.254
15	0.550			13	0.476		13	0.481		11	0.385		10	0.360		10	0.362
Completely random data sets (RAND)
N, [n,r]			FPI					FPI-VEA									FPI-TEA
			IT	CPU	Error	Fvalue		$k=4$			$k=5$			$k=6$			$k=4$			$k=5$			$k=6$
								IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU
$30,[25,2]$			203	0.130	$9.62\times {10}^{-7}$	19059.419		144	0.090		144	0.072		144	0.071		176	0.101		172	0.083		169	0.081
$30,[25,3]$			523	0.246	$9.71\times {10}^{-7}$	18908.352		181	0.088		180	0.087		180	0.086		208	0.102		206	0.098		281	0.137
$50,[40,3]$			358	0.349	$9.56\times {10}^{-7}$	81523.263		246	0.246		248	0.244		252	0.252		282	0.284		270	0.267		270	0.264
$30,[40,5]$			274	0.173	$9.95\times {10}^{-7}$	48,131.172		129	0.083		131	0.088		134	0.088		158	0.106		180	0.117		158	0.105
$50,[60,3]$			1211	2.628	$9.87\times {10}^{-7}$	182304.537		678	1.489		673	1.442		669	1.430		797	1.706		737	1.570		689	1.477
$50,[60,5]$			485	1.079	$9.94\times {10}^{-7}$	181536.539		247	0.546		246	0.541		248	0.549		317	0.709		279	0.611		271	0.574
FPI-STEA										FPI-MPE									FPI-RRE
$k=4$				$k=5$			$k=6$			$k=4$			$k=5$			$k=6$			$k=4$			$k=5$			$k=6$
IT	CPU			IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU
176	0.108			172	0.079		169	0.076		142	0.074		142	0.068		144	0.070		143	0.076		142	0.071		144	0.070
216	0.106			213	0.100		279	0.138		167	0.081		168	0.080		169	0.080		168	0.080		168	0.081		169	0.082
282	0.282			270	0.266		271	0.269		244	0.238		238	0.230		240	0.235		246	0.243		240	0.233		240	0.235
157	0.100			180	0.118		158	0.108		130	0.088		131	0.089		127	0.084		129	0.083		131	0.085		127	0.085
806	1.739			760	1.628		821	1.755		652	1.376		648	1.362		649	1.371		649	1.382		645	1.374		641	1.370
315	0.676			283	0.613		271	0.586		245	0.527		238	0.499		236	0.505		245	0.523		243	0.509		240	0.513
FPI-MMPE										FPI-Anderson
$k=4$				$k=5$			$k=6$			$k=4$			$k=5$			$k=6$
IT	CPU			IT	CPU		IT	CPU		IT	CPU		IT	CPU		IT	CPU
144	0.072			143	0.071		144	0.071		145	0.083		144	0.067		144	0.065
169	0.081			169	0.081		169	0.079		200	0.098		197	0.093		190	0.094
251	0.239			243	0.231		244	0.234		255	0.243		247	0.241		248	0.245
132	0.089			131	0.086		127	0.083		141	0.093		140	0.092		140	0.096
650	1.382			647	1.374		641	1.358		690	1.474		676	1.424		669	1.417
248	0.526			242	0.517		240	0.504		266	0.569		252	0.535		255	0.547

, span a range of configurations including different data generation strategies for the matrices $X_i$, system dimensions $[n,r]$, number of components N, and acceleration window widths k. In the table, IT denotes the total number of iterations to reach convergence, CPU refers to the total computation time in seconds, and Error represents the final residual error. It is important to note that for all acceleration schemes—including FPI-VEA, FPI-TEA, FPI-STEA, FPI-MPE, FPI-RRE, FPI-MMPE, and FPI-Anderson—the reported iteration count (IT) includes the initial delayed-start iterations, the base iterations required to form the extrapolation sequence, and the subsequent accelerated iterations.

From Table 1, we observe that to achieve equivalent termination accuracy, the polynomial extrapolation method FPI-MPE generally outperforms the $\epsilon$-based methods in terms of iteration count and runtime. This performance gap is attributed to the number of sequence elements each method requires. Specifically, for a given window size k, polynomial extrapolation methods utilize $k+1$ vectors from the underlying sequence, while $\epsilon$-algorithms require $2k+1$ vectors [35]. Nonetheless, the $\epsilon$-based methods (FPI-VEA, FPI-TEA, and FPI-STEA) demonstrate consistent acceleration across different system sizes and window widths, exhibiting good performance scalability.

In Section 6, Theorem 6.8 of the paper [21], the theoretical analysis of the STEA algorithm for accelerating the convergence rate with the window width k is presented. Specifically, as k increases, the convergence order after acceleration improves. The specific content is as follows:

Theorem 4 

([21]). We consider sequences of the form

$$\begin{array}{cc}\hfill & S_n-S\sim \sum _{i=1}^{\infty }{a}_i{\lambda }_i^n{u}_i(n\to \infty )\mathrm{or}\hfill \\ \hfill & S_n-S\sim {(-1)}^n\sum _{i=1}^{\infty }{a}_i{\lambda }_i^n{u}_i(n\to \infty ),\hfill \end{array}$$

where $a_i,{\lambda }_i\in \mathbb{K}$, $u_i\in E$, and $1>{\lambda }_1>{\lambda }_2>\cdots >0$. Then, when k is fixed and n tends to infinity,

$$\begin{array}{ccc}\hfill & {\widehat{\epsilon }}_{2k}^{\left(n\right)}-S=\mathcal{O}\left({\lambda }_{k+1}^n\right),\hfill & \hfill {\displaystyle \frac{\parallel {\widehat{\epsilon }}_{2k+2}^{\left(n\right)}-S\parallel }{\parallel {\widehat{\epsilon }}_{2k}^{\left(n\right)}-S\parallel }}=\mathcal{O}\left({({\lambda }_{k+2}/{\lambda }_{k+1})}^n\right).\end{array}$$

(41)

Table 1 demonstrates that the choice of window width k significantly influences convergence behavior. While increasing k generally improves acceleration by leveraging more sequence information, it also raises the per-iteration computational cost. To strike a balance between efficiency and overhead, the acceleration window is fixed at $k=5$ for subsequent experiments.

Figure 3 illustrates the evolution of the error norm ${log}_{10}\parallel \mathrm{Error}\parallel$ as a function of iteration time across different system configurations. The results are presented for three data-generation scenarios: nonnegative definite (NND), indefinite (IND), and fully random (RAND), with $k=5$ held fixed throughout. For data generated via NND and IND schemes, the underlying fixed-point sequences exhibit relatively fast convergence. In these cases, extrapolation is applied immediately, without delay. As seen in the top four subplots of Figure 3 (with the top two corresponding to NND and the next two to IND), the application of $\epsilon$-acceleration after the initial $2k+1$ base iterations leads to a substantial and rapid drop in the residual error. In contrast, for RAND-generated data—where the underlying sequence converges more slowly—a delayed-start strategy is employed. The final six subplots of Figure 3 show the evolution of ${log}_{10}\left|\right|\mathrm{Error}\left|\right|$ for RAND matrices across varying system sizes. These results confirm that even under more challenging conditions, the accelerated methods remain effective and yield significant convergence improvements.

The numerical experiments collectively demonstrate that $\epsilon$-based acceleration methods achieve convergence performance comparable to polynomial extrapolation and Anderson acceleration when applied to the three-way GIPSCAL problem (5). A noteworthy advantage of the $\epsilon$-algorithms is their ability to operate directly on matrix sequences without requiring vectorization (or “straightening”) and inverse reshaping procedures—transformations that are typically needed for polynomial and Anderson-based methods. In addition, $\epsilon$-methods avoid costly matrix factorizations and auxiliary subproblem solves, resulting in simpler implementation and reduced computational overhead.

4.2. Comparison with Riemannian Optimization Methods in Manopt

In 2021, Trendafilov and Gallo [9] proposed a unified framework for classical multivariate data analysis models by leveraging the geometric structure of matrix manifolds. They further introduced a computational approach for the three-way GIPSCAL problem based on the Riemannian optimization toolbox Manopt [20]. In this section, we present a numerical comparison between the proposed fixed-point iteration acceleration methods (VEA, TEA, and STEA) and the existing optimization algorithms implemented in the Manopt toolbox. To enable the application of Riemannian optimization techniques, the original three-way GIPSCAL problem (5) is reformulated as a constrained optimization problem defined on a product manifold, as follows:

$$\begin{array}{cc}\hfill \mathrm{Minimize}& {\displaystyle \frac{1}{2}}\sum _{i=1}^N{\parallel X_i-Q\left({\tilde{D}}_i^2+K_i\right)Q^T\parallel }^2,\hfill \\ \hfill \mathrm{subject}\mathrm{to}& (Q,{\tilde{D}}_1,\dots ,{\tilde{D}}_N,K_1,\dots ,K_N)\in \mathcal{M}:=\mathcal{O}(n,r)\times \mathcal{D}{\left(r\right)}^N\times \mathcal{K}{\left(r\right)}^N.\hfill \end{array}$$

(42)

Here, $\mathcal{D}\left(r\right)$ denotes the linear subspace of diagonal $r\times r$ matrices. Through straightforward algebraic derivation, the Euclidean gradient of the objective function $\tilde{f}$ in (42) with respect to $Z=(Q,{\tilde{D}}_1,\dots ,{\tilde{D}}_N,K_1,\dots ,K_N)\in {\mathbb{R}}^{n\times r}\times \mathcal{S}{\left(r\right)}^N\times \mathcal{K}{\left(r\right)}^N$ can be expressed componentwise as

$$\begin{array}{cc}\hfill {\nabla }_Q\tilde{f}\left(Z\right)& =\sum _{i=1}^N\left(-2\mathrm{sym}\left(X_i\right)Q{\tilde{D}}_i^2+2\mathrm{skew}\left(X_i\right)Q{K}_i+2Q({\tilde{D}}_i^4-K_i^2)\right),\hfill \\ \hfill {\nabla }_{{\tilde{D}}_i}\tilde{f}\left(Z\right)& =-({\tilde{D}}_i{Q}^T{X}_{i}Q+Q^T{X}_{i}Q{\tilde{D}}_i)+2{\tilde{D}}_i^3+{\tilde{D}}_i{K}_i+K_i{\tilde{D}}_i,i=1,\dots ,N,\hfill \\ \hfill {\nabla }_{K_i}\tilde{f}\left(Z\right)& ={\tilde{D}}_i^2+K_i-Q^T{X}_{i}Q,i=1,\dots ,N.\hfill \end{array}$$

Since $\mathcal{M}$ is an embedded submanifold of the Euclidean space, the Riemannian gradient is obtained by orthogonally projecting the Euclidean gradient onto the tangent space ${\mathbf{T}}_Z\mathcal{M}$ [36]. Using the known projection operator (40) and the tangent space of the Stiefel manifold $\mathcal{O}(n,r)$ and recognizing that $\mathcal{D}\left(r\right)$ and $\mathcal{S}\left(r\right)$ are linear subspaces of $\mathcal{K}\left(r\right)$ and ${\mathbb{R}}^{r\times r}$, respectively, the Riemannian gradient of $\tilde{f}$ in (42) at $Z\in \mathcal{M}$ is given by

$$\begin{array}{cc}\hfill \mathrm{grad}\tilde{f}\left(Z\right)& =\{{\mathbf{P}}_Q\left(\sum _{i=1}^N\left(-2\mathrm{sym}\left(X_i\right)Q{\tilde{D}}_i^2+2\mathrm{skew}\left(X_i\right)Q{K}_i+2Q({\tilde{D}}_i^4-K_i^2)\right)\right),\hfill \\ & 2\left({\tilde{D}}_1^2-Q^T\mathrm{sym}\left(X_1\right)Q\right)\odot {\tilde{D}}_1,\cdots ,2\left({\tilde{D}}_N^2-Q^T\mathrm{sym}\left(X_N\right)Q\right)\odot {\tilde{D}}_N,\hfill \\ & K_1-Q^T\mathrm{skew}\left(X_1\right)Q\dots ,K_N-Q^T\mathrm{skew}\left(X_N\right)Q\}.\hfill \end{array}$$

The generic update step in a Riemannian optimization algorithm over $\mathcal{M}$ is given by

$$Z^{(k+1)}={\mathcal{R}}_{Z^{\left(k\right)}}\left({\alpha }_k\Delta Z^{\left(k\right)}\right),$$

where ${\alpha }_k$ is the step size, $\Delta Z^{\left(k\right)}=\left({\xi }^{\left(k\right)},{\eta }_1^{\left(k\right)},\dots ,{\eta }_N^{\left(k\right)},{\theta }_1^{\left(k\right)},\dots ,{\theta }_N^{\left(k\right)}\right)\in {\mathbf{T}}_{Z^{\left(k\right)}}\mathcal{M}$ is the search direction, and ${\mathcal{R}}_Z$ is a retraction operator that maps tangent vectors back to the manifold. Specifically, the retraction is defined as

$${\mathcal{R}}_Z(\Delta Z)=\left({\mathcal{R}}_Q\left(\xi \right),{\tilde{D}}_1+{\eta }_1,\dots ,{\tilde{D}}_N+{\eta }_N,K_1+{\theta }_1,\dots ,K_N+{\theta }_N\right),$$

(43)

where ${\mathcal{R}}_Q\left(\xi \right)$ is a retraction on the Stiefel manifold $\mathcal{O}(n,r)$. For conjugate gradient-type methods, vector transport operations are required as well. Given two tangent vectors $\Delta Z,\Delta Z^{\prime }\in {\mathbf{T}}_Z\mathcal{M}$, their transport is defined by

$${\mathcal{T}}_{\Delta Z}(\Delta Z^{\prime })=\left({\mathcal{T}}_{{\xi }_1}\left({\xi }_2\right),{\eta }_1^{\prime },\dots ,{\eta }_N^{\prime },{\theta }_1^{\prime },\dots ,{\theta }_N^{\prime }\right),$$

where ${\mathcal{T}}_{{\xi }_1}\left({\xi }_2\right)$ denotes transport on the Stiefel manifold $\mathcal{O}(n,r)$. Our experiments use Manopt’s default retraction and transport implementations. For second-order algorithms, the Riemannian Hessian is required as well. For brevity, derivations are omitted; detailed formulas can be found in Absil et al. [38]. For further literature on applying Riemannian optimization techniques to various matrix optimization models arising in multidimensional scaling, see also [14,39,40]. Optimization terminates when the following first-order optimality condition is satisfied:

$$\mathrm{Error}=∥\mathrm{grad}\tilde{f}\left(Q^{\left(k\right)},{\tilde{D}}_1^{\left(k\right)},\dots ,{\tilde{D}}_N^{\left(k\right)},K_1^{\left(k\right)},\dots ,K_N^{\left(k\right)}\right)∥\le {10}^{-6}.$$

(44)

We benchmarked our accelerated fixed-point methods against the following Manopt solvers: Riemannian steepest descent (Manopt-RSD), conjugate gradient (Manopt-RCG), Barzilai-Borwein (Manopt-RBB), trust-region (Manopt-RTR), limited-memory BFGS (Manopt-RLBFGS), and adaptive regularization by cubics (Manopt-ARC). All solvers were executed using default parameter settings with a maximum iteration cap of 10,000. To ensure consistency, all methods were initialized from the same starting point, and both the Riemannian gradient and (when required) Hessian were supplied explicitly. Notably, Manopt defaults to finite-difference approximations when the Hessian is not provided. In contrast, our implementation consistently utilized exact second-order information.

Table 2. Numerical comparison of the acclerated fixed-point iterations and existing algorithms in the toolbox Manopt.

	N, [n,r]	CPU	IT	$\mathbf{Error}$	Obj	N, [n,r]	CPU	IT	$\mathbf{Error}$	Obj
Partially structured with nnd weight matrices (NND)
FPI-VEA	30, [20, 2]	0.006	12	$3.4\times {10}^{-13}$	0.255	20, [20, 3]	0.019	23	$7.3\times {10}^{-12}$	0.305
FPI-TEA		0.006	12	$1.0\times {10}^{-13}$	0.255		0.014	23	$2.7\times {10}^{-9}$	0.305
FPI-STEA		0.006	12	$8.2\times {10}^{-13}$	0.255		0.024	23	$1.3\times {10}^{-9}$	0.305
RCG-Manopt		55.670	151	$8.5\times {10}^{-7}$	0.255		115.256	598	$9.3\times {10}^{-7}$	0.305
RBB-Manopt		92.000	306	$9.5\times {10}^{-7}$	0.255		172.084	1141	$9.7\times {10}^{-7}$	0.305
RSD-Manopt		333.157	2069	$7.4\times {10}^{-6}$	0.255		810.095	10,000	$1.3\times {10}^{-5}$	0.305
RTR-Manopt		112.788	7	$2.2\times {10}^{-7}$	0.255		80.434	9	$8.0\times {10}^{-7}$	0.305
RLBFGS-Manopt		662.733	115	$9.8\times {10}^{-7}$	0.255		428.122	159	$7.8\times {10}^{-7}$	0.305
ARC-Manopt		416.378	6	$6.2\times {10}^{-7}$	0.255		158.398	9	$4.3\times {10}^{-7}$	0.305
FPI-VEA	20, [30, 2]	0.016	12	$5.9\times {10}^{-14}$	0.184	20, [30, 3]	0.014	22	$9.0\times {10}^{-9}$	0.309
FPI-TEA		0.018	12	$6.7\times {10}^{-14}$	0.184		0.010	23	$1.5\times {10}^{-9}$	0.309
FPI-STEA		0.024	12	$1.8\times {10}^{-12}$	0.184		0.010	23	$1.8\times {10}^{-9}$	0.309
RCG-Manopt		26.947	129	$9.0\times {10}^{-7}$	0.184		64.849	355	$9.0\times {10}^{-7}$	0.309
RBB-Manopt		23.463	148	$9.9\times {10}^{-7}$	0.184		96.764	616	$9.3\times {10}^{-7}$	0.309
RSD-Manopt		81.875	979	$4.7\times {10}^{-6}$	0.184		427.409	5153	$7.3\times {10}^{-6}$	0.309
RTR-Manopt		39.143	5	$7.0\times {10}^{-7}$	0.184		82.419	9	$2.2\times {10}^{-7}$	0.309
RLBFGS-Manopt		291.052	107	$9.7\times {10}^{-7}$	0.184		375.096	144	$8.2\times {10}^{-7}$	0.309
ARC-Manopt		125.778	4	$7.2\times {10}^{-7}$	0.184		201.743	8	$3.1\times {10}^{-7}$	0.309
FPI-VEA	30, [60, 2]	0.041	12	$5.8\times {10}^{-14}$	0.247	20, [60, 3]	0.030	13	$5.5\times {10}^{-10}$	0.308
FPI-TEA		0.029	12	$3.9\times {10}^{-14}$	0.247		0.026	16	$5.7\times {10}^{-9}$	0.308
FPI-STEA		0.038	12	$4.3\times {10}^{-14}$	0.247		0.025	16	$5.7\times {10}^{-9}$	0.308
RCG-Manopt		28.099	134	$9.5\times {10}^{-7}$	0.247		90.802	264	$9.6\times {10}^{-7}$	0.308
RBB-Manopt		20.644	133	$9.8\times {10}^{-7}$	0.247		64.967	232	$9.9\times {10}^{-7}$	0.308
RSD-Manopt		158.428	560	$5.6\times {10}^{-6}$	0.247		155.453	1005	$1.1\times {10}^{-5}$	0.308
RTR-Manopt		273.369	5	$3.1\times {10}^{-7}$	0.247		111.849	5	$9.0\times {10}^{-7}$	0.308
RLBFGS-Manopt		1518.805	98	$9.5\times {10}^{-7}$	0.247		462.869	161	$8.7\times {10}^{-7}$	0.308
ARC-Manopt		867.478	4	$4.5\times {10}^{-7}$	0.247		192.517	5	$3.0\times {10}^{-7}$	0.308
Partially structured with indefinite weight matrices (IND)
FPI-VEA	30, [20, 2]	0.004	8	$1.4\times {10}^{-9}$	14.050	20, [20, 3]	0.009	12	$4.3\times {10}^{-9}$	13.503
FPI-TEA		0.004	8	$1.4\times {10}^{-9}$	14.050		0.008	15	$6.6\times {10}^{-9}$	13.503
FPI-STEA		0.004	8	$1.4\times {10}^{-9}$	14.050		0.012	15	$6.6\times {10}^{-9}$	13.503
RCG-Manopt		111.312	129	$9.5\times {10}^{-7}$	14.050		126.823	330	$9.5\times {10}^{-7}$	13.503
RBB-Manopt		121.659	136	$6.6\times {10}^{-7}$	14.050		286.979	755	$9.9\times {10}^{-7}$	13.503
RSD-Manopt		452.417	1065	$9.8\times {10}^{-7}$	14.050		1884.260	10,000	$4.4\times {10}^{-6}$	13.503
RTR-Manopt		281.018	7	$8.8\times {10}^{-7}$	14.050		131.532	8	$9.0\times {10}^{-7}$	13.503
RLBFGS-Manopt		1662.039	107	$8.8\times {10}^{-7}$	14.050		972.222	157	$7.0\times {10}^{-7}$	13.503
ARC-Manopt		1231.788	7	$4.6\times {10}^{-7}$	14.050		477.481	8	$2.4\times {10}^{-7}$	13.503
FPI-VEA	30, [30, 2]	0.005	8	$8.2\times {10}^{-9}$	13.993	20, [30, 3]	0.049	12	$8.0\times {10}^{-10}$	13.367
FPI-TEA		0.005	8	$8.2\times {10}^{-9}$	13.993		0.048	12	$2.9\times {10}^{-9}$	13.367
FPI-STEA		0.005	8	$8.2\times {10}^{-9}$	13.993		0.051	12	$2.9\times {10}^{-9}$	13.367
RCG-Manopt		32.592	161	$8.6\times {10}^{-7}$	13.993		111.185	266	$9.7\times {10}^{-7}$	13.367
RBB-Manopt		96.056	132	$9.2\times {10}^{-7}$	13.993		155.082	480	$1.0\times {10}^{-6}$	13.367
RSD-Manopt		668.282	1520	$9.3\times {10}^{-7}$	13.993		944.964	5986	$9.8\times {10}^{-7}$	13.367
RTR-Manopt		297.790	8	$2.4\times {10}^{-7}$	13.993		105.322	8	$5.7\times {10}^{-7}$	13.367
RLBFGS-Manopt		1333.034	85	$8.3\times {10}^{-7}$	13.993		584.491	107	$6.7\times {10}^{-7}$	13.367
ARC-Manopt		1212.596	7	$6.1\times {10}^{-7}$	13.993		480.133	8	$2.2\times {10}^{-7}$	13.367
FPI-VEA	30, [55, 2]	0.037	8	$7.0\times {10}^{-9}$	13.969	20, [55, 3]	0.038	12	$2.2\times {10}^{-10}$	13.380
FPI-TEA		0.037	8	$7.0\times {10}^{-9}$	13.969		0.037	12	$1.8\times {10}^{-10}$	13.380
FPI-STEA		0.039	8	$7.0\times {10}^{-9}$	13.969		0.038	12	$1.9\times {10}^{-10}$	13.380
RCG-Manopt		112.628	121	$9.8\times {10}^{-7}$	13.969		89.848	211	$9.8\times {10}^{-7}$	13.380
RBB-Manopt		154.269	219	$8.9\times {10}^{-7}$	13.969		74.459	233	$9.9\times {10}^{-7}$	13.380
RSD-Manopt		396.393	1122	$9.6\times {10}^{-7}$	13.969		506.581	3202	$1.0\times {10}^{-6}$	13.380
RTR-Manopt		228.985	7	$4.8\times {10}^{-7}$	13.969		108.314	8	$4.2\times {10}^{-7}$	13.380
RLBFGS-Manopt		1225.719	100	$7.0\times {10}^{-7}$	13.969		567.610	104	$6.1\times {10}^{-7}$	13.380
ARC-Manopt		954.378	7	$2.4\times {10}^{-7}$	13.969		375.834	7	$6.9\times {10}^{-7}$	13.380
Completely random data sets (RAND)
FPI-VEA	20, [25, 2]	0.009	13	$7.4\times {10}^{-7}$	12,415.989	20, [25, 3]	0.012	21	$8.4\times {10}^{-7}$	12,281.929
FPI-TEA		0.008	12	$7.5\times {10}^{-7}$	12,415.989		0.023	45	$3.9\times {10}^{-7}$	12,281.929
FPI-STEA		0.007	13	$7.9\times {10}^{-7}$	12,415.989		0.028	44	$9.8\times {10}^{-7}$	12,281.929
RCG-Manopt		0.217	1	$9.4\times {10}^{-2}$	12,415.989		0.209	1	$8.0\times {10}^{-2}$	12,281.929
RBB-Manopt		175.974	1573	$9.7\times {10}^{-7}$	12,415.989		866.715	6021	$1.0\times {10}^{-6}$	12,281.929
RSD-Manopt		320.402	4174	$3.7\times {10}^{-5}$	12,415.989		605.810	7096	$5.4\times {10}^{-5}$	12,281.929
RTR-Manopt		328.180	36	$8.4\times {10}^{-7}$	12,415.989		215.108	15	$6.0\times {10}^{-7}$	12,281.929
RLBFGS-Manopt		351.008	137	$5.8\times {10}^{-6}$	12,415.989		444.609	178	$2.1\times {10}^{-5}$	12,281.929
ARC-Manopt		1440.731	36	$8.4\times {10}^{-7}$	12,415.989		904.213	15	$5.7\times {10}^{-7}$	12,281.929
FPI-VEA	20, [40, 3]	0.011	23	$8.8\times {10}^{-7}$	32,116.860	30, [40, 5]	0.016	13	$9.5\times {10}^{-7}$	48,131.172
FPI-TEA		0.025	56	$5.8\times {10}^{-7}$	32,116.860		0.047	62	$9.3\times {10}^{-7}$	48,131.172
FPI-STEA		0.026	56	$4.0\times {10}^{-7}$	32,116.860		0.046	62	$9.9\times {10}^{-7}$	48,131.172
RCG-Manopt		0.197	1	$9.4\times {10}^{-2}$	32,116.860		0.454	1	$9.1\times {10}^{-2}$	48,131.172
RBB-Manopt		1278.205	10,000	$2.3\times {10}^{-3}$	32,116.860		3126.306	10,000	$1.4\times {10}^{-4}$	48,131.172
RSD-Manopt		727.261	10,000	$6.3\times {10}^{-4}$	32,116.860		958.490	5508	$1.8\times {10}^{-4}$	48,131.172
RTR-Manopt		737.793	32	$7.8\times {10}^{-7}$	32,116.860		1279.051	24	$8.9\times {10}^{-7}$	48,131.172
RLBFGS-Manopt		1414.241	525	$4.2\times {10}^{-5}$	32,116.860		1321.907	249	$2.1\times {10}^{-5}$	48,131.172
ARC-Manopt		2697.669	31	$9.9\times {10}^{-7}$	32,116.860		5498.762	24	$8.3\times {10}^{-7}$	48,131.172
FPI-VEA	30, [55, 3]	0.020	18	$8.5\times {10}^{-7}$	91,180.316	30, [55, 5]	0.066	44	$9.8\times {10}^{-7}$	90,577.201
FPI-TEA		0.046	44	$9.9\times {10}^{-7}$	91,180.316		0.136	121	$9.9\times {10}^{-7}$	90,577.201
FPI-STEA		0.040	43	$9.6\times {10}^{-7}$	91,180.316		0.135	115	$1.0\times {10}^{-6}$	90,577.201
RCG-Manopt		0.435	1	$9.0\times {10}^{-2}$	91,180.316		0.462	1	$9.6\times {10}^{-2}$	90,577.201
RBB-Manopt		2837.122	10,000	$1.1\times {10}^{-3}$	91,180.316		3126.555	10,000	$2.9\times {10}^{-3}$	90,577.201
RSD-Manopt		949.231	5953	$3.2\times {10}^{-4}$	91,180.316		1686.069	10,000	$1.3\times {10}^{-3}$	90,577.201
RTR-Manopt		1194.252	25	$8.5\times {10}^{-7}$	91,180.316		4798.699	53	$9.9\times {10}^{-7}$	90,577.201
RLBFGS-Manopt		978.798	174	$1.2\times {10}^{-4}$	91,180.316		2383.108	351	$7.3\times {10}^{-5}$	90,577.201
ARC-Manopt		5176.636	25	$8.1\times {10}^{-7}$	91,180.316		9758.528	53	$9.6\times {10}^{-7}$	90,577.201

summarizes performance across multiple problem sizes and input data types: completely random (RAND), and two structured categories (IND and NND). The performance metrics follow those in Table 1, with “CPU” denoting total runtime, “IT” indicating the number of iterations, and “Fvalue” representing the final objective value f or $\tilde{f}$. The accelerated fixed-point methods are applied to the original three-way GIPSCAL problem (5), while the Riemannian optimization algorithms solve the equivalent reformulation (42). The “Error” column records the norm associated with the respective stopping criteria (39) for accelerated fixed-point methods and (44) for Riemannian solvers. Convergence trajectories are visualized in Figure 4, where the horizontal axis denotes runtime and the vertical axis plots ${log}_{10}\parallel \mathrm{Error}\parallel$. The results clearly demonstrate that the proposed accelerated fixed-point methods outperform several Manopt solvers in terms of both convergence rate and computational efficiency. Notably, as shown by the pink-dotted solid line and black-dotted dashed line in Figure 4, both Manopt-RBB and Manopt-RSD exhibit pronounced slowdowns in convergence near stationary points. Furthermore, Table 2 highlights the elevated computational cost of Manopt-RLBFGS, which aligns with the internal implementation details of Manopt. Specifically, its default memory size of 30 necessitates 30 projection-based vector transport operations per iteration, contributing to significant per-iteration overhead.

4.3. Comparison with the Projected Gradient Flow Method

Trendafilov [10,13] reformulated the equivalent three-way GIPSCAL problem (42) as a constrained dynamical system and proposed a continuous-time projected gradient flow algorithm. This method is globally convergent, conceptually simple, and broadly applicable to matrix optimization problems arising in multidimensional data analysis [9,15,16,17,18]. In this subsection, we conduct a numerical comparison between the proposed accelerated fixed-point algorithms—VEA, TEA, and STEA—and the projected gradient flow algorithm.

For a general constrained optimization problem of the form ${min}_{X\in \mathcal{M}}E\left(X\right)$, the projected gradient method generates a sequence of iterates $\left\{X_t\right\}$ via

$$X_{t+1}={\pi }_{\mathcal{M}}\left(X_t-h_t{\nabla E\left(X\right)|}_{X=X_t}\right),$$

where $h_t$ is the step size, and ${\pi }_{\mathcal{M}}(·)$ denotes the orthogonal projection onto the feasible set $\mathcal{M}$. The associated continuous-time version, known as the projected gradient flow, evolves along the negative projected gradient and is governed by the following differential equation:

$${\displaystyle \frac{\mathrm{d}\mathbf{X}\left(\mathbf{t}\right)}{\mathrm{d}\mathbf{t}}}=-{\pi }_{\mathcal{M}}(\nabla E\left(X\left(t\right)\right)),X\left(0\right)=X_0\in \mathcal{M}.$$

For the equivalent reformulated three-way GIPSCAL problem (42), this yields the following system of ordinary differential equations:

$$\left\{\begin{array}{cc}\hfill {\displaystyle \frac{\mathrm{d}\mathbf{Q}}{\mathrm{d}\mathbf{t}}}=& -{\mathbf{P}}_Q\left(\sum _{i=1}^m\left(-2\mathrm{sym}\left(X_i\right)Q{\tilde{D}}_i^2+2\mathrm{skew}\left(X_i\right)Q{K}_i+2Q({\tilde{D}}_i^4-K_i^2)\right)\right),\hfill \\ \hfill {\displaystyle \frac{\mathrm{d}{\tilde{\mathbf{D}}}_{\mathbf{i}}}{\mathrm{d}\mathbf{t}}}=& -2\left({\tilde{D}}_i^2-Q^T\mathrm{sym}\left(X_i\right)Q\right)\odot {\tilde{D}}_i,i=1,\dots ,N,\hfill \\ \hfill {\displaystyle \frac{\mathrm{d}{\mathbf{K}}_{\mathbf{i}}}{\mathrm{d}\mathbf{t}}}=& -K_1+Q^T\mathrm{skew}\left(X_1\right)Q,i=1,\dots ,N.\hfill \end{array}\right.$$

We employ MATLAB’s ode15s solver [41,42] to integrate this system numerically. The ode15s routine is a variable-step, variable-order implicit solver designed for stiff differential equations and is part of the Klopfenstein–Shampine family of solvers. We set both absolute and relative error tolerances to ${10}^{-12}$ to ensure highly accurate tracking of the flow dynamics. While such precision may exceed practical requirements in typical data analysis tasks, it facilitates a fair and rigorous comparison of algorithmic performance. Although looser tolerance settings could reduce runtime, their effect is marginal in this context. During integration, solution states are recorded at regular intervals of 10 time units. The integration process is terminated automatically when the relative decrease in the objective function between successive outputs falls below ${10}^{-4}$, indicating proximity to a local minimum. This termination criterion, adopted from Loisel and Takane [19], is significantly more lenient than the convergence threshold used in the proposed accelerated fixed-point algorithms—VEA, TEA, and STEA.

Although the projected gradient flow algorithm exhibits global convergence and features a simple, intuitive structure that facilitates implementation, its efficiency tends to degrade when applied to large-scale problems.

Table 3. Numerical comparison of the acclerated fixed-point iterations and the projected gradient flow algorithm.

	N, [n,r]	CPU	IT	Error	Obj	N, [n,r]	CPU	IT	Error	Obj
Partially structured withnndweight matrices (NND)
FPI-VEA	50, [25, 2]	0.040	12	$3.5\times {10}^{-12}$	0.371	50, [25, 3]	0.027	14	$7.1\times {10}^{-9}$	0.661
FPI-TEA		0.023	12	$2.1\times {10}^{-11}$	0.371		0.029	23	$3.6\times {10}^{-10}$	0.661
FPI-STEA		0.029	12	$2.2\times {10}^{-11}$	0.371		0.030	23	$8.4\times {10}^{-9}$	0.661
PG-ODE		7.766	1321	$4.7\times {10}^{-9}$	0.371		13.526	1096	$8.3\times {10}^{-10}$	0.661
FPI-VEA	50, [50, 2]	0.028	12	$2.2\times {10}^{-12}$	0.370	50, [50, 5]	0.055	23	$2.9\times {10}^{-10}$	1.369
FPI-TEA		0.027	12	$2.4\times {10}^{-13}$	0.370		0.084	36	$6.5\times {10}^{-9}$	1.369
FPI-STEA		0.028	12	$1.8\times {10}^{-12}$	0.370		0.081	34	$4.9\times {10}^{-9}$	1.369
PG-ODE		7.926	853	$8.5\times {10}^{-10}$	0.370		508.936	1411	$7.3\times {10}^{-9}$	1.369
FPI-VEA	30, [100, 2]	0.289	12	$3.6\times {10}^{-13}$	0.256	50, [100, 5]	0.201	23	$2.7\times {10}^{-10}$	1.378
FPI-TEA		0.280	12	$1.3\times {10}^{-12}$	0.256		0.390	44	$9.4\times {10}^{-9}$	1.378
FPI-STEA		0.279	12	$1.9\times {10}^{-12}$	0.256		0.400	45	$6.1\times {10}^{-9}$	1.378
PG-ODE		26.166	555	$5.9\times {10}^{-9}$	0.256		188.403	1056	$7.5\times {10}^{-9}$	1.378
Partially structured with indefinite weight matrices (IND)
FPI-VEA	30, [30, 3]	0.057	12	$8.1\times {10}^{-10}$	20.587	30, [30, 5]	0.012	13	$7.6\times {10}^{-9}$	41.498
FPI-TEA		0.024	14	$7.0\times {10}^{-9}$	20.587		0.015	23	$3.2\times {10}^{-10}$	41.498
FPI-STEA		0.030	14	$7.0\times {10}^{-9}$	20.587		0.017	23	$7.0\times {10}^{-11}$	41.498
PG-ODE		7.973	1451	$3.7\times {10}^{-9}$	20.587		26.815	1384	$1.4\times {10}^{-10}$	41.498
FPI-VEA	30, [50, 2]	0.019	9	$8.0\times {10}^{-10}$	13.985	30, [50, 3]	0.022	12	$1.5\times {10}^{-11}$	20.591
FPI-TEA		0.014	9	$8.0\times {10}^{-10}$	13.985		0.016	12	$1.3\times {10}^{-10}$	20.591
FPI-STEA		0.016	9	$8.0\times {10}^{-10}$	13.985		0.016	12	$1.4\times {10}^{-10}$	20.591
PG-ODE		5.668	984	$4.0\times {10}^{-9}$	13.985		13.004	1280	$9.5\times {10}^{-9}$	20.591
FPI-VEA	50, [100, 3]	0.148	12	$8.8\times {10}^{-13}$	31.567	30, [100, 5]	0.086	12	$1.3\times {10}^{-9}$	41.516
FPI-TEA		0.134	12	$2.5\times {10}^{-13}$	31.567		0.108	15	$5.1\times {10}^{-9}$	41.516
FPI-STEA		0.143	12	$1.9\times {10}^{-13}$	31.567		0.111	15	$5.1\times {10}^{-9}$	41.516
PG-ODE		50.604	786	$6.7\times {10}^{-9}$	31.567		78.532	1056	$3.9\times {10}^{-9}$	41.516
Completely random data sets (RAND)
FPI-VEA	30, [25, 2]	0.110	144	$8.9\times {10}^{-7}$	19,059.419	30, [25, 3]	0.085	180	$8.7\times {10}^{-7}$	18,908.352
FPI-TEA		0.093	172	$8.6\times {10}^{-7}$	19,059.419		0.096	206	$7.9\times {10}^{-7}$	18,908.352
FPI-STEA		0.097	172	$8.6\times {10}^{-7}$	19,059.419		0.103	213	$1.0\times {10}^{-6}$	18,908.352
PG-ODE		3.829	2778	$9.2\times {10}^{-14}$	19,157.130		9.497	3046	$2.4\times {10}^{-10}$	19,008.643
FPI-VEA	50, [30, 3]	0.347	397	$5.2\times {10}^{-7}$	45,923.018	50, [30, 5]	0.608	597	$9.1\times {10}^{-7}$	45,485.370
FPI-TEA		0.379	445	$9.0\times {10}^{-7}$	45,923.018		0.613	604	$9.0\times {10}^{-7}$	45,485.370
FPI-STEA		0.368	444	$9.4\times {10}^{-7}$	45,923.018		0.596	603	$9.9\times {10}^{-7}$	45,485.370
PG-ODE		25.986	3303	$1.6\times {10}^{-13}$	46,132.681		164.868	3775	$1.5\times {10}^{-11}$	45,811.876
FPI-VEA	30, [60, 2]	1.704	219	$7.7\times {10}^{-7}$	109,708.392	50, [60, 3]	8.621	673	$9.8\times {10}^{-7}$	182,304.537
FPI-TEA		2.213	285	$9.4\times {10}^{-7}$	109,708.392		9.378	737	$8.8\times {10}^{-7}$	182,304.537
FPI-STEA		2.215	285	$9.6\times {10}^{-7}$	109,708.392		9.648	760	$9.4\times {10}^{-7}$	182,304.537
PG-ODE		28.139	1997	$2.9\times {10}^{-13}$	109,927.833		171.939	4369	$2.1\times {10}^{-11}$	182,628.808

reports a detailed numerical comparison between the accelerated fixed-point iteration methods (namely, FPI-VEA, FPI-TEA, and FPI-STEA) and the projection gradient flow approach (denoted as PG-ODE), under a fixed acceleration window width parameter of $k=5$. The experiments are conducted across varying coefficient dimensions and under three distinct original data generation schemes: NND, IND, and RAND. The definitions of CPU, IT, Obj, and Error are consistent with those provided in Table 1. The results in Table 3 demonstrate that, in terms of iteration efficiency, the $\epsilon$-accelerated fixed-point iteration algorithms significantly outperform the projected gradient flow method.

5. Conclusions

This paper examines a Generalized Inner Product SCALing model (GIPSCAL) in multidimensional scaling from a numerical perspective, with a focus on individual differences among the observed objects. The model can be formulated as a multivariate constrained matrix optimization problem with column orthogonality and non-negative diagonal constraints (problem (5)). Using the alternating least squares iterative approach, the original model is first transformed into a matrix-based, fixed-point iteration problem. Furthermore, by incorporating the $\epsilon$-acceleration principle from vector sequence acceleration, we design fixed-point iteration acceleration algorithms based on the vector $\epsilon$-algorithm, topological $\epsilon$-algorithm, and simplified topological $\epsilon$-algorithm (denoted as FPI-VEA, FPI-TEA, and FPI-STEA). Extensive numerical experiments show that, when solving the GIPSCAL problem in (5), the fixed-point iteration acceleration algorithms combined with the $\epsilon$-algorithm achieve better acceleration convergence compared to the original fixed-point iteration algorithm. Additionally, compared to existing algorithms for solving matrix optimization models in multidimensional data analysis, such as the Riemannian optimization-based Manopt toolbox algorithms and the classical projected gradient flow algorithm, the fixed-point iteration acceleration algorithms demonstrate a clear advantage in iteration time. Improving the convergence speed of scalar, vector, matrix, or tensor sequences generated by iterative methods is highly significant in fields such as scientific and engineering computing and machine learning. It is worth noting that, unlike traditional vector sequence polynomial extrapolation acceleration methods, the implementation of FPI-VEA, FPI-TEA, and FPI-STEA does not require the use of matrix flattening and unflattening operators, nor does it involve matrix decomposition to solve related subproblems.