Numerical Methods Guide for Electronics & Communication

Engineering
Table of Contents
1. Power Method for Dominant Eigenvalue
2. Gauss-Seidel Method

3. LU Decomposition
4. Thomas Algorithm

5. Jacobi Method for Eigenvalues

6. Givens Method for Eigenvalues

1. Power Method for Dominant Eigenvalue

What is it?
The Power Method finds the largest eigenvalue (dominant eigenvalue) and its corresponding eigenvector
of a matrix. Think of it as repeatedly multiplying a vector by the matrix until it converges to the dominant
eigenvector.

How it works:
1. Start with an initial guess vector
2. Multiply by the matrix
3. Normalize the result

4. Repeat until convergence

C Code:
c
#include <stdio.h>
#include <math.h>
#define N 3
#define MAX_ITER 1000
#define TOLERANCE 1e-6

void power_method(double A[N][N], double eigenvalue, double eigenvector[N]) {

double x[N] = {1.0, 1.0, 1.0}; // Initial guess
double y[N];
double lambda_old = 0, lambda_new = 0;

for(int iter = 0; iter < MAX_ITER; iter++) {

// Matrix-vector multiplication: y = A * x
for(int i = 0; i < N; i++) {
y[i] = 0;
for(int j = 0; j < N; j++) {
y[i] += A[i][j] * x[j];
}
}

// Find the largest component (eigenvalue approximation)

lambda_new = y[0];
for(int i = 1; i < N; i++) {
if(fabs(y[i]) > fabs(lambda_new)) {
lambda_new = y[i];
}
}

// Normalize the vector

for(int i = 0; i < N; i++) {
x[i] = y[i] / lambda_new;
}

// Check convergence
if(fabs(lambda_new - lambda_old) < TOLERANCE) {
printf("Converged after %d iterations\n", iter + 1);
break;
}

lambda_old = lambda_new;
}

// Store results
eigenvalue = lambda_new;
for(int i = 0; i < N; i++) {
eigenvector[i] = x[i];
 }

printf("Dominant Eigenvalue: %.6f\n", eigenvalue);

printf("Corresponding Eigenvector: ");
for(int i = 0; i < N; i++) {
printf("%.6f ", eigenvector[i]);
}
printf("\n\n");
}

int main() {
double A[N][N] = {{4, -2, 1},
{1, 3, -1},
{2, 1, 5}};
double eigenvalue;
double eigenvector[N];

printf("Power Method Example:\n");

power_method(A, eigenvalue, eigenvector);

return 0;
}

2. Gauss-Seidel Method

What is it?
The Gauss-Seidel method solves systems of linear equations (Ax = b) iteratively. It's like solving each
equation for one variable and using updated values immediately.

How it works:
1. Rearrange each equation to solve for one variable

2. Use the most recent values in calculations

3. Repeat until solution converges

C Code:
c
#include <stdio.h>
#include <math.h>
#define N 3
#define MAX_ITER 1000
#define TOLERANCE 1e-6

void gauss_seidel(double A[N][N], double b[N], double x[N]) {

double x_old[N];
int iter;

// Initialize solution vector

for(int i = 0; i < N; i++) {
x[i] = 0.0;
}

for(iter = 0; iter < MAX_ITER; iter++) {

// Save old values
for(int i = 0; i < N; i++) {
x_old[i] = x[i];
}

// Update each variable

for(int i = 0; i < N; i++) {
double sum = b[i];

// Subtract known terms

for(int j = 0; j < N; j++) {
if(i != j) {
sum -= A[i][j] * x[j];
}
}

// Solve for x[i]

x[i] = sum / A[i][i];
}

// Check convergence
double max_error = 0;
for(int i = 0; i < N; i++) {
double error = fabs(x[i] - x_old[i]);
if(error > max_error) {
max_error = error;
}
}

if(max_error < TOLERANCE) {

 printf("Converged after %d iterations\n", iter + 1);
break;
}
}

printf("Solution:\n");
for(int i = 0; i < N; i++) {
printf("x[%d] = %.6f\n", i, x[i]);
}
printf("\n");
}

int main() {
// System: 10x + y + z = 12
// x + 10y + z = 12
// x + y + 10z = 12
double A[N][N] = {{10, 1, 1},
{1, 10, 1},
{1, 1, 10}};
double b[N] = {12, 12, 12};
double x[N];

printf("Gauss-Seidel Method Example:\n");

gauss_seidel(A, b, x);

return 0;
}

3. LU Decomposition

What is it?
LU Decomposition breaks a matrix A into two parts: L (Lower triangular) and U (Upper triangular), where A
= L × U. This makes solving Ax = b easier by solving two simpler triangular systems.

How it works:
1. Decompose A into L and U matrices
2. Solve Ly = b (forward substitution)

3. Solve Ux = y (backward substitution)

C Code:
c
#include <stdio.h>
#define N 3

void lu_decomposition(double A[N][N], double L[N][N], double U[N][N]) {

// Initialize L and U
for(int i = 0; i < N; i++) {
for(int j = 0; j < N; j++) {
L[i][j] = 0;
U[i][j] = 0;
}
L[i][i] = 1; // Diagonal of L is 1
}

// Decomposition
for(int i = 0; i < N; i++) {
// Upper triangular matrix U
for(int k = i; k < N; k++) {
double sum = 0;
for(int j = 0; j < i; j++) {
sum += L[i][j] * U[j][k];
}
U[i][k] = A[i][k] - sum;
}

// Lower triangular matrix L

for(int k = i + 1; k < N; k++) {
double sum = 0;
for(int j = 0; j < i; j++) {
sum += L[k][j] * U[j][i];
}
L[k][i] = (A[k][i] - sum) / U[i][i];
}
}
}

void forward_substitution(double L[N][N], double b[N], double y[N]) {

for(int i = 0; i < N; i++) {
double sum = 0;
for(int j = 0; j < i; j++) {
sum += L[i][j] * y[j];
}
y[i] = (b[i] - sum) / L[i][i];
}
}

void backward_substitution(double U[N][N], double y[N], double x[N]) {

 for(int i = N - 1; i >= 0; i--) {
double sum = 0;
for(int j = i + 1; j < N; j++) {
sum += U[i][j] * x[j];
}
x[i] = (y[i] - sum) / U[i][i];
}
}

int main() {
double A[N][N] = {{2, -1, -2},
{-4, 6, 3},
{-4, -2, 8}};
double b[N] = {-1, 0, 3};
double L[N][N], U[N][N];
double y[N], x[N];

printf("LU Decomposition Example:\n");

lu_decomposition(A, L, U);

printf("L matrix:\n");
for(int i = 0; i < N; i++) {
for(int j = 0; j < N; j++) {
printf("%.3f ", L[i][j]);
}
printf("\n");
}

printf("\nU matrix:\n");
for(int i = 0; i < N; i++) {
for(int j = 0; j < N; j++) {
printf("%.3f ", U[i][j]);
}
printf("\n");
}

forward_substitution(L, b, y);
backward_substitution(U, y, x);

printf("\nSolution:\n");
for(int i = 0; i < N; i++) {
printf("x[%d] = %.6f\n", i, x[i]);
}
printf("\n");
 return 0;
}

4. Thomas Algorithm

What is it?
The Thomas Algorithm efficiently solves tridiagonal systems of equations. It's a specialized version of
Gaussian elimination for matrices that have non-zero elements only on three diagonals.

When to use:
When your matrix looks like:

[b₁ c₁ 0 0 ] [x₁] [d₁]

[a₂ b₂ c₂ 0 ] [x₂] = [d₂]
[0 a₃ b₃ c₃ ] [x₃] [d₃]
[0 0 a₄ b₄ ] [x₄] [d₄]

C Code:
c
#include <stdio.h>
#define N 4

void thomas_algorithm(double a[N], double b[N], double c[N], double d[N], double x[N]) {
double c_prime[N], d_prime[N];

// Forward sweep
c_prime[0] = c[0] / b[0];
d_prime[0] = d[0] / b[0];

for(int i = 1; i < N; i++) {

double m = b[i] - a[i] * c_prime[i-1];
c_prime[i] = c[i] / m;
d_prime[i] = (d[i] - a[i] * d_prime[i-1]) / m;
}

// Back substitution
x[N-1] = d_prime[N-1];
for(int i = N-2; i >= 0; i--) {
x[i] = d_prime[i] - c_prime[i] * x[i+1];
}
}

int main() {
// Tridiagonal system example
// Note: a[0] and c[N-1] are not used
double a[N] = {0, -1, -1, -1}; // Lower diagonal
double b[N] = {2, 2, 2, 2}; // Main diagonal
double c[N] = {1, 1, 1, 0}; // Upper diagonal
double d[N] = {1, 0, 0, 1}; // Right hand side
double x[N];

printf("Thomas Algorithm Example:\n");

printf("Solving tridiagonal system...\n");

thomas_algorithm(a, b, c, d, x);

printf("Solution:\n");
for(int i = 0; i < N; i++) {
printf("x[%d] = %.6f\n", i, x[i]);
}
printf("\n");

return 0;
}
5. Jacobi Method for Eigenvalues

What is it?
The Jacobi method finds all eigenvalues of a symmetric matrix by repeatedly applying rotations to make
the matrix diagonal. The diagonal elements become the eigenvalues.

How it works:
1. Find the largest off-diagonal element
2. Apply a rotation to make it zero
3. Repeat until the matrix is diagonal

C Code:
c
#include <stdio.h>
#include <math.h>
#define N 3
#define MAX_ITER 1000
#define TOLERANCE 1e-10

void jacobi_method(double A[N][N], double eigenvalues[N]) {

double V[N][N]; // Eigenvectors matrix
int iter;

// Initialize eigenvectors matrix as identity

for(int i = 0; i < N; i++) {
for(int j = 0; j < N; j++) {
V[i][j] = (i == j) ? 1.0 : 0.0;
}
}

for(iter = 0; iter < MAX_ITER; iter++) {

// Find largest off-diagonal element
int p = 0, q = 1;
double max_val = fabs(A[0][1]);

for(int i = 0; i < N; i++) {

for(int j = i + 1; j < N; j++) {
if(fabs(A[i][j]) > max_val) {
max_val = fabs(A[i][j]);
p = i;
q = j;
}
}
}

// Check convergence
if(max_val < TOLERANCE) {
printf("Converged after %d iterations\n", iter);
break;
}

// Calculate rotation angle

double theta;
if(fabs(A[p][p] - A[q][q]) < TOLERANCE) {
theta = M_PI / 4.0;
} else {
theta = 0.5 * atan(2.0 * A[p][q] / (A[p][p] - A[q][q]));
}
 double c = cos(theta);
double s = sin(theta);

// Apply rotation to A
double temp_pp = A[p][p];
double temp_qq = A[q][q];
double temp_pq = A[p][q];

A[p][p] = c*c*temp_pp + s*s*temp_qq - 2*s*c*temp_pq;

A[q][q] = s*s*temp_pp + c*c*temp_qq + 2*s*c*temp_pq;
A[p][q] = A[q][p] = 0.0;

// Update other elements

for(int i = 0; i < N; i++) {
if(i != p && i != q) {
double temp_ip = A[i][p];
double temp_iq = A[i][q];
A[i][p] = A[p][i] = c*temp_ip - s*temp_iq;
A[i][q] = A[q][i] = s*temp_ip + c*temp_iq;
}
}
}

// Extract eigenvalues from diagonal

for(int i = 0; i < N; i++) {
eigenvalues[i] = A[i][i];
}

printf("Eigenvalues:\n");
for(int i = 0; i < N; i++) {
printf("λ[%d] = %.6f\n", i, eigenvalues[i]);
}
printf("\n");
}

int main() {
double A[N][N] = {{4, -2, 1},
{-2, 4, -2},
{1, -2, 4}};
double eigenvalues[N];

printf("Jacobi Method Example:\n");

jacobi_method(A, eigenvalues);

return 0;
}
6. Givens Method for Eigenvalues

What is it?
The Givens method uses Givens rotations to transform a symmetric matrix into tridiagonal form, then
applies the QR algorithm to find eigenvalues. It's more stable than Jacobi for large matrices.

How it works:
1. Transform matrix to tridiagonal form using Givens rotations

2. Apply QR iterations to find eigenvalues

C Code:
c
#include <stdio.h>
#include <math.h>
#define N 3
#define MAX_ITER 1000
#define TOLERANCE 1e-10

void givens_rotation(double *c, double *s, double a, double b) {

if(b == 0) {
*c = 1.0;
*s = 0.0;
} else {
if(fabs(b) > fabs(a)) {
double tau = -a / b;
*s = 1.0 / sqrt(1.0 + tau*tau);
*c = (*s) * tau;
} else {
double tau = -b / a;
*c = 1.0 / sqrt(1.0 + tau*tau);
*s = (*c) * tau;
}
}
}

void apply_givens(double A[N][N], int i, int j, double c, double s) {

for(int k = 0; k < N; k++) {
double temp1 = A[i][k];
double temp2 = A[j][k];
A[i][k] = c * temp1 - s * temp2;
A[j][k] = s * temp1 + c * temp2;
}

for(int k = 0; k < N; k++) {

double temp1 = A[k][i];
double temp2 = A[k][j];
A[k][i] = c * temp1 - s * temp2;
A[k][j] = s * temp1 + c * temp2;
}
}

void givens_method(double A[N][N], double eigenvalues[N]) {

// Transform to tridiagonal form
for(int k = 0; k < N-2; k++) {
for(int i = k+2; i < N; i++) {
if(fabs(A[i][k]) > TOLERANCE) {
double c, s;
givens_rotation(&c, &s, A[k+1][k], A[i][k]);
 apply_givens(A, k+1, i, c, s);
}
}
}

printf("Tridiagonal form achieved\n");

// Simple eigenvalue extraction from tridiagonal matrix

// (In practice, you'd use QR algorithm here)
for(int i = 0; i < N; i++) {
eigenvalues[i] = A[i][i];
}

printf("Approximate Eigenvalues:\n");
for(int i = 0; i < N; i++) {
printf("λ[%d] = %.6f\n", i, eigenvalues[i]);
}
printf("\n");
}

int main() {
double A[N][N] = {{4, 1, 2},
{1, 4, 1},
{2, 1, 4}};
double eigenvalues[N];

printf("Givens Method Example:\n");

givens_method(A, eigenvalues);

return 0;
}

Key Concepts Summary

When to Use Each Method:

1. Power Method: When you only need the largest eigenvalue

2. Gauss-Seidel: For solving linear systems when the matrix is diagonally dominant
3. LU Decomposition: For solving multiple systems with the same coefficient matrix
4. Thomas Algorithm: Specifically for tridiagonal systems (very efficient)

5. Jacobi Method: For all eigenvalues of small to medium symmetric matrices

6. Givens Method: For eigenvalues of larger matrices (more stable)

Tips for Understanding:

 Start with small matrices (2×2 or 3×3) to see how algorithms work
Print intermediate steps to understand the process

Convergence depends on the condition number of your matrix

Always check if your method is suitable for your specific matrix type

Common Applications in ECE:

Circuit Analysis: Solving node voltage equations (Gauss-Seidel)

Signal Processing: Finding dominant frequencies (Power Method)

Control Systems: Stability analysis (Eigenvalues)

Network Analysis: Solving large sparse systems (Thomas Algorithm)

Remember: These are fundamental building blocks used in more complex engineering software!