Newton Divided Difference Formula | Numerical Methods Full Tutorial

The Lagrange interpolation formula is constructed systematically by creating separate terms for each data point. For each term corresponding to (x_i, y_i): (1) the numerator is the product of (X - x_j) for all j ≠ i, omitting the current x_i; (2) the denominator is the product of (x_i - x_j) for all j ≠ i, also omitting the current x_i; (3) multiply the resulting fraction by y_i. This process is repeated for all data points from i=0 to i=n, and all terms are summed together to produce the final interpolated value at X.

Lagrange interpolation constructs a polynomial passing through given data points using basis functions L_i(x) = ∏(x-x_j)/(x_i-x_j) for j≠i, where each L_i(x) equals 1 at x_i and 0 at other x_j values. Newton interpolation uses divided differences to build the polynomial incrementally, with the choice between forward and backward formulas determined by whether the target x-value is closest to the first or last data point. Both methods enable finding polynomial functions that pass through specified (x,y) coordinate pairs, with Lagrange being more straightforward for small datasets while Newton's method offers computational advantages for larger datasets.

Lagrange interpolation is a mathematical technique that constructs a polynomial passing through a given set of n+1 distinct points (x₀,y₀), (x₁,y₁), ..., (xₙ,yₙ) by creating n+1 Lagrange basis polynomials lᵢ(x) = ∏ⱼ≠ᵢ[(x-xⱼ)/(xᵢ-xⱼ)], each of which equals 1 at its corresponding node xᵢ and 0 at all other nodes; the interpolating polynomial is then formed as P(x) = Σᵢ[yᵢ·lᵢ(x)], which guarantees P(xᵢ) = yᵢ for all i, and this polynomial is unique and of degree at most n.

Lagrange's interpolation formula is a polynomial method for finding the value of a function at a specific point given a set of data points (x_i, y_i). The formula is: f(x) = Σ [y_i * Π(x - x_j)/(x_i - x_j)] for j ≠ i, where the product runs over all points except i. This formula works by constructing a polynomial that passes through all given points, and the value at any x can be computed by substituting x into the formula. The formula is particularly useful when the x-values are not equally spaced, unlike Newton's interpolation method.

Lagrange interpolation has several advantages and disadvantages. Advantages include mathematical elegance—the formula is compact and theoretically beautiful, and it provides direct insight into how each data point contributes to the interpolating polynomial. However, disadvantages include computational inefficiency: each cardinal function must be computed separately and is different from others, requiring O(n²) operations for n points. Additionally, Lagrange interpolation lacks flexibility: adding a new data point requires recomputing all cardinal functions from scratch rather than building upon previous computations, unlike some other methods.

Cubic spline interpolation addresses the oscillation problem of high-degree polynomial interpolation by using piecewise cubic polynomials on subintervals. Unlike Lagrange interpolation with degree 20, which suffers from severe oscillation near endpoints, cubic splines maintain accuracy and stability. The method divides the main interval into smaller subintervals, fitting a separate cubic polynomial to each. Linear interpolation uses straight lines but creates discontinuities in the derivative at data points. A cubic spline is a piecewise cubic polynomial function defined on each subinterval, where each polynomial is different from its neighbors. The general form is S(x) = a + b(x - x_i) + c(x - x_i)² + d(x - x_i)³. For validity, the spline must satisfy interpolation conditions (S(x_i) = y_i), continuity conditions (C0, C1, C2) ensuring function values, first derivatives, and second derivatives match at interior points, and boundary conditions at endpoints. Natural boundary conditions set the second derivative to zero at both endpoints, while clamped boundary conditions specify the first derivative at endpoints. The error bound is |f(x) - S(x)| ≤ (M/384) * h^4, where M is the maximum absolute value of the fourth derivative of f on the interval, and h is the maximum subinterval length.

Cubic spline interpolation is a piecewise polynomial method for approximating functions or data points. Instead of using a single high-degree polynomial, which can cause oscillations (Runge phenomenon), splines use low-degree polynomials (degree ≤ 3) on each subinterval between support points. The resulting function is twice continuously differentiable (C²), meaning it has continuous first and second derivatives throughout the interval, producing smooth curves without corners or kinks. This approach is widely used in computer graphics for creating visually appealing curves.

Cubic spline interpolation constructs smooth piecewise cubic polynomials that pass through given data points. The method requires continuity of the first and second derivatives at internal knots, ensuring a smooth curve without oscillations that plague high-degree polynomial interpolation. The approach balances flexibility (passing through all points) with smoothness (continuous derivatives), making it superior to simple polynomial interpolation for approximating complex functions.

High-order polynomial interpolation (>3rd order) causes oscillation and unphysical behavior at boundaries. Cubic splines solve this by fitting separate cubic polynomials between each data point pair while ensuring smoothness. Each cubic has four coefficients requiring boundary conditions on slopes and derivatives. Python's scipy.interpolate.CubicSpline implements this by storing cubic polynomials between every point pair. The method provides stable, smooth interpolation without oscillation or unbounded values. Implementation involves importing CubicSpline, creating an instance with x and y data, then evaluating at desired points.

The MATLAB implementation uses nested loops to compute divided differences. The outer loop iterates through columns starting from the third column, while the inner loop processes rows. For each position (j,i), the value is computed as: table(j,i) = (table(j-1,i-1) - table(j-2,i-1)) / (x(j) - x(j-2)). The indices j-1 and j-2 reference the previous row and the row before that, while i-1 references the previous column. This algorithm efficiently fills the entire divided differences table.

The Python implementation constructs the divided difference table using nested loops. The first row (order 0) contains the original y values. For each subsequent order k, the divided differences are calculated using the recursive formula: f[x_i,...,x_{i+k}] = (f[x_{i+1},...,x_{i+k}] - f[x_i,...,x_{i+k-1}]) / (x_{i+k} - x_i). This formula calculates the divided difference of order k at point i by taking the difference between the divided difference of order k-1 at point i+1 and the divided difference of order k-1 at point i, then dividing by the difference in x values. The code demonstrates this with a test case using x values [1, 2, 3] and y values [-1, 1, -2], producing the expected divided differences.

The algorithm for constructing the divided differences table uses nested loops. The first column is initialized with y-values. For each column j from 2 to n, and for each row i from 1 to (n - j + 1), the value is computed as T[i,j] = (T[i+1, j-1] - T[i, j-1]) / (x[j+i-1] - x[i]). The Scilab implementation creates a function 'coeficientesNewton' that takes vectors x and y as inputs, initializes a matrix T of size n×n, sets the first column to y-values, and uses nested loops to compute all divided differences. The function returns the first row of T, which contains the coefficients b_0, b_1, ..., b_n.

Implementing the divided difference algorithm requires setting up a triangular table with x-values in the first column and y-values in the second. Compute each entry using f[xᵢ,xⱼ] = (f[xⱼ] - f[xᵢ])/(xⱼ - xᵢ). For higher-order divided differences, use the recursive formula f[x₀,x₁,...,xₖ] = [f[x₁,...,xₖ] - f[x₀,...,xₖ₋₁]]/(xₖ - x₀). The diagonal elements of this table contain the coefficients a₀ through aₙ for Newton's form. This algorithm can be implemented with two nested loops: one for columns and another for rows within each column.

For three points x_1, x_2, x_3, the divided differences are f(x_1, x_2) = [f(x_2) - f(x_1)] / (x_2 - x_1), f(x_2, x_3) = [f(x_3) - f(x_2)] / (x_3 - x_2), and f(x_1, x_2, x_3) = [f(x_2, x_3) - f(x_1, x_2)] / (x_3 - x_1). A key property is symmetry: f(x_1, ..., x_k) = f(x_{σ(1)}, ..., x_{σ(k)}) for any permutation σ. The instructor demonstrates a MATLAB function that computes the divided difference table and returns coefficients for the Newton form. The implementation uses nested loops following the recursive formula, with the top row containing coefficients a_0, a_1, ..., a_n.

Newton-Cotes formulas are derived by: (1) Approximating f(x) with its interpolating polynomial p_n(x) of degree ≤ n, (2) Integrating p_n(x) over [a,b], (3) Using the linearity of the integral to interchange summation and integration, (4) Computing the integral of each Lagrange basis polynomial to obtain the weights w_i. The resulting formula has the form: ∫f(x)dx ≈ Σf(x_i) × ∫L_i(x)dx, where L_i(x) are the Lagrange basis polynomials.

The Newton-Cotes method for numerical integration involves integrating interpolating polynomials to obtain formulas for approximating definite integrals. The process is the inverse of numerical differentiation: instead of differentiating polynomials, we integrate them. The simplest case uses a linear polynomial (degree 1), which leads to the trapezoidal rule.

The Newton-Cotes formula derives by dividing [a,b] into n sub-intervals of width h, changing variables to r via x=x₀+rh, then applying Newton's forward interpolation: f(x₀+rh) = y₀ + rΔy₀ + [r(r-1)/2!]Δ²y₀ + ... + [r(r-1)...(r-n+1)/(n-1)!]Δⁿ⁻¹y₀. Integration term-by-term yields ∫ₐᵇ f(x)dx ≈ nh[ y₀ + (1/2)Δy₀ + (1/6)Δ²y₀ + ... + (1/n!)Δⁿ⁻¹y₀ ]. Setting n=1 yields trapezoidal rule: ∫ₐᵇ f(x)dx ≈ (h/2)(y₀ + y₁). Setting n=2 yields Simpson's 1/3 rule: ∫ₐᵇ f(x)dx ≈ (h/3)(y₀ + 4y₁ + y₂), requiring even sub-intervals. Setting n=3 yields Simpson's 3/8 rule: ∫ₐᵇ f(x)dx ≈ (3h/8)(y₀ + 3y₁ + 3y₂ + y₃), requiring multiples of three sub-intervals.

Newton-Cotes formulas are constructed by: (1) Subdividing [a,b] into n equal subintervals with step size h = (b-a)/n; (2) Forming Lagrange interpolation polynomial pₙ(x) = Σₖ₌₀ⁿ f(xₖ)Lₖ(x); (3) Computing ∫ₐᵇ pₙ(x)dx = Σₖ₌₀ⁿ f(xₖ)∫ₐᵇ Lₖ(x)dx = Σₖ₌₀ⁿ aₖf(xₖ), where aₖ = ∫ₐᵇ Lₖ(x)dx are node-independent weights. This systematic approach transforms integration into linear combinations of function values, enabling derivation of specific formulas like trapezoidal and Simpson's rules through Lagrange basis function integration.

There is an equivalence between two approaches to deriving Newton-Cotes formulas: (1) Replacing the function with its interpolating polynomial and integrating exactly, and (2) Setting up a linear combination of function values at interpolation points that is exact for polynomials up to degree n. These two approaches are mathematically equivalent: if you start with the interpolating polynomial approach, you get a formula that is exact for quadratics; conversely, if you know a quadrature formula is exact for quadratics, the coefficients must equal the integrals of the Lagrange basis polynomials.