polyfit — Fit least-squares polynomials in MATLAB and RunMat.

polyfit(x, y, n) returns coefficients of an n-th degree least-squares polynomial fit. Coefficient ordering, centering/scaling outputs, and diagnostics follow MATLAB semantics.

Syntax

p = polyfit(X, Y, n)
p = polyfit(X, Y, n, weights)
[p, S] = polyfit(X, Y, n)
[p, S] = polyfit(X, Y, n, weights)
[p, S, mu] = polyfit(X, Y, n)
[p, S, mu] = polyfit(X, Y, n, weights)

Inputs

Returns

Returned values from polyfit depend on how many outputs the caller requests.

Errors

How polyfit works

• x and y must contain the same number of finite numeric elements. They can be row vectors, column vectors, or N-D arrays; RunMat flattens them column-major (MATLAB order).
• The optional fourth argument provides weights: polyfit(x, y, n, w) minimises ||sqrt(w) .* (y - polyval(p, x))||_2. All weights must be real, non-negative, and match the shape of x.
• polyfit applies centring and scaling to the independent variable for numerical stability. It returns the vector mu = [mean(x), std(x)], and the polynomial fits (x - mu(1)) / mu(2). Use polyval(p, x, [], mu) to evaluate with the same scaling.
• [p, S, mu] = polyfit(...) also returns S, a structure with fields R, df, and normr. These match MATLAB and are accepted directly by polyval for computing prediction intervals. S.R is the upper-triangular factor from the QR decomposition of the scaled Vandermonde matrix, S.df is the degrees of freedom (max(numel(x) - (n + 1), 0)), and S.normr is the 2-norm of the weighted residuals.
• RunMat mirrors MATLAB error messages for inconsistent dimensions, non-integer degrees, singular scaling, and invalid weights.

Does RunMat run polyfit on the GPU?

RunMat’s acceleration layer exposes a dedicated polyfit provider hook. The WGPU provider routes requests through this hook, gathers inputs to the host, executes the shared Householder QR solver, and returns MATLAB-compatible outputs while preserving residency metadata. Providers that have not implemented the hook yet fall back to the same host code path automatically, so results stay correct even when the inputs originated on the GPU.

Examples

Fitting a straight line through noisy samples

x = 0:5;
y = 2.5 * x + 1 + 0.05 * randn(size(x));
p = polyfit(x, y, 1)

Expected output:

p ≈ [2.5 1.0];   % slope and intercept recovered from noisy data

Computing a quadratic fit and reusing mu

x = -3:3;
y = x.^2 - 2 * x + 4;
[p, S, mu] = polyfit(x, y, 2);
smoothed = polyval(p, x, [], mu)

Expected output:

smoothed matches y exactly because the quadratic model fits perfectly.

Retrieving the structure S for prediction intervals

t = linspace(0, 2*pi, 25);
y = sin(t) + 0.1 * randn(size(t));
[p, S, mu] = polyfit(t, y, 3);
[fitted, delta] = polyval(p, t, S, mu)

Expected output:

delta contains the one-standard-deviation prediction interval for each fitted sample.

Weighted polynomial fit

x = linspace(-1, 1, 7);
y = [1.1 0.4 0.2 0.0 0.1 0.5 1.4];
w = [1 2 2 4 2 2 1];
p = polyfit(x, y, 2, w)

Expected output:

Central samples influence the fit more heavily, matching MATLAB's weighting semantics.

Using polyfit with gpuArray inputs

x = gpuArray.linspace(-2, 2, 50);
y = gpuArray((x - 0.5).^3);
p = polyfit(x, y, 3)

Expected output:

p is returned on the host today; convert it back to gpuArray if desired.

Complex-valued data with polyfit

x = 0:4;
y = exp(1i * x);
p = polyfit(x, y, 2)

Expected output:

p is complex-valued and matches MATLAB's complex least-squares solution.

Using polyfit with coding agents

Open a RunMat example with live inputs, then ask the agent to explain how polyfit changes the result.

FAQ

Related Math functions

Open-source implementation

Unlike proprietary runtimes, every RunMat function is open-source. Read exactly how polyfit is executed, line by line, in Rust.

• View the source for polyfit in Rust on GitHub
• Learn how the RunMat runtime works
• Found a bug? Open an issue with a minimal reproduction.

About RunMat

RunMat is an open-source runtime that executes MATLAB-syntax code blazing on any GPU. It is licensed under the Apache 2.0 license.

• RunMat automatically optimizes your math for GPU execution on Apple, Nvidia, and AMD hardware. No code changes needed. Simulations that took hours now take minutes.
• Start running code in seconds. RunMat runs in the browser, on the desktop, or from the CLI. No license server, no IT ticket.

Getting started · Benchmarks · Pricing