Power Fit — Control Systems/Curve Fitting

Power Fit

Control Systems / Curve Fitting

Fits a power law to the last W samples and emits its two parameters:

ŷ(x) = a·x^b

This is MATLAB's power1 library model, and the output carries a then b – coeffnames(fittype('power1'))'s own order. a is the fitted value at x = 1 and b is the exponent: the slope of the curve on log-log axes, so b = 1 is a straight line through the origin, b = 2 a parabola and b = −1 an inverse law.

Ports

• u – the sampled signal being fitted. Scalar: one channel and its own window – see Notes.
• ab – the parameter column, [2, 1]: row 1 is a, row 2 is b. Its height is fixed and does not follow any setting.

Parameters

• Window Length – W, how many samples the fit sees. A whole number from 3 to 101. Two parameters need at least two points, and a third is the first that makes it a fit rather than an interpolation. Bounded above because the dot products are unrolled at export.
• Abscissa Start – x₀, where the oldest sample of the window sits on the fitted axis. A single strictly positive number. It has to be positive because x^b is not a real number for a negative x and a fractional b, and undefined at zero.
• Abscissa Step – h, the spacing between consecutive samples on that axis, so the newest sample sits at x₀ + (W−1)·h. A single positive number. Set the pair in the same units the power law is written in – seconds of elapsed time, metres of distance – and both parameters come out in those units.
• Ordinate Floor – the smallest ordinate the fit will consider. A single strictly positive number. A sample at or below it is treated as being at it, because a power law is strictly positive in y and a sampled signal is not: the logarithm has no answer at zero or below. Set it just under the smallest value the signal legitimately reaches; a floor far below that lets a single dropout dominate the fit, because in the log domain the distance from 0.001 to 1 is the same as the distance from 1 to 1000.
• 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.

The 2×W coefficient bank is structural and is inlined into the arithmetic at export time rather than exposed as a tunable parameter: it follows from the window length, the abscissa start and the abscissa step together, and changing any of them changes how many multiplies the core contains. Re-export after changing them. The floor is inlined as a constant beside its own logarithm.

A generated core carries exactly two transcendental calls per step – one ln of the incoming sample and one exp of the fitted intercept. Both are the model itself. The W logarithms of the abscissa, by contrast, never reach a core at all: they were taken once at export time to build the bank.

The three HDL targets are simulation-only real arithmetic, quantizing only at the port boundary: a logarithm and an exponential have no Q16.16 form. They additionally clamp the amplitude to the [0, 32767] that format can carry, which the seven software targets and this block's own simulation do not.

Simulink bridge

None (Support::None). Fitting a power law to a running window is a Curve Fitting Toolbox function (fit with the power1 model), and that toolbox ships no Simulink library at all, so there is no path a diagram could name. The bridge reports this block rather than dropping it silently, and it therefore has no parity testbench; code export verification still covers it across all ten languages.

Notes

• Stateful, and discrete by nature (setDiscreteOnlyBlock(true)): the window advances once per sample.
• ⚠ The abscissa runs forwards here and backwards on every other block of this family. Polynomial Fit, Fourier Fit, Gaussian Fit and Exponential Fit put the newest sample at x = 0 and the sample i steps back at x = −i·h. A power law has no value at zero and none below it, so this block's window is oldest at x₀ and increases towards the newest sample – an elapsed-time axis rather than a look-back one. Reading it the other way flips the sign of b.
• ⚠ The fit is done in the log-log domain and MATLAB's is not. ln y = ln a + b·ln x is an ordinary straight-line least squares whose design matrix is fixed by the configuration – which is what lets the whole solve happen once and every sample afterwards be two dot products. fit(x, y, 'power1') instead minimises the residual in y by iteration, weighting large ordinates more heavily, and no closed form produces its answer. The two agree only on data that lies exactly on a power law. Measured on the thirteen-sample window in this block's source banner, the log-log answer is a = 0.8932, b = −0.4355 and R2026a's power1 answers a = 1.0885, b = −0.3819 – 22 % and 12 % apart. If the y-residual objective is what you need, fit offline; this block is the one that runs in a generated core.
• ⚠ Only the two-parameter model is offered. MATLAB's power2, a·x^b + c, does not survive the logarithm – an added constant has no linear form in the log domain – so it would need an iterative solve every sample in ten backends. Subtract a known offset with a Bias block first if you have one.
• ⚠ The ordinate is floored, and the floor is part of the answer. Every sample at or below Ordinate Floor enters the fit as that floor, in all ten targets and in this block's own simulation alike. Flooring is not a convenience: VHDL's LOG asserts on a non-positive argument, which aborts a simulation rather than returning a bad number, so it has to exist somewhere and it exists in one place. The abscissa needs no such floor – it is positive by configuration, which is what Abscissa Start is checked for.
• One solve, then arithmetic. The 2×2 normal-equation system is solved once when the configuration loads; every sample afterwards is two fixed dot products over the window, plus the one logarithm and the one exponential.
• The window holds logarithms of the ordinate, and is prefilled at y = 1. The register stores ln y rather than y, so the logarithm is taken once per sample rather than W times; every backend zero-initializes its state, and zero in that register means ln y = 0. The first W−1 outputs of a run are therefore a startup transient, as they are on Detrend, Savitzky-Golay Filter, Polynomial Fit, Fourier Fit, Gaussian Fit and Exponential Fit.
• ⚠ Its output is NOT a polynomial, and Evaluate Fit cannot read it. Evaluate Fit, Fit Derivative and Fit Integral all speak coefficients in descending powers; these are the two parameters of a power law, and b is not required to be a whole number. Wiring this block into any of the three produces a number rather than an error, so the mistake is silent. To evaluate the fitted curve at some x, compute a·x^b with a Math Function in its pow mode.
• For growth in time rather than in a variable, use Exponential Fit. y = a·e^bx is the same straight line against x instead of ln x, and Exponential Fit is that block. The two are easy to confuse and are not interchangeable: a power law is straight on log-log axes and an exponential is straight on semi-log ones.
• Scalar only. One channel and its own history; wire one block per channel.
• No state space. Linear in ln y and not in y, so there is no A/B/C/D pair to seed and model reduction correctly declines to merge it.