matrix_rotation_v1.c

/*

    matrix_rotation_v1.c        by Dragan Milicev

https://www.facebook.com/groups/3092811364081112/permalink/7581588861869984/
https://www.geeksforgeeks.org/turn-an-image-by-90-degree/
https://www.geeksforgeeks.org/inplace-rotate-square-matrix-by-90-degrees/
https://prepinsta.com/c-program/rotate-a-matrix-by-90-degree-in-clockwise-direction/

    Matrix rotation:

- 90 degrees to the right, three versions
- 90 degrees to the left
- around the horizontal axis, two versions
- around the vertical axis, two versions


You can find all my C programs at Dragan Milicev's pastebin:

https://pastebin.com/u/dmilicev

https://www.facebook.com/dmilicev

*/


#include <stdio.h>
#include <stdlib.h> // for exit()

#define MAX_SIZE 15


// Displays the matrix M[r][k] that has r rows and k columns
void print_matrix( char *text, int M[][MAX_SIZE], int r, int k )
{
    int i, j;

    printf("\n%s\n\n",text);

    for(i=0;i<r;i++) {
        for(j=0;j<k;j++)
            printf("%4d",M[i][j]);

        printf("\n\n");
    }
    printf("\n");
}


// Create the matrix M[r][k] that has r rows and k columns
// Elements are ordinal numbers.
void create_matrix( int M[][MAX_SIZE], int r, int k )
{
    int i, j;

    for(i=0;i<r;i++)
        for(j=0;j<k;j++)
            M[i][j] = i*k + j+1;
}


// Functions that do not change the matrix M, just displays rotated matrix


// Displays a matrix rotated around a horizontal axis.
void display_matrix_rotated_around_horizontal_axis( int M[][MAX_SIZE], int r, int k )
{
   int i,j;

    for(i=r-1;i>=0;i--){
        for(j=0;j<k;j++){
            printf(" %4d",M[i][j]);
        }
        printf("\n\n");
    }
}


// Displays a matrix rotated around a horizontal axis, version 1.
void display_matrix_rotated_around_horizontal_axis_v1( int M[][MAX_SIZE], int r, int k )
{
   int i,j,ip=r-1,jp;       // ip and jp are indexes for displaying M[ip][jp]

    for(i=0;i<r;i++){
        jp=0;
        for(j=0;j<k;j++)
            printf(" %4d",M[ip][jp++]);
        ip--;
        printf("\n\n");
    }
}


// Displays a matrix rotated around a vertical axis, version 1
void display_matrix_rotated_around_vertical_axis_v1( int M[][MAX_SIZE], int r, int k )
{
   int i,j,ip=0,jp;     // ip and jp are indexes for displaying M[ip][jp]

    for(i=0;i<r;i++){
        jp=k-1;
        for(j=0;j<k;j++)
            printf(" %4d",M[ip][jp--]);
        ip++;
        printf("\n\n");
    }
}


// Displays a matrix rotated around a vertical axis
void display_matrix_rotated_around_vertical_axis( int M[][MAX_SIZE], int r, int k )
{
   int i,j;

    for(i=0;i<r;i++){
        for(j=k-1;j>=0;j--)
            printf(" %4d",M[i][j]);
        printf("\n\n");
    }
}


// Displays the matrix rotated to the right by 90 degrees, version 2.
// The first is the bottom left element and its column is displayed backwards as the first row.
// Columns become rows and are displayed backwards.
void display_matrix_rotated_right_90_degrees_v2( int M[][MAX_SIZE], int r, int k )
{
   int i,j,ip,jp=0;     // ip and jp are indexes for displaying M[ip][jp]

    for(i=0;i<r;i++){
        ip=r-1;
        for(j=0;j<k;j++)
            printf(" %4d",M[ip--][jp]);
        jp++;
        printf("\n\n");
    }
}


// Displays the matrix rotated to the right by 90 degrees, version 1.
// The first is the bottom left element and its column is displayed backwards as the first row.
// Columns become rows and are displayed backwards.
void display_matrix_rotated_right_90_degrees_v1( int M[][MAX_SIZE], int r, int k )
{
    int i,j;

    for(j=0;j<k;j++){
        for(i=r-1;i>=0;i--)
            printf(" %4d",M[i][j]);
        printf("\n\n");
    }
}


// Displays the matrix rotated to the right by 90 degrees.
// The first is the bottom left element and its column is displayed backwards as the first row.
// Columns become rows and are displayed backwards.
void display_matrix_rotated_right_90_degrees( int M[][MAX_SIZE], int r, int k )
{
    int i,j;

    for(i=0;i<k;i++){
        for(j=k-1;j>=0;j--)
            printf(" %4d",M[j][i]); // ATTENTION, indexes replaced places M[j][i]
        printf("\n\n");
    }
}


// Displays the matrix rotated to the left by 90 degrees.
// The first is the top right element and its first right column is displayed as the first row.
// Columns become rows.
void display_matrix_rotated_left_90_degrees( int M[][MAX_SIZE], int r, int k )
{
   int i,j,ip,jp=k-1;   // ip and jp are indexes for displaying M[ip][jp]

    for(i=0;i<r;i++){
        ip=0;
        for(j=0;j<k;j++)
            printf(" %4d",M[ip++][jp]);
        jp--;
        printf("\n\n");
    }
}


// Copies matrix M to matrix M1, r is the number of rows, k is the number of columns
void copy_matrix( int M1[][MAX_SIZE], int M[][MAX_SIZE], int r, int k )
{
    int i,j;

    for(i=0;i<r;i++)
        for(j=0;j<k;j++)
            M1[i][j] = M[i][j];
}


// Functions that change the matrix M when rotating


// Rotates the matrix to the right 90 degrees.
void rotate_matrix_right_90_degrees( int M[][MAX_SIZE], int r, int k )
{
    int M1[MAX_SIZE][MAX_SIZE];     // declare a new matrix M1
    int i,j;

    copy_matrix(M1,M,r,k);          // copy matrix M to matrix M1

    // Form the matrix M again by taking from the matrix M1
    // certain elements and put them in the matrix M.
    for(i=0;i<r;i++)
        for(j=0;j<k;j++)
            M[i][j] = M1[k-1-j][i];
}

// auxiliary function
void swap(int *x, int *y){
    int temp = *x;
    *x = *y;
    *y= temp;
}

// Rotation the matrix to the right 90 degrees without auxiliary matrix,
// ONLY FOR SQUARE MATRICES !
void rotate_matrix_right_90_degrees_v1( int M[][MAX_SIZE], int r, int k )
{
    int i,j;

    //Rotate the matrix about the main diagonal
    for(int i=0; i<r; i++)
     for(int j=0; j<i; j++)
         swap(&M[i][j], &M[j][i]); // The above auxiliary function for swapping places

    //Rotate the matrix about middle column
    for(int i=0; i<r; i++)
     for(int j=0; j<r/2; j++)
        swap(&M[i][j], &M[i][r-j-1]); // The above auxiliary function for swapping places
}


// Rotates the matrix to the left 90 degrees.
void rotate_matrix_left_90_degrees( int M[][MAX_SIZE], int r, int k )
{
    int M1[MAX_SIZE][MAX_SIZE];     // declare a new matrix M1
    int i,j;

    copy_matrix(M1,M,r,k);          // Copy matrix M to matrix M1

    // Form the matrix M again by taking from the matrix M1
    // certain elements and put them in the matrix M.
    for(i=0;i<r;i++)
        for(j=0;j<k;j++)
            M[i][j] = M1[j][r-1-i];
}


// Rotates the matrix around the horizontal axis.
void rotate_matrix_around_horizontal_axis( int M[][MAX_SIZE], int r, int k )
{
    int M1[MAX_SIZE][MAX_SIZE]; // declare a new matrix M1
    int i,j;

    copy_matrix(M1,M,r,k);      // Copy matrix M to matrix M1

    // Form the matrix M again by taking from the matrix M1
    // certain elements and put them in the matrix M.
    for(i=0;i<r;i++)
        for(j=0;j<k;j++)
            M[i][j] = M1[r-i-1][j];
}


// Rotates the matrix around the vertical axis.
void rotate_matrix_around_vertical_axis( int M[][MAX_SIZE], int r, int k )
{
    int M1[MAX_SIZE][MAX_SIZE]; // declare a new matrix M1
    int i,j;

    copy_matrix(M1,M,r,k);      // Copy matrix M to matrix M1

    // Form the matrix M again by taking from the matrix M1
    // certain elements and put them in the matrix M.
    for(i=0;i<r;i++)
        for(j=0;j<k;j++)
            M[i][j] = M1[i][k-1-j];
}



int main(void)
{
    int M[MAX_SIZE][MAX_SIZE];
    int i, r=4, c=4;
    // r is the number of rows and c is the number of columns of the matrix M[][]

    create_matrix(M,r,c);
    print_matrix(" Matrix M is: ",M,r,c);

    printf("\n Functions that do not change the matrix M, just displays rotated matrix : \n\n");

    printf(" \n Matrix rotated to the right by 90 degrees is: \n\n");
    display_matrix_rotated_right_90_degrees(M,r,c);

    printf(" \n Matrix rotated to the right by 90 degrees v1 is: \n\n");
    display_matrix_rotated_right_90_degrees_v1(M,r,c);

    printf(" \n Matrix rotated to the right by 90 degrees v2 is: \n\n");
    display_matrix_rotated_right_90_degrees_v2(M,r,c);

    printf(" \n Matrix rotated to the left by 90 degrees is: \n\n");
    display_matrix_rotated_left_90_degrees(M,r,c);

    printf(" \n Matrix rotated around the horizontal axis is: \n\n");
    display_matrix_rotated_around_horizontal_axis(M,r,c);

    printf(" \n Matrix rotated around the horizontal axis v1 is: \n\n");
    display_matrix_rotated_around_horizontal_axis_v1(M,r,c);

    printf(" \n Matrix rotated around the vertical axis is: \n\n");
    display_matrix_rotated_around_vertical_axis(M,r,c);

    printf(" \n Matrix rotated around the vertical axis v1 is: \n\n");
    display_matrix_rotated_around_vertical_axis_v1(M,r,c);

    print_matrix(" Matrix M is: ",M,r,c);


    printf("\n Functions that change the matrix M when rotating : \n\n");

    rotate_matrix_right_90_degrees(M,r,c);
    print_matrix(" Matrix rotated to the right 90 degrees is: ",M,r,c);

    create_matrix(M,r,c);    // reset the matrix M because it was modified
    rotate_matrix_left_90_degrees(M,r,c);
    print_matrix(" Matrix rotated to the left 90 degrees is: ",M,r,c);

    create_matrix(M,r,c);    // reset the matrix M because it was modified
    rotate_matrix_around_horizontal_axis(M,r,c);
    print_matrix(" Matrix rotated around the horizontal axis is: ",M,r,c);

    create_matrix(M,r,c);    // reset the matrix M because it was modified
    rotate_matrix_around_vertical_axis(M,r,c);
    print_matrix(" Matrix rotated around the vertical axis is: ",M,r,c);

    create_matrix(M,r,c);    // reset the matrix M because it was modified
    print_matrix(" Matrix M is: ",M,r,c);


    // Rotation without auxiliary matrix, ONLY FOR SQUARE MATRICES !
    rotate_matrix_right_90_degrees_v1(M,r,c);
    print_matrix(" Matrix rotated to the right 90 degrees v1 is: ",M,r,c);


    return 0;
}