Design and Implementation of a Reduced-Space SQP Solver with Column Reordering for Large-Scale Process Optimization

Abstract

Process industries increasingly face large-scale nonlinear programs with high dimensionality and tight constraints. This study reports on the design and implementation of a reduced-space sequential quadratic programming (RSQP) solver for such settings. The solver couples a column-reordering space-decomposition strategy with sparse-matrix storage/kernels, and is implemented in a modular C++ framework that supports range/null-space splitting, line search, and convergence checks. We evaluate six small-scale benchmarks with non-convex/exponential characteristics, a set of variable-dimension tests up to 128 k variables, and an industrial reverse-osmosis (RO) optimization. On small problems, RSQP attains an accuracy comparable to a full-space sequential quadratic programming (SQP) baseline. In variable-dimension tests, the solver shows favorable scaling when moving from 64 k to 128 k variables; under dynamically varying degrees of freedom, the iteration count decreases by about 62% with notable time savings. In the RO case, daily operating cost decreases by 4.98% and 1.46% across two scenarios while satisfying water-quality constraints. These results indicate that consolidating established RSQP components with column reordering and sparse computation yields a practical, scalable solver for large-scale process optimization.

1. Introduction

As the process industries advance toward greater integration and intelligence, real-world optimization problems increasingly exhibit typical characteristics such as variable dimensions ranging from thousands to millions, tightly coupled constraints, and limited computational resources. In such large-scale nonlinear programming (NLP) settings—e.g., full-process simulation and dynamic optimization—traditional methods often fail to meet requirements due to the prohibitive storage cost of the Hessian matrix and insufficient convergence robustness [1,2]. Among available methods, SQP—owing to its strong robustness and fast convergence—has become one of the core techniques for large-scale nonlinear optimization [3,4]. However, the computational complexity of its quadratic programming (QP) subproblems grows rapidly with the number of variables, leading to real-time bottlenecks in high-dimensional, low-degrees-of-freedom scenarios.

The core logic of SQP is to approximate the original problem by iteratively solving QP subproblems, and its technical evolution has laid the groundwork for subsequent improvements: in 1963, Wilson first proposed the SQP framework [5]; in 1976, Han combined a second-order approximation of the Lagrangian with a penalty function and established global convergence [6,7]; in 1978, Powell introduced a penalty-free SQP variant that avoids the difficulty of choosing penalty parameters and significantly improves stability [8,9,10]; in 1989, Nocedal and Wright incorporated trust-region constraints to address instabilities of second-order models, further enhancing numerical reliability [11]; and in 1992, Gill et al. developed sparse SQP tailored to exploit sparsity, providing an efficiency foundation for high-dimensional problems [12,13,14]. Despite these advances, the fundamental bottlenecks remain in high-dimensional, low-degrees-of-freedom settings: the storage and computational cost of the full-space Hessian and the tight coupling of QP subproblem size to the number of variables have yet to be fundamentally resolved.

To overcome these bottlenecks, RSQP algorithm, developed from dimensionality-reduction ideas, has become an effective approach for such problems. By employing three core strategies—variable decomposition (splitting primary and dependent variables), low-rank Hessian approximation, and reduced-dimensional search-direction computation—RSQP shrinks the QP subproblem size from the original variable dimension to the degree-of-freedom dimension, thereby substantially lowering computational cost.

Early work on RSQP focused on laying the foundations of variable decomposition and reduced-dimension QP. Biegler and co-workers introduced the degrees-of-freedom concept from chemical engineering into SQP, proposing a split between independent and dependent variables. This transformation converts process models containing on the order of 10⁵ state variables into QP subproblems with only a few hundred primary variables, thereby establishing the prototype of RSQP. Nocedal and Byrd (1990–1998) further incorporated the limited-memory Broyden–Fletcher–Goldfarb–Shanno (L-BFGS) method, replacing the dense Hessian with O(m) vector pairs and reducing storage and computational complexity from O(n²) to O(mn), which opened the door to problems with tens of thousands of variables and beyond.

Since the early 2000s, research has shifted toward global convergence and robustness to ill-conditioning. In 2003, Tits et al. proposed projected SQP, which uses a generalized projection operator to map infeasible QP solutions back to the feasible region, thereby eliminating reliance on penalty functions and markedly improving stability near bounds; it also indirectly enhances adaptability to the initial point [15,16]. In 2005, Shao Zhijiang’s team combined dynamic basis transformation with hybrid automatic differentiation to monitor the Jacobian condition number in real time, reducing the failure rate of parameter estimation for a methanol–hydrocarbon reactor by 30% and accelerating gradient evaluation by two orders of magnitude, providing an important reference for improving RSQP’s numerical stability [17]. In 2006, Jiang Aipeng et al. employed an L-BFGS implicit representation of the Hessian, cutting memory usage for a 30,000-variable polypropylene optimization problem from 2400 MB to 800 MB and enabling online solutions for ten-thousand-variable problems [18]. In 2015, Biegler’s group proposed a new EO optimization framework that exploits structural sparsity and vectorized automatic differentiation, extending RSQP to the million-variable scale and breaking traditional dimensional limits in process optimization [19]. Taken together, these advances complete the theoretical foundation of RSQP in finite-dimensional, deterministic settings and bring the algorithmic core to maturity.

Although the RSQP method and its variants have evolved into a relatively mature theoretical framework—and its core architecture has not undergone disruptive changes in recent years, which partly explains the limited surge of publications—the field is far from stagnant. Current frontiers are shifting from framework-level innovation to deeper performance and domain integration, leveraging stochastic analysis, infinite-dimensional theory, and GPU parallelism to push RSQP toward more complex mathematical settings and broader applications. Curtis and Robinson proposed a stochastic RSQP for models with stochastic objectives and deterministic equality constraints, proving worst-case complexity on par with unconstrained stochastic gradient methods and, for the first time, providing performance guarantees for constrained optimization with high-noise simulations [20]. Uihlein and Wollner extended RSQP to Hilbert spaces; via a two-phase feasibility/optimality strategy and adaptive line search, they achieved superlinear convergence without requiring LICQ/MFCQ, laying a new foundation for PDE-constrained optimization [21]. Ma et al. proposed a hybrid approach to handle the inconsistency of subproblems and corrected key numerical errors, thereby enabling the new algorithm to exhibit improved robustness and computational efficiency [22]. The group led by Leyffer designed a unified funnel restoration SQP that restricts search directions through a projection operator, ensuring global convergence without penalty functions; its funnel mechanism can be embedded directly into RSQP as an alternative to tuning penalty parameters [23]. Fang et al. mapped the multiple-shooting and reduced-space decomposition onto GPUs and employed a block-sparse Schur complement technique, achieving real-time solutions within 5 min for state-control problems of dimension 10⁷, along with a theoretical analysis of parallel scalability [24].

In summary, after more than forty years of development, the RSQP method has progressed from a dimensionality-reduction strategy to a mature algorithmic framework. Recent international research has further brought stochasticity, infinite-dimensional settings, and industrial-scale problems into scope, achieving closed-loop validation in complex systems such as chemicals and energy. Nevertheless, adaptive selection of basic variables and reordering for ill-conditioned Jacobians remain common bottlenecks, which motivates the column-reordering space-decomposition strategy pursued in this work.

In response to the above challenges, this paper designs and implements, in C++, an RSQP solver based on a column-reordering space-decomposition strategy and sparse-matrix techniques. The core innovation is to optimize the column ordering of the Jacobian, dynamically generating an optimal column-exchange scheme so that the reordered matrix is closer to diagonal dominance, thereby improving the numerical stability of the basis matrix and the efficiency of variable decomposition. Combined with efficient sparse-matrix storage and computation, this further and significantly reduces the storage cost of the Hessian and the solution cost of the QP subproblems.

This work evaluates the algorithm with two categories of case studies. First, small-scale cases—including non-convex and exponential characteristics—are used to verify that the RSQP solver attains convergence accuracy consistent with the commercial solver Fmincon. Second, large-scale variable-dimension cases are used to assess scalability and memory optimization. For the engineering application, the solver is applied to the optimization of a single-stage, three-pass high-pressure RO unit for high-salinity wastewater treatment at a coal-fired power plant, achieving reductions in product-water cost of 4.98% and 1.46% under two typical operating scenarios, while all key water-quality indicators satisfy the imposed constraints.

The main contributions of this paper are as follows:

(1)

For large-scale nonlinear optimization in process industries, a solver algorithm based on a column-reordering space-decomposition strategy is designed. It reconstructs the reduced QP subproblem, projecting the high-dimensional optimization problem onto a low-dimensional subspace for solution, thereby significantly reducing computational complexity.

(2)

Implemented in C++ with a top-down design, an RSQP solver is developed in a modular manner, partitioned into functional modules such as program invocation, input checking, preliminary preprocessing, and iterative solving, with clear interfaces that improve maintainability and extensibility.

(3)

In implementing the RSQP algorithm, we make full use of efficient sparse-matrix storage and computation methods to further improve computational efficiency and memory utilization for large-scale problems, enhancing the algorithm’s engineering applicability in high-dimensional sparse settings.

(4)

Through small- and large-scale case studies with diverse characteristics, as well as an industrial application test, we systematically evaluate performance across different problem sizes and structures, providing a practical solution for large-scale nonlinear optimization in process industries.

2. Theoretical Foundations

2.1. Mathematical Model of the Optimization Problem

An optimization problem seeks, under given constraints, a decision vector that maximizes or minimizes an objective function. Its mathematical model can be written in the following general form:

$$\begin{array}{cc}min& f\left(\mathit{x}\right)\hfill \\ \hfill s.t.& g_i\left(\mathit{x}\right)\le 0,\hspace{1em}i=\mathrm{1,2},\dots ,m\\ & h_j(\mathit{x})=0,\hspace{1em}j=\mathrm{1,2},\dots ,p\end{array}$$

(1)

where $\mathit{x}=(x_1,x_2,\dots ,x_n)$ is the decision-variable vector, $f\left(\mathit{x}\right)$ is the objective function, $g_i(\mathit{x})$ are inequality constraints, and $h_j(\mathit{x})$ are equality constraints; $m$ and $p$ denote the numbers of inequality and equality constraints, respectively.

In an optimization problem, the decision variables must satisfy the prescribed constraints. The set of all such points constitutes the feasible region, that is, the set of admissible values of the decision variables for which all constraints hold. In particular, the inequality constraints $g_i(\mathit{x})\le 0$ and the equality constraints $h_j(\mathit{x})=0$ partition the space into feasible and infeasible regions. Every point in the feasible region is a feasible solution, but not every feasible solution is optimal; an optimal solution is one that makes $f(\mathit{x})$ attain its minimum (or maximum) over the feasible region.

When both the objective and all constraint functions are linear, the problem is a linear optimization problem for which mature and relatively simple algorithms exist. In many real applications, however, the objective and some constraints are nonlinear, yielding a nonlinear program whose solution is considerably more challenging.

2.2. Necessary and Sufficient Conditions

Every feasible solution yields a value of the objective; the key is to determine whether a given feasible point is optimal.

Optimal solutions must satisfy certain necessary and sufficient optimality conditions, derived from the gradients of the objective and constraints, and typically treated separately for unconstrained and constrained problems. For an unconstrained problem with objective $f(\mathit{x})$, an optimizer ${\mathit{x}}^{\ast }$ must satisfy

$$\nabla f({\mathit{x}}^{\ast })=0$$

(2)

This means that, at an optimal solution, the gradient of the objective function must be zero. A point with zero gradient is a critical point of the objective and may be a local optimum, a saddle point, or an unstable point. To determine whether the point is actually optimal, one typically examines second-order optimality conditions, namely the definiteness of the Hessian matrix: if the Hessian is positive definite, the point is a local minimum, whereas if it is negative definite, the point is a local maximum. Specifically, for a continuously differentiable objective function $f(\mathit{x})$, if at some point ${\mathit{x}}^{\ast }$, the following is satisfied:

$$\nabla f({\mathit{x}}^{\ast })=0\mathrm{and} \mathit{H}({\mathit{x}}^{\ast })\succ 0$$

(3)

Here, $\mathit{H}({\mathit{x}}^{\ast })$ denotes the Hessian matrix of the objective $f(\mathit{x})$ at ${\mathit{x}}^{\ast }$; and $>0$ indicates that the Hessian is positive definite. Then, ${\mathit{x}}^{\ast }$ is a local minimizer.

For constrained optimization problems, beyond the objective’s gradient being zero, an optimal solution must also satisfy the constraints and additional, more intricate conditions. The most used theoretical tools are the Lagrange multiplier method and the Karush–Kuhn–Tucker (KKT) conditions. The Lagrange multiplier method reformulates the problem by constructing a Lagrangian. Specifically, for an optimization problem with inequality constraints $g_i(\mathit{x})\le 0$ and equality constraints $h_j(\mathit{x})=0$, one introduces Lagrange multipliers ${\lambda }_i$ and ${\mu }_j$ to incorporate the constraints into the objective, thereby converting it into an unconstrained problem to be solved. The construction of this function is as follows:

$$L(\mathit{x},\lambda ,\mu )=f(\mathit{x})+{\sum }_{i=1}^m{\lambda }_i{g}_i(\mathit{x})+{\sum }_{j=1}^p{\mu }_j{h}_j(\mathit{x})$$

(4)

Its optimal solution $x^{\ast }$ must satisfy the KKT conditions, namely, the stationarity, primal feasibility, dual feasibility, and complementary slackness conditions; the specific forms required are as follows:

$${\nabla }_{\mathit{x}}L({\mathit{x}}^{\ast },{\lambda }^{\ast },{\mu }^{\ast })=\nabla f({\mathit{x}}^{\ast })+{\sum }_{i=1}^m{\lambda }_i^{\ast }\nabla g_i({\mathit{x}}^{\ast })+{\sum }_{j=1}^p{\mu }_j^{\ast }\nabla h_j({\mathit{x}}^{\ast })=0$$

(5)

$$g_i({\mathit{x}}^{\ast })\le 0,h_j({\mathit{x}}^{\ast })=0$$

(6)

$${\lambda }_i^{\ast }\ge 0,{\mu }_j^{\ast }\in \mathbb{R}$$

(7)

$${\lambda }_i^{\ast }{g}_i({\mathit{x}}^{\ast })=0$$

(8)

For constrained optimization problems, if the objective function and the constraint functions are sufficiently smooth, second-order sufficient conditions can help determine the nature of an optimal solution. Building on the KKT conditions, if certain requirements on the objective’s Hessian and the constraint matrices are satisfied, one can further ensure that the solution is a local optimum.

2.3. SQP Algorithm

The SQP algorithm is a powerful iterative optimization method that is widely used to solve optimization problems with nonlinear constraints. By constructing and solving a QP subproblem at each iteration, SQP progressively approaches the optimal solution of the original nonlinear optimization problem.

Specifically, its basic principles are as follows:

Quadratic approximation of the objective: At the current iterate ${\mathit{x}}_k$, perform a second-order Taylor expansion of the objective function $f(\mathit{x})$ to obtain the quadratic approximation of the objective as follows:

$$f({\mathit{x}}_k+\mathit{d})\approx f({\mathit{x}}_k)+\nabla f({\mathit{x}}_k{)}^T\mathit{d}+{\displaystyle \frac{1}{2}}{\mathit{d}}^T{\mathit{H}}_k\mathit{d}$$

(9)

Here, $\mathit{d}$ is the search direction, $\nabla f({\mathit{x}}_k)$ is the derivative of $f({\mathit{x}}_k)$, and ${\mathit{H}}_k$ is the Hessian matrix of the objective function; its full Hessian is as follows:

$$\mathit{H}({\mathit{x}}_k)={\nabla }^{2}f({\mathit{x}}_k)+{\sum }_{i=1}^m{\lambda }_i{\nabla }^2{g}_i({\mathit{x}}_k)+{\sum }_{j=1}^p{\mu }_j{\nabla }^2{h}_j({\mathit{x}}_k)$$

(10)

Because in practice, the second-derivative matrix is difficult to obtain or requires substantial computation to construct, the SQP algorithm typically approximates it by a quasi-Newton matrix $\mathit{B}({\mathit{x}}_k)$ as a surrogate for $\mathit{H}({\mathit{x}}_k)$. The quasi-Newton Hessian $\mathit{B}({\mathit{x}}_k)$ is updated as the iterations proceed; common update strategies include the BFGS (Broyden–Fletcher–Goldfarb–Shanno) update, the DFP (Davidon–Fletcher–Powell) update, and the symmetric rank-one (SR1) correction. Many studies indicate that the BFGS update is the most effective. When the curvature condition for the BFGS update is not satisfied, one may adopt Powell’s damped BFGS update or simply skip the update. The BFGS update is as follows:

$$\mathrm{Let} {\mathit{y}}_k={\nabla }_{\mathit{x}}L({\mathit{x}}_{k+1},{\lambda }_k,{\mu }_k)-{\nabla }_{\mathit{x}}L({\mathit{x}}_k,{\lambda }_k,{\mu }_k)\hspace{0.33em},{\mathit{s}}_k={\mathit{x}}_{k+1}-{\mathit{x}}_k$$

(11)

$$\mathrm{Then} {\mathit{B}}_{k+1}={\mathit{B}}_k+{\displaystyle \frac{{\mathit{y}}_k^T{\mathit{y}}_k}{{\mathit{s}}_k^T{\mathit{y}}_k}}-{\displaystyle \frac{{\mathit{B}}_k{\mathit{s}}_k{\mathit{s}}_k^T{\mathit{B}}_k}{{\mathit{s}}_k^T{\mathit{B}}_k{\mathit{s}}_k}}$$

(12)

Linearization of the constraints: For the inequality and equality constraints, perform a first-order Taylor expansion at the current point ${\mathit{x}}_k$ to obtain their linearized forms.

$$\begin{array}{c}{g}_i({\mathit{x}}_k+\mathit{d})\approx g_i({\mathit{x}}_k)+\nabla g_i({\mathit{x}}_k{)}^T\mathit{d}\le 0,\hspace{1em}i=\mathrm{1,2},\dots ,m\\ h_j({\mathit{x}}_k+\mathit{d})\approx h_j({\mathit{x}}_k)+\nabla h_j({\mathit{x}}_k{)}^T\mathit{d}=0,\hspace{1em}j=\mathrm{1,2},\dots ,p\end{array}$$

(13)

Construction of the quadratic programming subproblem: Combining the quadratic approximation of the objective and the linearization of the constraints, we formulate the following QP subproblem:

$$\begin{array}{cc}min& \nabla f({\mathit{x}}_k{)}^T\mathit{d}+{\displaystyle \frac{1}{2}}{\mathit{d}}^T{\mathit{B}}_k\mathit{d}\\ s.t.& g_i({\mathit{x}}_k)+\nabla g_i({\mathit{x}}_k{)}^T\mathit{d}\le 0,\hspace{1em}i=\mathrm{1,2},\dots ,m\\ & h_j({\mathit{x}}_k)+\nabla h_j({\mathit{x}}_k{)}^T\mathit{d}=0,\hspace{1em}j=\mathrm{1,2},\dots ,p\end{array}$$

(14)

Solving the subproblem and updating the iterate: By solving the above quadratic programming subproblem, obtain the search direction ${\mathit{d}}_k$, and then update the iterate via a line search or another stepsize rule.

$${\mathit{x}}_{k+1}={\mathit{x}}_k+{\alpha }_k{\mathit{d}}_k$$

(15)

Here, ${\alpha }_k$ is the stepsize, which is typically required to satisfy suitable sufficient-decrease or feasibility conditions.

In this manner, SQP uses local quadratic and linear approximations at each iteration to progressively approach the optimum of the original problem; compared with first-order methods, it leverages second-order information from the objective and constraints and is therefore theoretically capable of faster convergence.

3. Proposed Method

3.1. Algorithmic Principles and Workflow

To address large-scale nonlinear optimization problems in process industries, this paper proposes an RSQP algorithm that combines a column-reordering-based space-decomposition strategy with sparse-matrix techniques. The core innovation is that, by structurally optimizing the constraint Jacobian via column reordering and projecting the high-dimensional optimization space onto a low-dimensional subspace through space decomposition, the algorithm needs to handle only a low-dimensional sparse projected Hessian rather than the high-dimensional global Hessian of the original problem. In parallel, it integrates sparse-matrix storage and computational techniques to further reduce matrix operations and memory usage, improving efficiency from both dimensionality reduction and sparsification. Consequently, the method significantly enhances computational stability and iteration speed when solving large-scale problems with high variable dimensionality and low degrees of freedom, and is particularly well suited to process systems modeling and optimization. Detailed RSQP principles and related formulas are provided in Appendix A.

The overall workflow of the RSQP algorithm is shown in Figure 1. First, perform initialization and preprocessing to set the initial point and related parameters. Next, solve a linear system to obtain the range-space search direction and, on this basis, estimate or ignore the quadratic term. The algorithm then solves the reduced QP subproblem to obtain the null-space search direction, from which the final search direction is computed. A line-search strategy is applied to determine the next iterate. Finally, check the convergence criteria: if not satisfied, continue iterating; if satisfied, output the optimization results and terminate. This process illustrates how, for large-scale nonlinear optimization, space decomposition and subproblem solutions effectively reduce computational complexity and improve convergence efficiency.

3.2. Column-Reordering-Based Space Decomposition

Space decomposition partitions variables and applies basis transformations to split the high-dimensional optimization space into lower-dimensional subspaces, thereby greatly shrinking the problem size and effectively reducing computational complexity.

Before decomposition, the RSQP algorithm divides all variables into independent (also called basic or free) and dependent (also called non-basic or non-free) variables; that is, the full variable vector $\mathit{x}\in {\mathbb{R}}^n$ is split into dependent variables $\mathit{y}\in {\mathbb{R}}^m$ and independent variables $\mathit{Z}\in {\mathbb{R}}^{\mathit{n}-\mathit{m}}$, and the corresponding Jacobian can be written as:

$$\begin{array}{cc}\hfill \mathit{J}(\mathit{x})& =\left[{\displaystyle \frac{\partial \mathit{c}}{\partial \mathit{x}}}\right]\hfill \\ & =\left[\begin{array}{cc}{\displaystyle \frac{\partial \mathit{c}}{\partial \mathit{y}}}& {\displaystyle \frac{\partial \mathit{c}}{\partial \mathit{z}}}\end{array}\right]\hfill \\ & =\left[\begin{array}{cccccccc}{\displaystyle \frac{\partial c_1}{\partial y_1}}& {\displaystyle \frac{\partial c_1}{\partial y_2}}& \dots & {\displaystyle \frac{\partial c_1}{\partial y_m}}& {\displaystyle \frac{\partial c_1}{\partial z_1}}& {\displaystyle \frac{\partial c_1}{\partial z_2}}& \dots & {\displaystyle \frac{\partial c_1}{\partial z_{n-m}}}\\ {\displaystyle \frac{\partial c_2}{\partial y_1}}& {\displaystyle \frac{\partial c_2}{\partial y_2}}& \dots & {\displaystyle \frac{\partial c_2}{\partial y_m}}& {\displaystyle \frac{\partial c_2}{\partial z_1}}& {\displaystyle \frac{\partial c_2}{\partial z_2}}& \dots & {\displaystyle \frac{\partial c_2}{\partial z_{n-m}}}\\ ⋮& ⋮& \ddots & ⋮& ⋮& ⋮& \ddots & ⋮\\ {\displaystyle \frac{\partial c_m}{\partial y_1}}& {\displaystyle \frac{\partial c_m}{\partial y_2}}& \dots & {\displaystyle \frac{\partial c_m}{\partial y_m}}& {\displaystyle \frac{\partial c_m}{\partial z_1}}& {\displaystyle \frac{\partial c_m}{\partial z_2}}& \dots & {\displaystyle \frac{\partial c_m}{\partial z_{n-m}}}\end{array}\right]\hfill \\ & =\left[\begin{array}{cc}\mathit{C}& \mathit{N}\end{array}\right]\in {\mathbb{R}}^{m\times n}\hfill \end{array}$$

(16)

Based on this partition, the search space is decomposed via a coordinate-basis factorization; the explicit formulas are given in (17):

$${\mathit{Z}}_k=\left[\begin{array}{c}-{\mathit{C}}_k^{-1}{\mathit{N}}_k\\ {\mathit{I}}_{n-m}\end{array}\right]{ \mathit{Y}}_k=\left[\begin{array}{c}{\mathit{I}}_m\\ 0\end{array}\right]$$

(17)

At this point, the formula for the range-space stepsize ${\mathit{d}}_y$ is given in (18):

$${\mathit{d}}_y=-({\mathit{J}}_k^T{\mathit{Y}}_k{)}^{-1}{\mathit{c}}_k={\mathit{C}}_k^{-1}{\mathit{c}}_k$$

(18)

The coordinate-basis decomposition fully exploits the sparsity of the Jacobian ${\mathit{J}}_k^T$. When computing the range-space search direction ${\mathit{d}}_y$, ${\mathit{J}}_k^T{\mathit{Y}}_k$ is simplified to the principal-constraint submatrix ${\mathit{C}}_k$, greatly reducing the algorithm’s time and memory complexity. However, as indicated by (18), if the Jacobian ${\mathit{C}}_k$ formed by the dependent variables is ill-conditioned or nearly singular, the computation of the range-space step ${\mathit{d}}_y$ may become numerically unstable or difficult to carry out, thereby affecting the accuracy of the range-space search direction. To address this, we adopt a column-reordering strategy: by applying simple column swaps to the original Jacobian—equivalently, reselecting the basic variables—we reconstruct the Jacobian to enhance the robustness of the principal-constraint submatrix.

Executing the column-reordering strategy requires checking whether the smallest singular value of ${\mathit{C}}_k$ is too small, whether its condition number is excessively large, or whether its rank is less than $m$. The specific steps are as follows:

First, perform a singular value decomposition (SVD) of ck:

$${\mathit{C}}_k={\mathit{U}}_k{\sum }_k{\mathit{V}}_k^T$$

(19)

Here, ${\mathit{U}}_k$ is an $m\times m$ orthogonal matrix, ${\mathit{U}}_k^T{\mathit{U}}_k={\mathit{I}}_m$ ($I_m$ is the $m\times m$ identity matrix). ${\sum }_k$ is an $m\times n$ diagonal matrix whose main-diagonal entries ${\sigma }_1,{\sigma }_1,\dots ,{\sigma }_p,p=\mathit{min}(m,n)$ are non-negative real numbers and satisfy ${\sigma }_1\ge {\sigma }_2\ge \dots \ge {\sigma }_p\ge 0$; these entries are the singular values of ${\mathit{C}}_k$. ${\mathit{V}}_k^T$ is an $n\times n$ orthogonal matrix, ${\mathit{V}}_k^T{\mathit{V}}_k={\mathit{I}}_n$.

Take the smallest singular value among them and check whether it is much smaller than 1:

$${\sigma }_{min}(C_k)=min({\sigma }_1,{\sigma }_2,\dots ,{\sigma }_m)<{\epsilon }_1$$

(20)

Here, ${\epsilon }_1$ is typically set to 10⁻⁸. If ${\sigma }_{min}(C_k)$ is too small, it indicates that the matrix ${\mathit{C}}_k$ may be nearly singular, and a basis change should be considered.

Set a threshold and count the number of nonzero singular values in the diagonal matrix ${\sum }_k$:

$$Rank({\mathit{C}}_k)={\sum }_i({\sigma }_i>{ϵ}_2)$$

(21)

Here, ${ϵ}_2$ is typically set to 10⁻¹⁰. If $Rank(C_k)<m$, this indicates that the constraint matrix is degenerate, and some variables need to be reselected as basic variables.

Compute the condition number of matrix ${\mathit{C}}_k$:

$$\kappa ({\mathit{C}}_k)={\displaystyle \frac{{\sigma k}_{max}}{{\sigma k}_{min}>{ϵ}_3}}$$

(22)

Here, ${ϵ}_3$ is typically set to 10¹⁰. If the condition number is excessively large, the matrix is ill-conditioned and numerical computations may be unstable, so a basis change may be required. In addition, if the stepsize $\alpha$ is too small, a basis transformation may also be necessary to avoid stalling or being trapped in a local optimum.

In addition, since the reduced-space SQP algorithm is essentially an iterative optimization method, even if the Jacobian matrix is nonsingular at the current iteration, there is no guarantee that it will retain good numerical properties in subsequent iterations. Therefore, if the Jacobian becomes ill-conditioned or singular during any iteration, it is still necessary to repartition the basic variables to ensure computational stability. The specific transformation steps are as follows:

Invoke the column approximate minimum degree (COLAMD) sublibrary of the open-source sparse-matrix package SuiteSparse 7.7.0 to perform a column ordering of the Jacobian $\mathit{J}(\mathit{x})$ (i.e., apply column reordering) to make ${\mathit{C}}_k$ more stable; during reordering, record the column swaps in the permutation matrix $\mathit{P}$.

The COLAMD sublibrary used here for column ordering of the Jacobian matrix is one of the core submodules of the open-source sparse matrix computation library SuiteSparse. SuiteSparse was developed by Professor David Amestoy’s team at the University of Florida and is widely used in scientific computing and engineering optimization. The core function of COLAMD is to perform column approximate minimum-degree ordering of sparse matrices; its basic principle is to analyze the sparsity structure of the matrix and select a column ordering that minimizes the number of new nonzero elements (hereinafter referred to as fill-ins) introduced during matrix factorizations such as LU and QR. The fewer the fill-ins, the more significant the reduction in memory usage—an effect particularly notable for high-dimensional sparse Jacobians; at the same time, it reduces the propagation of rounding errors in numerical computation, thereby improving numerical stability and avoiding factorization failures or biased results caused by ill-conditioning.

In the basis repartitioning procedure of the RSQP algorithm in this paper, invoking the COLAMD sublibrary to reorder the columns of the Jacobian serves two purposes: first, by optimizing the column order, the reordered Jacobian becomes closer to a diagonally dominant structure, reducing the likelihood of numerical singularity when selecting the subsequent basis matrix; second, COLAMD automatically generates the corresponding permutation matrix that records the column exchanges, i.e., the permutation matrix $P$ which can be directly used in the subsequent decomposition of the variable space to ensure that the partition of basic and non-basic variables matches the optimized matrix structure, thereby further ensuring the stability and efficiency of solving the reduced QP subproblems.

Adjustments to the variable partition also affect how the Hessian is computed and updated. For the quadratic-term update, one can derive that, in the new basis, the reduced Hessian takes the following form:

$$\overline{\mathit{B}}={\overline{\mathit{Z}}}^T\overline{\mathit{H}}\overline{\mathit{Z}}={\overline{\mathit{Z}}}^T{\mathit{P}}^T\mathit{H}\mathit{P}\overline{\mathit{Z}}={\overline{\mathit{Z}}}^T{\mathit{P}}^T{\mathit{T}}^T\mathit{B}\mathit{T}\mathit{P}\overline{\mathit{Z}}$$

(23)

Here, $\mathit{T}=[\mathit{I} 0]$ is the basis-transformation matrix, $\mathit{B}={\mathit{Z}}^T\mathit{H}\mathit{Z}$ is the original Hessian matrix, and the transformation relations for the other variables are as follows:

$$\overline{\mathit{\lambda }}={\mathit{P}}^T\mathit{\lambda }$$

(24)

$$\overline{\mathit{x}}={\mathit{P}}^T\mathit{x}$$

(25)

$$\overline{\mathit{g}}={\mathit{P}}^T\mathit{g}$$

(26)

The workflow of the space-decomposition algorithm based on the column-reordering strategy is illustrated in Figure 2.

First, the algorithm reads the Jacobian and decomposes it by partitioning the variables. It then checks a series of criteria to decide whether a basis transformation is needed: whether the solver is configured to enforce a basis change at every step, whether initialization of basic variables is required on the first call (if so, a flag is modified so that subsequent iterations skip reinitialization), and whether the smallest singular value, rank, and condition number of the matrix meet the required thresholds.

If a basis transformation is necessary, the algorithm executes column reordering, reconstructs the C and N matrices, and recalculates the other variables according to the recorded transformation matrix. If all numerical criteria are satisfied, the algorithm directly completes the basic-variable partition. For the decomposition procedure, the workflow further checks whether to use coordinate-basis decomposition or a custom decomposition method; if neither is selected, the solver defaults to coordinate-basis decomposition to ensure proper iterative solving.

Ultimately, the algorithm outputs the null-space and range-space matrices, completing the decomposition. By examining the numerical properties of the Jacobian at each step, incorporating dynamic column-reordering and basis-transformation mechanisms, and providing flexible choices for decomposition strategies, the workflow ensures numerical stability and adaptability of the decomposition results. This makes it suitable for space decomposition and variable management in large-scale nonlinear optimization problems.

3.3. Sparse-Matrix Processing Techniques

In the practical implementation of the RSQP algorithm, sparse-matrix handling techniques play a crucial role. Large-scale nonlinear optimization solvers must process a wide range of operations involving dense matrices, sparse matrices, vectors, and the management of optimization variables. Choosing appropriate sparse-matrix techniques therefore not only boosts computational efficiency but also reduces memory usage.

To achieve this, the RSQP solver in this work employs a Compressed Sparse Column (CSC) storage format for sparse matrices. This is combined with multiple optimized data structures—including vectors, matrices, hash tables, stacks, and queues—and mainstream numerical libraries to realize efficient storage, computation, and management of matrices and related data in large-scale nonlinear optimization. As a result, both the overall solving efficiency and the data-handling capability of the solver are significantly improved. Further definitions, schematics, and implementation details are provided in Appendix B.

3.4. Solver Algorithm Framework Design

Under the Windows 10 operating system, with VSCode (1.105.1) as the development platform and C++ as the programming language, this paper implements the software development of the RSQP solver algorithm. Before diving into the detailed design of the solver’s core algorithms, it is crucial to construct a sound software framework. The framework is intended to ensure efficient collaboration among modules and good scalability. A carefully designed framework not only enhances the execution efficiency of the algorithm but also provides the flexibility and maintainability required to adapt to evolving application demands.

To achieve these goals, the RSQP solver adopts a modular and top-down design philosophy. Based on the core functional requirements of the solver—such as program invocation, input checking, preprocessing, iterative solving, output control, and flexible invocation—the solver is divided into several independent functional modules. These modules cooperate through well-defined interfaces and efficient data transfer mechanisms.

The final RSQP solver structure is shown in Figure 3. Among them, the program invocation, output control, and flexible invocation modules directly expose interfaces to the user, while the other modules are encapsulated within the solver. This design not only satisfies the fundamental solving requirements but also supports appropriate extension of each module through reserved interfaces, facilitating secondary development.

(1)

Program Invocation Module

This module mainly describes the user-facing interface of the solver. It includes the solver’s invocation function RSQP() and the necessary interface encapsulation files, ensuring that users can seamlessly call the solver to perform optimization tasks.

(2)

Input Validation Module

This module serves as the input component and acts as the front-end processing unit of the optimization solver. It adopts a multi-level validation strategy to achieve standardized data management. Its primary functions include: receiving user-defined mathematical elements such as the objective function, constraints, initial solution, and optimization parameters; performing completeness checks and constructing a three-tier data validation mechanism; establishing an exception grading system in accordance with IEEE standards, classifying the results into fatal errors, recoverable errors, and warnings. Finally, the validated data is encapsulated into a SolverInput object with Jacobian/Hessian matrix attributes, providing the solver with a standardized input interface.

(3)

Preprocessing Module

This module functions as the preprocessing unit and serves as the numerical stabilizer in the optimization computation chain. It is responsible for performing the necessary adjustments to the data filtered and validated by the input module before the iterative solving process begins. Specifically, its tasks include scaling the objective function and constraints to eliminate the impact of differing units or magnitudes on optimization results. In addition, this module configures the variables required by the optimization algorithm—such as maximum iteration count, convergence tolerance, and algorithmic schemes—based on user-specified options combined with the solver’s default parameters. The preprocessing module is also responsible for initializing the data structures required by the algorithm, including setting variable initial values and decomposing or transforming constraint conditions. These preprocessing steps improve the stability and convergence of the subsequent optimization process.

(4)

Iterative Solving Module

This module is primarily responsible for the iterative solution of the optimization problem and serves as the solver’s core processing unit. It consists of four key components: space decomposition, search direction computation, line search, and convergence testing. Specifically, the space decomposition module partitions variables and performs basis transformations, decomposing the high-dimensional optimization space into lower-dimensional subspaces. This decomposition greatly reduces the problem scale to be solved and effectively lowers the computational complexity of the optimization process. Building upon this decomposition, the search direction computation module calculates the optimization direction at each step by solving a reduced-dimensional QP subproblem with high precision. The line search module, guided by evaluation functions and descent criteria, determines a suitable step length in each iteration. It ensures that the objective function decreases sufficiently and monotonically, while also preventing divergence caused by overly large step sizes. Finally, the convergence testing module monitors the algorithm’s convergence, determining whether the solution meets the stopping criteria based on the current error or residual.

(5)

Output Module

This module serves as the output component, responsible for printing error messages, intermediate results during the iterative process, final solutions, and statistical information. In traditional solvers, this module typically acts as the primary interface for user interaction. It outputs exception information received from the preceding modules and monitors the current iteration state, providing detailed feedback based on the convergence status. If the solver has not converged, it reports comprehensive data on the optimization iterations, including the computational results of each iteration, changes in the objective function, and the satisfaction of the constraints. If convergence has been achieved, the module outputs the optimal solution, the optimal objective value, memory consumption, and time statistics, while also supporting multiple export formats such as plain text and CSV files to facilitate further analysis and processing by the user. If no feasible solution is found, the module outputs a notification indicating solver failure.

(6)

Flexible Invocation Module

To address the interaction limitations of traditional solvers, the flexible invocation module provides an extensible design interface that significantly enhances solver adaptability by allowing users to directly intervene in the iterative solving process.

Specifically, this module introduces a five-dimensional layered callback mechanism to restructure the user interface, establishing programmable access points along five critical dimensions of the algorithm execution pipeline: preprocessing, algorithm selection, iteration stepping, convergence verification, and output control. The essence of this mechanism lies in defining standardized function interfaces through function pointers, thereby decoupling the algorithmic kernel from user-defined logic.

At the implementation level, the solver’s core program encapsulates key parameters generated during the iterative process into context objects, which are then exposed to users via a predefined CallbackProtocol interface. This protocol defines four standard callback hooks: PreIteration() (before iteration), InIteration() (during iteration), PostIteration() (after iteration), and ConvergenceCheck() (for convergence testing). In addition, callback points such as SpaceDecom() and MeritFunction() are incorporated into the algorithm selection module, allowing users to inject custom logic or algorithms by implementing their own callback functions. Through this design, users can flexibly extend and tailor the solver to meet specific problem requirements or research needs.

Taking the space decomposition algorithm in the algorithm selection dimension as an example, its interface reconstruction is illustrated in Figure 4.

The solver’s space decomposition module returns the partitioned matrix $[\mathit{C} \mathbf{N}]$ to the user, and after the user applies their own space decomposition method for iterative computation, a null-space matrix is returned to the solver. The solver itself does not concern itself with the specific logic of the user’s decomposition method.

From the above process, it can be seen that this design elevates the interface extension dimension from fixed parameters of order $O(1)$ to functional spaces of order $O(n)$. While maintaining the spatiotemporal complexity of the core algorithm, it enables users to inject domain knowledge according to problem-specific characteristics. For optimization problems that require customized algorithmic strategies, this approach can significantly improve development efficiency without introducing any additional computational overhead.

This architecture design, which separates control flow from functional business logic, enables the iterative sequence of the algorithm kernel to support a wider range of extension scenarios without modifying the core code: (1) Preprocessing enhancement: inserting data standardization steps before iterations begin, such as applying condition number correction to ill-conditioned Hessian matrices. (2) Process monitoring: recording additional information on the iterative trajectory through callbacks during iterations, for example, updating memory matrices in the construction of L-BFGS algorithms. (3) Convergence strategy extension: overloading the convergence check function to implement hybrid termination criteria, such as dual or multiple combinations of gradient norm thresholds, KKT violation levels, and relative improvement criteria. (4) Flexible algorithm selection: adapting the implementation of specific algorithms based on user application scenarios.

Through the above modular partitioning, combined with layered computation strategies, the global optimization problem is decoupled into independently manageable subtasks, greatly reducing the complexity of solver implementation. This design not only improves code maintainability and extensibility but also provides a flexible framework for performance optimization and functional expansion of the solver.

The relationships among solver modules and the program control flow are shown in Figure 5.

4. Experimental Analysis and Validation

This chapter consists of three groups of experiments. Experiment I selects small-scale test cases with typical nonlinear characteristics to provide a preliminary verification of the feasibility of the solver algorithm. Experiment II considers variable-dimensional test cases, in which the problem size is gradually increased to further verify the effectiveness of the solver in handling high-dimensional problems. Experiment III builds a first-stage three-pass RO process model based on practical process industry applications, and conducts optimization under the criterion of minimizing operating costs, thereby validating the solver’s performance in a real industrial scenario.

To accurately evaluate the solver’s performance while avoiding discrepancies caused by different hardware configurations, and to more directly reflect the impact of dimensionality on computational performance, all experiments are conducted in the VSCode software platform (version 1.102.1) with a C++ compilation environment, running under the Windows 10 operating system. Prior to solving, the solver is allocated a 2.8 GHz single-core CPU and 1 GB of memory. Consequently, this work primarily evaluates the solver’s effectiveness through solution time, while memory usage is roughly estimated using the computer’s task manager.

4.1. Small-Scale Case Studies: Computation and Analysis

To verify the solver’s performance in basic scenarios, this section selects six benchmark test cases featuring typical nonlinear characteristics such as non-convexity and exponential-type behavior. Through convergence tests conducted within low-dimensional variable spaces, the robustness of the algorithm is systematically evaluated under complex function landscapes. The mathematical descriptions of each case study, along with the RSQP iteration trajectories, are provided in Case 1 through Case 6.

Case 1 is a high-dimensional exponential-type objective function coupled with a spherical constraint and a nonlinear equality constraint. This test is designed to examine stability in scenarios prone to exponential explosion. Its specific formulation is given as follows:

Objective Function and Constraints:

$$\begin{array}{cc}\mathit{min}& e^{x_1{x}_2{x}_3{x}_4{x}_5}\hfill \\ s.t.& x_1^2+x_2^2+x_3^2+x_4^2+x_5^2=10\\ & x_2{x}_3-5x_4{x}_5=0\\ & x_1^3+x_2^3=-1\end{array}$$

Variable Bounds:

$$\begin{array}{cc}\hfill \mathit{l}\mathit{b}& ={\left[\begin{array}{ccccc}-2.3,& -2.3,& -3.2,& -3.2,& -3.2\end{array}\right]}^T\hfill \\ \hfill \mathit{u}\mathit{b}& ={\left[\begin{array}{ccccc}2.3,& 2.3,& 3.2,& 3.2,& 3.2\end{array}\right]}^T\hfill \end{array}$$

Initial Point:

$${\mathit{x}}_0={\left[\begin{array}{ccccc}-2,& 2,& 2,& -1,& -1\end{array}\right]}^T$$

Minimum Objective Function Value:

$$f({\mathit{x}}^{\ast })=0.1239$$

The iteration procedure is presented in

Table A1. Iteration trajectory of small-scale Case 1.

$\mathbf{I}\mathbf{t}\mathbf{e}\mathbf{r}$	$\mathbf{M}\mathbf{e}\mathbf{r}\mathbf{i}\mathbf{t}$ $\mathbf{C}\mathbf{o}\mathbf{u}\mathbf{n}\mathbf{t}$	$\mathbf{f}(\mathbf{x})$	$\begin{array}{c}\mathbf{M}\mathbf{a}\mathbf{x}\\ \mathbf{C}\mathbf{o}\mathbf{n}\mathbf{s}\mathbf{t}\mathbf{r}\mathbf{a}\mathbf{i}\mathbf{n}\mathbf{t}\end{array}$	$\mathbf{S}\mathbf{t}\mathbf{e}\mathbf{p}\mathbf{s}\mathbf{i}\mathbf{z}\mathbf{e}$	$\begin{array}{c}\mathbf{D}\mathbf{i}\mathbf{r}\mathbf{e}\mathbf{c}\mathbf{t}\mathbf{i}\mathbf{o}\mathbf{n}\mathbf{a}\mathbf{l}\\ \mathbf{D}\mathbf{e}\mathbf{r}\mathbf{i}\mathbf{v}\mathbf{a}\mathbf{t}\mathbf{i}\mathbf{v}\mathbf{e}\end{array}$	$\begin{array}{c}\mathbf{F}\mathbf{i}\mathbf{r}\mathbf{s}\mathbf{t}\text{-}\mathbf{O}\mathbf{r}\mathbf{d}\mathbf{e}\mathbf{r}\\ \mathbf{O}\mathbf{p}\mathbf{t}\mathbf{i}\mathbf{m}\mathbf{a}\mathbf{l}\mathbf{i}\mathbf{t}\mathbf{y}\end{array}$	$\begin{array}{c}\mathbf{H}\mathbf{e}\mathbf{s}\mathbf{s}\mathbf{i}\mathbf{a}\mathbf{n}\\ \mathbf{P}\mathbf{r}\mathbf{o}\mathbf{c}\mathbf{e}\mathbf{d}\mathbf{u}\mathbf{r}\mathbf{e}\end{array}$
1	3	0.0564161	0.4	1	0.196	1.3
2	5	0.118883	0.05764	1	0.0799	0.804
3	7	0.123875	0.002727	1	0.00506	0.372
4	9	0.123893	1.255 × 10−5	1	1.86 × 10−5	0.031
5	11	0.123893	2.298 × 10−10	1	2.74 × 10−10	0.745	modified

.

Case 2 features a negative product objective function with mixed cubic/square constraints, aiming to evaluate the solver’s capability of escaping from local optima in non-convex problems. The specific formulation is as follows:

Objective Function and Constraints:

$$\begin{array}{cc}\mathit{min}& -x_1{x}_2{x}_3{x}_4\hfill \\ s.t.& x_1^3+x_2^2=1\hfill \\ & x_1^2{x}_4-x_3=0\hfill \\ & x_4^2-x_2=0\hfill \end{array}$$

Initial Point:

$${\mathit{x}}_0={\left[\begin{array}{cccc}0.8,& 0.8,& 0.8,& 0.8\end{array}\right]}^T$$

Minimum Objective Function Value:

$$f({\mathit{x}}^{\ast })=-0.25$$

The iteration procedure is presented in

Table A2. Iteration Trajectory of Small-Scale Case 2.

$\mathbf{I}\mathbf{t}\mathbf{e}\mathbf{r}$	$\mathbf{M}\mathbf{e}\mathbf{r}\mathbf{i}\mathbf{t}$ $\mathbf{C}\mathbf{o}\mathbf{u}\mathbf{n}\mathbf{t}$	$\mathbf{f}(\mathbf{x})$	$\begin{array}{c}\mathbf{M}\mathbf{a}\mathbf{x}\\ \mathbf{C}\mathbf{o}\mathbf{n}\mathbf{s}\mathbf{t}\mathbf{r}\mathbf{a}\mathbf{i}\mathbf{n}\mathbf{t}\end{array}$	$\mathbf{S}\mathbf{t}\mathbf{e}\mathbf{p}\mathbf{s}\mathbf{i}\mathbf{z}\mathbf{e}$	$\begin{array}{c}\mathbf{D}\mathbf{i}\mathbf{r}\mathbf{e}\mathbf{c}\mathbf{t}\mathbf{i}\mathbf{o}\mathbf{n}\mathbf{a}\mathbf{l}\\ \mathbf{D}\mathbf{e}\mathbf{r}\mathbf{i}\mathbf{v}\mathbf{a}\mathbf{t}\mathbf{i}\mathbf{v}\mathbf{e}\end{array}$	$\begin{array}{c}\mathbf{F}\mathbf{i}\mathbf{r}\mathbf{s}\mathbf{t}\text{-}\mathbf{O}\mathbf{r}\mathbf{d}\mathbf{e}\mathbf{r}\\ \mathbf{O}\mathbf{p}\mathbf{t}\mathbf{i}\mathbf{m}\mathbf{a}\mathbf{l}\mathbf{i}\mathbf{t}\mathbf{y}\end{array}$	$\begin{array}{c}\mathbf{H}\mathbf{e}\mathbf{s}\mathbf{s}\mathbf{i}\mathbf{a}\mathbf{n}\\ \mathbf{P}\mathbf{r}\mathbf{o}\mathbf{c}\mathbf{e}\mathbf{d}\mathbf{u}\mathbf{r}\mathbf{e}\end{array}$
1	3	−0.24576	0.288	1	0.17	0.296
2	5	−0.266937	0.01574	1	−0.0135	0.238
3	7	−0.250586	0.03064	1	0.0165	0.437
4	9	−0.2501	0.001733	1	0.000528	0.029	modified
5	11	−0.25	0.0001623	1	0.0001	0.0342	modified
6	13	−0.25	1.158 × 10−7	1	8.08 × 10−8	0.00154	modified

Case 3 is a chained polynomial objective with a set of linear equality constraints, aimed at examining the convergence accuracy of piecewise linear structures. Its specific form is described as follows:

Objective Function and Constraints:

$$\begin{array}{cc}\mathit{min}& {\left(x_1-x_2\right)}^2+{\left(x_2-x_3\right)}^2+{\left(x_3-x_4\right)}^4+{\left(x_4-x_5\right)}^2\hfill \\ s.t.& x_1+2x_2+3x_3=6\hfill \\ & x_2+2x_3+3x_4=6\hfill \\ & x_3+2x_4+3x_5=6\hfill \end{array}$$

Initial Point:

$${\mathit{x}}_0={\left[\begin{array}{ccccc}35,& -31,& 11,& 5,& -5\end{array}\right]}^T$$

Optimal Value of Variables:

$${\mathit{x}}^{\ast }={\left[\begin{array}{ccccc}1,& 1,& 1,& 1,& 1\end{array}\right]}^T$$

Minimum Objective Function Value:

$$f({\mathit{x}}^{\ast })=0$$

The iteration procedure is presented in

Table A3. Iteration Trajectory of Small-Scale Case 3.

$\mathbf{I}\mathbf{t}\mathbf{e}\mathbf{r}$	$\mathbf{M}\mathbf{e}\mathbf{r}\mathbf{i}\mathbf{t}$ $\mathbf{C}\mathbf{o}\mathbf{u}\mathbf{n}\mathbf{t}$	$\mathbf{f}(\mathbf{x})$	$\begin{array}{c}\mathbf{M}\mathbf{a}\mathbf{x}\\ \mathbf{C}\mathbf{o}\mathbf{n}\mathbf{s}\mathbf{t}\mathbf{r}\mathbf{a}\mathbf{i}\mathbf{n}\mathbf{t}\end{array}$	$\mathbf{S}\mathbf{t}\mathbf{e}\mathbf{p}\mathbf{s}\mathbf{i}\mathbf{z}\mathbf{e}$	$\begin{array}{c}\mathbf{D}\mathbf{i}\mathbf{r}\mathbf{e}\mathbf{c}\mathbf{t}\mathbf{i}\mathbf{o}\mathbf{n}\mathbf{a}\mathbf{l}\\ \mathbf{D}\mathbf{e}\mathbf{r}\mathbf{i}\mathbf{v}\mathbf{a}\mathbf{t}\mathbf{i}\mathbf{v}\mathbf{e}\end{array}$	$\begin{array}{c}\mathbf{F}\mathbf{i}\mathbf{r}\mathbf{s}\mathbf{t}\text{-}\mathbf{O}\mathbf{r}\mathbf{d}\mathbf{e}\mathbf{r}\\ \mathbf{O}\mathbf{p}\mathbf{t}\mathbf{i}\mathbf{m}\mathbf{a}\mathbf{l}\mathbf{i}\mathbf{t}\mathbf{y}\end{array}$	$\begin{array}{c}\mathbf{H}\mathbf{e}\mathbf{s}\mathbf{s}\mathbf{i}\mathbf{a}\mathbf{n}\\ \mathbf{P}\mathbf{r}\mathbf{o}\mathbf{c}\mathbf{e}\mathbf{d}\mathbf{u}\mathbf{r}\mathbf{e}\end{array}$
1	9	4373.12	1.421 × 10−14	0.0156	−3.68 × 104	869
2	13	280.551	9.415 × 10−14	0.25	1.08 × 104	110
3	15	4.53044	1.776 × 10−14	1	−4.84	8.63
4	17	3.51233	8.882 × 10−16	1	−0.904	4.97
5	19	0.858637	0	1	−1.47	3.35
6	21	0.256953	8.882 × 10−16	1	−0.394	1.12
7	23	0.031691	0	1	−0.113	0.425
8	25	0.000770494	0	1	−0.00829	0.0915
9	27	3.73693 × 10−7	8.882 × 10−16	1	−3.13 × 10−5	0.0149
10	29	3.73693 × 10−7	0	1	5.53 × 10−20	0.00134

:

Case 4 features a quadratic non-convex objective function with ellipsoidal inequality constraints, designed to test the efficiency of boundary search under constraints. The specific description is as follows:

Objective Function and Constraints:

$$\begin{array}{cc}& \mathit{min}{\displaystyle \frac{x_1^2}{2}}+x_2^2-x_1{x}_2-7x_1-7x_2\hfill \\ & s.t. 4x_1^2+x_2^2\le 25\hfill \end{array}$$

Initial Point:

$${\mathit{x}}_0={\left[\begin{array}{cc}1,& 1\end{array}\right]}^T$$

Optimal Value of Variables:

$${\mathit{x}}^{\ast }={\left[\begin{array}{cc}2,& 3\end{array}\right]}^T$$

Minimum Objective Function Value:

$$f({\mathit{x}}^{\ast })=-30$$

The iteration procedure is presented in

Table A4. Iteration Trajectory of Small-Scale Case 4.

$\mathbf{I}\mathbf{t}\mathbf{e}\mathbf{r}$	$\mathbf{M}\mathbf{e}\mathbf{r}\mathbf{i}\mathbf{t}$ $\mathbf{C}\mathbf{o}\mathbf{u}\mathbf{n}\mathbf{t}$	$\mathbf{f}(\mathbf{x})$	$\begin{array}{c}\mathbf{M}\mathbf{a}\mathbf{x}\\ \mathbf{C}\mathbf{o}\mathbf{n}\mathbf{s}\mathbf{t}\mathbf{r}\mathbf{a}\mathbf{i}\mathbf{n}\mathbf{t}\end{array}$	$\mathbf{S}\mathbf{t}\mathbf{e}\mathbf{p}\mathbf{s}\mathbf{i}\mathbf{z}\mathbf{e}$	$\begin{array}{c}\mathbf{D}\mathbf{i}\mathbf{r}\mathbf{e}\mathbf{c}\mathbf{t}\mathbf{i}\mathbf{o}\mathbf{n}\mathbf{a}\mathbf{l}\\ \mathbf{D}\mathbf{e}\mathbf{r}\mathbf{i}\mathbf{v}\mathbf{a}\mathbf{t}\mathbf{i}\mathbf{v}\mathbf{e}\end{array}$	$\begin{array}{c}\mathbf{F}\mathbf{i}\mathbf{r}\mathbf{s}\mathbf{t}\text{-}\mathbf{O}\mathbf{r}\mathbf{d}\mathbf{e}\mathbf{r}\\ \mathbf{O}\mathbf{p}\mathbf{t}\mathbf{i}\mathbf{m}\mathbf{a}\mathbf{l}\mathbf{i}\mathbf{t}\mathbf{y}\end{array}$	$\begin{array}{c}\mathbf{H}\mathbf{e}\mathbf{s}\mathbf{s}\mathbf{i}\mathbf{a}\mathbf{n}\\ \mathbf{P}\mathbf{r}\mathbf{o}\mathbf{c}\mathbf{e}\mathbf{d}\mathbf{u}\mathbf{r}\mathbf{e}\end{array}$
1	3	−36.0762	20	1	−9.59	10.2
2	5	−30.2524	26.33	1	7.02	8.77
3	7	−30.2359	3.376	1	0.635	0.898
4	9	−30.0021	0.5897	1	0.252	0.872
5	11	−30.002	0.01717	1	0.00391	0.207
6	13	−30	0.00412	1	0.00205	0.0821
7	15	−30	7.403 × 10−6	1	3.64 × 10−6	0.00314	modified
8	17	−30	6.147 × 10−8	1	3.07 × 10−8	0.000296	modified

:

Case 5 involves a mixed exponential–polynomial objective function coupled with a spherical constraint and a cubic equality, designed to evaluate the robustness of the solver in handling highly nonlinear coupled systems. Its specific formulation is as follows:

Objective Function and Constraints:

$$\begin{array}{cc}\mathit{min}& e^{x_1{x}_2{x}_3{x}_4{x}_5}-{\displaystyle \frac{1}{2}}{\left(x_1^3+x_2^3+1\right)}^2\hfill \\ s.t.& x_1^2+x_2^2+x_3^2+x_4^2+x_5^2=10\hfill \\ & x_2{x}_3-5x_4{x}_5=0\\ & x_1^3+x_2^3=-1\end{array}$$

Variable bounds:

$$\begin{array}{cc}\hfill \mathit{l}\mathit{b}& ={\left[\begin{array}{ccccc}-2.3,& -2.3,& -3.2,& -3.2,& -3.2\end{array}\right]}^T\hfill \\ \hfill \mathit{u}\mathit{b}& ={\left[\begin{array}{ccccc}2.3& 2.3& 3.2& 3.2& 3.2\end{array}\right]}^T\hfill \end{array}$$

Initial Point:

$${\mathit{x}}_0={\left[\begin{array}{ccccc}-2,& 2,& 2,& -1,& -1\end{array}\right]}^T$$

Minimum Objective Function Value:

$$f({\mathit{x}}^{\ast })=0.0539498478$$

The iteration procedure is presented in

Table A5. Iteration Trajectory of Small-Scale Case 5.

$\mathbf{I}\mathbf{t}\mathbf{e}\mathbf{r}$	$\mathbf{M}\mathbf{e}\mathbf{r}\mathbf{i}\mathbf{t}$ $\mathbf{C}\mathbf{o}\mathbf{u}\mathbf{n}\mathbf{t}$	$\mathbf{f}(\mathbf{x})$	$\begin{array}{c}\mathbf{M}\mathbf{a}\mathbf{x}\\ \mathbf{C}\mathbf{o}\mathbf{n}\mathbf{s}\mathbf{t}\mathbf{r}\mathbf{a}\mathbf{i}\mathbf{n}\mathbf{t}\end{array}$	$\mathbf{S}\mathbf{t}\mathbf{e}\mathbf{p}\mathbf{s}\mathbf{i}\mathbf{z}\mathbf{e}$	$\begin{array}{c}\mathbf{D}\mathbf{i}\mathbf{r}\mathbf{e}\mathbf{c}\mathbf{t}\mathbf{i}\mathbf{o}\mathbf{n}\mathbf{a}\mathbf{l}\\ \mathbf{D}\mathbf{e}\mathbf{r}\mathbf{i}\mathbf{v}\mathbf{a}\mathbf{t}\mathbf{i}\mathbf{v}\mathbf{e}\end{array}$	$\begin{array}{c}\mathbf{F}\mathbf{i}\mathbf{r}\mathbf{s}\mathbf{t}\text{-}\mathbf{O}\mathbf{r}\mathbf{d}\mathbf{e}\mathbf{r}\\ \mathbf{O}\mathbf{p}\mathbf{t}\mathbf{i}\mathbf{m}\mathbf{a}\mathbf{l}\mathbf{i}\mathbf{t}\mathbf{y}\end{array}$	$\begin{array}{c}\mathbf{H}\mathbf{e}\mathbf{s}\mathbf{s}\mathbf{i}\mathbf{a}\mathbf{n}\\ \mathbf{P}\mathbf{r}\mathbf{o}\mathbf{c}\mathbf{e}\mathbf{d}\mathbf{u}\mathbf{r}\mathbf{e}\end{array}$
1	3	0.0482947	0.485	1	0.168	7.65
2	5	0.0438279	0.198	1	−0.00157	0.015
3	7	0.0538201	0.005112	1	0.00982	0.0355
4	9	0.0538249	0.002234	1	5.7 × 10−5	0.000772	modified
5	11	0.0539497	1.859 × 10−6	1	0.000125	0.000398	modified
6	13	0.0539498	1.839 × 10−13	1	1.1 × 10−7	1.46 × 10−6	modified

:

Case 6 is a variant of the classical Rosenbrock problem (with a parabolic equality constraint), designed to verify the iteration stability on ill-conditioned surfaces. Its specific description is as follows:

Objective Function and Constraints:

$$\begin{array}{cc}& \mathit{min} {\left(1-x_1\right)}^2\hfill \\ & s.t. 10\left(x_2-x_1^2\right)=0\hfill \end{array}$$

Initial Point:

$${\mathit{x}}_0={\left[\begin{array}{cc}-1.2,& 1\end{array}\right]}^T$$

Minimum Objective Function Value:

$$f({\mathit{x}}^{\ast })=0$$

The iteration procedure is presented in

Table A6. Iteration Trajectory of Small-Scale Case 6.

$\mathbf{I}\mathbf{t}\mathbf{e}\mathbf{r}$	$\mathbf{M}\mathbf{e}\mathbf{r}\mathbf{i}\mathbf{t}$ $\mathbf{C}\mathbf{o}\mathbf{u}\mathbf{n}\mathbf{t}$	$\mathbf{f}(\mathbf{x})$	$\begin{array}{c}\mathbf{M}\mathbf{a}\mathbf{x}\\ \mathbf{C}\mathbf{o}\mathbf{n}\mathbf{s}\mathbf{t}\mathbf{r}\mathbf{a}\mathbf{i}\mathbf{n}\mathbf{t}\end{array}$	$\mathbf{S}\mathbf{t}\mathbf{e}\mathbf{p}\mathbf{s}\mathbf{i}\mathbf{z}\mathbf{e}$	$\begin{array}{c}\mathbf{D}\mathbf{i}\mathbf{r}\mathbf{e}\mathbf{c}\mathbf{t}\mathbf{i}\mathbf{o}\mathbf{n}\mathbf{a}\mathbf{l}\\ \mathbf{D}\mathbf{e}\mathbf{r}\mathbf{i}\mathbf{v}\mathbf{a}\mathbf{t}\mathbf{i}\mathbf{v}\mathbf{e}\end{array}$	$\begin{array}{c}\mathbf{F}\mathbf{i}\mathbf{r}\mathbf{s}\mathbf{t}\text{-}\mathbf{O}\mathbf{r}\mathbf{d}\mathbf{e}\mathbf{r}\\ \mathbf{O}\mathbf{p}\mathbf{t}\mathbf{i}\mathbf{m}\mathbf{a}\mathbf{l}\mathbf{i}\mathbf{t}\mathbf{y}\end{array}$	$\begin{array}{c}\mathbf{H}\mathbf{e}\mathbf{s}\mathbf{s}\mathbf{i}\mathbf{a}\mathbf{n}\\ \mathbf{P}\mathbf{r}\mathbf{o}\mathbf{c}\mathbf{e}\mathbf{d}\mathbf{u}\mathbf{r}\mathbf{e}\end{array}$
1	3	1.56945	4.4	1	−2.37	1.83
2	9	0.280009	13.65	0.0625	−12.3	2.04	modified
3	14	0.494598	12.24	0.125	1.96	2.65
4	20	0.673138	11.62	0.0625	3.08	1.49	modified
5	27	0.814987	11.32	0.0312	4.76	2.77	modified
6	34	1.0287	11.09	0.0312	7.24	5.03	modified
7	46	0.741412	11.32	0.000977	−270	10.4
8	48	0.607985	11.32	1	−0.127	1.56	modified
9	56	0.57058	0.07103	0.0156	−2.36	1.51
10	64	0.535476	0.07549	0.0156	−2.21	1.46
11	72	0.502532	0.07954	0.0156	−2.07	1.42
12	79	0.441678	0.09669	0.0312	−1.88	1.33
13	86	0.388194	0.1109	0.0312	−1.66	1.25
14	92	0.297211	0.1646	0.0625	−1.36	1.09
15	98	0.227552	0.2008	0.0625	−1.04	0.954
16	104	0.174219	0.2238	0.0625	−0.796	0.835
17	109	0.0979985	0.3047	0.125	−0.523	0.626
18	114	0.0551241	0.3279	0.125	−0.294	0.47
19	118	0.013781	0.3837	0.25	−0.11	0.235
20	121	0	0.3297	0.5	0	0
21	123	0	0.3297	1	0	0
22	125	0	0	1	0	0

:

The iteration trajectories of small-scale Cases 1 through 6 are shown more intuitively in Figure 6, Figure 7, Figure 8, Figure 9, Figure 10 and Figure 11.

In the benchmark tests, a comparison with the full-space standard SQP algorithm implemented in Fmincon (MATLAB 2022b) shows that the RSQP solver exhibits a very similar convergence trend. The objective function descent curves of the two methods almost overlap, and the final convergence accuracy remains at the same order of magnitude. This indicates that the RSQP solver possesses numerical stability comparable to that of well-established solvers.

It is worth noting that in cases involving non-convex constraints, the RSQP solver requires slightly more iterations than Fmincon. This is because the space decomposition strategy introduces additional basis transformation calibrations to ensure the stability of the reduced-degree-of-freedom subspace. Although the iteration steps increase, the convergence process remains stable without oscillations or divergence.

A deeper comparison further reveals that RSQP has potential advantages in memory management and architectural scalability. Its modular design reserves interfaces for large-scale problem solving, whereas Fmincon’s full-space strategy already shows limitations when extending to higher dimensions. This design trade-off allows RSQP to acceptably increase the number of iterations in small-scale problems in exchange for improved generalization capabilities in industrial-scale applications.

Additionally, regarding memory usage, since the test problems are of small scale, the difference in memory consumption between the two algorithms for storing dense matrices is minor. In fact, for matrices with high density, the improved reduced-space SQP algorithm may even use slightly more memory than traditional SQP. However, in small-scale cases, this overhead is within an acceptable range.

4.2. Variable-Dimension Case Studies and Analysis

To fully highlight the unique advantages of the RSQP algorithm in high-dimensional, low-degree-of-freedom scenarios typical of process simulation, this section presents three sets of scalable-dimension test problems. By dynamically adjusting the size of the decision variables, the study systematically compares the computational efficiency of the RSQP solver with MATLAB’s Fmincon under both global and decomposition strategies, thereby providing a comprehensive quantitative evaluation of the algorithm’s engineering practicality.

Case Study 1: Degree of Freedom = 1

Objective Function and Constraints:

$$\begin{array}{cc}min& {\displaystyle \frac{1}{2}}{\sum }_{i=1}^n{x}_i^2\\ s.t.& x_1(x_{i+1}-1)-10x_{i+1}=0, i=1,\dots ,n-1\end{array}$$

Initial Point:

$${\mathit{x}}_0={\left[\begin{array}{cccc}{x}_{1,}& x_2,& ...& x_i\end{array}\right]}^T, x_i=0.1$$

Case Study 2: Degree of Freedom = 1/2n

Objective Function and Constraints:

$$\begin{array}{cc}min& {\displaystyle \frac{1}{2}}{\sum }_{i=1}^n(x_i{)}^2\\ s.t.& x_i(x_{i+{\displaystyle \frac{n}{2}}}-1)-10x_{i+{\displaystyle \frac{n}{2}}}=0, i=1,\dots ,{\displaystyle \frac{n}{2}}\end{array}$$

Initial Point:

$${\mathit{x}}_0={\left[\begin{array}{cccc}{x}_1,& x_2,& ...& x_i\end{array}\right]}^T, x_i=0.1$$

Case Study 3: Degree of Freedom = 2

Objective Function and Constraints:

$$\begin{array}{cc}min& {\displaystyle \frac{1}{2}}{\sum }_{i=1}^n(x_i+x_{i+1}{)}^2\\ s.t.& x_i+2x_{i+1}+3x_{i+2}-1=0, i=1,\dots ,n-2\end{array}$$

Initial Point:

$${\mathit{x}}_0=\left[\begin{array}{ccccc}-4,& x_2,& x_3,& ...& x_i\end{array}\right], x_i=1$$

The results of the variable-dimension cases are shown in

Table 1. Solution Results of Variable-Dimension Problems.

Case	Number of Variables	Degrees of Freedom	RSQP			FMINCON SQP
			Iterations	Time (s)	Basis Transformations	Iterations	Time (s)
1	1000	1	8	0.229	1	3	25.263
	2000	1	9	0.411	1	2	178.334
	4000	1	9	1	1	#	#
	8000	1	10	2.816	1	#	#
	16,000	1	10	8.448	1	#	#
	32,000	1	10	26.191	1	#	#
	64,000	1	11	101.722	1	#	#
	128,000	1	12	419.936	1	#	#
2	1000	500	15	4.496	0	2	10.42
	2000	1000	17	25.991	0	2	77.961
	4000	2000	6	15.032	1	2	989.919
	6000	3000	6	41.749	1	#	#
3	4000	2	6	0.711	1	#	#
	8000	2	6	1.725	1	#	#
	16,000	2	6	4.362	1	#	#
	20,000	2	6	6.189	1	#	#
	50,000	2	6	27.988	1	#	#

Note: # denotes memory overflow or timeout.

.

In Case 1, namely the large-scale low-degree-of-freedom test, the variable dimension reaches up to 128,000 with the degrees of freedom fixed at 1, and the RSQP solver demonstrates significant advantages. When the dimension reaches 32,000, RSQP completes the solution in only 26.191 s, whereas Fmincon already takes 178.334 s at 2000 dimensions, a performance gap of approximately 6.809 times. More notably, as the dimension increases from 64,000 to 128,000, the runtime of RSQP grows by about 4.128 times, far below the theoretical complexity expectation. In contrast, the full-space SQP algorithm encounters memory overflow at 4000 dimensions due to matrix decomposition, showing that the space decomposition strategy reduces memory consumption by at least 65%. The number of iterations remains stable, with the basis transformation consistently maintained at 1, verifying the robustness of the quadratic correction strategy.

In Case 2, namely the medium-to-high dimensional dynamic degree-of-freedom scenario, the dimension is adjusted up to 6000, with the degree-of-freedom ratio reaching 50%. RSQP achieves a performance boost through basis transformations. When the degrees of freedom increase from 1000 to 2000, the number of iterations decreases by about 62%, and computation time drops by approximately 42.165%. Particularly, at 6000 dimensions, RSQP successfully converges in 41.749 s, while the full-space SQP algorithm already suffers memory overflow at 3000 dimensions, highlighting the adaptability of the decomposition strategy to degree-of-freedom-sensitive problems. The turning point where the number of basis transformations increases from 0 to 1 reveals the algorithm’s self-adjustment mechanism in response to sudden changes in degrees of freedom.

In Case 3, namely the relatively extreme industrial-scale dimension test, the dimension is adjusted up to 50,000 with the degrees of freedom fixed at 2, and RSQP exhibits superlinear computational characteristics. When the dimension increases from 4000 to 50,000—a 12.5-fold increase—the runtime grows by about 39.364 times, which is significantly better than the cubic-level complexity of traditional algorithms. It is noteworthy that in this test, the RSQP iteration count remains stable at 6, and the number of basis transformations remains at 1, demonstrating that the algorithm’s stability under high-dimensional stress is unaffected by problem scale.

4.3. Single-Stage Three-Pass Reverse Osmosis Process Model

To evaluate the effectiveness of the RSQP solver on real industrial problems, we apply it to the high-salinity wastewater treatment process of a coal-fired power plant in Inner Mongolia. The process employs a single-stage, three-pass high-pressure RO system; its technical principle is shown in Figure 12, and the plant setup is shown in Figure 13. The RO process involves complex mass-transfer and fluid-mechanics phenomena, and its mathematical model is high-dimensional and strongly nonlinear, placing stringent demands on the efficiency and stability of the optimization algorithm.

Based on a rigorous mechanistic model and an economic model of the RO unit, we formulate a large-scale NLP using a finite-difference simultaneous-equations approach [25,26,27,28]. The optimization objective is to minimize the system’s daily operating cost of water production; the decision variables include the operating pressures of each pass and the allocation of flow rates, subject to strict product-water quality requirements and equipment constraints. The complete mathematical model—covering mass conservation, membrane transport equations (solution–diffusion model), concentration–polarization effects, and economic metrics—is provided in Appendix D.

This case study is intended to assess, through a complex optimization problem with a clear engineering background, the computational performance and practical applicability of the RSQP solver under conditions that closely approximate real industrial scenarios.

4.4. Operation Optimization Based on Minimizing Daily Operating Costs

According to the actual operating conditions of the coal-fired power plant’s high-salinity wastewater RO system,

Table 2. Data of Two Typical Operating Scenarios.

Typical Condition	Feed Temperature/°C	Feed Concentration (kg/m3)	Feed Flow Rate (m3/h)	Operating Pressure (bar)	Booster Pump Pressure (bar)
Case 1	10	23.3	28.8	36.87	35
Case 2	15	21.8	25	36.87	36

presents data for two typical operating scenarios.

For Case 1 and Case 2, a target function φ is defined and set to zero, with the objective of minimizing φ. The RO model involved contains nonlinear equality constraints, making this an NLP problem. The number of finite difference nodes is set to 56, with a total of 12,185 variables and 12,173 constraint equations, resulting in 12 degrees of freedom. The feedwater flow rate, operating pressure, and booster pump pressure of the RO process are kept constant. The RSQP solver is used to solve the problem, and its iteration curves are shown in Figure 14 and Figure 15.

Before optimization, the optimized economic cost was 2264.5585 CNY for Case 1 and 2088.4695 CNY for Case 2. The detailed breakdown of cost components is shown in Table 2.

An optimization problem is formulated based on minimizing the daily operating cost, described as follows [29]:

Objective Function:

$$\underset{\mathit{x}}{min}OC, \mathit{x}={\left[\begin{array}{cccc}Pf,& Qf,& P_{bp},& T\end{array}\right]}^T$$

(27)

Equality Constraints:

RO process mechanism model: Equations (A10)–(A40)

RO economic evaluation model: Equations (A41)–(A46)

Inequality Constraints:

$$P_f^L\le P_f\le P_f^U$$

(28)

$$P_{bp}^L\le P_{bp}\le P_{bp}^U$$

(29)

$$C_{p,out}\le C_{limit}$$

(30)

$$V_f^L\le V_f\le V_f^U$$

(31)

$${\varphi }^L\le \varphi \le {\varphi }^U$$

(32)

$$T_f^L\le T_f\le T_f^U$$

(33)

Initial and Termination Conditions:

$$P_b=\left\{\begin{array}{c}{P}_f,z=0\\ P_r,z=L\end{array}\right.$$

(34)

$$C_b=\left\{\begin{array}{c}{C}_f,z=0\\ C_r,z=L\end{array}\right.$$

(35)

$$V=\left\{\begin{array}{c}{V}_f={\displaystyle \frac{Q_f}{n_{e}W{h}_{sp}}},z=0\\ V_f={\displaystyle \frac{Q_r}{n_{e}W{h}_{sp}}},z=L\end{array}\right.$$

(36)

During the optimization process, to ensure the safety of the RO process and meet practical operating conditions, upper- and lower-bound constraints are imposed on the feedwater flow rate, operating pressure, and booster pump pressure. The specific data are shown in

Table 3. Upper- and Lower-Bound Constraints of RO System Variables.

Parameter	Value
Maximum element feed pressure $P_f^{up}$	82.53 bar
Maximum element pressure drop $P_d^{up}$	1.03 bar
Maximum interstage booster pump pressure $P_{bp}^{up}$	40 bar
Maximum element feed flow $Q_f^{up}$	13.6 m3/h
Maximum element permeate flow $Q_p^{up}$	1.04 m3/h
Minimum element channel flow $Q_b^{lo}$	2.3 m3/h
Maximum element recovery $R^{up}$	15%
Feed surface velocity $V_b^{up}$	0.35 m/s
Minimum feed surface velocity $V_b^{lo}$	0.038 m/s
Maximum element concentration polarization ${\phi }^{up}$	1.5

.

The product water concentration of the RO system is set to 800 mg/L, and the minimum permeate flow rate is set to 21 m³/h. The data obtained from the simulation calculations are used as the initial values for optimization. The RSQP solver is then applied to optimize both Case 1 and Case 2.

The iteration trajectories for Case 1 and Case 2 are shown in Figure 16 and Figure 17, respectively.

Additional optimization results across more dimensions are presented in

Table 4. Optimization results of the RSQP solver under two typical operating scenarios.

Comparison Metric	Case 1	Case 2
Iteration count	19	19
Function evaluation count	57	59
Basis change count	1	1
Gradient evaluation count	28	29
Constraint residual	3.919 × 10−8	9.5771 × 10−9
Time (seconds)	20.331	23.412

.

After optimization, data results before and after process optimization for the two typical RO operating scenarios were obtained. The detailed data are presented in

Table 5. Comparison of Daily Operating Costs of the RO System Before and After Optimization.

RO System Parameters	Case 1		Case 2
	Before Optimization	After Optimization	Before Optimization	After Optimization
Feed Pressure (bar)	36.8700	40.3070	36.8700	35.7844
Feed Flow Rate (m3/h)	28.8000	32.9261	25.0000	32.4267
Booster Pump Pressure (bar)	35.0000	15.1809	36.0000	15.3830
Permeate Flow Rate (m3/h)	22.1629	21.0000	20.0000	21.0000
Permeate Concentration (mg/L)	594.3214	800.0000	901.4206	700.3871
Water Recovery Rate (%)	76.9545	72.9167	80.0000	84.0000
Salt Rejection Rate (%)	97.4493	96.5666	95.8650	96.7872
Operating Cost (CNY/day)	2264.5585	2151.8265	2088.4695	2058.0259

.

From an engineering perspective, the optimization strategy of the RSQP algorithm achieves an effective balance between energy consumption and water quality. In the optimization of Case 1, the system significantly improved product water quality and reduced operating costs by adjusting the feed pressure and booster pump pressure. Before optimization, the permeate concentration was 594.32 mg/L, which was below the target value of 800 mg/L, while the permeate flow rate was 22.16 m³/h, exceeding the minimum requirement of 21 m³/h. After optimization using the RSQP solver, the feed pressure increased from 36.87 bar to 40.31 bar, whereas the booster pump pressure was dramatically reduced from 35 bar to 15.18 bar. This redistribution of pressures optimized energy utilization efficiency. While the permeate flow rate was reduced to the critical value of 21 m³/h, the permeate concentration increased to 800 mg/L, still meeting the constraint requirements. Meanwhile, the water recovery rate decreased from 76.95% to 72.92%, indicating that the system sacrificed some recovery efficiency to satisfy the product water concentration target.

In Case 2, the optimization goal was more complex, requiring the permeate concentration to be reduced from 901.42 mg/L to below 800 mg/L, while increasing the permeate flow rate from 20 m³/h to 21 m³/h. After optimization, the system not only reduced the concentration to 700.39 mg/L, significantly outperforming the target limit, but also increased the flow rate to 21 m³/h, achieving both objectives. This improvement was achieved through a fine-tuning of the feed pressure, which decreased from 36.87 bar to 35.78 bar, and a significant reduction in booster pump pressure, from 36 bar to 15.38 bar. Combined with an adjustment in feedwater flow rate from 25 m³/h to 32.43 m³/h, system efficiency was markedly improved. The water recovery rate increased from 80% to 84%, and the salt rejection rate rose from 95.87% to 96.79%, demonstrating that the optimization strategy effectively enhanced resource utilization.

The comparative information of each cost item before and after optimization is shown in

Table 6. Changes in Cost Items Before and After Optimization.

Cost Item	Case 1			Case 2
	Before Optimization (CNY)	After Optimization (CNY)	Change (CNY)	Before Optimization (CNY)	After Optimization (CNY)	Change (CNY)
$O{C}_{CH}$	102.5965	106.9436	+4.3471	89.0595	105.1964	+16.1369
$O{C}_{IP}$	68.1035	70.9891	+2.8856	59.1176	69.8293	+10.7117
$O{C}_{EN}$	972.6862	854.5628	−118.1234	822.5446	763.6691	−58.8755
$O{C}_{ME}$	186.0822	186.0822	0	186.0822	186.0822	0
$O{C}_{MN}$	35.0900	33.2489	−1.8411	31.6656	33.2489	+1.5833
$O{C}_{LB}$	900.0000	900.0000	0	900.0000	900.0000	0
Total	2264.5585	2151.8265	−112.732	2088.4695	2058.0259	−30.4436

.

The comparison of each cost item before and after optimization is shown in Figure 18 and Figure 19.

From an economic perspective, the total operating cost of Case 1 decreased from CNY 2264.56 to CNY 2151.83, a reduction of CNY 112.73, or approximately 4.98%. This reduction was primarily due to a significant drop in the RO energy consumption cost $O{C}_{EN}$, which fell from CNY 972.69 to CNY 854.56, saving CNY 118.12. The main factor behind the energy savings was the reduction in booster pump pressure from 35 bar to 15.18 bar, greatly reducing the electricity consumption of the high-pressure pump. However, the chemical cost $O{C}_{CH}$ and intake energy cost $O{C}_{IP}$ increased by CNY 4.35 and CNY 2.89, respectively.

The chemical cost rose because the permeate concentration increased from 594 mg/L to 800 mg/L, requiring more chemicals to maintain water quality. The optimization also reduced equipment wear, slightly lowering maintenance costs $O{C}_{MN}$ by CNY 1.84. Other costs, such as membrane replacement and labor, remained stable, indicating that optimization did not affect long-term equipment investment or staffing needs.

In Case 2, the total operating cost decreased from CNY 2088.47 to CNY 2058.03, a reduction of CNY 30.44 or approximately 1.46%. The primary optimization again lies in reducing the RO energy consumption cost $O{C}_{EN}$, which dropped from CNY 822.54 to CNY 763.67, saving CNY 58.88. This was mainly achieved by lowering the booster pump pressure from 36 bar to 15.38 bar, combined with a slight adjustment of feed pressure from 36.87 bar to 35.78 bar, optimizing the energy distribution. However, the chemical cost $O{C}_{CH}$ increased significantly by CNY 16.14, due to the need to reduce permeate concentration from 901 mg/L to 700 mg/L, which required additional chemicals to enhance desalination.

The intake energy cost $O{C}_{IP}$ also rose by CNY 10.71, directly related to the increase in feed flow rate from 25 m³/h to 32.43 m³/h, leading to higher intake energy consumption. Maintenance costs $O{C}_{MN}$ increased slightly by CNY 1.58 because of the higher demand for equipment maintenance caused by increased flow rates. Membrane replacement and labor costs remained unchanged, indicating that the optimization strategy did not affect equipment lifespan or staffing structure.

Through comparison and analysis, the optimization strategy of the RSQP solver provides effective guidance for improving this RO system. The optimization results achieve a practical balance between energy consumption and water quality. In both cases, the optimization primarily focused on reducing RO energy consumption, achieving significant savings by adjusting booster pump pressure—approximately CNY 112 for Case 1 and CNY 30 for Case 2. However, meeting water quality requirements led to an increase in chemical costs, rising by about CNY 4 in Case 1 and CNY 16 in Case 2, becoming the main offsetting factor.

These results indicate that future efforts should focus on: 1. Improving chemical efficiency: Explore desalination technologies with lower chemical dependency or optimize chemical dosing strategies to control increases in $O{C}_{CH}$. 2. Balancing intake energy consumption: Coordinate flow and pressure optimization to minimize rises in $O{C}_{IP}$, for example, by using variable-frequency pumps to adjust intake flow rates. 3. Long-term equipment monitoring: Ensure that low-pressure operation modes do not negatively impact membrane lifespan, preventing hidden increases in $O{C}_{ME}$.

In summary, while ensuring permeate water quality, the RSQP solver’s operational optimization strategy improved the system’s economic efficiency, demonstrating its feasibility in this RO system.

5. Summary

This work targets large-scale nonlinear optimization and builds an efficient, stable solution framework centered on RSQP, validated end-to-end through theory, solver engineering, numerical tests, and an industrial application. The main contributions are:

(1)

Theory. We review NLP fundamentals and optimality conditions; present the core mechanics of SQP (quadratic approximation, constraint linearization, and QP subproblem formulation/solution); and introduce RSQP, which employs a column-reordering-based space decomposition to project the high-dimensional problem into a low-dimensional subspace, solving a reduced QP and markedly lowering computational cost.

(2)

Solver development. For high-dimensional/low-degrees-of-freedom problems in process industries, we integrate sparse-matrix storage/computation. A top-down modular architecture implements the column-reordering space-decomposition module. The numeric core is built in C++ with STL, Armadillo, and SuiteSparse, and exposes extensible interfaces for user-defined functions, improving usability and maintainability.

(3)

Numerical tests. On small-scale benchmarks (including non-convex/exponential cases) and variable-dimension tests, RSQP attains accuracy/stability comparable to commercial software; objective trajectories align closely. In variable-size tests, RSQP breaks dimensional limits, achieving notable speedups and ~65% memory reduction versus Fmincon; when variables increase from 64 k to 128 k, runtime rises by ~4.128× with iteration counts essentially stable. Under dynamic degrees of freedom, autonomous basis transformation cuts iterations by >50% and solves stably up to 6 k dimensions. Near-industrial tests show runtime growth at only ~⅓ of the theoretical rate, supporting applicability to 10 k-scale optimization.

(4)

Engineering application. For a high-salinity wastewater RO unit (single-stage, three-pass), we construct a rigorous mechanistic/economic model and formulate a large-scale NLP via a finite-difference simultaneous-equations approach, then optimize daily operating cost with RSQP. Two typical scenarios reduce product-water cost by 4.98% and 1.46% while satisfying all quality and equipment constraints, confirming feasibility and effectiveness in process-simulation settings.

Algorithmic characteristics. RSQP’s strengths lie in efficient basis transformation and reliable convergence: by reducing redundant searches, residuals remain below 1 × 10⁻⁸ under complex constraints, meeting engineering accuracy. Nonetheless, runtime still trails mainstream solvers, due to: (i) the high space–time complexity of SVD inflating basis-decision cost; (ii) repeated Armijo–Wolfe checks in line search increasing the burden of the L1 merit; and (iii) under-exploitation of Jacobian sparsity constraining linear-algebra efficiency. Hence, there is ample room for improvement: introduce fast SVD approximations or iteration-aware preconditioning to cut basis-decision cost; refine line-search strategy and merit evaluation to reduce condition checks; and strengthen sparse-matrix handling to streamline linear algebra. These upgrades are especially critical for time-sensitive engineering scenarios.

Future work. We will advance this line of research along three directions:

(1)

Broader comparisons. Conduct systematic evaluations against advanced SQP variants (e.g., interior-point SQP, filter SQP, stochastic SQP) on a unified platform, quantifying accuracy, efficiency, and robustness to ill-conditioning to delineate strengths and scope.

(2)

Performance and robustness. For million-variable problems, integrate GPU parallelism and distributed memory; embed trust-region and interior-point strategies; and develop adaptive regularization for stable Hessian updates on non-smooth/ill-conditioned models.

(3)

Cross-domain validation. Extend beyond high-salinity wastewater to petrochemical processes (e.g., FCC and ethylene pyrolysis) to validate generality on ultra-large-scale, strongly nonlinear problems and enhance engineering impact.

In summary, spanning theory, implementation, and application, this work provides an integrated solution for large-scale nonlinear optimization in process industries, with interim validation on a real project and a general simulation platform, offering a viable path toward efficient and stable solutions at extreme scales.