C Program For Addition Of Two Matrices Using Functions

Matrix addition is a fundamental operation in linear algebra, widely used in various computational fields. Understanding how to perform this operation efficiently, especially using functions in C, is crucial for modular and readable code.

In this article, you will learn how to write a C program to add two matrices using a dedicated function, enhancing code organization and reusability.

Problem Statement

The problem involves adding two matrices of the same dimensions to produce a third matrix. Each element in the resulting matrix is the sum of the corresponding elements from the input matrices. This operation is common in data processing, scientific computing, and graphics. A key constraint is that matrix addition is only defined for matrices with identical numbers of rows and columns.

Example

Consider two 2x2 matrices, A and B:

Matrix A:

1  2
3  4

Matrix B:

5  6
7  8

The result of adding Matrix A and Matrix B, resulting in Matrix C, would be:

Matrix C (A + B):

(1+5)  (2+6)    =   6   8
(3+7)  (4+8)        10  12

Background & Knowledge Prerequisites

To understand and implement matrix addition in C using functions, you should be familiar with:

• C Basics: Variables, data types, input/output operations (printf, scanf).
• Arrays: Declaring and manipulating one-dimensional and two-dimensional arrays.
• Loops: for loops for iterating through array elements.
• Functions: Defining functions, passing arguments (especially arrays), and returning values (implicitly modifying arrays passed by reference).

For setup, you only need a standard C compiler (like GCC) installed on your system. No special libraries are required for this basic operation.

Use Cases or Case Studies

Matrix addition finds application in numerous domains:

• Image Processing: Used for blending two images by adding their pixel intensity matrices. For example, combining two photographic exposures.
• Computer Graphics: In transformations, combining multiple transformation matrices (though typically matrix multiplication is more common here, additive adjustments can occur). It's also used for combining light sources or texture layers.
• Data Analysis: Combining datasets or features represented as matrices. For instance, aggregating survey results from multiple sources.
• Physics and Engineering Simulations: Solving systems of linear equations or modeling physical phenomena where quantities are represented in matrix form and need to be combined.
• Machine Learning (Neural Networks): While complex operations dominate, fundamental matrix additions are part of calculating biases and propagating values through layers.

Solution Approaches

For adding two matrices, the most straightforward and common approach is element-wise addition using nested loops. When structuring this in C, using functions is key for modularity.

Adding Matrices Using Functions

This approach encapsulates the matrix addition logic within a function, making the main program cleaner and the addition logic reusable.

One-line summary: Define a function that takes two input matrices and a result matrix along with their dimensions, then performs element-wise addition.

// Matrix Addition using Functions
#include <stdio.h>

// Function to add two matrices and store the result in a third matrix
// Note: For simplicity, matrices are assumed to have a maximum size of 10x10.
// In real-world scenarios, dynamic memory allocation or VLAs might be used.
void addMatrices(int mat1[10][10], int mat2[10][10], int result[10][10], int rows, int cols) {
    // Step 1: Iterate through each row of the matrices
    for (int i = 0; i < rows; i++) {
        // Step 2: Iterate through each column in the current row
        for (int j = 0; j < cols; j++) {
            // Step 3: Add corresponding elements from mat1 and mat2
            // Store the sum in the result matrix at the same position
            result[i][j] = mat1[i][j] + mat2[i][j];
        }
    }
}

// Function to display a matrix
void displayMatrix(int matrix[10][10], int rows, int cols) {
    // Step 1: Print a header for the matrix
    printf("Matrix:\\n");
    // Step 2: Iterate through each row to print its elements
    for (int i = 0; i < rows; i++) {
        // Step 3: Iterate through each column to print the element
        for (int j = 0; j < cols; j++) {
            // Print the element followed by a tab for spacing
            printf("%d\\t", matrix[i][j]);
        }
        // Move to the next line after printing all elements in a row
        printf("\\n");
    }
}

int main() {
    // Step 1: Declare variables for matrix dimensions and the matrices themselves
    int rows, cols;
    int matrix1[10][10], matrix2[10][10], sumMatrix[10][10]; // Assuming max 10x10

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

    // Basic validation for dimensions
    if (rows <= 0 || rows > 10 || cols <= 0 || cols > 10) {
        printf("Invalid dimensions. Please enter rows/cols between 1 and 10.\\n");
        return 1; // Indicate an error
    }

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

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

    // Step 5: Display the input matrices for verification
    printf("\\n--- Input Matrices ---\\n");
    printf("First ");
    displayMatrix(matrix1, rows, cols);
    printf("\\nSecond ");
    displayMatrix(matrix2, rows, cols);

    // Step 6: Call the addMatrices function to perform the addition
    addMatrices(matrix1, matrix2, sumMatrix, rows, cols);

    // Step 7: Display the resulting sum matrix
    printf("\\n--- Result ---\\n");
    printf("Sum of the two matrices:\\n");
    displayMatrix(sumMatrix, rows, cols);

    return 0; // Indicate successful execution
}

Run

Sample Output:

Enter number of rows (max 10): 2
Enter number of columns (max 10): 2
Enter elements of the first matrix:
Enter element a11: 1
Enter element a12: 2
Enter element a21: 3
Enter element a22: 4
Enter elements of the second matrix:
Enter element b11: 5
Enter element b12: 6
Enter element b21: 7
Enter element b22: 8

--- Input Matrices ---
First Matrix:
1       2
3       4

Second Matrix:
5       6
7       8

--- Result ---
Sum of the two matrices:
Matrix:
6       8
10      12

Stepwise explanation for clarity:

1. Include Header: The stdio.h header is included for standard input/output functions like printf and scanf.
2. addMatrices Function Definition:
   • This function takes three 2D integer arrays (mat1, mat2, result) and two integers (rows, cols) as parameters. mat1 and mat2 are the matrices to be added, and result will store their sum.

1. displayMatrix Function Definition:
   • This helper function takes a 2D integer array and its dimensions to print its contents neatly to the console.

1. main Function:
   • Declare Variables: Integer variables rows and cols are declared for matrix dimensions. Three 2D arrays (matrix1, matrix2, sumMatrix) are declared to store the input matrices and their sum, respectively. They are given a fixed maximum size (10x10) for simplicity.

Conclusion

Adding matrices is a foundational operation in many computing applications. By implementing this operation using functions in C, we achieve better code organization, readability, and reusability. The example demonstrates a clear and structured approach to define and call a function for matrix addition, which is crucial for handling complex mathematical operations in a modular way. This method ensures that the core logic for addition is separated from input/output concerns, making the program easier to understand and maintain.

Summary

• Matrix addition is an element-wise operation, requiring both matrices to have identical dimensions.
• Functions in C allow for modular programming, making code reusable and easier to manage.
• A dedicated addMatrices function can encapsulate the logic for summing corresponding elements using nested loops.
• Helper functions, such as displayMatrix, improve code clarity by separating concerns.
• Understanding 2D arrays and how to pass them to functions is essential for matrix operations in C.