Matrix auf Symmetrie prüfen

[Havoc17]

Hi,

Ich würde in meinem Programm gerne eine Matrix einlesen und auf Symetrie überprüfen.

Bsp. Matrix______________ Matrix Transponiert
____1 2 3_______________ 1 2 3 --> ist symetrisch
____2 5 4_______________ 2 5 4
____3 4 6_______________ 3 4 6


main.c

#include <stdio.h>
#include <math.h>
#include <stdlib.h>

void main()
{

    int *ptr_mat;
    int *ptr_mat_trans;
    int *ptr_mat_sym;
    int n, m;


    do
    {

    printf("Bitte n der Matrix eingben ");

    scanf("%d", &n);

    printf("Bitte m der Matrix eingben ");

    scanf("%d", &m);

    if(n!=m)printf("Matrix ist nicht quadratisch \n \n");

    }
    while(m!=n);

    


    ptr_mat=(int*)malloc(n*m*sizeof(int));
    ptr_mat_trans=(int*)malloc(m*n*sizeof(int));
    ptr_mat_sym=(int*)malloc(m*n*sizeof(int));


    mat_eingabe(ptr_mat,m ,n);

    mat_trans (ptr_mat, ptr_mat_trans, m, n);

    printf("\n Matrix normal \n");

    mat_ausgabe(ptr_mat, m, n);

    printf("\n Matrix transformiert \n");
     
    mat_ausgabe(ptr_mat_trans, m, n);

    //mat_sym ();

    free(ptr_mat);
    free(ptr_mat_trans);

    getch();


}

mat_eingabe.c

void mat_eingabe(

                    int *ptr_mat,
                    int m,
                    int n
                    
                    )

        
{
            int i,j;

            for(i=0;i<m;i++)
                for(j=0;j<m;j++)
                {
                    scanf("%d", ptr_mat+i*n+j);

                }

}

mat_trans.c

void mat_trans (
                int *ptr_ein,
                int *ptr_aus,
                int zeilen,
                int spalten
                )

        {
            int i, j ;

            for(i=0;i<zeilen;i++)
                for(j=0;j<spalten;j++)

                    *(ptr_aus+j*zeilen+i)
                    =*(ptr_ein+i*spalten+j);
            

        }

mat_ausgabe

void mat_ausgabe (int *ptr_mat,
                  int zeilen,
                  int spalten)

        {
            int i, j ;
            for(i=0;i<zeilen;i++)
            {printf("\n");

            for(j=0;j<spalten;j++)
            {printf("\t%6d", *(ptr_mat+i*spalten+j));
            }}

        }

mat_sym //FALSCH

void mat_sym (
                int *ptr_mat,
                int *ptr_mat_trans,
                int *ptr_ein,
                int *ptr_aus,
                int zeilen,
                int spalten
                )

{ 
    int m, n;
    if(mat_ausgabe(ptr_mat, m, n)!=mat_ausgabe(ptr_mat_trans, m, n)){printf("asymetrich");}
            

}

Wie kann ich jetzt überprüfen ob die Matrix welche ich eingegeben habe und mat_trans identisch sind?

 

[metax.]

Öh, warum prüfst du nicht in einer Schleife, ob alle Koeffizienten gleich sind?

int matrix_gleich(
                int *ptr_matrix1,
                int *ptr_matrix2,
                int zeilen,
                int spalten
                )
{
  int i;
  for(i=0 ; i < zeilen*spalten ; i++)
  {
    if ( *(ptr_matrix1 + i) != *(ptr_matrix2 + i) ) return 0;
  }
  return 1;
}

mfg, metax.

 

[benediktibk]

Zum Überprüfen auf Symmetrie müsstest du nicht einmal transponieren (so heißt das doch, oder? http://de.wikipedia.org/wiki/Matrix_(Mathematik)#Die_transponierte_Matrix).

bool MatrixSymmetrisch(int *Matrix, unsigned int Zeilen, unsigned int Spalten)
{
     // Überprüfen, ob die rechte obere Hälfte der Matrix mit der linken unteren übereinstimmt
     for (unsigned int i = 0; i < Zeilen; i++)
     for (unsigned int j = i + 1; j < Spalten; j++)
          if (Matrix[i * Spalten + j] != Matrix[j * Spalten + i])
               return false;

     return true;
}

Ungetestet, natürlich. So viel Faulheit muss sein