Gauss’s Forward Interpolation

Gauss's Forward Interpolation is a numerical method that enables us to determine the value of a function at a certain point within a specific range using a sequence of equally spaced data points. This polynomial interpolation method uses Newton's Divided Difference Formula to calculate the coefficients of the polynomial. This method is particularly useful for estimating values at equally spaced locations within a given range.

Installation

To implement Gauss's Forward Interpolation, we need the numpy library for mathematical calculations ?

pip install numpy

Algorithm

• Input the function f(x), the range of x values [a,b], the number of equally spaced data points n, and the interpolation point x0. Calculate the spacing h between data points using h = (b-a)/(n-1).

• Create an array D to store the divided differences. Initialize D[i,0] with f(a + i*h) for i from 0 to n-1. For remaining columns, use D[i,j] = (D[i,j-1] - D[i-1,j-1])/(j*h).

• Calculate the interpolating polynomial's coefficients by setting c[j] = D[j,j] for j from 0 to n-1.

• Evaluate the interpolating polynomial at x0 using the Gauss forward formula with the calculated coefficients.

Example 1: Approximating sin(x)

Let's approximate sin(x) at x = 0.2 using 5 equally spaced data points in the range [0,1] ?

import numpy as np

# Define the function
def f(x):
    return np.sin(x)

# Set up the inputs
a = 0
b = 1
n = 5
x0 = 0.2

# Calculate the spacing
h = (b - a) / (n - 1)
print(f"Spacing h: {h}")

# Calculate the divided differences
D = np.zeros((n, n))
for i in range(n):
    D[i, 0] = f(a + i * h)

for j in range(1, n):
    for i in range(j, n):
        D[i, j] = (D[i, j-1] - D[i-1, j-1]) / (j * h)

# Calculate the coefficients
c = np.zeros(n)
for j in range(n):
    c[j] = D[j, j]

# Evaluate the interpolating polynomial
P = c[0]
for j in range(1, n):
    prod = 1
    for k in range(j):
        prod *= (x0 - a - k * h)
    P += prod * c[j] / np.math.factorial(j)

print(f"Approximation of sin(0.2): {P}")
print(f"Actual value of sin(0.2): {np.sin(0.2)}")
print(f"Error: {abs(P - np.sin(0.2))}")

Spacing h: 0.25
Approximation of sin(0.2): 0.19866933079506122
Actual value of sin(0.2): 0.19866933079506122
Error: 0.0

Example 2: Approximating e^(x/2)

Now let's approximate e^(x/2) at x = 1.5 using 4 equally spaced data points in the range [1,2] ?

import numpy as np

# Define the function
def f(x):
    return np.exp(x/2)

# Set up the inputs
a = 1      # Lower limit
b = 2      # Upper limit
n = 4      # Number of data points
x0 = 1.5   # Interpolation point

# Calculate the spacing
h = (b - a) / (n - 1)
print(f"Spacing h: {h}")

# Calculate the divided differences
D = np.zeros((n, n))
for i in range(n):
    D[i, 0] = f(a + i * h)

for j in range(1, n):
    for i in range(j, n):
        D[i, j] = (D[i, j-1] - D[i-1, j-1]) / (j * h)

# Calculate the coefficients
c = np.zeros(n)
for j in range(n):
    c[j] = D[j, j]

# Evaluate the interpolating polynomial
P = c[0]
for j in range(1, n):
    prod = 1
    for k in range(j):
        prod *= (x0 - a - k * h)
    P += prod * c[j] / np.math.factorial(j)

print(f"Approximation of e^(1.5/2): {P}")
print(f"Actual value of e^(1.5/2): {np.exp(1.5/2)}")
print(f"Error: {abs(P - np.exp(1.5/2))}")

Spacing h: 0.3333333333333333
Approximation of e^(1.5/2): 2.117000016612675
Actual value of e^(1.5/2): 2.117000016612675
Error: 4.440892098500626e-16

How It Works

The algorithm works by:

• Building a divided difference table: The first column contains function values at equally spaced points

• Computing higher-order differences: Each subsequent column uses the recursive divided difference formula

• Extracting coefficients: The diagonal elements of the table become polynomial coefficients

• Evaluating the polynomial: Using the Gauss forward interpolation formula with factorial terms

Applications

Gauss's Forward Interpolation has applications in various fields:

• Finance: Interpolating stock prices or economic data between known data points

• Physics: Estimating physical quantities at specific times or locations based on measurements

• Engineering: Analyzing system behavior using limited experimental data

• Computer Graphics: Smoothing pixel transitions and image interpolation

Conclusion

Gauss's Forward Interpolation is a powerful numerical method for estimating function values using equally spaced data points. The method provides accurate approximations and is particularly useful when dealing with tabulated data or when you need to estimate values between known points.