Solvers and applications of second-order cone programming

Abstract

This invention provides a solver for second-order cone programming. The solver comprises an input module, a solution module, and an output module. The solution module incorporates a solution method for second-order cone programming specific to rocket trajectory planning. This solver accelerates convergence by fully utilizing the sparsity of the problem through coefficient matrix sparsity. It also includes a warm-start module, which further accelerates convergence by leveraging the correlation between subproblems for practical applications requiring sequential convexity, such as rocket trajectory planning. Furthermore, the program running on domestically produced equipment such as rocket-borne processors is entirely independently developed; only during preprocessing on general-purpose equipment does it utilize the computational results from open-source software.

Description

Technical Field

[0001] This invention relates to solvers, and more particularly to a second-order cone programming solver. Background Technology

[0002] Second-order cone programming (SOCP) is a class of convex optimization problems with wide applications in automatic control, industrial product design, and quantitative finance. Rocket trajectory planning problems are often transformed into SOCP problems for solution, requiring strong real-time performance. However, onboard processing is constrained by power, heat dissipation, size, and weight, resulting in generally weaker performance and a significant real-time performance conflict. Especially when considering nonlinear aerodynamics, it requires sequential convexification into a series of SOCP problems, significantly increasing the computational load compared to when aerodynamics are not considered, posing an even greater challenge. Efficiently solving SOCP problems is a key challenge in real-time rocket trajectory planning.

[0003] To efficiently solve second-order cone programming problems (PDGs), the University of Washington, JPL Laboratory, and other institutions developed the efficient solver BSOCP. This solver can utilize existing onboard equipment to solve trajectory planning problems without considering aerodynamics within a feasible timeframe and has successfully completed multiple flight tests. This solver addresses the specific structure linear equations problem, which constitutes the majority of the computational load in SOCP, by automatically generating code during the preprocessing stage. This simplifies the program logic and avoids complex operand address calculations on the onboard equipment, significantly improving computational efficiency compared to existing solvers. However, numerical experiments show that for PDGs with aerodynamics, the number of non-zero elements in the coefficient matrix increases dramatically when solving the linear equations using the BSOCP algorithm, leading to a significant decrease in computational efficiency. Furthermore, BSOCP is neither open-source nor currently available commercially. Among currently available solvers, ECOS has the highest efficiency for trajectory planning problems, lower than BSOCP without aerodynamics, but expected to be higher than BSOCP with aerodynamics. Neither BSOCP nor ECOS supports warm starts; each SOCP problem can only be solved using default initial values. This prevents the use of solutions to earlier subproblems to accelerate convergence in applications such as sequential convexity. Further improvements are needed to meet real-time requirements. Other commercial solvers capable of solving SOCP problems include Coneprog and Seduci.

[0004] Developing an efficient SOCP solver that fully utilizes the sparsity of the problem for acceleration, and leveraging the correlation between subproblems to accelerate convergence in applications such as sequential convexization, as well as achieving autonomous controllability, is of great value. Summary of the Invention

[0005] To address the aforementioned technical problems, this invention provides a second-order cone programming solution method that fully utilizes the sparsity of the problem for acceleration, enabling faster convergence in applications such as sequential convexization by leveraging the correlation between subproblems.

[0006] To achieve the above objectives, the technical solution adopted by the present invention is as follows:

[0007] The present invention provides a solver for second-order cone programming, comprising an input module for input, a solution module for solving, and an output module for outputting the optimal solution;

[0008] The input module is used to input the error threshold ε, initial value (x0, y0, s0, τ0, κ0), and problem parameters A, b, c, K; the solution module includes a solution method for second-order cone programming for rocket trajectory planning; the output module is used to output the optimal solution (x * ,y * ,s * ,τ * ,κ * );

[0009] The solution method for the second-order cone programming for rocket trajectory planning includes:

[0010] Initialize (x,y,s,τ,κ) such that (x,y,s,τ,κ)=(x0,y0,s0,τ0,κ0);

[0011] Prediction step: ν,E xs E κτ Set all values ​​to 0, solve the system of linear equations; calculate the step size scaling factor α; update the error term E. xs E κτ and the central parameter ν;

[0012] Calibration step: ν,E xs E κτ The values ​​are all set to the calculation results of the estimated step, and the linear equation system is solved; the step size scaling factor is α; (x,y,s,τ,κ) is updated so that (x,y,s,τ,κ)=(x,y,s,τ,κ)+α(Δx,Δy,Δs,Δτ,Δκ);

[0013] Determine the updated (x,y,s,τ,κ) and if x T If s+κτ>ε, then repeat the prediction step and the correction step; otherwise (x * ,y * ,s * ,τ * ,κ * )=(x,y,s,τ,κ).

[0014] The present invention provides a solver for second-order cone programming, wherein preferably, the "solving of linear equations" specifically refers to:

[0015] The requirement is to solve the system of linear equations.

[0016]

[0017] Let the corresponding parts in the above formula be B0, v, l;

[0018] in,

[0019] For vectors Define arrow matrix

[0020] definition

[0021]

[0022] x (i) Represents the cone constraint of the i-th term;

[0023] For the i-th cone constraint, define

[0024] If it is a linear cone, G = 1, Q = 1; if it is a second-order cone, Q = diag(1, -1, ..., -1).

[0025]

[0026] Variables in a single cone constraint are scaled to

[0027] Connecting the variables in each cone constraint yields

[0028] Θ=diag(θ (1) ,…,θ (k) ),

[0029] remember

[0030] The method for solving a system of linear equations is as follows:

[0031] Because B0 is asymmetric, it is rewritten as follows for ease of solution:

[0032]

[0033] remember R and S are the corresponding parts.

[0034] First, solve the three systems of linear equations.

[0035] Then, calculate v = v0 - (v1, v2)(I + S) T (v1,v2)) -1 S T v0;

[0036] Here, R1 and R2 are two columns of R. R2 = (0,0,…,0,1) T ,according to The structure is such that v2 does not actually need to be calculated; it is v2 = (0,0,…,0,1). T ;I+S T (v1,v2) is a second-order matrix, and (I+S) can be calculated directly by solving a system of linear equations. T (v1,v2)) -1 S T v0.

[0037] The present invention provides a solver for second-order cone programming, preferably using the maximum Newton step size method to determine the step size scaling factor:

[0038] Based on the above predicted update direction and step size, the predicted complementary interval is:

[0039] g p =(x+αΔx) p ) T (s+αΔs p )+(κ+Δκ p )(τ+Δτ p );

[0040] The ratio of the estimated complementary gap to the original complementary gap is:

[0041]

[0042] The "update error term E" xs E κτ The central parameter ν = 1 - α is specifically:

[0043]

[0044] in, ν min This is the lower bound of ν; ν min The default value is 0.1.

[0045] The present invention provides a solver for second-order cone programming, which further includes a hot-start module; the hot-start module includes a hot-start method;

[0046] The hot-start method includes: assigning values ​​to (x0, y0, s0, τ0, κ0) when starting the solver.

[0047]

[0048] in, This is the solution to the earlier SOCP problem; To find the minimum value for each element; ψ is to change all linear cone variables to 0, and the first term of the second-order cone variable is changed to the L2 norm of the vector formed by the remaining terms of the second-order cone, while other terms remain unchanged; η = max(1 / (||A ∞ +||b|| ∞ ),η0); The default value is η0 = 0.001.

[0049] This invention provides a solver for second-order cone programming, which, in the step of "solving three linear equations",... "Including:

[0050] right Perform preprocessing, record the positions of non-zero elements in the decomposition, and save them as a file;

[0051] Based on the saved file Perform LDL decomposition.

[0052] This invention provides a solver for second-order cone programming, used to solve the second-order cone programming problem transformed from rocket trajectory planning.

[0053] The above technical solution has the following advantages or beneficial effects:

[0054] The solver for second-order cone programming provided by this invention, by setting up an input module, a solution module, and an output module, incorporates a solution method for second-order cone programming for rocket trajectory planning into the solution module. This solver accelerates convergence by fully utilizing the sparsity of the problem through coefficient matrix sparsification; it also includes a warm-start module, which can further accelerate convergence by utilizing the correlation between subproblems for practical applications such as rocket trajectory planning that require sequential convexity. Furthermore, the program running on domestically produced equipment such as rocket-borne processors is entirely independently developed, and only the calculation results from open-source software are needed for preprocessing on general-purpose equipment. Attached Figure Description

[0055] The invention, its features, shape, and advantages will become more apparent from the following detailed description of non-limiting embodiments with reference to the accompanying drawings. Like reference numerals denote like parts throughout the drawings. The drawings are not intentionally drawn to scale; the focus is on illustrating the spirit of the invention.

[0056] Figure 1 This is a flowchart illustrating a solver for a second-order cone programming problem provided in Embodiment 1 of the present invention. Detailed Implementation

[0057] The present invention will be further described below with reference to the accompanying drawings and specific embodiments, but these are not intended to limit the scope of the invention.

[0058] Example 1:

[0059] The standard form of a second-order cone programming problem (SOCP) is defined as follows:

[0060]

[0061] in, Represents a linear cone, where l is the dimension of the linear cone; K S This represents a second-order cone, where m is the number of second-order cones;

[0062] linear cone and second-order cone K S The definitions are as follows:

[0063]

[0064] like Figure 1 As shown in Embodiment 1 of the present invention, a solver for second-order cone programming is characterized by comprising an input module for input, a solution module for solving, and an output module for outputting the optimal solution;

[0065] The input module is used to input the error threshold ε, initial value (x0, y0, s0, τ0, κ0), and problem parameters A, b, c, K; the solution module includes a solution method for second-order cone programming oriented towards rocket trajectory planning; the output module is used to output the optimal solution (x * ,y * ,s * ,τ * ,κ * );

[0066] The solution method for the second-order cone programming for rocket trajectory planning includes:

[0067] S101: Initialize (x,y,s,τ,κ) such that (x,y,s,τ,κ)=(x0,y0,s0,τ0,κ0);

[0068] S102: Prediction step: ν,E xs E κτ Set all values ​​to 0, solve the system of linear equations; calculate the step size scaling factor α; update the error term E. xs E κτ and the central parameter ν;

[0069] S103: Calibration step: ν, E xs E κτ The values ​​are all set to the calculation results of the estimated step, and the linear equation system is solved; the step size scaling factor α; (x,y,s,τ,κ) is updated so that

[0070] (x,y,s,τ,κ)=(x,y,s,τ,κ)+α(Δx,Δy,Δs,Δτ,Δκ);

[0071] S104: Determine the updated (x,y,s,τ,κ) and if x T If s+κτ>ε, then repeat the prediction step and the correction step; otherwise (x * ,y * ,s * ,τ * ,κ * )=(x,y,s,τ,κ).

[0072] The solver for second-order cone programming provided by this invention sets up an input module, a solution module, and an output module. The solution module incorporates a solution method for second-order cone programming oriented towards rocket trajectory planning, which fully utilizes the sparsity of the problem to accelerate convergence. In applications such as sequential convexization, it leverages the correlation between subproblems to accelerate convergence. For practical applications such as rocket trajectory planning, once the problem definition and scale are determined, its sparse structure is already determined. It is only necessary to generate a preprocessed result file externally for use during the solution process, without the need for preprocessing on domestically produced equipment such as rocket-borne processors.

[0073] In Embodiment 1 of the invention, "solving the system of linear equations" specifically refers to:

[0074] The requirement is to solve the system of linear equations.

[0075]

[0076] Let the corresponding parts in the above formula be B0, v, l;

[0077] in,

[0078] For vectors Define arrow matrix

[0079] definition

[0080]

[0081] x (i) Represents the cone constraint of the i-th term;

[0082] For the i-th cone constraint, define

[0083] If it is a linear cone, G = 1, Q = 1; if it is a second-order cone, Q = diag(1, -1, ..., -1).

[0084]

[0085] Variables in a single cone constraint are scaled to

[0086] Connecting the variables in each cone constraint yields

[0087] Θ=diag(θ (1) ,…,θ (k) ),

[0088] remember

[0089] The method for solving a system of linear equations is as follows:

[0090] Because B0 is asymmetric, it is rewritten as follows for ease of solution:

[0091]

[0092] remember R and S are the corresponding parts;

[0093] Solve the three linear equations.

[0094] Calculate v = v0 - (v1, v2)(I + S) T (v1,v2)) -1 S T v0;

[0095] Here, R1 and R2 are two columns of R. R2 = (0,0,…,0,1) T ,according to The structure is such that v2 does not actually need to be calculated; it is v2 = (0,0,…,0,1). T ;I+S T (v1,v2) is a second-order matrix, and (I+S) can be calculated directly by solving a system of linear equations. T (v1,v2)) -1 S T v0.

[0096] Solve the above For a system of equations with coefficient matrices, it is necessary to first... Perform LDL decomposition. In practical applications, the problem structure can usually be predetermined. To perform LDL decomposition quickly, it is necessary to pre-determine the problem structure. Preprocessing is performed to record the positions of non-zero elements in the decomposition and save them to a file. The preprocessing process requires the use of the open-source software AMD library to reduce the number of non-zero elements. The preprocessing results depend only on the sparse structure of the problem. In general, in practical applications, the sparse structure is determined once the problem size (such as the number of time steps) is determined. Therefore, when solving the SOCP problem, the pre-preprocessed result file can be used directly without further preprocessing, avoiding the computational cost of preprocessing, significantly improving computational efficiency, and eliminating the need for the open-source software AMD library. Except for the results requiring the use of the AMD library, all programs in this invention are independently developed. For sensitive applications that need to run on domestic processors, preprocessing can be performed on general-purpose devices for the potential problem size, eliminating the need for preprocessing on domestic processors. All programs to be run are independently developed.

[0097] This invention provides a solver for second-order cone programming, which uses the maximum Newton step size method to determine the step size scaling factor:

[0098] Based on the above predicted update direction and step size, the predicted complementary interval is:

[0099] g p =(x+αΔx) p ) T (s+αΔs p )+(κ+Δκ p )(τ+Δτ p );

[0100] The ratio of the estimated complementary gap to the original complementary gap is:

[0101]

[0102] The "update error term E" xs E κτ The central parameter ν = 1 - α is specifically:

[0103]

[0104] in, ν min This is the lower bound of ν; ν min The default value is 0.1.

[0105] In this embodiment, the coefficient matrix of the required solution is... Although the dimension is high, the number of non-zero elements is often relatively small. Especially in relatively complex applications such as PDG problems that consider aerodynamics, the number of non-zero elements in the coefficient matrix is ​​significantly lower than in traditional algorithms, which significantly reduces the computational load. Therefore, the coefficient matrix is ​​called the coefficient matrix. The construction process involves sparsifying the coefficient matrix.

[0106] In order to estimate the error term E xs E κτ The central parameter ν is determined, and the Mehrotra prediction correction is improved in this embodiment, specifically as follows:

[0107] Determine the step size scaling factor using the maximum Newton step size method:

[0108]

[0109] Based on the above predicted update direction and step size, the predicted complementary interval is:

[0110] g p =(x+αΔx) p ) T (s+αΔs p )+(κ+Δκ p )(τ+Δτ p );

[0111] The ratio of the estimated complementary gap to the original complementary gap is:

[0112]

[0113] Therefore, the step "update error term E" xs E κτ The central parameter ν = 1 - α is specifically:

[0114]

[0115] in,

[0116]

[0117] ν min This is the lower bound of ν; ν min The default value is 0.1. In applications such as sequential convexity transformation, when the parameters of the subproblem change little, the solutions to previously solved subproblems can be used as initial values ​​after processing, thereby giving the solver a smaller initial error and accelerating the solution process. Compared to other algorithms, the warm-start method of interior point methods is relatively difficult. If the previous solutions are close to the constraint boundaries, using them as initial values ​​often leads to subsequent iterations making it difficult to make effective progress and convergence being extremely slow. Therefore, it is necessary to adjust the components of the constraints that are close to the constraint boundaries. Therefore, this embodiment also includes a warm-start module; the warm-start module includes a warm-start method;

[0118] The warm-start method includes: assigning values ​​to (x0, y0, s0, τ0, κ0) when starting the solver.

[0119]

[0120] in, This is the solution to the earlier SOCP problem; To find the minimum value for each element; ψ is to change all linear cone variables to 0, and the first term of the second-order cone variable is changed to the L2 norm of the vector formed by the remaining terms of the second-order cone, while other terms remain unchanged; η = max(1 / (||A ∞ +||b|| ∞ ),η0); The default value is η0 = 0.001.

[0121] In summary, the embodiments of the present invention have the following beneficial effects: ① Acceleration is achieved by fully utilizing the sparsity of the problem. Firstly, by sparsifying the coefficient matrix, the number of non-zero elements in the coefficient matrix is ​​reduced when solving linear equation systems, thereby accelerating the LDL decomposition of the coefficient matrix. Secondly, by preprocessing and saving operand addresses, zero-element-related terms are avoided in LDL decomposition, and the determination of whether matrix elements are zero is also avoided, thus fully utilizing the sparsity of the coefficient matrix itself to achieve acceleration; ② The correction error is reduced by improving Mehrotra prediction correction, thereby accelerating convergence and reducing the number of iteration steps for each SOCP solution; ③ Hot start is supported, further reducing computational cost. In application scenarios such as sequential convexity or solving similar problems multiple times, the solutions of previous subproblems, after processing, can be used as initial values, thereby reducing the total number of iteration steps required for convergence.

[0122] For ease of explanation, the second-order cone programming solver provided in this embodiment of the invention is used to solve the rocket trajectory planning problem. In this embodiment, the main goal is to solve the rocket stage recovery powered descent guidance (PDG) problem under aerodynamic and nonlinear aerodynamic conditions. For ease of explanation, the second-order cone programming solver provided in this embodiment of the invention will be referred to as FSOCP below.

[0123] The problem requires the rocket stage to land precisely vertically at a predetermined landing point with a landing velocity of 0, while minimizing fuel consumption (i.e., maximizing the remaining fuel mass upon landing).

[0124] The parameters for the first stage of the rocket are set as shown in Table 1:

[0125]

[0126] Table 1. Rocket First Stage Parameter Settings

[0127] Note: Air density is calculated as ρ = ρ₀ exp(-c ρ r y Calculate the density variation coefficient c. ρ There is no precise value available, but in this embodiment, it is taken as 0.0001, which means that for every 1000m increase in altitude, the air density decreases to 90.48% of its original value.

[0128] When considering nonlinear aerodynamic forces, the aerodynamic parameters are shown in Table 2:

[0129] Mach number 0.2 0.3 0.5 1.0 drag coefficient Ca 0.32 0.32 0.51 0.53

[0130] Table 2 Aerodynamic parameters

[0131] The computing environment is a laptop with an R7 4800H CPU (base frequency 2.9GHz, maximum boost frequency 4.2GHz) and 16GB of memory. The program runs serially. Since preprocessing can be completed beforehand, rather than requiring initial conditions to start, the computation time for FSOCP and ECOS only includes the solution time, excluding preparation time. During sequence convexity transformation, the termination conditions are that the end position and velocity error are both less than 1m and 0.1m / s, respectively. The number of discrete time intervals is fixed at 30 (corresponding to 31 time grid points). The maximum number of subproblems to be solved is 30; if the maximum number of subproblems is reached and the convergence condition is still not met, the solution is considered a failure.

[0132] Each solver solves the PDG problem without aerodynamics and with nonlinear aerodynamics. The computation time for a single SOCP problem is shown in Table 3. For the case without aerodynamics, ECOS and FSOCP use an average of 1000 iterations, while other solvers use an average of 10 iterations. For the case with aerodynamics, the average values ​​in Table 4 are used. FSOCP(a) does not use coefficient matrix sparsification and improved Mehrotra correction, but instead uses a common algorithm. With aerodynamics, the maximum number of iterations for each SOCP problem solution by FSOCP is 50. CVX is based on the Sedumi solver.

[0133]

[0134] Table 3 Comparison of average computation time for a single SOCP run for each solver

[0135]

[0136] Table 4. Comparison of the number of subproblems solved, computation time, and remaining fuel at convergence for each method.

[0137] The above calculations show that FSOCP has the highest computational efficiency for solving single SOCP problems, both for PDG problems without aerodynamics and those considering aerodynamics. Because the PDG problem without aerodynamics has good sparsity, FSOCP's speedup compared to FSOCP(a) based on the traditional algorithm is not significant, but both are significantly faster than ECOS. ECOS's computational efficiency is also significantly higher than CVX and ConeProg. The SOCP problem with aerodynamics is transformed into a more complex constraint, and its sparsity is slightly worse than without aerodynamics. In this case, FSOCP(a) based on the traditional algorithm has 41,605 non-zero elements after coefficient matrix decomposition, resulting in low computational efficiency. Although still faster than CVX and ConeProg, it lags significantly behind ECOS. After introducing coefficient matrix sparsity in FSOCP, the number of non-zero elements after coefficient matrix decomposition is only 11,904, and the computational efficiency is significantly higher than ECOS, verifying the significant speedup brought by the improved FSOCP algorithm.

[0138] Table 4 compares the number of subproblems solved, computation time, and remaining fuel when FSOCP and ECOS reach convergence under different initial total flight times, considering nonlinear aerodynamic forces. When both use cold starts, FSOCP's computation time is only 24.7% of ECOS's, and the number of subproblems solved is roughly equivalent. Compared to cold starts, hot starts (supported only by FSOCP) further significantly reduce the total computational cost. Although the number of subproblems increases due to fewer iteration steps per subproblem, the total number of iteration steps decreases significantly. FSOCP's average computation time is only 13.0% of that of cold starts and only 3.2% of that of ECOS. Regarding remaining fuel mass, since the PDG problem under nonlinear aerodynamic forces is nonconvex, different methods may converge to different local optima. Based on the results in Table 4, FSOCP (hot start) significantly outperforms other methods in terms of remaining fuel, while FSOCP (cold start) and ECOS are roughly equivalent.

[0139] The above results verify that the FSOCP solver has higher computational efficiency than other solvers such as ECOS when solving SOCP problems, especially in sequential convexity applications, where it can further significantly improve computational efficiency through warm start.

[0140] Those skilled in the art should understand that variations can be implemented by combining existing technology and the above embodiments, and will not be elaborated here. Such variations do not affect the essence of the present invention, and will not be elaborated here.

[0141] The preferred embodiments of the present invention have been described above. It should be understood that the present invention is not limited to the specific embodiments described above, and the devices and structures not described in detail should be understood as being implemented in a manner common to the art; any possible variations and modifications made by those skilled in the art without departing from the technical solution of the present invention, or equivalent embodiments with equivalent changes, do not affect the essential content of the present invention. Therefore, any simple modifications, equivalent changes, and modifications made to the above embodiments based on the technical essence of the present invention without departing from the content of the technical solution of the present invention still fall within the protection scope of the technical solution of the present invention.

Claims

1. A solver for second-order cone programming, characterized in that, It includes an input module for input, a solution module for solving, and an output module for outputting the optimal solution; The input module is used to input the error threshold. initial value Problem parameters The solution module includes a solution method for second-order cone programming for rocket trajectory planning; the output module is used to output the optimal solution. ; The solution method for the second-order cone programming for rocket trajectory planning includes: right Perform initialization so that = ; Prediction step: , Set all values ​​to 0, solve the system of linear equations; calculate the step size scaling factor. Update error terms and center parameters ; Calibration step: , The values ​​are all set to the calculation results of the estimated step, and the linear equation system is solved; step size scaling factor ;right To update, = + ; For the updated Make a judgment, if If so, repeat the prediction and correction steps; otherwise... = ; It also includes a hot start module; the hot start module includes a hot start method; The hot start method includes: when starting the solver, ... Assign a value. ； in, This is the solution to the earlier SOCP problem; Find the minimum value for each element; To change all linear cone variables to 0, the first term of the second-order cone variable is changed to the L2 norm of the vector formed by the remaining terms of the second-order cone, while the other terms remain unchanged; ; default value is =0.

001.

2. The solver for second-order cone programming as described in claim 1, characterized in that, The "solving of the system of linear equations" specifically refers to: The requirement is to solve the system of linear equations. ； Let the corresponding part in the above formula be... ; in, ; For vectors Define the arrow matrix ; definition ; ； Represents the cone constraint of the i-th term; For the i-th cone constraint, define If it is a linear cone If it is a second-order cone , ; ; Variables in a single cone constraint are scaled to ; Connecting the variables in each cone constraint yields ; ； remember ; The method for solving a system of linear equations is as follows: because Asymmetric, for ease of solution, it is rewritten as remember For the corresponding part; First, solve the three systems of linear equations. ; Then, calculate ; in, for Two columns; ,according to The structure, In practice, no calculation is needed, for ; Since it is a second-order matrix, it can be directly calculated by solving a system of linear equations. .

3. The solver for second-order cone programming as described in claim 1, characterized in that, Determine the step size scaling factor using the maximum Newton step size method: ; Based on the predicted update direction and step size, the predicted complementary interval is: ； The ratio of the estimated complementary gap to the original complementary gap is: ； The "update error term" and center parameters Specifically: ； in, ; for The lower bound; The default value is 0.

1.

4. The solver for second-order cone programming as described in claim 2, characterized in that, The above refers to "solving three systems of linear equations". "Including: right Perform preprocessing, record the positions of non-zero elements in the decomposition, and save them as a file; Based on the saved file Perform LDL decomposition.

Images