Trapezoidal Rule

By Rafael Mendoza Published June 6, 2023 Numerical Methods

Introduction to Numerical Integration

Numerical integration is a fundamental technique in engineering and applied mathematics used to approximate the definite integral of a function when analytical integration is difficult or impossible. Many real-world engineering problems involve functions that cannot be integrated analytically, such as experimental data points, empirical functions, or complex mathematical expressions. Numerical integration methods provide practical solutions to these challenges.

The basic principle behind numerical integration is to approximate the area under a curve by dividing it into simpler geometric shapes whose areas can be calculated easily. The most common methods include the Trapezoidal Rule, Simpson’s 1/3 Rule, and Simpson’s 3/8 Rule. Each method offers different levels of accuracy and computational complexity, making them suitable for various engineering applications.

Theoretical Foundation

The definite integral of a function f(x) over the interval [a, b] is defined as:

∫_a^b f(x)dx

This integral represents the area under the curve f(x) from x = a to x = b. In numerical integration, we approximate this area by partitioning the interval [a, b] into n subintervals and approximating the function within each subinterval using simple functions such as constants, linear polynomials, or quadratic polynomials.

The general approach involves:

Dividing the integration interval into n equal subintervals of width h = (b – a)/n
Approximating the function within each subinterval
Summing the areas of all subintervals to obtain the total approximate integral

Trapezoidal Rule

Derivation

The trapezoidal rule approximates the area under a curve by dividing it into trapezoids rather than rectangles. For a single interval [x_i, x_i+1], the function is approximated by a straight line connecting the points (x_i, f(x_i)) and (x_i+1, f(x_i+1)).

The area of a single trapezoid is given by:

A = h/2 × [f(x_i) + f(x_i+1)]

where h = x_i+1 – x_i is the width of the subinterval.

For n subintervals over the entire interval [a, b], the composite trapezoidal rule is:

∫_a^b f(x)dx ≈ h/2 × [f(x₀) + 2f(x₁) + 2f(x₂) + … + 2f(x_n-1) + f(x_n)]

where x₀ = a, x_n = b, and h = (b – a)/n.

Error Analysis

The error in the trapezoidal rule for a single interval is given by:

E_T = -h³/12 × f”(ξ)

where ξ is some point in the interval [a, b]. For the composite trapezoidal rule over n intervals, the total error is:

E_T = -(b – a)h²/12 × f”(ξ) = -(b – a)³/(12n²) × f”(ξ)

This shows that the error is proportional to h² (or 1/n²), meaning the trapezoidal rule is second-order accurate. Doubling the number of intervals reduces the error by approximately a factor of four.

Simpson’s Rules

Simpson’s 1/3 Rule

Simpson’s 1/3 Rule uses quadratic polynomials to approximate the function over pairs of subintervals. This method requires an even number of intervals (n must be even). The rule approximates the function with parabolic arcs rather than straight lines, providing better accuracy for smooth curves.

For a single application over two intervals [x₀, x₂], the formula is:

∫_x₀^x₂ f(x)dx ≈ h/3 × [f(x₀) + 4f(x₁) + f(x₂)]

The composite Simpson’s 1/3 Rule for n intervals (n even) is:

∫_a^b f(x)dx ≈ h/3 × [f(x₀) + 4f(x₁) + 2f(x₂) + 4f(x₃) + 2f(x₄) + … + 4f(x_n-1) + f(x_n)]

The error for Simpson’s 1/3 Rule is:

E_S1/3 = -(b – a)h⁴/180 × f⁽⁴⁾(ξ) = -(b – a)⁵/(180n⁴) × f⁽⁴⁾(ξ)

This shows fourth-order accuracy (error proportional to h⁴), making it significantly more accurate than the trapezoidal rule for smooth functions.

Simpson’s 3/8 Rule

Simpson’s 3/8 Rule uses cubic polynomials to approximate the function over three intervals. This method requires that n be divisible by 3. The formula for a single application is:

∫_x₀^x₃ f(x)dx ≈ 3h/8 × [f(x₀) + 3f(x₁) + 3f(x₂) + f(x₃)]

The composite Simpson’s 3/8 Rule is:

∫_a^b f(x)dx ≈ 3h/8 × [f(x₀) + 3f(x₁) + 3f(x₂) + 2f(x₃) + 3f(x₄) + … + f(x_n)]

The error for Simpson’s 3/8 Rule is:

E_S3/8 = -(b – a)h⁴/80 × f⁽⁴⁾(ξ)

Like Simpson’s 1/3 Rule, this is also fourth-order accurate but with a slightly smaller error coefficient.

Comparison of Methods

Method	Order of Accuracy	Error Term	Intervals Required	Best Use Case
Trapezoidal Rule	O(h²)	-(b-a)h²/12 × f”(ξ)	Any n ≥ 1	Linear or slowly varying functions, quick estimates
Simpson’s 1/3	O(h⁴)	-(b-a)h⁴/180 × f⁽⁴⁾(ξ)	n must be even	Smooth curves, higher accuracy needed
Simpson’s 3/8	O(h⁴)	-(b-a)h⁴/80 × f⁽⁴⁾(ξ)	n divisible by 3	When n = 3k, slightly better than 1/3 rule

Worked Examples

Example 1: Basic Trapezoidal Rule Application

Problem: Evaluate ∫₀¹ x² dx using the trapezoidal rule with n = 4 intervals.

Solution:

Step 1: Calculate h = (b – a)/n = (1 – 0)/4 = 0.25

Step 2: Determine the x values:
x₀ = 0, x₁ = 0.25, x₂ = 0.5, x₃ = 0.75, x₄ = 1

Step 3: Calculate function values:
f(x₀) = 0² = 0
f(x₁) = (0.25)² = 0.0625
f(x₂) = (0.5)² = 0.25
f(x₃) = (0.75)² = 0.5625
f(x₄) = 1² = 1

Step 4: Apply the trapezoidal rule:
∫₀¹ x² dx ≈ (0.25/2) × [0 + 2(0.0625) + 2(0.25) + 2(0.5625) + 1]
= 0.125 × [0 + 0.125 + 0.5 + 1.125 + 1]
= 0.125 × 2.75
= 0.34375

Exact value: ∫₀¹ x² dx = [x³/3]₀¹ = 1/3 ≈ 0.33333

Error: |0.34375 – 0.33333| = 0.01042 (approximately 3.1% relative error)

Example 2: Simpson’s 1/3 Rule Application

Problem: Evaluate ∫₀¹ x² dx using Simpson’s 1/3 rule with n = 4 intervals.

Solution:

Using the same h = 0.25 and function values from Example 1:

Apply Simpson’s 1/3 Rule:
∫₀¹ x² dx ≈ (0.25/3) × [0 + 4(0.0625) + 2(0.25) + 4(0.5625) + 1]
= (0.25/3) × [0 + 0.25 + 0.5 + 2.25 + 1]
= (0.25/3) × 4
= 0.33333

Error: |0.33333 – 0.33333| ≈ 0 (exact result!)

This is exact because Simpson’s 1/3 Rule is exact for polynomials up to degree 3, and x² is a second-degree polynomial.

Example 3: Exponential Function Integration

Problem: Evaluate ∫₀² e^x dx using both trapezoidal and Simpson’s 1/3 rule with n = 6 intervals.

Solution:

Step 1: h = (2 – 0)/6 = 0.33333

Step 2: Calculate x values and function values:

i	x_i	f(x_i) = e^x
0	0.0000	1.0000
1	0.3333	1.3956
2	0.6667	1.9477
3	1.0000	2.7183
4	1.3333	3.7937
5	1.6667	5.2945
6	2.0000	7.3891

Trapezoidal Rule:
∫ ≈ (0.33333/2) × [1.0000 + 2(1.3956 + 1.9477 + 2.7183 + 3.7937 + 5.2945) + 7.3891]
= 0.16667 × [1.0000 + 2(15.1498) + 7.3891]
= 0.16667 × 38.6887
= 6.4481

Simpson’s 1/3 Rule:
∫ ≈ (0.33333/3) × [1.0000 + 4(1.3956) + 2(1.9477) + 4(2.7183) + 2(3.7937) + 4(5.2945) + 7.3891]
= 0.11111 × [1.0000 + 5.5824 + 3.8954 + 10.8732 + 7.5874 + 21.1780 + 7.3891]
= 0.11111 × 57.5055
= 6.3895

Exact value: ∫₀² e^x dx = [e^x]₀² = e² – e⁰ = 7.3891 – 1 = 6.3891

Errors:
Trapezoidal: |6.4481 – 6.3891| = 0.0590 (0.92% relative error)
Simpson’s 1/3: |6.3895 – 6.3891| = 0.0004 (0.006% relative error)

Example 4: Trigonometric Function

Problem: Evaluate ∫₀^π/2 sin(x) dx using Simpson’s 3/8 rule with n = 6 intervals.

Solution:

Step 1: h = (π/2 – 0)/6 = π/12 ≈ 0.2618

Step 2: Calculate function values at each point:

f(x₀) = sin(0) = 0
f(x₁) = sin(π/12) = 0.2588
f(x₂) = sin(2π/12) = 0.5000
f(x₃) = sin(3π/12) = 0.7071
f(x₄) = sin(4π/12) = 0.8660
f(x₅) = sin(5π/12) = 0.9659
f(x₆) = sin(6π/12) = 1.0000

Simpson’s 3/8 Rule:
∫ ≈ (3 × 0.2618/8) × [0 + 3(0.2588) + 3(0.5000) + 2(0.7071) + 3(0.8660) + 3(0.9659) + 1.0000]
= 0.0982 × [0 + 0.7764 + 1.5000 + 1.4142 + 2.5980 + 2.8977 + 1.0000]
= 0.0982 × 10.1863
= 1.0003

Exact value: ∫₀^π/2 sin(x) dx = [-cos(x)]₀^π/2 = -cos(π/2) + cos(0) = 0 + 1 = 1.0000

Error: |1.0003 – 1.0000| = 0.0003 (0.03% relative error)

Example 5: Complex Engineering Function

Problem: A sensor measures velocity v(t) = 2t + 3sin(t) m/s over 5 seconds. Calculate the total distance traveled using Simpson’s 1/3 rule with n = 10 intervals.

Solution:

Distance = ∫₀⁵ v(t) dt = ∫₀⁵ (2t + 3sin(t)) dt

Step 1: h = (5 – 0)/10 = 0.5

Step 2: Calculate v(t) at each point and apply Simpson’s 1/3 rule:

i	t_i	v(t_i)	Coefficient	Contribution
0	0.0	0.000	1	0.000
1	0.5	2.438	4	9.752
2	1.0	4.525	2	9.050
3	1.5	6.997	4	27.988
4	2.0	6.728	2	13.456
5	2.5	6.796	4	27.184
6	3.0	6.423	2	12.846
7	3.5	6.427	4	25.708
8	4.0	7.243	2	14.486
9	4.5	9.086	4	36.344
10	5.0	7.122	1	7.122

Distance ≈ (0.5/3) × 183.936 = 30.656 meters

Exact value: ∫₀⁵ (2t + 3sin(t)) dt = [t² – 3cos(t)]₀⁵ = (25 – 3cos(5)) – (0 – 3) = 25 + 3 – 3cos(5) = 28 + 3(1 – cos(5)) = 28 + 3(1.7163) = 28 + 5.149 = 30.638 meters

Error: |30.656 – 30.638| = 0.018 meters (0.06% relative error)

Implementation Code

Python Implementation

import numpy as np
import matplotlib.pyplot as plt

def trapezoidal_rule(f, a, b, n):
    """
    Compute the definite integral using the trapezoidal rule.

    Parameters:
    f : function - The function to integrate
    a : float - Lower limit of integration
    b : float - Upper limit of integration
    n : int - Number of intervals

    Returns:
    float - Approximate value of the integral
    """
    h = (b - a) / n
    x = np.linspace(a, b, n + 1)
    y = f(x)

    # Apply trapezoidal rule formula
    integral = h / 2 * (y[0] + 2 * np.sum(y[1:-1]) + y[-1])

    return integral

def simpsons_one_third(f, a, b, n):
    """
    Compute the definite integral using Simpson's 1/3 rule.

    Parameters:
    f : function - The function to integrate
    a : float - Lower limit of integration
    b : float - Upper limit of integration
    n : int - Number of intervals (must be even)

    Returns:
    float - Approximate value of the integral
    """
    if n % 2 != 0:
        raise ValueError("Number of intervals must be even for Simpson's 1/3 rule")

    h = (b - a) / n
    x = np.linspace(a, b, n + 1)
    y = f(x)

    # Apply Simpson's 1/3 rule formula
    integral = h / 3 * (y[0] + 4 * np.sum(y[1:-1:2]) +
                        2 * np.sum(y[2:-1:2]) + y[-1])

    return integral

def simpsons_three_eighth(f, a, b, n):
    """
    Compute the definite integral using Simpson's 3/8 rule.

    Parameters:
    f : function - The function to integrate
    a : float - Lower limit of integration
    b : float - Upper limit of integration
    n : int - Number of intervals (must be divisible by 3)

    Returns:
    float - Approximate value of the integral
    """
    if n % 3 != 0:
        raise ValueError("Number of intervals must be divisible by 3")

    h = (b - a) / n
    x = np.linspace(a, b, n + 1)
    y = f(x)

    # Apply Simpson's 3/8 rule formula
    integral = 3 * h / 8 * (y[0] + 3 * np.sum(y[1:-1:3]) +
                             3 * np.sum(y[2:-1:3]) +
                             2 * np.sum(y[3:-1:3]) + y[-1])

    return integral

def convergence_analysis(f, a, b, exact_value, max_n=100):
    """
    Analyze convergence of different numerical integration methods.

    Parameters:
    f : function - The function to integrate
    a, b : float - Integration limits
    exact_value : float - Exact value of the integral
    max_n : int - Maximum number of intervals to test
    """
    n_values = np.arange(2, max_n + 1, 2)
    trap_errors = []
    simp13_errors = []

    for n in n_values:
        trap_result = trapezoidal_rule(f, a, b, n)
        trap_errors.append(abs(trap_result - exact_value))

        simp_result = simpsons_one_third(f, a, b, n)
        simp13_errors.append(abs(simp_result - exact_value))

    # Plot convergence
    plt.figure(figsize=(10, 6))
    plt.loglog(n_values, trap_errors, 'o-', label='Trapezoidal Rule')
    plt.loglog(n_values, simp13_errors, 's-', label="Simpson's 1/3 Rule")
    plt.xlabel('Number of Intervals (n)')
    plt.ylabel('Absolute Error')
    plt.title('Convergence Analysis of Numerical Integration Methods')
    plt.legend()
    plt.grid(True, which="both", ls="-", alpha=0.2)
    plt.show()

    return n_values, trap_errors, simp13_errors

# Example usage
if __name__ == "__main__":
    # Define test function
    def f(x):
        return x**2

    # Integration parameters
    a, b = 0, 1
    n = 10
    exact = 1/3

    # Compute integrals
    trap_result = trapezoidal_rule(f, a, b, n)
    simp_result = simpsons_one_third(f, a, b, n)

    print(f"Exact value: {exact:.10f}")
    print(f"Trapezoidal rule (n={n}): {trap_result:.10f}")
    print(f"Simpson's 1/3 rule (n={n}): {simp_result:.10f}")
    print(f"\nTrapezoidal error: {abs(trap_result - exact):.10e}")
    print(f"Simpson's 1/3 error: {abs(simp_result - exact):.10e}")

    # Convergence analysis
    convergence_analysis(f, a, b, exact, max_n=50)

MATLAB Implementation

function result = trapezoidal_rule(f, a, b, n)
    % TRAPEZOIDAL_RULE Numerical integration using trapezoidal rule
    %   result = trapezoidal_rule(f, a, b, n)
    %
    %   Inputs:
    %       f - Function handle
    %       a - Lower limit of integration
    %       b - Upper limit of integration
    %       n - Number of intervals
    %
    %   Output:
    %       result - Approximate integral value

    h = (b - a) / n;
    x = linspace(a, b, n + 1);
    y = f(x);

    result = h/2 * (y(1) + 2*sum(y(2:end-1)) + y(end));
end

function result = simpsons_one_third(f, a, b, n)
    % SIMPSONS_ONE_THIRD Numerical integration using Simpson's 1/3 rule
    %   result = simpsons_one_third(f, a, b, n)
    %
    %   Inputs:
    %       f - Function handle
    %       a - Lower limit of integration
    %       b - Upper limit of integration
    %       n - Number of intervals (must be even)
    %
    %   Output:
    %       result - Approximate integral value

    if mod(n, 2) ~= 0
        error('Number of intervals must be even');
    end

    h = (b - a) / n;
    x = linspace(a, b, n + 1);
    y = f(x);

    result = h/3 * (y(1) + 4*sum(y(2:2:end-1)) + ...
                    2*sum(y(3:2:end-2)) + y(end));
end

function result = simpsons_three_eighth(f, a, b, n)
    % SIMPSONS_THREE_EIGHTH Numerical integration using Simpson's 3/8 rule
    %   result = simpsons_three_eighth(f, a, b, n)
    %
    %   Inputs:
    %       f - Function handle
    %       a - Lower limit of integration
    %       b - Upper limit of integration
    %       n - Number of intervals (must be divisible by 3)
    %
    %   Output:
    %       result - Approximate integral value

    if mod(n, 3) ~= 0
        error('Number of intervals must be divisible by 3');
    end

    h = (b - a) / n;
    x = linspace(a, b, n + 1);
    y = f(x);

    result = 3*h/8 * (y(1) + 3*sum(y(2:3:end-2)) + ...
                      3*sum(y(3:3:end-1)) + ...
                      2*sum(y(4:3:end-3)) + y(end));
end

% Example usage and convergence analysis
f = @(x) x.^2;
a = 0;
b = 1;
exact = 1/3;

% Test different values of n
n_values = 2:2:50;
trap_errors = zeros(size(n_values));
simp_errors = zeros(size(n_values));

for i = 1:length(n_values)
    n = n_values(i);
    trap_errors(i) = abs(trapezoidal_rule(f, a, b, n) - exact);
    simp_errors(i) = abs(simpsons_one_third(f, a, b, n) - exact);
end

% Plot convergence
figure;
loglog(n_values, trap_errors, 'o-', 'LineWidth', 2, 'DisplayName', 'Trapezoidal');
hold on;
loglog(n_values, simp_errors, 's-', 'LineWidth', 2, 'DisplayName', 'Simpson 1/3');
xlabel('Number of Intervals (n)');
ylabel('Absolute Error');
title('Convergence Analysis');
legend('Location', 'best');
grid on;

% Display results
fprintf('Integration of f(x) = x^2 from 0 to 1\n');
fprintf('Exact value: %.10f\n', exact);
fprintf('\nResults for n = 10:\n');
fprintf('Trapezoidal: %.10f (error: %.2e)\n', ...
    trapezoidal_rule(f, a, b, 10), trap_errors(5));
fprintf('Simpson 1/3: %.10f (error: %.2e)\n', ...
    simpsons_one_third(f, a, b, 10), simp_errors(5));

Engineering Applications

Signal Processing

In signal processing, numerical integration is essential for calculating the energy of signals, finding area under power spectral density curves, and computing signal statistics. For a discrete signal sampled at regular intervals, the trapezoidal rule provides a natural way to estimate continuous signal properties.

Application Example: Computing the total energy of a signal x(t) over time interval [0, T]:

E = ∫₀^T |x(t)|² dt

For sampled data with sampling period Δt, this becomes a perfect application for the trapezoidal rule, as the signal is already discretized.

Area Under Curves

Engineers frequently need to calculate areas under curves for various purposes:

Stress-strain diagrams: The area under a stress-strain curve represents the energy absorbed by a material before failure
Velocity-time graphs: The area represents total displacement
Pressure-volume diagrams: In thermodynamics, the area under a P-V curve represents work done
Flow rate curves: Integration gives total volume transferred

Sensor Data Integration

Modern sensor systems produce discrete data points that must be integrated to obtain meaningful physical quantities:

Example: Accelerometer Data Integration

An accelerometer measures acceleration a(t). To find velocity and position:

v(t) = v₀ + ∫₀^t a(τ) dτ
x(t) = x₀ + ∫₀^t v(τ) dτ

Python code for accelerometer integration:

import numpy as np

def integrate_accelerometer_data(accel_data, time_data, initial_velocity=0):
    """
    Integrate accelerometer data to obtain velocity.

    Parameters:
    accel_data : array - Acceleration measurements (m/s^2)
    time_data : array - Time stamps (seconds)
    initial_velocity : float - Initial velocity (m/s)

    Returns:
    velocity : array - Velocity at each time point
    """
    n = len(time_data) - 1
    velocity = np.zeros(n + 1)
    velocity[0] = initial_velocity

    for i in range(n):
        h = time_data[i+1] - time_data[i]
        # Trapezoidal integration
        velocity[i+1] = velocity[i] + h/2 * (accel_data[i] + accel_data[i+1])

    return velocity

# Example: GPS-denied navigation
time = np.linspace(0, 10, 100)  # 100 samples over 10 seconds
accel = 2 * np.sin(time)  # Sinusoidal acceleration
velocity = integrate_accelerometer_data(accel, time, initial_velocity=0)

print(f"Final velocity: {velocity[-1]:.2f} m/s")

Error Analysis and Convergence

Understanding error behavior is crucial for selecting appropriate integration methods and determining required computational effort.

Theoretical Error Bounds

For each method, the error can be bounded if we know the derivatives of the function:

Trapezoidal Rule: |E_T| ≤ (b-a)³/(12n²) × max|f”(x)|
Simpson’s 1/3: |E_S| ≤ (b-a)⁵/(180n⁴) × max|f⁽⁴⁾(x)|
Simpson’s 3/8: |E_S| ≤ (b-a)⁵/(80n⁴) × max|f⁽⁴⁾(x)|

Convergence Rates

The convergence rate determines how quickly the error decreases as we increase n:

Trapezoidal: Error ∝ n⁻² (quadratic convergence)
Simpson’s rules: Error ∝ n⁻⁴ (quartic convergence)

This means that to reduce error by factor of 100 using trapezoidal rule, we need to increase n by factor of 10. For Simpson’s rule, we only need to increase n by factor of √10 ≈ 3.16.

Richardson Extrapolation

Richardson extrapolation can improve accuracy by combining results from different step sizes. For the trapezoidal rule with step sizes h and h/2:

I_improved = (4I_h/2 – I_h)/3

This cancels the leading error term and provides fourth-order accuracy, matching Simpson’s rule.

Practice Problems

Problem 1

Evaluate ∫₁³ (1/x) dx using the trapezoidal rule with n = 4. Compare with the exact value.

Solution:
h = (3 – 1)/4 = 0.5
x values: 1.0, 1.5, 2.0, 2.5, 3.0
f(x) values: 1.0000, 0.6667, 0.5000, 0.4000, 0.3333

∫ ≈ (0.5/2)[1.0000 + 2(0.6667 + 0.5000 + 0.4000) + 0.3333]
= 0.25[1.0000 + 2(1.5667) + 0.3333]
= 0.25[4.4667]
= 1.1167

Exact: ∫₁³ (1/x)dx = [ln(x)]₁³ = ln(3) – ln(1) = 1.0986
Error: |1.1167 – 1.0986| = 0.0181 (1.65% relative error)

Problem 2

Calculate ∫₀^π cos(x) dx using Simpson’s 1/3 rule with n = 6.

Solution:
h = π/6 ≈ 0.5236
Applying Simpson’s 1/3 rule:
∫ ≈ (π/18)[cos(0) + 4cos(π/6) + 2cos(2π/6) + 4cos(3π/6) + 2cos(4π/6) + 4cos(5π/6) + cos(π)]
= (π/18)[1 + 4(0.8660) + 2(0.5) + 4(0) + 2(-0.5) + 4(-0.8660) + (-1)]
= (π/18)[1 + 3.464 + 1 + 0 – 1 – 3.464 – 1]
= (π/18)[0]
= 0

Exact: ∫₀^π cos(x)dx = [sin(x)]₀^π = sin(π) – sin(0) = 0
Error: 0 (Exact!)

Problem 3

A water tank is being filled. The flow rate Q(t) in liters/minute varies as Q(t) = 10 + 2t – 0.1t². Calculate the total volume of water added between t = 0 and t = 10 minutes using Simpson’s 3/8 rule with n = 6.

Solution:
Volume = ∫₀¹⁰ Q(t) dt
h = 10/6 = 1.667 minutes

Calculate Q(t) at each point:
Q(0) = 10.000
Q(1.667) = 13.056
Q(3.333) = 15.556
Q(5.000) = 17.500
Q(6.667) = 18.889
Q(8.333) = 19.722
Q(10.000) = 20.000

Volume ≈ (3 × 1.667/8)[10 + 3(13.056) + 3(15.556) + 2(17.500) + 3(18.889) + 3(19.722) + 20]
= 0.625[10 + 39.168 + 46.668 + 35 + 56.667 + 59.166 + 20]
= 0.625[266.669]
= 166.67 liters

Exact: ∫₀¹⁰ (10 + 2t – 0.1t²)dt = [10t + t² – 0.1t³/3]₀¹⁰
= 100 + 100 – 33.33 = 166.67 liters
Error: Essentially zero (excellent agreement)

Conclusion

Numerical integration methods are indispensable tools in engineering practice. The trapezoidal rule offers simplicity and reliability for quick estimates, while Simpson’s rules provide superior accuracy for smooth functions at minimal additional computational cost. Understanding the theoretical foundations, error characteristics, and practical implementations enables engineers to select the most appropriate method for their specific applications.

Key takeaways:

Always consider the smoothness of the function when selecting a method
Simpson’s rules are generally preferred for smooth functions due to higher accuracy
The trapezoidal rule is robust and works for any number of intervals
Error decreases rapidly as interval count increases
Modern computing power makes high-accuracy integration feasible for most applications

References

[1] Burden, R. L., and Faires, J. D., “Numerical Analysis,” 9th ed., Brooks/Cole, Boston, MA, 2011.

[2] Chapra, S. C., and Canale, R. P., “Numerical Methods for Engineers,” 7th ed., McGraw-Hill, New York, 2015.

[3] Press, W. H., Teukolsky, S. A., Vetterling, W. T., and Flannery, B. P., “Numerical Recipes: The Art of Scientific Computing,” 3rd ed., Cambridge University Press, Cambridge, UK, 2007.

[4] Atkinson, K. E., “An Introduction to Numerical Analysis,” 2nd ed., John Wiley & Sons, New York, 1989.

[5] Davis, P. J., and Rabinowitz, P., “Methods of Numerical Integration,” 2nd ed., Academic Press, Orlando, FL, 1984, doi: 10.1016/C2013-0-10566-1.

[6] Ralston, A., and Rabinowitz, P., “A First Course in Numerical Analysis,” 2nd ed., Dover Publications, Mineola, NY, 2001.

[7] Stoer, J., and Bulirsch, R., “Introduction to Numerical Analysis,” 3rd ed., Springer-Verlag, New York, 2002, doi: 10.1007/978-0-387-21738-3.

[8] Süli, E., and Mayers, D. F., “An Introduction to Numerical Analysis,” Cambridge University Press, Cambridge, UK, 2003, doi: 10.1017/CBO9780511801181.

Explore Related Numerical Methods

Numerical Methods in Engineering – Comprehensive guide to numerical techniques
Numerical Differentiation – Learn differentiation methods to complement integration
Introduction to Differential Equations – Understand equations that often require numerical solutions
Wolfram Alpha for Differential Equations – Computational tools for equation solving

Post Views: 82

Introduction to Numerical Integration

Theoretical Foundation

Trapezoidal Rule

Derivation

Error Analysis

Simpson’s Rules

Simpson’s 1/3 Rule

Simpson’s 3/8 Rule

Comparison of Methods

Worked Examples

Example 1: Basic Trapezoidal Rule Application

Example 2: Simpson’s 1/3 Rule Application

Example 3: Exponential Function Integration

Example 4: Trigonometric Function

Example 5: Complex Engineering Function

Implementation Code

Python Implementation

MATLAB Implementation

Engineering Applications

Signal Processing

Area Under Curves

Sensor Data Integration

Error Analysis and Convergence

Theoretical Error Bounds

Convergence Rates

Richardson Extrapolation

Practice Problems

Problem 1

Problem 2

Problem 3

Conclusion

References

Explore Related Numerical Methods

Related Articles