Scalar Root Find — Control Systems/Optimization

Scalar Root Find

Control Systems / Optimization

Solves p(x) = 0 for a polynomial whose coefficients arrive on a port, inside a bracket [a, b] given in the configuration – MATLAB's fzero(@(z) polyval(c, z), [a b]), solved again on every sample:

p(x) = c₀·x^L−1 + c₁·x^L−2 + … + c_L−1, and x is the point in [a, b] where it crosses zero.

The iteration is Dekker's and Brent's: bisection, secant and inverse quadratic interpolation, each step whichever of the three is safe. It is fzero's own, so the answer is the same double MATLAB reports.

Ports

• c – the polynomial's coefficients in descending powers, a column [L,1] with L from 1 to 64 – the shape Polynomial Fit emits and Evaluate Fit reads, so a curve fitted every sample can be solved every sample. A row is refused, because the block reads the column entry by entry.
• x – the root, a scalar [1,1], always inside the bracket.
• f(x) – the polynomial AT that point, a scalar [1,1]. Near zero when the solve converged; it is the honest measure of how well.
• exitflag – a scalar [1,1] saying which of the outcomes below produced x.

Exit flag

• 1 – converged: |x − the bracket's remaining half| is within the tolerance.
• 0 – stopped at Maximum Iterations. x is the best point reached.
• −5 – converged to a point where |p| is LARGER than at both bracket ends, which is what a pole rather than a root looks like. fzero reports the same −5.
• −6 – p(a) and p(b) have the same sign, so the bracket holds no crossing this sample. x is the end where |p| is smaller and f(x) its value there.
• −3 – p(a) or p(b) is not finite (an infinity or a NaN arrived on c). Same rule for x as −6.

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.
• Bracket – the two ends [a b] as a 1×2 row, the second argument of fzero. They may be given in either order. A bracket is a configuration and not a port because it states where the answer is being looked for, which is a property of the diagram rather than of the sample.
• X Tolerance – optimset's TolX, positive. The default is eps = 2.220446049250313e−16, which is fzero's own default and asks for all the precision a double has.
• Maximum Iterations – how many function evaluations the main loop may make, 1 to 10000. Reaching it gives exit flag 0. fzero itself has NO limit; a generated core needs one, because a loop printed into ten languages must terminate in all of them. The default, 500, is far above what this iteration needs: over 1003 random polynomials the worst case was 74 evaluations and the median 8.
• 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. The bracket, the tolerance and the iteration limit are baked in at export time; the coefficients are a signal, so nothing about the polynomial is.

The loop is emitted with a fixed trip count – Maximum Iterations + 1 – 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 cost of a large limit is therefore paid in every target whether or not the samples need it.

The three HDL targets carry the iteration in real arithmetic and quantize only at the ports: simulation-only, not offered as synthesizable. Q16.16 resolves 1.5×10⁻⁵ and this block's whole business is a difference of two nearly equal numbers below that scale; a fixed-point root finder would stall at its own quantum.

Simulink bridge

None (Support::None). The Optimization Toolbox ships no Simulink library at all – measured, not assumed – so there is no block to map onto and no library path a diagram could name. fzero is a MATLAB function. The bridge reports this block rather than dropping it silently, and it therefore has no parity testbench; code export verification covers it across all ten languages.

Notes

• Algebraic and stateless: the whole solve happens inside one sample and nothing is carried to the next. That also means a bracket that stops holding a crossing does not fall back on the previous answer – it reports −6, and a diagram that must hold the last good root does it with a Switch and a Memory.
• The bracket is not searched for. fzero also accepts a single starting point and hunts outward for a sign change; that search is unbounded, so this block takes the bracket instead and reports −6 when it does not straddle a root.
• Cost is bounded and not constant: between 1 and Maximum Iterations polynomial evaluations per sample, each L − 1 multiply-adds.
• Verified against R2026a bit for bit – x, f(x), the exit flag, the iteration count and every intermediate iterate, over 1003 random polynomials and brackets. The source banner carries the measurement.
• No state space. The relation is nonlinear in the coefficients, so the block carries none and model reduction correctly reports it as unmergeable.