C Program For Transpose Of Two Matrices

Introduction

Matrix transposition is a fundamental operation in linear algebra, with wide-ranging applications in various fields like computer graphics, data analysis, and scientific computing. It involves converting a matrix by swapping its rows with its columns. In this article, you will learn how to write a C program to transpose a given matrix.

Problem Statement

The problem is to take an input matrix, which can have 'm' rows and 'n' columns, and produce a new matrix where the rows of the original matrix become the columns of the new matrix, and the columns of the original become the rows of the new matrix. If the original matrix is of dimension m x n, its transpose will be of dimension n x m.

Example

Consider an original 2x3 matrix:

1 2 3
4 5 6

Its transpose, which will be a 3x2 matrix, would be:

1 4
2 5
3 6

Background & Knowledge Prerequisites

To understand and implement matrix transposition in C, readers should have a basic grasp of the following concepts:

• C Language Basics: Variables, data types, input/output operations (printf, scanf).
• Loops: for loops for iteration.
• Arrays: Understanding how to declare and manipulate one-dimensional and especially two-dimensional arrays (matrices).
• Basic Matrix Concepts: Familiarity with rows, columns, and matrix elements.

Use Cases

Matrix transposition is not just an academic exercise; it has practical applications across many domains:

• Linear Algebra Operations: Essential for matrix multiplication, finding inverses, and solving systems of linear equations.
• Image Processing: Used for operations like rotating images by 90 degrees or performing specific filters.
• Data Analysis and Machine Learning: Often employed to reshape datasets for algorithms, converting features from rows to columns or vice-versa.
• Graph Theory: When representing graphs using adjacency matrices, transposing the matrix can reveal properties like reverse edges.
• Computer Graphics: Used in transformations and projections to manipulate 3D objects in a 2D space.

Solution Approaches

For transposing a matrix, the most common approach involves creating a new matrix to store the result. This method is straightforward and works for matrices of any dimension (square or non-square).

Approach 1: Transposing a Matrix into a New Matrix

This approach involves iterating through the elements of the original matrix and placing them into a new matrix such that the element at original[i][j] is placed at transpose[j][i].

One-line Summary: Create a new matrix with swapped dimensions and populate it by assigning transpose[j][i] = original[i][j] for each element.

Code Example:

// Matrix Transposition
#include <stdio.h>

#define MAX_ROWS 10
#define MAX_COLS 10

int main() {
    int original[MAX_ROWS][MAX_COLS];
    int transpose[MAX_COLS][MAX_ROWS]; // Dimensions are swapped for the transpose
    int rows, cols, i, j;

    // Step 1: Get matrix dimensions from the user
    printf("Enter the number of rows and columns for the matrix (max %d x %d):\\n", MAX_ROWS, MAX_COLS);
    if (scanf("%d %d", &rows, &cols) != 2 || rows <= 0 || cols <= 0 || rows > MAX_ROWS || cols > MAX_COLS) {
        printf("Invalid dimensions. Please enter positive values within limits.\\n");
        return 1;
    }

    // Step 2: Input elements of the original matrix
    printf("Enter elements of the matrix:\\n");
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            printf("Enter element original[%d][%d]: ", i, j);
            if (scanf("%d", &original[i][j]) != 1) {
                printf("Invalid input. Please enter an integer.\\n");
                return 1;
            }
        }
    }

    // Step 3: Print the original matrix
    printf("\\nOriginal Matrix:\\n");
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            printf("%d\\t", original[i][j]);
        }
        printf("\\n");
    }

    // Step 4: Compute the transpose matrix
    // Rows of original become columns of transpose, and vice-versa
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            transpose[j][i] = original[i][j];
        }
    }

    // Step 5: Print the transposed matrix
    printf("\\nTransposed Matrix:\\n");
    for (i = 0; i < cols; i++) { // Iterate up to original 'cols' for rows of transpose
        for (j = 0; j < rows; j++) { // Iterate up to original 'rows' for columns of transpose
            printf("%d\\t", transpose[i][j]);
        }
        printf("\\n");
    }

    return 0;
}

Run

Sample Output:

Enter the number of rows and columns for the matrix (max 10 x 10):
2 3
Enter elements of the matrix:
Enter element original[0][0]: 1
Enter element original[0][1]: 2
Enter element original[0][2]: 3
Enter element original[1][0]: 4
Enter element original[1][1]: 5
Enter element original[1][2]: 6

Original Matrix:
1	2	3	
4	5	6	

Transposed Matrix:
1	4	
2	5	
3	6

Stepwise Explanation for Approach 1:

1. Declare Matrices: Two 2D arrays are declared: original to store the input matrix and transpose to store the resulting transposed matrix. It's crucial to declare transpose with dimensions MAX_COLS x MAX_ROWS because the rows and columns will be swapped.
2. Get Dimensions: The program prompts the user to enter the number of rows (rows) and columns (cols) for the original matrix. Basic input validation is included to ensure valid dimensions.
3. Input Elements: Using nested for loops, the program iterates through each position [i][j] of the original matrix and prompts the user to enter its element.
4. Print Original Matrix: The program then prints the entered original matrix to allow the user to verify the input.
5. Compute Transpose: This is the core step. Another set of nested for loops iterates through the original matrix. For each element original[i][j], it is assigned to transpose[j][i]. This effectively swaps the row and column indices.
6. Print Transposed Matrix: Finally, the program prints the transpose matrix. Note that when printing the transposed matrix, the outer loop now runs cols times (for the new number of rows) and the inner loop runs rows times (for the new number of columns).

Conclusion

Matrix transposition is a fundamental operation with broad utility in various computational tasks. By understanding how to iterate through a matrix and swap its indices, you can effectively transpose any given matrix in C. The approach of creating a new matrix is robust and straightforward for matrices of any dimension, providing a clear and efficient solution.

Summary

• Matrix Transposition: Swapping rows with columns of a matrix; an m x n matrix becomes an n x m matrix.
• Core Logic: An element at original[i][j] is moved to transpose[j][i].
• Implementation Steps:
• Declare two 2D arrays: one for the original matrix and another for the transposed matrix (with swapped dimensions).
• Read the dimensions and elements of the original matrix from the user.
• Use nested loops to populate the transpose matrix: transpose[j][i] = original[i][j];.
• Print both the original and the transposed matrices.