cyberangles blog

Program to Implement Simpson's 3/8 Rule

Numerical integration is a crucial technique in computational mathematics, used to approximate the definite integral of a function when an analytical solution is difficult or impossible to obtain. Simpson's 3/8 rule is one such numerical integration method. It provides a more accurate approximation compared to some simpler methods like the trapezoidal rule, especially for functions that can be well - approximated by cubic polynomials.

In this blog, we will explore the theory behind Simpson's 3/8 rule, how to implement it in a programming language, and provide some example usages.

2026-07

Table of Contents#

  1. Theory of Simpson's 3/8 Rule
  2. Mathematical Formula
  3. Algorithm for Implementing Simpson's 3/8 Rule
  4. Python Implementation
  5. Example Usage
  6. Common Practices and Best Practices
  7. Conclusion
  8. References

1. Theory of Simpson's 3/8 Rule#

Simpson's 3/8 rule is based on approximating the function (y = f(x)) over an interval ([a,b]) by a cubic polynomial. The interval ([a,b]) is divided into sub - intervals, and for each set of three consecutive sub - intervals, the area under the curve is approximated using a cubic polynomial.

The basic idea is to fit a cubic polynomial (P(x)=Ax^{3}+Bx^{2}+Cx + D) to the function (y = f(x)) at four equally - spaced points (x_0,x_1,x_2,x_3) within a sub - interval. The integral of this cubic polynomial over the sub - interval ([x_0,x_3]) gives us the approximation formula for the area under the curve of (y = f(x)) over that sub - interval.

2. Mathematical Formula#

Let the interval ([a,b]) be divided into (n) sub - intervals of equal width (h=\frac{b - a}{n}), where (n) must be a multiple of 3.

The Simpson's 3/8 rule formula for approximating the definite integral (\int_{a}^{b}f(x)dx) is given by:

[ \int_{a}^{b}f(x)dx\approx\frac{3h}{8}\left[f(x_0)+3f(x_1)+3f(x_2)+2f(x_3)+3f(x_4)+3f(x_5)+2f(x_6)+\cdots + f(x_n)\right] ]

where (x_i=a + ih) for (i = 0,1,\cdots,n).

3. Algorithm for Implementing Simpson's 3/8 Rule#

  1. Input: The lower limit (a), upper limit (b), and the number of sub - intervals (n) (where (n) is a multiple of 3).
  2. Calculate the width: (h=\frac{b - a}{n}).
  3. Initialize the sum: (S = f(a)+f(b)).
  4. Loop through the sub - intervals:
    • For (i = 1) to (n - 1):
      • If (i) is divisible by 3, then (S=S + 2f(a+ih)).
      • Otherwise, (S=S + 3f(a+ih)).
  5. Calculate the integral approximation: (I=\frac{3h}{8}S).
  6. Output: Return the value of (I).

4. Python Implementation#

def f(x):
    # Example function, you can change it according to your needs
    return x**2
 
def simpsons_3_8_rule(a, b, n):
    if n % 3 != 0:
        raise ValueError("The number of sub - intervals n must be a multiple of 3.")
    h = (b - a) / n
    S = f(a) + f(b)
    for i in range(1, n):
        if i % 3 == 0:
            S = S + 2 * f(a + i * h)
        else:
            S = S + 3 * f(a + i * h)
    I = (3 * h / 8) * S
    return I

5. Example Usage#

# Define the limits and number of sub - intervals
a = 0
b = 1
n = 6
 
# Calculate the integral approximation
result = simpsons_3_8_rule(a, b, n)
print(f"The approximation of the integral is: {result}")

6. Common Practices and Best Practices#

Common Practices#

  • Choose an appropriate number of sub - intervals: A larger number of sub - intervals generally leads to a more accurate approximation. However, increasing the number of sub - intervals also increases the computational cost.
  • Check the input: Always check if the number of sub - intervals (n) is a multiple of 3, as required by Simpson's 3/8 rule.

Best Practices#

  • Error estimation: Use error estimation techniques to determine the accuracy of the approximation. For Simpson's 3/8 rule, the error is proportional to (h^4), where (h) is the width of the sub - intervals.
  • Function evaluation optimization: If the function (f(x)) is computationally expensive to evaluate, try to reduce the number of function evaluations by reusing previously calculated values.

7. Conclusion#

Simpson's 3/8 rule is a powerful numerical integration method that provides a good balance between accuracy and computational complexity. By following the algorithm and best practices outlined in this blog, you can effectively implement this rule in your programs to approximate definite integrals.

8. References#

  • Burden, R. L., & Faires, J. D. (2011). Numerical Analysis. Cengage Learning.
  • Press, W. H., Teukolsky, S. A., Vetterling, W. T., & Flannery, B. P. (2007). Numerical Recipes: The Art of Scientific Computing. Cambridge University Press.