Fitting data to a 3rd degree polynomial

I'm currently writing a C++ program where I have vectors of independent and dependent data that I would like to fit to a cubic function. However, I'm having trouble generating a polynomial that can fit my data.

Part of the problem is that I can't use various numerical packages, such as GSL (long story); it's possible that it might even be overkill for my case. I don't need a very generalized solution for least squares fitting. I specifically want to fit my data to a cubic function. I do have access to Sony's vector library, which supports 4x4 matrices and can calculate their inverses, among other things.

While prototyping this i开发者_JAVA技巧n Scilab, I used a function like:

function p = polyfit(x, y, n)
    m = length(x);
    aa = zeros(m, n+1)
    aa(:,1) = ones(m,1)
    for k = 2:n+1
        aa(:,k) = x.^(k-1)
    end
    p = aa\y
endfunction

Unfortunately, this doesn't map well to my current environment. The above example needs to support a matrix of M x N+1 dimensions. In my case, that's M x 4, where M depends on how much sample data that I have. There's also the problem of left division. I would need a matrix library that supported the inverse of matrices of arbitrary dimensions.

Is there an algorithm for least squares where I can avoid having to calculate aa\y, or at least limit it to a 4x4 matrix? I suppose that I'm trying to rewrite the above algorithm into a simpler case that works for fitting to a cubic polynomial. I'm not looking for a code solution, but if someone can point me in the right direction, I'd appreciate it.

Here is the page I am working from, although that page itself doesn't address your question directly. The summary of my answer would be:

If you can't work with Nx4 matrices directly, then do those matrix computations "manually" until you have the problem down to something that has only 4x4 or smaller matrices. In this answer I'll outline how to do the specific matrix computations you need "manually."

--

Let's suppose you have a bunch of data points (x1,y1)...(xn,yn) and you are looking for the cubic equation y = ax^3 + bx^2 + cx + d that fits those points best.

Then following the link above, you'd write this equation:

I'll write A, x, and B for those matrices. Then following my link above, you'd like to multiply by the transpose of A, which will give you the 4x4 matrix A^T*A that you can invert. In equations, the following is the plan:

A * x = B .................... [what we started with]

(A^T * A) * x = A^T * B ..... [multiply by A^T]

x = (A^T * A)^-1 * A^T * B ... [multiply by the inverse of A^T * A]

You said you are happy with inverting 4x4 matrices, so if we can code a way to get at these matrices without actually using matrix objects, we should be okay.

So, here is a method, although it might be a little bit too much like making your own matrix library for your taste. :)

• Write an explicit equation for each of the 16 entries of the 4x4 matrix. The (i,j)th entry (I'm starting with (0,0)) is given by x₁ⁱ * x₁^j + x₂ⁱ * x₂^j + ... + x_Nⁱ * x_N^j.

• Invert that 4x4 matrix using your matrix library. That is (A^T * A)^-1.

• Now all we need is A^T * B, which is a 4x1 matrix. The ith entry of it is given by x₁ⁱ * y₁ + x₂ⁱ * y₂ + ... + x_Nⁱ * y_N.

• Multiply our hand-created 4x4 matrix (A^T * A)^-1 by our hand-created 4x1 matrix A^T * B to get the 4x1 matrix of least-squares coefficients for your cubic.

Good luck!

Yes, we can limit the problem to computing with "a 4x4 matrix". The least squares fit of a cubic, even for M data points, only requires the solution of four linear equations in four unknowns. Assuming all the x-coordinates are distinct the coefficient matrix is invertible, so in principle the system can be solved by inverting the coefficient matrix. We assume that M is more than 4, as would typically be the case for least squares fits.

Here's a write-up for Maple, Fitting a cubic to data, that hides almost completely the details of what is being solved. The first-order minimum criteria (first derivatives with respect to coefficients as parameters of sum of squares error) gets us the four linear equations, often called the normal equations.

You can "assemble" these four equations in code, then apply your matrix inverse or a more sophisticated solution strategy. Obviously you need to have the data points stored in some form. One possibility is two linear arrays, one for the x-coordinates and one for the y-coordinates, both of length M the number of data points.

NB: I'm going to discuss this matrix assembly in terms of 1-based array subscripts. The polynomial coefficients are actually one application where 0-based array subscripts make things cleaner and simpler, but rewriting it in C or any other language that favors 0-based subscripts is left as an exercise for the reader.

The linear system of normal equations is most easily expressed in matrix form by referring to an Mx4 array A whose entries are powers of x-coordinate data:

A(i,j) = x-coordinate of ith data point raised to power j-1

Let A' denote the transpose of A, so that A'A is a 4x4 matrix.

If we let d be a column of length M containing the y-coordinates of data points (in the given order), then the system of normal equations is just this:

A'A u = A' d

where u = [p0,p1,p2,p3]' is the column of coefficients for the cubic polynomial with least squares fit:

P(x) = p0 + p1*x + p2*x^2 + p3*x^3

Your objections seem to center on a difficulty in storing and/or manipulating the Mx4 array A or its transpose. Therefore my answer will focus on how to assemble matrix A'A and column A'd without explicitly storing all of A at one time. In other words we will be doing the indicated matrix-matrix and matrix-vector multiplications implicitly to get a 4x4 system that you can solve:

C u = f

If you think about the entry C(i,j) being the product of the ith row of A' with the jth column of A, plus the fact that the ith row of A' is really just the transpose of the ith column of A, it should be clear that:

C(i,j) = SUM x^(i+j-2) over all data points

This is certainly one place where the exposition would be simplified by using 0-based subscripts!

It might make sense to accumulate the entries for matrix C, which depend only on the value of i+j, i.e. a so-called Hankel matrix, in a linear array of length 7 such that:

W(k) = SUM x^k over all data points

where k = 0,..,6. The 4x4 matrix C has a "striped" structure that means only these seven values appear. Looping over the list of x-coordinates of data points, you can accumulate the appropriate contributions of each power of each data point in the appropriate entry of W.

A similar strategy can be used to assemble the column f = A' d, namely to loop over the data points and accumulate the following four summations:

f(k) = SUM (x^k)*y over all data points

where k = 0,1,2,3. [Of course in the above sums the values x,y are the coordinates for a common data point.]

Caveats: This satisfies the goal of working only with a 4x4 matrix. However one typically tries to avoid the explicit formation of the matrix of coefficients for the normal equations because these matrices are often what in numerical analysis is called ill-conditioned. In particular the cases where x-coordinates are closely spaced can cause difficulty when one tries to solve the system by inverting the matrix of coefficients.

A more sophisticated approach to solving these normal equations would be the conjugate gradient method on the normal equations, which can be done with code that computes the matrix-vector products A u and A' v one entry at a time (using what we say above about entries of A).

The accuracy of the conjugate gradient method is often satisfactory because of its natural iterative approach, esp. when one can compute the required dot-products with a little extra precision.

You should never do full matrix inversion for stability reasons. Do LU decomposition and forward-back substitution. The other solutions are spot on otherwise.