Free entropy

In numerical linear algebra, the tridiagonal matrix algorithm, also known as the Thomas algorithm (named after Llewellyn Thomas), is a simplified form of Gaussian elimination that can be used to solve tridiagonal systems of equations. A tridiagonal system for n unknowns may be written as

$a_i{x}_{i-1}+b_i{x}_i+c_i{x}_{i+1}=d_i,$

where $a_1=0$ and $c_n=0$.

$\left[\begin{array}{ccccc}{b}_1& c_1& & & 0\\ a_2& b_2& c_2& & \\ & a_3& b_3& \ddots & \\ & & \ddots & \ddots & c_{n-1}\\ 0& & & a_n& b_n\\ \end{array}\right]\left[\begin{array}{c}{x}_1\\ x_2\\ x_3\\ ⋮\\ x_n\\ \end{array}\right]=\left[\begin{array}{c}{d}_1\\ d_2\\ d_3\\ ⋮\\ d_n\\ \end{array}\right].$

For such systems, the solution can be obtained in $O(n)$ operations instead of $O(n^3)$ required by Gaussian elimination. A first sweep eliminates the $a_i$'s, and then an (abbreviated) backward substitution produces the solution. Examples of such matrices commonly arise from the discretization of 1D Poisson equation (e.g., the 1D diffusion problem) and natural cubic spline interpolation; similar systems of matrices arise in tight binding physics or nearest neighbor effects models.

Method

The forward sweep consists of modifying the coefficients as follows, denoting the new modified coefficients with primes:

$c{\text{'}}_i=\{\begin{array}{l}\begin{array}{lcl}\frac{c_i}{b_i}& ;& i=1\\ \frac{c_i}{b_i-c{\text{'}}_{i-1}{a}_i}& ;& i=2,3,\dots ,n-1\\ \end{array}\end{array}$

and

$d{\text{'}}_i=\{\begin{array}{l}\begin{array}{lcl}\frac{d_i}{b_i}& ;& i=1\\ \frac{d_i-d{\text{'}}_{i-1}{a}_i}{b_i-c{\text{'}}_{i-1}{a}_i}& ;& i=2,3,\dots ,n.\\ \end{array}\end{array}$

The solution is then obtained by back substitution:

$x_n=d{\text{'}}_n$

$x_i=d{\text{'}}_i-c{\text{'}}_i{x}_{i+1};i=n-1,n-2,\dots ,1.$

Implementations

All the provided implementations assume that the three diagonals, a (below), b (main), and c (above), are passed as arguments.

C

The following C function will solve a general tridiagonal system (though it will destroy the input vector c in the process). Note that the index $i$ here is zero based, in other words $i=0,1,\dots ,N-1$ where $N$ is the number of unknowns.

void solve_tridiagonal_in_place_destructive(double x[], const size_t N, const double a[], const double b[], double c[]) {
    /* unsigned integer of same size as pointer */
    size_t in;
    
    /*
     solves Ax = v where A is a tridiagonal matrix consisting of vectors a, b, c
     note that contents of input vector c will be modified, making this a one-time-use function
     x[] - initially contains the input vector v, and returns the solution x. indexed from [0, ..., N - 1]
     N — number of equations
     a[] - subdiagonal (means it is the diagonal below the main diagonal) -- indexed from [1, ..., N - 1]
     b[] - the main diagonal, indexed from [0, ..., N - 1]
     c[] - superdiagonal (means it is the diagonal above the main diagonal) -- indexed from [0, ..., N - 2]
     */
    
    c[0] = c[0] / b[0];
    x[0] = x[0] / b[0];
    
    /* loop from 1 to N - 1 inclusive */
    for (in = 1; in < N; in++) {
        double m = 1.0 / (b[in] - a[in] * c[in - 1]);
        c[in] = c[in] * m;
        x[in] = (x[in] - a[in] * x[in - 1]) * m;
    }
    
    /* loop from N - 2 to 0 inclusive, safely testing loop end condition */
    for (in = N - 1; in-- > 0; )
        x[in] = x[in] - c[in] * x[in + 1];
}

The following variant preserves the system of equations for reuse on other inputs. Note the necessity of library calls to allocate and free scratch space - a more efficient implementation for solving the same tridiagonal system on many inputs would rely on the calling function to provide a pointer to the scratch space.

void solve_tridiagonal_in_place_reusable(double x[], const size_t N, const double a[], const double b[], const double c[]) {
    size_t in;
    
    /* Allocate scratch space. */
    double * cprime = malloc(sizeof(double) * N);
    
    if (!cprime) {
        /* do something to handle error */
    }
    
    cprime[0] = c[0] / b[0];
    x[0] = x[0] / b[0];
    
    /* loop from 1 to N - 1 inclusive */
    for (in = 1; in < N; in++) {
        double m = 1.0 / (b[in] - a[in] * cprime[in - 1]);
        cprime[in] = c[in] * m;
        x[in] = (x[in] - a[in] * x[in - 1]) * m;
    }
    
    /* loop from N - 2 to 0 inclusive, safely testing loop end condition */
    for (in = N - 1; in-- > 0; )
        x[in] = x[in] - cprime[in] * x[in + 1];
    
    /* free scratch space */
    free(cprime);
}

Python

Note that the index $i$ here is zero-based, in other words $i=0,1,\dots ,N-1$ where $N$ is the number of unknowns.

# note: function also modifies b[] and d[] params while solving
def TDMASolve(a, b, c, d):
    n = len(d) # n is the numbers of rows, a and c has length n-1
    for i in xrange(n-1):
        d[i+1] -= d[i] * a[i] / b[i]
        b[i+1] -= c[i] * a[i] / b[i]
    for i in reversed(xrange(n-1)):
        d[i] -= d[i+1] * c[i] / b[i+1]
    return [d[i] / b[i] for i in xrange(n)] # return the solution

MATLAB

function x = TDMAsolver(a,b,c,d)
%a, b, c are the column vectors for the compressed tridiagonal matrix, d is the right vector
n = length(d); % n is the number of rows
 
% Modify the first-row coefficients
c(1) = c(1) / b(1);    % Division by zero risk.
d(1) = d(1) / b(1);   
 
for i = 2:n-1
    temp = b(i) - a(i) * c(i-1);
    c(i) = c(i) / temp;
    d(i) = (d(i) - a(i) * d(i-1))/temp;
end
 
d(n) = (d(n) - a(n) * d(n-1))/( b(n) - a(n) * c(n-1));
 
% Now back substitute.
x(n) = d(n);
for i = n-1:-1:1
    x(i) = d(i) - c(i) * x(i + 1);
end

Fortran 90

Note that the index $i$ here is one based, in other words $i=1,2,\dots ,n$ where $n$ is the number of unknowns.

Sometimes it is undesirable to have the solver routine overwrite the tridiagonal coefficients (e.g. for solving multiple systems of equations where only the right side of the system changes), so this implementation gives an example of a relatively inexpensive method of preserving the coefficients.

      subroutine solve_tridiag(a,b,c,d,x,n)
      implicit none
!	 a - sub-diagonal (means it is the diagonal below the main diagonal)
!	 b - the main diagonal
!	 c - sup-diagonal (means it is the diagonal above the main diagonal)
!	 d - right part
!	 x - the answer
!	 n - number of equations

        integer,intent(in) :: n
        real(8),dimension(n),intent(in) :: a,b,c,d
        real(8),dimension(n),intent(out) :: x
        real(8),dimension(n) :: cp,dp
        real(8) :: m
        integer i

! initialize c-prime and d-prime
        cp(1) = c(1)/b(1)
        dp(1) = d(1)/b(1)
! solve for vectors c-prime and d-prime
         do i = 2,n
           m = b(i)-cp(i-1)*a(i)
           cp(i) = c(i)/m
           dp(i) = (d(i)-dp(i-1)*a(i))/m
         enddo
! initialize x
         x(n) = dp(n)
! solve for x from the vectors c-prime and d-prime
        do i = n-1, 1, -1
          x(i) = dp(i)-cp(i)*x(i+1)
        end do

    end subroutine solve_tridiag

This subroutine offers an option of overwriting d or not.

      subroutine tdma(n,a,b,c,d,x)
	  implicit none
      integer, intent(in) :: n
      real, intent(in) :: a(n), c(n)
      real, intent(inout), dimension(n) :: b, d
	  real, intent(out) :: x(n)
	  !  --- Local variables ---
	  integer :: i
	  real :: q
      !  --- Elimination ---
      do i = 2,n
         q = a(i)/b(i - 1)
         b(i) = b(i) - c(i - 1)*q
         d(i) = d(i) - d(i - 1)*q
      end do
      ! --- Backsubstitution ---
      q = d(n)/b(n)
      x(n) = q
      do i = n - 1,1,-1
         q = (d(i) - c(i)*q)/b(i)
         x(i) = q
      end do
      return
      end

Derivation

The derivation of the tridiagonal matrix algorithm involves manually performing some specialized Gaussian elimination in a generic manner.

Suppose that the unknowns are $x_1,\dots ,x_n$, and that the equations to be solved are:

$\begin{array}{rlrl}{b}_1{x}_1+c_1{x}_2& =d_1;& i& =1\\ a_i{x}_{i-1}+b_i{x}_i+c_i{x}_{i+1}& =d_i;& i& =2,\dots ,n-1\\ a_n{x}_{n-1}+b_n{x}_n& =d_n;& i& =n.\end{array}$

Consider modifying the second ($i=2$) equation with the first equation as follows:

$(\text{equation 2})\cdot b_1-(\text{equation 1})\cdot a_2$

which would give:

$(a_2{x}_1+b_2{x}_2+c_2{x}_3)b_1-(b_1{x}_1+c_1{x}_2)a_2=d_2{b}_1-d_1{a}_2$

$(b_2{b}_1-c_1{a}_2)x_2+c_2{b}_1{x}_3=d_2{b}_1-d_1{a}_2$

and the effect is that $x_1$ has been eliminated from the second equation. Using a similar tactic with the modified second equation on the third equation yields:

$(a_3{x}_2+b_3{x}_3+c_3{x}_4)(b_2{b}_1-c_1{a}_2)-((b_2{b}_1-c_1{a}_2)x_2+c_2{b}_1{x}_3)a_3=d_3(b_2{b}_1-c_1{a}_2)-(d_2{b}_1-d_1{a}_2)a_3$

$(b_3(b_2{b}_1-c_1{a}_2)-c_2{b}_1{a}_3)x_3+c_3(b_2{b}_1-c_1{a}_2)x_4=d_3(b_2{b}_1-c_1{a}_2)-(d_2{b}_1-d_1{a}_2)a_3.$

This time $x_2$ was eliminated. If this procedure is repeated until the $n^{th}$ row; the (modified) $n^{th}$ equation will involve only one unknown, $x_n$. This may be solved for and then used to solve the $(n-1{)}^{th}$ equation, and so on until all of the unknowns are solved for.

Clearly, the coefficients on the modified equations get more and more complicated if stated explicitly. By examining the procedure, the modified coefficients (notated with tildes) may instead be defined recursively:

${\tilde{a}}_i=0$

${\tilde{b}}_1=b_1$

${\tilde{b}}_i=b_i{\tilde{b}}_{i-1}-{\tilde{c}}_{i-1}{a}_i$

${\tilde{c}}_1=c_1$

${\tilde{c}}_i=c_i{\tilde{b}}_{i-1}$

${\tilde{d}}_1=d_1$

${\tilde{d}}_i=d_i{\tilde{b}}_{i-1}-{\tilde{d}}_{i-1}{a}_i.$

To further hasten the solution process, ${\tilde{b}}_i$ may be divided out (if there's no division by zero risk), the newer modified coefficients notated with a prime will be:

$a{\text{'}}_i=0$

$b{\text{'}}_i=1$

$c{\text{'}}_1=\frac{c_1}{b_1}$

$c{\text{'}}_i=\frac{c_i}{b_i-c{\text{'}}_{i-1}{a}_i}$

$d{\text{'}}_1=\frac{d_1}{b_1}$

$d{\text{'}}_i=\frac{d_i-d{\text{'}}_{i-1}{a}_i}{b_i-c{\text{'}}_{i-1}{a}_i}.$

This gives the following system with the same unknowns and coefficients defined in terms of the original ones above:

$\begin{array}{lcl}b{\text{'}}_i{x}_i+c{\text{'}}_i{x}_{i+1}=d{\text{'}}_i& ;& i=1,\dots ,n-1\\ b{\text{'}}_n{x}_n=d{\text{'}}_n& ;& i=n.\\ \end{array}$

The last equation involves only one unknown. Solving it in turn reduces the next last equation to one unknown, so that this backward substitution can be used to find all of the unknowns:

$x_n=d{\text{'}}_n/b{\text{'}}_n$

$x_i=(d{\text{'}}_i-c{\text{'}}_i{x}_{i+1})/b{\text{'}}_i;i=n-1,n-2,\dots ,1.$

Variants

In some situations, particularly those involving periodic boundary conditions, a slightly perturbed form of the tridiagonal system may need to be solved:

$\begin{array}{rl}{a}_1{x}_n+b_1{x}_1+c_1{x}_2& =d_1,\\ a_i{x}_{i-1}+b_i{x}_i+c_i{x}_{i+1}& =d_i,i=2,\dots ,n-1\\ a_n{x}_{n-1}+b_n{x}_n+c_n{x}_1& =d_n.\end{array}$

In this case, we can make use of the Sherman-Morrison formula to avoid the additional operations of Gaussian elimination and still use the Thomas algorithm. The method requires solving a modified non-cyclic version of the system for both the input and a sparse corrective vector, and then combining the solutions. This can be done efficiently if both solutions are computed at once, as the forward portion of the pure tridiagonal matrix algorithm can be shared.

In other situations, the system of equations may be block tridiagonal (see block matrix), with smaller submatrices arranged as the individual elements in the above matrix system(e.g., the 2D Poisson problem). Simplified forms of Gaussian elimination have been developed for these situationsPotter or Ceramic Artist Truman Bedell from Rexton, has interests which include ceramics, best property developers in singapore developers in singapore and scrabble. Was especially enthused after visiting Alejandro de Humboldt National Park..

The textbook Numerical Mathematics by Quarteroni, Sacco and Saleri, lists a modified version of the algorithm which avoids some of the divisions (using instead multiplications), which is beneficial on some computer architectures.

References

• 20 year-old Real Estate Agent Rusty from Saint-Paul, has hobbies and interests which includes monopoly, property developers in singapore and poker. Will soon undertake a contiki trip that may include going to the Lower Valley of the Omo.
  
  My blog: http://www.primaboinca.com/view_profile.php?userid=5889534
• Template:CFDWiki
• 20 year-old Real Estate Agent Rusty from Saint-Paul, has hobbies and interests which includes monopoly, property developers in singapore and poker. Will soon undertake a contiki trip that may include going to the Lower Valley of the Omo.
  
  My blog: http://www.primaboinca.com/view_profile.php?userid=5889534

External links

• Example with VBA code