Write A Program For Matrix Multiplication By Checking Compatibility In C

In this article, you will learn how to implement matrix multiplication in C, including the essential step of checking for matrix compatibility before performing the operation.

Problem Statement

Matrix multiplication is a fundamental operation in linear algebra, but it comes with a strict rule: for two matrices, A and B, to be multiplied (A * B), the number of columns in matrix A must be equal to the number of rows in matrix B. If this condition is not met, the matrices are incompatible for multiplication, and attempting to multiply them will result in an error or incorrect dimensions. The challenge is to write a C program that not only performs the multiplication but also robustly validates this compatibility rule.

Example

Consider two 2x2 matrices:

Matrix A:

1 2
3 4

Matrix B:

5 6
7 8

Since Matrix A has 2 columns and Matrix B has 2 rows, they are compatible for multiplication. The resulting matrix C will be 2x2:

Matrix C (A * B):

1*5 + 2*7   1*6 + 2*8    =>   19  22
3*5 + 4*7   3*6 + 4*8    =>   43  50

Background & Knowledge Prerequisites

To understand and implement matrix multiplication in C, you should have a basic grasp of:

• C Programming Fundamentals: Variables, data types, loops (for loops are critical), conditional statements (if-else).
• Arrays in C: How to declare, initialize, and access elements in 2D arrays.
• Functions in C: Basic understanding of defining and calling functions.
• Basic Linear Algebra: The concept of a matrix, rows, columns, and the fundamental rule of matrix multiplication.

Use Cases or Case Studies

Matrix multiplication is a cornerstone in various fields due to its ability to transform and combine data efficiently. Here are a few practical examples:

• Computer Graphics: Used extensively for 2D and 3D transformations such as translation, rotation, scaling, and projection of objects in gaming and visualization software.
• Image Processing: Applied in filters for blurring, sharpening, edge detection, and other image manipulation tasks.
• Machine Learning: Essential for neural networks, where it's used in forwarding and backward propagation to compute weighted sums of inputs and update parameters.
• Physics and Engineering Simulations: Used to solve systems of linear equations, model complex systems, and perform structural analysis.
• Data Analysis: Employed in statistical models and algorithms like Principal Component Analysis (PCA) for dimensionality reduction.

Solution Approaches

Approach 1: Basic Matrix Multiplication with Compatibility Check

This approach involves reading the dimensions of two matrices from the user, checking if they are compatible, and then proceeding with the multiplication if they are. If not, an appropriate error message is displayed.

• One-line summary: Reads matrix dimensions, validates compatibility, then performs the standard triple-nested loop multiplication.

// Matrix Multiplication with Compatibility Check
#include <stdio.h>

#define MAX_DIM 10 // Define a maximum dimension for matrices

// Function to read matrix elements
void readMatrix(int matrix[MAX_DIM][MAX_DIM], int rows, int cols) {
    printf("Enter elements:\\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("Enter element [%d][%d]: ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }
}

// Function to print matrix elements
void printMatrix(int matrix[MAX_DIM][MAX_DIM], int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d\\t", matrix[i][j]);
        }
        printf("\\n");
    }
}

int main() {
    int mat1[MAX_DIM][MAX_DIM], mat2[MAX_DIM][MAX_DIM], result[MAX_DIM][MAX_DIM];
    int r1, c1, r2, c2;

    // Step 1: Get dimensions for the first matrix
    printf("Enter rows and columns for first matrix (e.g., 2 3): ");
    scanf("%d %d", &r1, &c1);

    // Step 2: Get dimensions for the second matrix
    printf("Enter rows and columns for second matrix (e.g., 3 2): ");
    scanf("%d %d", &r2, &c2);

    // Step 3: Check compatibility for multiplication
    if (c1 != r2) {
        printf("Error: Matrices are not compatible for multiplication.\\n");
        printf("Number of columns in first matrix must be equal to number of rows in second matrix.\\n");
        return 1; // Indicate an error
    }

    // Step 4: Read elements for the first matrix
    printf("\\n--- Enter elements for First Matrix (%dx%d) ---\\n", r1, c1);
    readMatrix(mat1, r1, c1);

    // Step 5: Read elements for the second matrix
    printf("\\n--- Enter elements for Second Matrix (%dx%d) ---\\n", r2, c2);
    readMatrix(mat2, r2, c2);

    // Step 6: Perform matrix multiplication
    // The resulting matrix will have dimensions r1 x c2
    for (int i = 0; i < r1; i++) {
        for (int j = 0; j < c2; j++) {
            result[i][j] = 0; // Initialize element to 0
            for (int k = 0; k < c1; k++) { // Or k < r2, since c1 == r2
                result[i][j] += mat1[i][k] * mat2[k][j];
            }
        }
    }

    // Step 7: Display the matrices and their product
    printf("\\n--- First Matrix ---\\n");
    printMatrix(mat1, r1, c1);

    printf("\\n--- Second Matrix ---\\n");
    printMatrix(mat2, r2, c2);

    printf("\\n--- Product of Matrices (%dx%d) ---\\n", r1, c2);
    printMatrix(result, r1, c2);

    return 0; // Indicate successful execution
}

Run

• Sample Output:

Enter rows and columns for first matrix (e.g., 2 3): 2 2
Enter rows and columns for second matrix (e.g., 3 2): 2 2

--- Enter elements for First Matrix (2x2) ---
Enter element [0][0]: 1
Enter element [0][1]: 2
Enter element [1][0]: 3
Enter element [1][1]: 4

--- Enter elements for Second Matrix (2x2) ---
Enter element [0][0]: 5
Enter element [0][1]: 6
Enter element [1][0]: 7
Enter element [1][1]: 8

--- First Matrix ---
1	2	
3	4	

--- Second Matrix ---
5	6	
7	8	

--- Product of Matrices (2x2) ---
19	22	
43	50

• Stepwise Explanation:

1. Define MAX_DIM: A constant MAX_DIM is defined to set the maximum size for the rows and columns of the matrices. This simplifies array declaration for demonstration purposes. For very large matrices or unknown sizes at compile time, dynamic memory allocation using malloc would be preferred.
2. readMatrix and printMatrix Functions: These utility functions handle user input for matrix elements and displaying matrices, respectively, making the main function cleaner.
3. Dimension Input: The program prompts the user to enter the number of rows and columns for both matrices (e.g., r1, c1 for the first matrix and r2, c2 for the second).
4. Compatibility Check: An if (c1 != r2) statement is used to check the core compatibility rule: the number of columns in the first matrix (c1) must equal the number of rows in the second matrix (r2). If they are not equal, an error message is printed, and the program exits.
5. Matrix Element Input: If compatible, the readMatrix function is called to populate both mat1 and mat2 with user-entered values.
6. Multiplication Logic: The heart of the program is the triple-nested for loop structure:
   • The outer two loops (i from 0 to r1-1 and j from 0 to c2-1) iterate through each element of the result matrix. The resultant matrix will have r1 rows and c2 columns.

1. Display Results: Finally, all three matrices (the two input matrices and their product) are printed to the console using the printMatrix function for clear visualization.

Conclusion

Implementing matrix multiplication in C requires careful attention to the compatibility rule where the number of columns of the first matrix must match the number of rows of the second. By incorporating this check, programs become more robust, preventing errors and ensuring valid mathematical operations. The standard approach involves triple-nested loops to compute each element of the product matrix, accumulating the sum of products for corresponding row and column elements.

Summary

• Matrix multiplication A * B is only possible if the number of columns in A equals the number of rows in B.
• The resulting product matrix will have the number of rows from A and the number of columns from B.
• In C, 2D arrays are typically used to represent matrices.
• The core multiplication logic uses three nested for loops: two for iterating through the result matrix elements and one for calculating the sum of products.
• Input validation for matrix dimensions is crucial for preventing runtime errors and ensuring mathematical correctness.
• Common use cases include computer graphics transformations, image processing filters, and computations in machine learning.