Nonlinear System Solve — Control Systems/Optimization

Nonlinear System Solve

Control Systems / Optimization

Finds the x that makes n multivariate polynomials vanish together, their coefficients arriving on a port – MATLAB's fsolve at its default algorithm, the trust-region dogleg, solved again on every sample:

F_j(x) = Σ_t c_j,t · x₁^e(t,1) · … · x_n^e(t,n) = 0,   j = 1 … n

The system is square: as many equations as unknowns, which is the only shape fsolve's dogleg accepts. The exponents e are configuration – they are the system's shape, and shape fixes the loop bounds every export unrolls. The coefficients c are the signal, one column per equation over the same term dictionary, so the surface being rooted can change on every sample while its form does not.

The factory setting is a circle met by a parabola: x₁² + x₂² − 4 = 0 and x₁² − x₂ − 1 = 0 – the four terms [2 0; 0 2; 0 0; 0 1] against coefficients [1; 1; −4; 0; 1; 0; −1; −1] from [1; 1], whose root is (1.5175…, 1.3027…).

Ports

• c – the term coefficients of every equation, a single column [T·n, 1]: rows (j−1)·T+1 … j·T are equation j's, one per ROW of Term Exponents and in the same order. A row vector, or any other height, is refused – the block reads the column entry by entry, and a matrix port would be flattened one way by MATLAB and the other by Python.
• x – the root, [n,1], one entry per variable (n = the columns of Term Exponents).
• F(x) – the equations there, [n,1]. At a root these are zero; when the search stops short they are what it stopped at, which is why the port exists.
• exitflag – a scalar [1,1], fsolve's own numbers: 1 the first-order measure fell below Optimality Tolerance, 2 the step got too small to matter, 3 the residual stopped changing, −2 it converged to a point that is not a root, −3 the trust region collapsed, 0 a limit below stopped it first.

Parameters

• Options – empty (default), or the path of a Solver Options block (Home/Solver Options), MATLAB’s options argument: for the run, every option it sets replaces this block’s parameter of the same name; one it leaves at default, or one this block does not have, changes nothing.
• Term Exponents – a [T,n] matrix of whole numbers from 0 to 4: row t, column i is the power of x_i in term t. T is 1 to 8 terms, n is 1 to 4 variables, and no single term may total more than degree 4. Those three caps are the export's, not the solver's – see Code export.
• Start Point – x0, fsolve's second argument, a vector of n entries. The search is LOCAL: a square polynomial system generally has several roots, and this parameter chooses which one is reported.
• Optimality Tolerance – fsolve's OptimalityTolerance (TolFun), positive; default 1e-6. The largest entry of J′F must fall below it, on a step that was accepted.
• Function Tolerance – FunctionTolerance (TolFunValue), positive; default 1e-6. It does two jobs, both MATLAB's: it is the residual test that ends the search with flag 3, and its square root is the bar a stopped point must clear to be called a root at all – above it the flag becomes −2.
• Step Tolerance – StepTolerance (TolX), positive; default 1e-6. Its SQUARE is what the relative step is compared against, as trustnleqn does.
• Maximum Iterations – MaxIterations, 1 to 2000, default 400, which is MATLAB's own.
• Maximum Function Evaluations – MaxFunctionEvaluations, 0 to 2000. 0 means automatic and resolves to MATLAB's default for this algorithm, 100·n. Whichever limit binds first stops the search and the exit flag is 0.
• Sampling Time (s) – zero or less inherits the solver's rate; a positive value runs the block at that period.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text, printed from one description of the iteration, so every target does the same arithmetic in the same order as the simulation – including the three summation orders below, which are association orders and nothing else.

The exponent pattern is unrolled, for F and for every entry of the Jacobian: a power becomes repeated multiplication, because no target can take a loop bound out of a real array. The body holds two copies of that (one before the loop, one inside it), which is why T, n and the degree are capped where they are – Java refuses a method over 64 KB. The main loop is emitted with a fixed trip count (Maximum Iterations) and a flag that stops the arithmetic once the answer is found, because none of the ten has an unbounded loop a hardware target could also carry.

⚠ The three HDL targets run the search in simulation-only real arithmetic, quantizing only at the port boundaries: a dogleg step divides and compares across many orders of magnitude, which a Q16.16 datapath does not carry.

Simulink bridge

None (Support::None). The Optimization Toolbox ships no Simulink library at all and fsolve is a MATLAB function, so there is no block to map onto; the bridge reports this block rather than dropping it silently, and it has no parity testbench. Code export verification still covers it across all ten languages.

Notes

• Stateless: the search restarts from Start Point on every sample, so the answer depends only on the coefficients present at that step, exactly as its four neighbours in this family do.
• ⚠ The Jacobian used after a REJECTED step is the rejected point's. That is what trustnleqn does – it evaluates F and J together at every trial point and only puts F back when the step is accepted – and it is transcribed rather than corrected, because correcting it is a different solver.
• ⚠ LOCAL, and a square polynomial system has several roots. A different Start Point gives a different one; that is the method, not a defect.
• ⚠ A stopped point is not always a root. When the residual is above the square root of Function Tolerance the flag is −2 and F(x) says how far off it is. Every port still carries a number on every sample, which a block must do and fsolve need not.
• The Gauss-Newton step is an LU factorization with partial pivoting of the Jacobian. An exactly singular Jacobian is not an error: the step falls back to the Cauchy point, which is what MATLAB's non-finite test does with the Inf that \ returns there.