simpson rule calculator

Guri Bee

2 min read

·

20-10-2024

1

0

Share

Simpson's Rule: A Powerful Tool for Approximating Integrals

Simpson's rule is a numerical method for approximating definite integrals. It is more accurate than the midpoint rule and trapezoidal rule, especially when the function being integrated is smooth and has a high degree of curvature. This article will explore the fundamentals of Simpson's rule, delve into its practical applications, and showcase a Python implementation for calculating approximations.

Understanding the Foundation:

Simpson's rule derives its accuracy by approximating the function with a parabolic curve. This differs from the trapezoidal rule, which uses straight line segments, and the midpoint rule, which uses rectangles.

How does it work?

1. Divide and Conquer: Divide the interval of integration into an even number of subintervals.

2. Parabola Approximation: Approximate the function within each pair of subintervals with a parabolic curve that passes through the function's values at the endpoints and the midpoint of the pair.

3. Summation and Scaling: Calculate the area under each parabolic segment and sum them up. This sum, multiplied by a scaling factor, gives the approximation of the integral.

The Formula:

∫(a to b) f(x) dx ≈ (h/3) [f(a) + 4f(a + h) + 2f(a + 2h) + 4f(a + 3h) + ... + 2f(b - 2h) + 4f(b - h) + f(b)]

Where:

• h = (b - a) / n (width of each subinterval)
• n = number of subintervals (must be even)

Example:

Let's approximate the integral of the function f(x) = x^2 from 0 to 2 using Simpson's rule with n = 4.

1. Calculate h: h = (2 - 0)/4 = 0.5

2. Apply the formula:

∫(0 to 2) x^2 dx ≈ (0.5/3) [f(0) + 4f(0.5) + 2f(1) + 4f(1.5) + f(2)]
≈ (1/6) [0 + 4(0.25) + 2(1) + 4(2.25) + 4] 
≈ 2.6667

The actual value of the integral is 2.6667, demonstrating the accuracy of Simpson's rule.

Python Implementation:

The following Python code demonstrates how to implement Simpson's rule:

import numpy as np

def simpsons_rule(f, a, b, n):
  """Calculates the approximation of the integral of f(x) from a to b using Simpson's rule.

  Args:
    f: The function to integrate.
    a: The lower limit of integration.
    b: The upper limit of integration.
    n: The number of subintervals (must be even).

  Returns:
    The approximation of the integral.
  """
  h = (b - a) / n
  x = np.linspace(a, b, n + 1)
  y = f(x)
  return (h / 3) * (y[0] + 4 * np.sum(y[1:n:2]) + 2 * np.sum(y[2:n:2]) + y[n])

# Example usage:
def f(x):
  return x**2

a = 0
b = 2
n = 4
result = simpsons_rule(f, a, b, n)
print("Approximation:", result)

This code defines a simpsons_rule function that takes the function, integration limits, and the number of subintervals as input. It then implements the Simpson's rule formula using NumPy for efficient array operations.

Conclusion:

Simpson's rule provides a powerful and accurate method for approximating definite integrals. Its ability to utilize parabolic curves yields more precise results compared to simpler methods like the trapezoidal rule. This makes it a valuable tool in various fields, including physics, engineering, and finance, where integral calculations are often required. The Python implementation showcased here provides a readily accessible and efficient way to apply Simpson's rule to diverse real-world problems.

Note: This article is based on the principles and examples provided in various GitHub repositories and online resources related to Simpson's rule.