C Program To Find Transpose Of A Matrix Using Functions

Matrix transposition is a fundamental operation in linear algebra, essential for various computational tasks. In this article, you will learn how to implement a C program to find the transpose of a matrix efficiently using functions.

Problem Statement

A matrix transpose is an operation where the rows and columns of a matrix are interchanged. If the original matrix is denoted as A and its transpose as Aᵀ, then the element at row i and column j in A becomes the element at row j and column i in Aᵀ. This transformation is crucial in areas like data manipulation, image processing, and scientific computing.

Example

Consider a 2x3 matrix A:

1  2  3
4  5  6

Its transpose Aᵀ would be a 3x2 matrix:

1  4
2  5
3  6

Background & Knowledge Prerequisites

To understand this article, readers should have a basic grasp of:

• C Programming Basics: Variables, data types, loops (for loops).
• Arrays: Specifically, two-dimensional arrays (matrices) in C.
• Functions: Defining, declaring, and calling user-defined functions in C.
• Standard I/O: Using stdio.h for input (scanf) and output (printf).

Use Cases or Case Studies

Matrix transposition is applied in numerous fields:

• Linear Algebra: Solving systems of linear equations, calculating determinants, and in various matrix decompositions.
• Image Processing: Rotating images, applying filters, and other transformations often involve matrix transpositions.
• Data Analysis: In statistics, covariance matrices or correlation matrices might be transposed for specific calculations or presentations.
• Computer Graphics: Transformations of 3D objects, such as rotations and reflections, often utilize matrix operations, including transposition.
• Graph Theory: Representing graphs using adjacency matrices, where transposing can reveal properties like reachability in directed graphs.

Solution Approaches

For transposing a matrix using functions in C, the most direct approach involves creating a dedicated function that takes the original matrix and its dimensions, then computes and stores the transpose.

Transposing a Matrix Using a User-Defined Function

This approach encapsulates the transposition logic within a function, promoting modularity and reusability. The main function handles user input and output, calling the transpose function to perform the core operation.

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

// Function to read elements of a matrix
void readMatrix(int rows, int cols, int matrix[rows][cols]) {
    printf("Enter elements of the matrix (%d x %d):\\n", rows, cols);
    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 a matrix
void printMatrix(int rows, int cols, int matrix[rows][cols]) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d\\t", matrix[i][j]);
        }
        printf("\\n");
    }
}

// Function to find the transpose of a matrix
void transposeMatrix(int rows, int cols, int originalMatrix[rows][cols], int transposedMatrix[cols][rows]) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            transposedMatrix[j][i] = originalMatrix[i][j];
        }
    }
}

int main() {
    int rows, cols;

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

    // Step 2: Declare original and transposed matrices using Variable Length Arrays (VLAs)
    // VLAs are a C99 feature; for older C standards, dynamic allocation or fixed size arrays are needed.
    int originalMatrix[rows][cols];
    int transposedMatrix[cols][rows]; // Transposed matrix will have cols rows and rows cols

    // Step 3: Read elements into the original matrix using a function
    readMatrix(rows, cols, originalMatrix);

    // Step 4: Print the original matrix using a function
    printf("\\nOriginal Matrix:\\n");
    printMatrix(rows, cols, originalMatrix);

    // Step 5: Compute the transpose using a function
    transposeMatrix(rows, cols, originalMatrix, transposedMatrix);

    // Step 6: Print the transposed matrix using a function
    printf("\\nTransposed Matrix:\\n");
    printMatrix(cols, rows, transposedMatrix); // Note: dimensions are swapped for printing

    return 0;
}

Run

Sample Output

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

Original Matrix:
1       2       3
4       5       6

Transposed Matrix:
1       4
2       5
3       6

Stepwise Explanation

1. readMatrix Function: This function takes the number of rows, columns, and a 2D array as input. It uses nested for loops to iterate through each element and prompt the user to enter its value, storing it in the provided matrix.
2. printMatrix Function: Similar to readMatrix, this function takes dimensions and a matrix. It iterates through the matrix and prints each element, followed by a tab (\t) for formatting. A newline character (\n) is printed after each row to maintain matrix structure.
3. transposeMatrix Function: This is the core logic. It accepts the original matrix's dimensions (rows, cols), the originalMatrix, and an empty transposedMatrix (note its dimensions are cols by rows). It iterates through the originalMatrix using i for rows and j for columns. For each element originalMatrix[i][j], it assigns it to transposedMatrix[j][i], effectively swapping row and column indices.
4. main Function:
   • It first prompts the user to enter the number of rows and columns for the matrix.

It then declares two 2D arrays: originalMatrix with the user-defined rows and cols, and transposedMatrix with cols and rows (since its dimensions are inverted). These are Variable Length Arrays (VLAs), a C99 feature.

It calls readMatrix to populate the originalMatrix.

It calls printMatrix to display the originalMatrix.

It invokes transposeMatrix to compute the transpose, passing both matrices and the original dimensions.

Finally, it calls printMatrix again to display the transposedMatrix. Note that when printing the transposed matrix, the arguments for rows and columns are swapped (cols, rows) to correctly reflect its dimensions.

Conclusion

Using functions to modularize a program, such as finding the transpose of a matrix, enhances code readability, maintainability, and reusability. By separating input, output, and the core transposition logic into distinct functions, the program becomes easier to understand and debug. This approach demonstrates a clean and structured way to handle matrix operations in C.

Summary

• A matrix transpose swaps the rows and columns of a matrix.
• Functions improve code organization and reusability for tasks like matrix operations.
• The transposeMatrix function iterates through the original matrix, assigning originalMatrix[i][j] to transposedMatrix[j][i].
• Variable Length Arrays (VLAs) in C allow defining array dimensions at runtime, useful for dynamic matrix sizes.
• Separate functions for reading and printing matrices streamline the main program flow.