Modelling the Taylor Table Method in Python

The Taylor Table method is an efficient technique for deriving finite difference schemes for derivatives using a specific stencil. A stencil is a collection of grid points used to approximate derivatives numerically.

Understanding the Taylor Table Method

Consider evaluating the second derivative using Taylor series expansions. For points around $x_i$:

The Taylor series expansions are:

$$f(x_i + h) = f(x_i) + hf'(x_i) + \frac{h^2}{2!}f''(x_i) + \frac{h^3}{3!}f'''(x_i) + \ldots$$

$$f(x_i - h) = f(x_i) - hf'(x_i) + \frac{h^2}{2!}f''(x_i) - \frac{h^3}{3!}f'''(x_i) + \ldots$$

Adding these equations and solving for the second derivative gives:

$$f''(x_i) = \frac{f(x_i + h) - 2f(x_i) + f(x_i - h)}{h^2}$$

For complex stencils with many points, the Taylor Table method systematizes this process.

Python Implementation

Taylor Series Coefficient Function

First, we create a function to generate Taylor series coefficients ?

import numpy as np
from math import factorial

def taylor_series_coeffs(n, alpha):
    """
    Generate Taylor series coefficients.
    n: Number of terms in the series
    alpha: Coefficient of h (position relative to x_i)
    """
    coeffs = np.empty(n)
    for i in range(n):
        coeffs[i] = alpha**i / factorial(i)
    return coeffs

# Test the function
print(taylor_series_coeffs(4, 1))  # For x_i + h

[1.         1.         0.5        0.16666667]

Complete Taylor Table Implementation

Here's a complete implementation for finding finite difference coefficients ?

import numpy as np
from math import factorial

def taylor_series_coeffs(n, alpha):
    """Generate Taylor series coefficients"""
    coeffs = np.empty(n)
    for i in range(n):
        coeffs[i] = alpha**i / factorial(i)
    return coeffs

def finite_difference_coeffs(stencil, derivative_order):
    """
    Calculate finite difference coefficients using Taylor table method.
    
    stencil: Array of relative positions (e.g., [-1, 0, 1] for f_{i-1}, f_i, f_{i+1})
    derivative_order: Order of derivative to approximate
    """
    n_points = len(stencil)
    
    # Build Taylor table
    taylor_table = np.empty((n_points, n_points))
    for i in range(n_points):
        taylor_table[i, :] = taylor_series_coeffs(n_points, stencil[i])
    
    # Right-hand side vector
    rhs = np.zeros(n_points)
    rhs[derivative_order] = 1
    
    # Solve the system
    coeffs = np.linalg.solve(taylor_table.T, rhs)
    
    return coeffs, taylor_table

# Example 1: Second derivative with 3-point stencil
stencil = np.array([-1, 0, 1])  # f_{i-1}, f_i, f_{i+1}
derivative_order = 2

coeffs, table = finite_difference_coeffs(stencil, derivative_order)

print("Taylor Table:")
print(table)
print(f"\nCoefficients for 2nd derivative:")
for i, coeff in enumerate(coeffs):
    print(f"f_{{i{stencil[i]:+d}}} coefficient: {coeff:.6f}/h^{derivative_order}")

Taylor Table:
[[1.  -1.   0.5]
 [1.   0.   0. ]
 [1.   1.   0.5]]

Coefficients for 2nd derivative:
f_{i-1} coefficient: 1.000000/h^2
f_{i+0} coefficient: -2.000000/h^2
f_{i+1} coefficient: 1.000000/h^2

Example: Third Derivative with 4-Point Stencil

Let's solve the problem from the introduction ? finding the third derivative using points $f_i, f_{i+1}, f_{i+2}, f_{i+3}$:

# Third derivative with forward stencil
stencil = np.array([0, 1, 2, 3])  # f_i, f_{i+1}, f_{i+2}, f_{i+3}
derivative_order = 3

coeffs, table = finite_difference_coeffs(stencil, derivative_order)

print("Third derivative coefficients:")
for i, coeff in enumerate(coeffs):
    print(f"f_{{i{stencil[i]:+d}}} coefficient: {coeff:.6f}/h^{derivative_order}")

# The resulting finite difference formula
print(f"\nFinite difference formula:")
print(f"f'''(x_i) ? ({coeffs[0]:.1f}*f_i + {coeffs[1]:.1f}*f_{{i+1}} + {coeffs[2]:.1f}*f_{{i+2}} + {coeffs[3]:.1f}*f_{{i+3}})/h^3")

Third derivative coefficients:
f_{i+0} coefficient: -1.000000/h^3
f_{i+1} coefficient: 3.000000/h^3
f_{i+2} coefficient: -3.000000/h^3
f_{i+3} coefficient: 1.000000/h^3

Finite difference formula:
f'''(x_i) ? (-1.0*f_i + 3.0*f_{i+1} + -3.0*f_{i+2} + 1.0*f_{i+3})/h^3

Comparison of Different Stencils

Conclusion

The Taylor Table method provides a systematic approach to derive finite difference coefficients for any derivative order and stencil configuration. Python implementation automates the tedious algebraic manipulations, making it practical for complex stencils and high-order derivatives.