Curve Fitting and Interpolation

Analogy categoryAnalogies

Polynomial Fitting with polyfit and polyval

polyfit(x, y, n) fits an n-th degree polynomial to the data (x, y) using least-squares regression, returning a coefficient vector p ordered from the highest to lowest power, so p(1) is the coefficient of x^n and p(end) is the constant term. Once you have coefficients, polyval(p, xq) evaluates the fitted polynomial at new query points xq, which is essential for both plotting a smooth fitted curve over the original data and for extrapolating predictions beyond the sampled range (with the caveat that extrapolation accuracy degrades quickly for higher-degree polynomials). Choosing too high a degree n relative to the number of data points causes overfitting, where the curve wiggles to pass through noise rather than capturing the underlying trend — a classic bias-variance tradeoff that MATLAB will warn about via a poorly-conditioned polynomial warning when n approaches the number of unique x values.

🏏

Cricket analogy: polyfit finding the best-fit trend through noisy strike-rate data across an innings is like a commentator drawing a smooth momentum curve through a scatter of over-by-over run rates rather than connecting every jagged point.

matlab

x = [1 2 3 4 5 6 7];
y = [2.1 3.9 9.2 15.8 24.9 36.1 48.8];

p = polyfit(x, y, 2);          % fit a quadratic
xq = linspace(1, 7, 100);
yq = polyval(p, xq);

plot(x, y, 'ko', xq, yq, 'r-');
legend('Data', 'Quadratic fit');

The Curve Fitting Toolbox fit Function

For nonlinear or non-polynomial models — exponential decay, logistic growth, custom equations — the Curve Fitting Toolbox's fit(x, y, 'exp1') function fits a named model type (like 'exp1' for a*exp(b*x), or 'poly3' for a cubic polynomial) using nonlinear least squares, returning both a fit object and a gof (goodness-of-fit) struct containing statistics like rsquare and rmse. Custom model equations are supported via fittype('a*sin(b*x) + c'), which lets you fit arbitrary parametric forms beyond the built-in library, with optional 'StartPoint' values to help the nonlinear solver converge since a poor initial guess can cause it to settle on a local rather than global optimum. Unlike polyfit, which always finds the unique least-squares solution for a linear-in-parameters model, fit()'s nonlinear solvers are iterative and can fail to converge or converge to different local minima depending on the starting point.

🏏

Cricket analogy: Fitting 'exp1' to a bowler's declining pace over a long spell is like modeling fatigue as an exponential decay curve rather than forcing a straight-line fit that ignores the natural tapering shape.

Interpolation with interp1

interp1(x, y, xq, method) estimates y-values at new query points xq that lie between existing (x, y) samples, unlike curve fitting which finds an approximate model — interpolation passes exactly through every original data point. The method argument controls the interpolation scheme: 'linear' (the default) connects points with straight segments, 'spline' fits a smooth piecewise cubic that also matches first and second derivatives at each knot for a visually smoother curve, and 'nearest' simply returns the value of the closest known sample, useful for categorical or step-like data. Querying xq outside the range of the original x data returns NaN by default unless you specify an 'extrap' flag or a fixed extrapolation value, e.g. interp1(x, y, xq, 'linear', 'extrap'), and it's important to remember that spline extrapolation can behave wildly since cubic polynomials diverge quickly outside their fitted range.

🏏

Cricket analogy: interp1 estimating a fielder's exact position at an in-between timestamp from tracked GPS samples, passing exactly through the known points, is like a broadcast graphic smoothly animating a player's path between two tracked frames.

The key conceptual difference: curve fitting (polyfit, fit) finds an approximate model that may not pass through every data point and is meant to capture an underlying trend or reduce noise, while interpolation (interp1) always passes exactly through the given data points and is meant to estimate values between them.

Extrapolating with interp1('spline',...) or a high-degree polyfit beyond the range of the original data can produce wildly inaccurate or even nonsensical results, since both methods are only constrained by the data within the sampled range — always visually check extrapolated regions before trusting them.

polyfit(x,y,n) performs least-squares polynomial fitting; polyval evaluates the resulting polynomial at new points.
Too high a polynomial degree relative to the data leads to overfitting and numerically ill-conditioned fits.
fit() from the Curve Fitting Toolbox supports nonlinear and custom models via fittype, with a gof struct for fit quality.
Nonlinear fits are iterative and sensitive to 'StartPoint' initial guesses, which can affect convergence.
interp1(x,y,xq,method) estimates values between known points and always passes exactly through the original data.
'linear', 'spline', and 'nearest' are common interpolation methods with different smoothness tradeoffs.
Extrapolation outside the original data range is unreliable for both curve fitting and interpolation methods.