Matrizenmultiplikation

Elektrostudi

Hallo,

im Rahmen meines Studiums absolviere ich im 2. Semester ein Informatik-Praktikum und bei der Aufgabe ein Programm zur Multiplikation von Matrizen hängen geblieben.

Momentaner Stand:

#include <stdio.h>

int main (void)
{
    struct mat
    {
        int n;
        int m;
    };

    struct mat matrize1={0}, matrize2={0};
    int retwert = 0, zaehl = 0, zaehl2 = 0, zaehl3 = 0, sum = 0;
    printf("Matrizenmultiplikation!!!\n\n");
    printf("Bitte geben Sie Spalten,Zeilen der 1. Matrize ein:");
    retwert = scanf("%i,%i",&matrize1.n, &matrize1.m);
    fpurge(stdin); //bzw fflush!!!

    if (retwert != 2)
    {
        printf("Ungueltige Eingabe!");
    }
    else
    {
        printf("Bitte geben Sie Spalten,Zeilen der 2. Matrize ein:");
        retwert = scanf("%i,%i",&matrize2.n, &matrize2.m);
        fpurge(stdin);  //bzw fflush!!!
        if(retwert != 2)
        {
            printf("Ungueltige Eingabe!");
        }
        else
        {
            if (matrize1.m != matrize2.n)
            {
                printf("Anzahl der Spalten der 1. Matrix muss mit der Anzahl der Zeilen der 2. Matrix übereinstimmen!");
            }
            else
            {
                int mat1[matrize1.m][matrize1.n], mat2[matrize2.m][matrize2.n], mat3[matrize2.n][matrize1.m];
                printf("Eingabe der Elemente der 1. Matrix:\n\n");

                for (zaehl = 1; zaehl <= matrize1.m; zaehl++)
                {
                    for (zaehl2 = 1; zaehl2 <= matrize1.n; zaehl2++)
                    {
                        printf("Element %i,%i:    ",zaehl,zaehl2);
                        retwert = scanf("%i",&mat1[zaehl][zaehl2]);
                        if (retwert != 1)
                        {
                            printf("Ungueltige Eingabe");
                            return 0;
                        }
                    }
                }

                printf("\n\nEingabe der Elemente der 2. Matrix\n\n");
                for (zaehl = 1; zaehl <= matrize2.m; zaehl++)
                {
                    for (zaehl2 = 1; zaehl2 <= matrize2.n; zaehl2++)
                    {
                        printf("Element %i,%i:    ",zaehl,zaehl2);
                        retwert = scanf("%i",&mat2[zaehl][zaehl2]);
                        if (retwert != 1)
                        {
                            printf("Ungueltige Eingabe");
                            return 0;
                        }
                    }
                }

                printf("\n\n Matrix 1:\n\n");
                for (zaehl = 1; zaehl <= matrize1.m; zaehl++)
                {
                    for (zaehl2 = 1; zaehl2 <= matrize1.n; zaehl2++)
                    {
                        printf("%3i   ",mat1[zaehl][zaehl2]);

                    }
                    printf("\n");
                }

                printf("\n\n Matrix 2:\n\n");
                for (zaehl = 1; zaehl <= matrize2.m; zaehl++)
                {
                    for (zaehl2 = 1; zaehl2 <= matrize2.n; zaehl2++)
                    {
                        printf("%3i   ",mat2[zaehl][zaehl2]);

                    }
                    printf("\n");
                }
//////////////////////// Problem:

                for(zaehl2 = 0; zaehl2 < matrize1.m; zaehl2++)
                {
                    for(zaehl = 0; zaehl < matrize2.n; zaehl++)
                    {
                        mat3[zaehl][zaehl2] = mat3[zaehl][zaehl2] + sum;
                        for (zaehl3 = 0; zaehl3<matrize1.n; zaehl3++)
                        {
                            sum = mat1[zaehl][zaehl3]*mat2[zaehl3][zaehl2];
                        }
                    }
                }

////////////////////////
                printf("\n\n Ergebnismatrix:\n\n");
                for (zaehl = 1; zaehl <= matrize1.m; zaehl++)
                {
                    for (zaehl2 = 1; zaehl2 <= matrize2.n; zaehl2++)
                    {
                        printf("%3i   ",mat3[zaehl][zaehl2]);

                    }
                    printf("\n");
                }

            }
        }
    }
}

Mein Problem ist die eigentliche Multiplikation. Da steh ich etwas auf dem Schlauch. Über Hilfe würde ich mich sehr freuen.

LG

Wutz

- VLA (Zeile 40) benutzen nur Deppen
- fflush(stdin) benutzen nur Deppen
- Array-Indexe laufen in C von 0...n-1, Zeile 95+97 ist richtig, der Rest falsch

Zeile 99: Welche Werte haben mat3[zaehl][zaehl2] und sum beim ersten Aufruf?
Und welche Werte, Wenn du ein anderes Element der Matrix berechnest?

Elektrostudi

Danke für alle Antworten. Wutz du musst genauer sein, warum nutzen das nur Deppen deiner Meinung?! Welche Alternative empfiehlst du... Ich bin im 2. Semester.... ich habe keine große Praxiserfahrung, bitte um Verständnis

//		#include der Form <...>

#include <stdio.h>

//		#define-Konstanten und Makros

//		#Datentypen (typedef)

//		Globale Konstanten

//		Globale Variablen

//		Modullokale Konstanten

//		Modullokale Variablen

//		Prototypen modullokaler Funktionen

int main(void)
{

    /*Deklaration und Initialisierung der Variablen */

    double MatrixA[100][100]={0}, MatrixB[100][100]={0}, ErgebnisMatrix[100][100]={0};
    int retwert = 0, ColumnA=0, RowA = 0, ColumnB= 0, RowB = 0, CountColumn = 0, CountRow = 0, Count = 0;

    /*           Ende der Deklarationen             */

    /*           Kopfzeile                          */
    printf("####################################\n");
    printf("###### Matrizenmultiplikation ###### \n");
    printf("####################################\n");

    printf("\n\n");
    /*           Ende Kopfzeile                     */

    /*           Eingabe                            */

    //Format der Matrix A
    printf("Bitte geben Sie die Anzahl der Zeilen und Spalten der 1. Matrix ein:    ");
    retwert = scanf("%i,%i",&RowA,&ColumnA);
    getchar();
    if(retwert != 2)
    {
        printf("\n\nFalsche Eingabe"); return 0; //Abbruch bei weniger als 2 gueltigen Zahlen
    }

    //Format der Matrix B
    printf("Bitte geben Sie die Anzahl der Zeilen und Spalten der 2. Matrix ein:    ");
    retwert = scanf("%i,%i",&RowB,&ColumnB);
    getchar();
    if(retwert != 2)
    {
        printf("\n\nFalsche Eingabe"); return 0; //Abbruch bei weniger als 2 gueltigen Zahlen
    }

    //Ueberpruefung der mathematischen Machbarkeit
    if(ColumnA != RowB)
    {
        printf("\n\nSpaltenzahl der Matrix 1 muss mit der Zeilenzahl der Matrix 2 uebereinstimmen.");
        return 0;
    }

    //Eingabe der Elemente der Matrix 1
    printf("\n\nBitte geben Sie die Elemente der Matrix 1 ein:\n\n");
    for(CountRow = 1; CountRow <= RowA; CountRow++)
    {
        for(CountColumn = 1; CountColumn <= ColumnA; CountColumn++)
        {
            printf("Bitte Element %i,%i eingeben:   ",CountRow,CountColumn);
            retwert = scanf("%lf",&MatrixA[CountColumn][CountRow]);
            getchar();
            if(retwert != 1)
            {
                printf("\n\nFalsche Eingabe");
                return 0;
            }
        }
    }

    //Eingabe der Elemente der Matrix 2
    printf("\n\nBitte geben Sie die Elemente der Matrix 2 ein:\n\n");
    for(CountRow = 1; CountRow <= RowB; CountRow++)
    {
        for(CountColumn = 1; CountColumn <= ColumnB; CountColumn++)
        {
            printf("Bitte Element %i,%i eingeben:   ",CountRow,CountColumn);
            retwert = scanf("%lf",&MatrixB[CountColumn][CountRow]);
            getchar();
            if(retwert != 1)
            {
                printf("\n\nFalsche Eingabe");
                return 0;
            }
        }
    }
    /*           Ende Eingabe                       */

    /*           Ausgabe der Eingabe                */

    //Ausgabe der Matrix 1
    printf("\n\nMatrix 1\n\n");
    for(CountRow = 1; CountRow <= RowA; CountRow++)
    {
        for(CountColumn = 1; CountColumn <= ColumnA; CountColumn++)
        {
            printf("%5.2lf    ",MatrixA[CountColumn][CountRow]);
        }
        printf("\n");
    }
    printf("\n");

    //Ausgabe der Matrix 2
    printf("\n\nMatrix 2\n\n");
    for(CountRow = 1; CountRow <= RowB; CountRow++)
    {
        for(CountColumn = 1; CountColumn <= ColumnB; CountColumn++)
        {
            printf("%5.2lf    ",MatrixB[CountColumn][CountRow]);
        }
        printf("\n");
    }
    printf("\n");
    /*           Ende der Ausgabe der Eingabe       */

    /*           Beginn der Berechnung              */

    for(CountRow = 1;CountRow <= RowA;CountRow++)
    {
        for(CountColumn = 1;CountColumn<=ColumnB;CountColumn++)
        {
            for (Count = 1; Count <= ColumnA; Count++)
            {
                ErgebnisMatrix[CountColumn][CountRow] = ErgebnisMatrix[CountColumn][CountRow] + MatrixA[Count][CountRow]*MatrixB[CountColumn][Count];
            }
        }
    }

    /*           Ende der Berechnung                */

    /*           Beginn Ausgabe Ergebnis            */

    printf("\n\nErgebnis der Matrixmultiplikation:\n\n");
    for(CountRow = 1; CountRow <= RowA; CountRow++)
    {
        for(CountColumn = 1; CountColumn <= ColumnB; CountColumn++)
        {
            printf("%5.2lf    ",ErgebnisMatrix[CountColumn][CountRow]);
        }
        printf("\n");
    }
    /*           Ende Ausgabe Ergebnis              */

    return 0;
}

So funktionierts aufjedenfall für meine Zwecke

Elektrostudi schrieb:

So funktionierts aufjedenfall für meine Zwecke

Ist aber trotzdem falsch, denn:

Wutz schrieb:

- Array-Indexe laufen in C von 0...n-1,

Immer!

Das klappt bei dir, wiel du keine 100x100 Matrix probiert hast.

Elektrostudi schrieb:

/*Deklaration und Initialisierung der Variablen */

Das sind Definitionen.

Es macht sich auch immer gut, wenn man die Berechnung von der Ein-/Ausgabe trennt.
Da bietet es sich an, Funktionen zu nutzen.

Elektrostudi

so sollte der n-1 nicht erreicht werden denk ich.

/*Definition und Initialisierung der Variablen */

    double MatrixA[101][101]={0}, MatrixB[101][101]={0}, ErgebnisMatrix[101][101]={0};
    int retwert = 0, ColumnA=0, RowA = 0, ColumnB= 0, RowB = 0, CountColumn = 0, CountRow = 0, Count = 0;

    /*           Ende der Definition            */

    /*           Kopfzeile                          */
    printf("####################################\n");
    printf("###### Matrizenmultiplikation ###### \n");
    printf("####################################\n");

    printf("\n\n");
    /*           Ende Kopfzeile                     */

    /*           Eingabe                            */

    //Format der Matrix A
    printf("Bitte geben Sie die Anzahl der Zeilen und Spalten der 1. Matrix ein:    ");
    retwert = scanf("%i,%i",&RowA,&ColumnA);
    getchar();
    if(retwert != 2 || RowA>100 || ColumnA>100)
    {
        printf("\n\nFalsche Eingabe"); return 0; //Abbruch bei weniger als 2 gueltigen Zahlen
    }

    //Format der Matrix B
    printf("Bitte geben Sie die Anzahl der Zeilen und Spalten der 2. Matrix ein:    ");
    retwert = scanf("%i,%i",&RowB,&ColumnB);
    getchar();
    if(retwert != 2 || RowB > 100 || ColumnB > 100)
    {
        printf("\n\nFalsche Eingabe"); return 0; //Abbruch bei weniger als 2 gueltigen Zahlen
    }

Danke für deine Hilfe. Du meintest die Berechnung in eine Funktion packen. kann ich den Array als Rückgabewert zurückgeben? Wenn ja wie geht das?

Elektrostudi schrieb:

so sollte der n-1 nicht erreicht werden denk ich.

Besser du fängst bei 0 an zu zählen und gehst in deinen Schleifen bis < statt <=.

Elektrostudi schrieb:

kann ich den Array als Rückgabewert zurückgeben? Wenn ja wie geht das?

Übergib das (Ziel-)Array als Paramter. (Wird bei strcpy auch gemacht)