C Program To Add Two Matrix

This article will guide you through the process of adding two matrices using the C programming language. You will learn the fundamental logic, necessary syntax, and practical implementation steps to perform matrix addition.

Problem Statement

Matrix addition is a fundamental operation in linear algebra where two matrices of the same dimensions are combined to produce a new matrix. Each element in the resulting sum matrix is the sum of the corresponding elements in the input matrices. The primary challenge lies in correctly iterating through the elements of both matrices and storing their sums in a third matrix, ensuring that the input matrices have identical numbers of rows and columns.

Example

Consider two 2x2 matrices:

Matrix A:

1 2
3 4

Matrix B:

5 6
7 8

Their sum, Matrix C, would be:

6  8
10 12

Background & Knowledge Prerequisites

To understand and implement matrix addition in C, you should have a basic understanding of:

• C Fundamentals: Variables, data types, and basic input/output operations.
• Arrays: How to declare, initialize, and access elements in one-dimensional and multi-dimensional arrays (specifically 2D arrays for matrices).
• Loops: for loops are crucial for iterating through matrix elements.
• Conditional Statements: Basic if statements for dimension checks.

Use Cases or Case Studies

Matrix addition is a foundational operation with applications across various fields:

• Image Processing: Used for blending images, where pixel values (often represented as matrices) are added to combine visual data.
• Computer Graphics: In transformations, matrices can be added to combine different geometric operations or translate objects.
• Physics and Engineering: Solving systems of linear equations, analyzing structural loads, or combining force vectors often involves matrix operations.
• Data Analysis: Combining datasets or features where data is structured as matrices, such as merging financial data or sensor readings.
• Machine Learning: While more complex matrix operations are common, addition forms a base for understanding how layers combine information in neural networks or in certain data aggregation tasks.

Solution Approaches

The most common and straightforward approach for matrix addition involves iterating through each corresponding element of the two matrices and summing them into a new result matrix.

Direct Element-wise Addition

This approach involves using nested loops to traverse both input matrices simultaneously, adding their respective elements, and storing the sum in the corresponding position of a third matrix.

• One-line summary: Iterate through rows and columns, adding elements at the same index from two input matrices into a result matrix.

// Matrix Addition
#include <stdio.h>

int main() {
    int rows, cols;

    // Step 1: Get matrix dimensions from the user
    printf("Enter the number of rows: ");
    scanf("%d", &rows);
    printf("Enter the number of columns: ");
    scanf("%d", &cols);

    // Step 2: Declare two matrices and a result matrix
    // Using variable length arrays (VLA) available in C99,
    // otherwise, fixed-size arrays or dynamic allocation would be needed.
    int matrix1[rows][cols];
    int matrix2[rows][cols];
    int sumMatrix[rows][cols];

    // Step 3: Input elements for the first matrix
    printf("\\nEnter elements of first matrix:\\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("Enter element matrix1[%d][%d]: ", i, j);
            scanf("%d", &matrix1[i][j]);
        }
    }

    // Step 4: Input elements for the second matrix
    printf("\\nEnter elements of second matrix:\\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("Enter element matrix2[%d][%d]: ", i, j);
            scanf("%d", &matrix2[i][j]);
        }
    }

    // Step 5: Perform matrix addition
    printf("\\nPerforming Matrix Addition...\\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            sumMatrix[i][j] = matrix1[i][j] + matrix2[i][j];
        }
    }

    // Step 6: Display the sum matrix
    printf("\\nSum of the two matrices:\\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d\\t", sumMatrix[i][j]);
        }
        printf("\\n"); // Move to the next line after each row
    }

    return 0;
}

Run

• Sample Output:

Enter the number of rows: 2
Enter the number of columns: 2

Enter elements of first matrix:
Enter element matrix1[0][0]: 1
Enter element matrix1[0][1]: 2
Enter element matrix1[1][0]: 3
Enter element matrix1[1][1]: 4

Enter elements of second matrix:
Enter element matrix2[0][0]: 5
Enter element matrix2[0][1]: 6
Enter element matrix2[1][0]: 7
Enter element matrix2[1][1]: 8

Performing Matrix Addition...

Sum of the two matrices:
6	8	
10	12

• Stepwise Explanation:

1. Get Dimensions: The program first prompts the user to enter the number of rows and columns. It's crucial that both matrices have the same dimensions for addition to be valid.
2. Declare Matrices: Three two-dimensional integer arrays (matrix1, matrix2, and sumMatrix) are declared using the user-provided rows and cols.
3. Input First Matrix: Nested for loops iterate rows times for the outer loop and cols times for the inner loop. Inside, scanf reads each element into matrix1[i][j].
4. Input Second Matrix: Similar to the first, this step prompts for and reads elements into matrix2[i][j].
5. Perform Addition: Another set of nested for loops is used. For each (i, j) position, the element from matrix1[i][j] is added to matrix2[i][j], and the result is stored in sumMatrix[i][j].
6. Display Result: Finally, the sumMatrix is printed to the console using nested loops, formatting it as a matrix with tabs between elements and newlines after each row.

Conclusion

Adding two matrices in C involves obtaining the dimensions, reading elements into two separate matrices, performing element-wise addition using nested loops, and then displaying the resulting sum matrix. This fundamental operation highlights the use of 2D arrays and iterative constructs in C for data manipulation.

Summary

• Matrix addition requires two matrices to have identical dimensions (same number of rows and columns).
• The sum matrix is created by adding corresponding elements from the input matrices.
• C programming utilizes two-dimensional arrays to represent matrices.
• Nested for loops are essential for iterating through rows and columns to input elements and perform the addition.
• The resulting sum matrix can then be displayed in a structured format.