Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Gauss’s Forward Interpolation
Gauss's Forward Interpolation is a numerical method that enables us to ascertain the value of a function at a certain point within a specific range using a sequence of equally spaced data points. This method of polynomial interpolation uses Newton's Divided Difference Formula to calculate the coefficients of the polynomial. This method is particularly useful for estimating values for several equally spaced locations inside a given range. We'll examine the Python implementation method in this article.
Installation
To use Gauss' Forward Interpolation method, the numpy library can be installed via this command since we will be performing complex mathematical calculations.
pip install numpy
Algorithm
Let's start by inputting the function f(x), the range of x values [a,b], the number of equally spaced data points n, and the point at which we want to approximate the function value x0. We need to determine the spacing h between data points first, which we can do by using the formula h = (b-a)/(n-1).
Next, we need to create an array D that will store the divided differences of f(x) at equally spaced points. To do this, we can assign D[i,0] with f(a + (i-1)h) for I ranging from 1 to n, which will help us compute the major section of D. For the excess sections of D, we can use the formula D[i,j] = (D[i,j-1] - D[i-1,j-1])/(jh), where i runs from j+1 to n and j ranges from 1 to n-1.
The interpolating polynomial's coefficients can be determined once the divided differences of f(x) at equally spaced points fill our array D.
Finally, we can use the formula P(x0) = c[1] + (x0 - a)c[2] + (x0 - a)(x0 - a - h)c[3]/2 +... to evaluate the interpolating polynomial at x0 (x0). This can be accomplished by setting c[j] equal to D[j,j] for j ranging from 1 to n.
Example
Approximating the function 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)
# 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("Approximation of sin(0.2): ", P)
Output
Approximation of sin(0.2): 0.20824045983077355
The function f(x) is defined to calculate sin(x).
a, b, n, and x0 are initialized as input values.
The spacing h is calculated as (b - a)/(n - 1).
The divided differences D are calculated by filling the first column with the function values at evenly spaced points, and then the rest of the columns using the formula (D[i,j-1] - D[i-1,j-1])/(j*h).
The coefficients c are calculated by taking the diagonal of the divided differences matrix.
The interpolating polynomial is evaluated using the coefficients c and the input value x0. The prod variable is used to calculate the product of (x0 - a - k*h) for the required values of k. Finally, the P variable is updated using this product and the coefficients.
The output of this code is the approximation of sin(0.2). The implementation can be modified for different input values and functions.
2. Approximating the function 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 # data pts count
x0 = 1.5 # Interpolation point
# Calculate the spacing
h = (b - a)/(n - 1)
# Calculate the divided differences
D = np.zeros((n,n)) # Initialize divided differences matrix
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 = prod * (x0 - a - k*h)
P += prod*c[j]/np.math.factorial(j)
# Print the result
print("Approximation of e^(1.5/2): ", P)
Output
Approximation of e^(1.5/2): 2.1073059306325783
Applications
Gauss' Forward Addition technique can be utilized in various fields like money, material science, designing, and PC illustrations. For instance, it very well may be utilized to introduce monetary information, like stock costs, to gauge future qualities. It can be used to estimate a physical quantity's value at a specific time or location in physics. It can be used in engineering to estimate the behavior of a complicated system, like an aircraft, based on a small amount of data. In visualizations, it very well may be utilized to add the variety or power of pixels in a picture to make a smooth progress between neighboring pixels.
Conclusion
The numerical Gauss's Forward Interpolation method, which interpolates a function using a series of evenly spaced data points, was covered in this article. We thoroughly discussed the technique and included several Python implementation examples. The use of Gauss' Forward Interpolation technique in many domains was also covered. Overall, Gauss' Forward Interpolation approach may be applied in a number of real-world scenarios and is a valuable tool for approximating functions.
830 Views
