Goal Attainment — Control Systems/Optimization

Goal Attainment

Control Systems / Optimization

Brings m polynomials as close to their goals as the weights allow, their coefficients arriving on a port – MATLAB's fgoalattain, solved again on every sample:

minimize γ over x and γ   such that   F_i(x) − w_i·γ ≤ goal_i,   i = 1 … m

with F_i(x) = Σ_t c_i,t · x₁^e(t,1) · … · x_n^e(t,n). γ is the attainment factor: negative when every goal is beaten, positive when they cannot all be met, and the weights say how the shortfall is shared – objective i gives up w_i·γ against its goal. A weight of 0 makes that goal a hard constraint, F_i(x) ≤ goal_i, which is fgoalattain's own convention.

The exponents e are configuration – the problem's shape, which fixes the loop bounds every export unrolls. The m objectives share that ONE term dictionary, and their coefficients c are the signal: one column per objective, stacked into a single port. The goals and weights are configuration. The search is fgoalattain's own sequential quadratic programming method – a BFGS Hessian approximation, an active-set QP with its own feasibility phase, and a merit line search – with exact gradients, because a polynomial's gradient is another polynomial. It is the solver Minimax runs, at every goal 0 and every weight 1.

The factory setting is fgoalattain's documented example: F₁ = 2 + (x−3)² and F₂ = 5 + x²/4 over the terms [2; 1; 0] (x², x, 1) with coefficients [1; −6; 11; 0.25; 0; 5], goals [3; 6] and weights 1/3 and 1/6 – entered as [0.3333333333333333; 0.16666666666666666], because a setting is a number list and not an expression – from x = 1. Its answer is x = 2, where both goals are met exactly and γ = 0.

Ports

• c – the coefficients, a column [m·T,1]: rows 1..T are objective 1's, one per ROW of Term Exponents in the same order, rows T+1..2T objective 2's, and so on. A row vector is refused.
• x – the solution, [n,1] (n = the columns of Term Exponents).
• F(x) – every objective at x, [m,1].
• attainfactor – γ, a scalar [1,1] (fgoalattain's attainfactor).
• exitflag – a scalar [1,1], fgoalattain's own: 4 the search direction became smaller than twice Step Tolerance; 5 the predicted change in γ became smaller than Function Tolerance (both with the constraints met); 0 a limit below stopped the search; −2 no point was found where the constraints hold – which a hard goal (weight 0) that cannot be met produces. fgoalattain has no flag 1: its first-order test is switched off for this problem.

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, n is 1 to 4, and no term may total more than degree 4. The caps are the export's, not the search's – see Code export.
• Goal – the goals, one per objective: its length is m, from 1 to 6.
• Weight – the weights, the same length as Goal. Positive weights share an over- or under-attainment in proportion; MATLAB suggests |Goal| to make the shortfall relative (1 where a goal is 0), and a negative weight asks an objective to exceed its goal. 0 makes the goal a hard constraint.
• Start Point – x0, n entries. The search is LOCAL, so on a non-convex problem this chooses which solution is found.
• Step Tolerance – StepTolerance, positive; default 1e-6. The search stops with flag 4 once the largest entry of the QP step is below twice this.
• Function Tolerance – FunctionTolerance, positive; default 1e-6. The search stops with flag 5 once the step's predicted change in γ is below this.
• Constraint Tolerance – ConstraintTolerance, positive; default 1e-6: how far a goal constraint may be exceeded and still count as met.
• Maximum Iterations – MaxIterations, 1 to 2000, default 400, MATLAB's own.
• Maximum Function Evaluations – MaxFunctionEvaluations, 0 to 2000. 0 (the default) means MATLAB's own, 100·(n+1) – the +1 is γ, which fgoalattain counts as a variable.
• 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. Each prints the same description of the iteration that the simulation itself runs, so every target does the same arithmetic in the same order as the simulation. The goals and weights are printed into the code as literals.

The exponent pattern is unrolled once: each term's monomial and its n partial derivatives, shared by every objective. The iteration is emitted with fixed trip counts and flags that stop 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 QP 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 fgoalattain 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.
• ⚠ LOCAL. The method finds a point no small step improves; on a non-convex problem that can depend on Start Point.
• ⚠ If γ is unbounded below – every weighted objective can be driven down together – there is no answer, and the point reported is wherever the evaluation limit stopped the search (flag 0) or the line search gave up.
• eps has no spelling in nine of the ten targets, so MATLAB's eps and the constants built from it are the exact binary values here.