Program for Gauss-Jordan Elimination Method

Prerequisite : Gaussian Elimination to Solve Linear Equations

Introduction : The Gauss-Jordan method, also known as Gauss-Jordan elimination method is used to solve a system of linear equations and is a modified version of Gauss Elimination Method.

It is similar and simpler than Gauss Elimination Method as we have to perform 2 different process in Gauss Elimination Method i.e. 

1. Formation of upper triangular matrix, and 
2. Back substitution

But in case of Gauss-Jordan Elimination Method, we only have to form a reduced row echelon form (diagonal matrix). Below given is the flow-chart of Gauss-Jordan Elimination Method.

Flow Chart of Gauss-Jordan Elimination Method :

Examples :

Input :  2y + z = 4
         x + y + 2z = 6
         2x + y + z = 7

Output :
Final Augmented Matrix is : 
1 0 0 2.2 
0 2 0 2.8 
0 0 -2.5 -3 

Result is : 2.2 1.4 1.2 

Explanation : Below given is the explanation of the above example. 

• Input Augmented Matrix is :

• Interchanging R1 and R2, we get

• Performing the row operation R3 <- R3 – (2*R1)

• Performing the row operations R1 <- R1 – ((1/2)* R2) and R3 <- R3 + ((1/2)*R2)

• Performing R1 <- R1 + ((3/5)*R3) and R2 <- R2 + ((2/5)*R3)

• Unique Solutions are :

Implementation:

C++

// C++ Implementation for Gauss-Jordan
// Elimination Method
#include <bits/stdc++.h>
using namespace std;

#define M 10

// Function to print the matrix
void PrintMatrix(float a[][M], int n)
{
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= n; j++)
          cout << a[i][j] << " ";
        cout << endl;
    }
}

// function to reduce matrix to reduced
// row echelon form.
int PerformOperation(float a[][M], int n)
{
    int i, j, k = 0, c, flag = 0, m = 0;
    float pro = 0;

    // Performing elementary operations
    for (i = 0; i < n; i++)
    {
        if (a[i][i] == 0)
        {
            c = 1;
            while ((i + c) < n && a[i + c][i] == 0)
                c++;
            if ((i + c) == n) {
                flag = 1;
                break;
            }
            for (j = i, k = 0; k <= n; k++)
                swap(a[j][k], a[j+c][k]);
        }

        for (j = 0; j < n; j++) {

            // Excluding all i == j
            if (i != j) {

                // Converting Matrix to reduced row
                // echelon form(diagonal matrix)
                float pro = a[j][i] / a[i][i];

                for (k = 0; k <= n; k++)
                    a[j][k] = a[j][k] - (a[i][k]) * pro;
            }
        }
    }
    return flag;
}

// Function to print the desired result
// if unique solutions exists, otherwise
// prints no solution or infinite solutions
// depending upon the input given.
void PrintResult(float a[][M], int n, int flag)
{
    cout << "Result is : ";

    if (flag == 2)
      cout << "Infinite Solutions Exists" << endl;
    else if (flag == 3)
      cout << "No Solution Exists" << endl;


    // Printing the solution by dividing constants by
    // their respective diagonal elements
    else {
        for (int i = 0; i < n; i++)
            cout << a[i][n] / a[i][i] << " ";
    }
}

// To check whether infinite solutions
// exists or no solution exists
int CheckConsistency(float a[][M], int n, int flag)
{
    int i, j;
    float sum;

    // flag == 2 for infinite solution
    // flag == 3 for No solution
    flag = 3;
    for (i = 0; i < n; i++)
    {
        sum = 0;
        for (j = 0; j < n; j++)
            sum = sum + a[i][j];
        if (sum == a[i][j])
            flag = 2;
    }
    return flag;
}

// Driver code
int main()
{
    float a[M][M] = {{ 0, 2, 1, 4 },
                     { 1, 1, 2, 6 },
                     { 2, 1, 1, 7 }};

    // Order of Matrix(n)
    int n = 3, flag = 0;

    // Performing Matrix transformation
    flag = PerformOperation(a, n);

    if (flag == 1)
        flag = CheckConsistency(a, n, flag);

    // Printing Final Matrix
    cout << "Final Augmented Matrix is : " << endl;
    PrintMatrix(a, n);
    cout << endl;

    // Printing Solutions(if exist)
    PrintResult(a, n, flag);

    return 0;
}

Java

// Java Implementation for Gauss-Jordan
// Elimination Method
class GFG {

static int M = 10;

// Function to print the matrix
static void PrintMatrix(float a[][], int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j <= n; j++)
            System.out.print(a[i][j] + " ");
        System.out.println();
    }
}

// function to reduce matrix to reduced
// row echelon form.
static int PerformOperation(float a[][], int n)
{
    int i, j, k = 0, c, flag = 0, m = 0;
    float pro = 0;

    // Performing elementary operations
    for (i = 0; i < n; i++)
    {
        if (a[i][i] == 0)
        {
            c = 1;
            while ((i + c) < n && a[i + c][i] == 0)
                c++;
            if ((i + c) == n)
            {
                flag = 1;
                break;
            }
            for (j = i, k = 0; k <= n; k++)
            {
                float temp =a[j][k];
                a[j][k] = a[j+c][k];
                a[j+c][k] = temp;
            }
        }

        for (j = 0; j < n; j++)
        {

            // Excluding all i == j
            if (i != j)
            {

                // Converting Matrix to reduced row
                // echelon form(diagonal matrix)
                float p = a[j][i] / a[i][i];

                for (k = 0; k <= n; k++)
                    a[j][k] = a[j][k] - (a[i][k]) * p;
            }
        }
    }
    return flag;
}

// Function to print the desired result
// if unique solutions exists, otherwise
// prints no solution or infinite solutions
// depending upon the input given.
static void PrintResult(float a[][], int n, int flag)
{
    System.out.print("Result is : ");

    if (flag == 2)
    System.out.println("Infinite Solutions Exists");
    else if (flag == 3)
    System.out.println("No Solution Exists");


    // Printing the solution by dividing constants by
    // their respective diagonal elements
    else {
        for (int i = 0; i < n; i++)
            System.out.print(a[i][n] / a[i][i] +" ");
    }
}

// To check whether infinite solutions
// exists or no solution exists
static int CheckConsistency(float a[][], int n, int flag)
{
    int i, j;
    float sum;

    // flag == 2 for infinite solution
    // flag == 3 for No solution
    flag = 3;
    for (i = 0; i < n; i++)
    {
        sum = 0;
        for (j = 0; j < n; j++)
            sum = sum + a[i][j];
        if (sum == a[i][j])
            flag = 2;
    }
    return flag;
}

// Driver code
public static void main(String[] args)
{
    float a[][] = {{ 0, 2, 1, 4 },
                    { 1, 1, 2, 6 },
                    { 2, 1, 1, 7 }};

    // Order of Matrix(n)
    int n = 3, flag = 0;

    // Performing Matrix transformation
    flag = PerformOperation(a, n);

    if (flag == 1)
        flag = CheckConsistency(a, n, flag);

    // Printing Final Matrix
    System.out.println("Final Augmented Matrix is : ");
    PrintMatrix(a, n);
    System.out.println("");

    // Printing Solutions(if exist)
    PrintResult(a, n, flag);
}
}

/* This code contributed by PrinciRaj1992 */

Python3

# Python3 Implementation for Gauss-Jordan
# Elimination Method
M = 10

# Function to print the matrix
def PrintMatrix(a, n):
    for i in range(n):
        print(*a[i])

# function to reduce matrix to reduced
# row echelon form.
def PerformOperation(a, n):
    i = 0
    j = 0
    k = 0
    c = 0
    flag = 0
    m = 0
    pro = 0

    # Performing elementary operations
    for i in range(n):
        if (a[i][i] == 0):

            c = 1
            while ((i + c) < n and a[i + c][i] == 0):
                c += 1
            if ((i + c) == n):

                flag = 1
                break

            j = i
            for k in range(1 + n):

                temp = a[j][k]
                a[j][k] = a[j+c][k]
                a[j+c][k] = temp

        for j in range(n):

            # Excluding all i == j
            if (i != j):
                # Converting Matrix to reduced row
                # echelon form(diagonal matrix)
                p = a[j][i] / a[i][i]

                k = 0
                for k in range(n + 1):
                    a[j][k] = a[j][k] - (a[i][k]) * p

    return flag

# Function to print the desired result
# if unique solutions exists, otherwise
# prints no solution or infinite solutions
# depending upon the input given.
def PrintResult(a, n, flag):

    print("Result is : ")

    if (flag == 2):
        print("Infinite Solutions Exists<br>")
    elif (flag == 3):
        print("No Solution Exists<br>")

    # Printing the solution by dividing constants by
    # their respective diagonal elements
    else:
        for i in range(n):
            print(a[i][n] / a[i][i], end=" ")

# To check whether infinite solutions
# exists or no solution exists
def CheckConsistency(a, n, flag):

    # flag == 2 for infinite solution
    # flag == 3 for No solution
    flag = 3
    for i in range(n):
        sum = 0
        for j in range(n):
            sum = sum + a[i][j]
        if (sum == a[i][j]):
            flag = 2

    return flag

# Driver code
a = [[0, 2, 1, 4],  [1, 1, 2, 6],   [2, 1, 1, 7]]

# Order of Matrix(n)
n = 3
flag = 0

# Performing Matrix transformation
flag = PerformOperation(a, n)

if (flag == 1):
    flag = CheckConsistency(a, n, flag)

# Printing Final Matrix
print("Final Augmented Matrix is : ")
PrintMatrix(a, n)
print()

# Printing Solutions(if exist)
PrintResult(a, n, flag)

# This code is contributed by phasing17

C#

// C# Implementation for Gauss-Jordan
// Elimination Method
using System;
using System.Collections.Generic;

class GFG
{
static int M = 10;

// Function to print the matrix
static void PrintMatrix(float [,]a, int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j <= n; j++)
            Console.Write(a[i, j] + " ");
        Console.WriteLine();
    }
}

// function to reduce matrix to reduced
// row echelon form.
static int PerformOperation(float [,]a, int n)
{
    int i, j, k = 0, c, flag = 0;

    // Performing elementary operations
    for (i = 0; i < n; i++)
    {
        if (a[i, i] == 0)
        {
            c = 1;
            while ((i + c) < n && a[i + c, i] == 0)
                c++;
            if ((i + c) == n)
            {
                flag = 1;
                break;
            }
            for (j = i, k = 0; k <= n; k++)
            {
                float temp = a[j, k];
                a[j, k] = a[j + c, k];
                a[j + c, k] = temp;
            }
        }

        for (j = 0; j < n; j++)
        {

            // Excluding all i == j
            if (i != j)
            {

                // Converting Matrix to reduced row
                // echelon form(diagonal matrix)
                float p = a[j, i] / a[i, i];

                for (k = 0; k <= n; k++)
                    a[j, k] = a[j, k] - (a[i, k]) * p;
            }
        }
    }
    return flag;
}

// Function to print the desired result
// if unique solutions exists, otherwise
// prints no solution or infinite solutions
// depending upon the input given.
static void PrintResult(float [,]a,
                        int n, int flag)
{
    Console.Write("Result is : ");

    if (flag == 2)
    Console.WriteLine("Infinite Solutions Exists");
    else if (flag == 3)
    Console.WriteLine("No Solution Exists");

    // Printing the solution by dividing
    // constants by their respective
    // diagonal elements
    else
    {
        for (int i = 0; i < n; i++)
            Console.Write(a[i, n] / a[i, i] + " ");
    }
}

// To check whether infinite solutions
// exists or no solution exists
static int CheckConsistency(float [,]a,
                            int n, int flag)
{
    int i, j;
    float sum;

    // flag == 2 for infinite solution
    // flag == 3 for No solution
    flag = 3;
    for (i = 0; i < n; i++)
    {
        sum = 0;
        for (j = 0; j < n; j++)
            sum = sum + a[i, j];
        if (sum == a[i, j])
            flag = 2;
    }
    return flag;
}

// Driver code
public static void Main(String[] args)
{
    float [,]a = {{ 0, 2, 1, 4 },
                  { 1, 1, 2, 6 },
                  { 2, 1, 1, 7 }};

    // Order of Matrix(n)
    int n = 3, flag = 0;

    // Performing Matrix transformation
    flag = PerformOperation(a, n);

    if (flag == 1)
        flag = CheckConsistency(a, n, flag);

    // Printing Final Matrix
    Console.WriteLine("Final Augmented Matrix is : ");
    PrintMatrix(a, n);
    Console.WriteLine("");

    // Printing Solutions(if exist)
    PrintResult(a, n, flag);
}
}

// This code is contributed by 29AjayKumar

Javascript

<script>

// JavaScript Implementation for Gauss-Jordan
// Elimination Method

let M = 10;

// Function to print the matrix
function PrintMatrix(a,n)
{
    for (let i = 0; i < n; i++)
    {
        for (let j = 0; j <= n; j++)
            document.write(a[i][j] + " ");
        document.write("<br>");
    }
}

// function to reduce matrix to reduced
// row echelon form.
function PerformOperation(a,n)
{
    let i, j, k = 0, c, flag = 0, m = 0;
    let pro = 0;

    // Performing elementary operations
    for (i = 0; i < n; i++)
    {
        if (a[i][i] == 0)
        {
            c = 1;
            while ((i + c) < n && a[i + c][i] == 0)
                c++;
            if ((i + c) == n)
            {
                flag = 1;
                break;
            }
            for (j = i, k = 0; k <= n; k++)
            {
                let temp =a[j][k];
                a[j][k] = a[j+c][k];
                a[j+c][k] = temp;
            }
        }

        for (j = 0; j < n; j++)
        {

            // Excluding all i == j
            if (i != j)
            {

                // Converting Matrix to reduced row
                // echelon form(diagonal matrix)
                let p = a[j][i] / a[i][i];

                for (k = 0; k <= n; k++)
                    a[j][k] = a[j][k] - (a[i][k]) * p;
            }
        }
    }
    return flag;
}

// Function to print the desired result
// if unique solutions exists, otherwise
// prints no solution or infinite solutions
// depending upon the input given.
function PrintResult(a,n,flag)
{
    document.write("Result is : ");

    if (flag == 2)
        document.write("Infinite Solutions Exists<br>");
    else if (flag == 3)
        document.write("No Solution Exists<br>");


    // Printing the solution by dividing constants by
    // their respective diagonal elements
    else {
        for (let i = 0; i < n; i++)
            document.write(a[i][n] / a[i][i] +" ");
    }
}

// To check whether infinite solutions
// exists or no solution exists
function CheckConsistency(a,n,flag)
{
    let i, j;
    let sum;

    // flag == 2 for infinite solution
    // flag == 3 for No solution
    flag = 3;
    for (i = 0; i < n; i++)
    {
        sum = 0;
        for (j = 0; j < n; j++)
            sum = sum + a[i][j];
        if (sum == a[i][j])
            flag = 2;
    }
    return flag;
}

// Driver code
let a=[[ 0, 2, 1, 4 ],
                    [ 1, 1, 2, 6 ],
                    [ 2, 1, 1, 7 ]];
// Order of Matrix(n)
let n = 3, flag = 0;

// Performing Matrix transformation
flag = PerformOperation(a, n);

if (flag == 1)
    flag = CheckConsistency(a, n, flag);

// Printing Final Matrix
document.write("Final Augmented Matrix is : <br>");
PrintMatrix(a, n);
document.write("<br>");

// Printing Solutions(if exist)
PrintResult(a, n, flag);



// This code is contributed by rag2127

</script>

Output

Final Augmented Matrix is : 
1 0 0 2.2 
0 2 0 2.8 
0 0 -2.5 -3 

Result is : 2.2 1.4 1.2 

Applications :

• Solving System of Linear Equations: Gauss-Jordan Elimination Method can be used for finding the solution of a systems of linear equations which is applied throughout the mathematics.
• Finding Determinant: The Gaussian Elimination can be applied to a square matrix in order to find determinant of the matrix.
• Finding Inverse of Matrix: The Gauss-Jordan Elimination method can be used in determining the inverse of a square matrix.
• Finding Ranks and Bases: Using reduced row echelon form, the ranks as well as bases of square matrices can be computed by Gaussian elimination method.