Zweidimensionale Array multiplizieren

Java-Forum Java-Grundlagen
1

In diesem Code geht es darum 2 Matrizen miteinander zu multiplizieren und das Ergebnis in einem dritten Array zu speichern.
Leider komme ich hier in eine Endlosschleife.
Ich sehe den Fehler einfach nicht. Kann jemand helfen ?

    {   int[][] matrix3 = new int[matrix1.length][matrix1.length];
        int i = 0;
        int j = 0;
        if( matrix1.length == matrix2.length)
        {
            while(i < matrix1**.length)
            {
                for(  j = 0; j < matrix1[j].length-1; j++)
                {
                    matrix3**[j] = matrix1**[j] * matrix2**[j];
                    
                    
                }
                if( j >= matrix1.length)
                    {
                        i++;
                        j = 0;
                    }
            }
            
         
        }
        return matrix3;
    }```
Würde mich über eine Antwort freuen, die Unwissende nicht verurteilt.
2

welch bessere Aufgabe zur Entwicklung eigener Fähigkeiten könnte es geben?
du hast doch alle Zeit der Welt, den Code systematisch zu untersuchen,

baue zunächst ein Thread.sleep(100) mit try/ catch drumherum in die Schleife, um nicht von Ausgaben überschwemmt zu werden,
und dann baue Ausgaben ein, System.out.println(), schaue dir an was dein Programm macht! (evtl. auch alternativ ein Debugger)

es geht gewiss in die Schleife rein, sonst nicht endlos,
gib zu Beginn jeder Schleife i aus und den Vergleichswert matrix1**.length

auch ohne Ausgabe kann man schon erahnen, dass i wohl gar nicht erst ansteigen wird,
und das ist ja auch im Code schnell als plausibel zu vermuten, die Erhöhung steht nur in einem if, wer weiß ob das ausgeführt wird
→ sofort mit Ausgabe darin prüfen, OB es ausgeführt wird,

wie kommt das innere if zum Funktionieren? j muss durch die innere Schleife einen bestimmten Wert erreichen, auch diesen loggen,
und dann schaue dir schließlich an was die Schleife mit j denn macht, bis welchen Wert läuft j?
schon ungewöhnlicher dynamischer Endwert matrix1[j].length-1 der von j abhängt, sich in jeder Runde ändern könnte

gewiss ist an dieser Stelle was anderes gemeint, aber wozu das noch genauer erwähnen?
all die Schritte bisher sind die simpelsten, auf die man als Programmierer kommen kann,

was hindert dich, falls du dazu überlegen und was schreiben willst?
falls das ganze zufällig extra eine Aufgabe für dich ist kannst du sie von anderen lösen lassen und ohne Lernfortschritt bleiben,
aber bei allen guten Geistern: dies zu lernen, dies zu können, hier selber zur Lösung zu finden ist zentrale Grundfähigkeit von Programmierung,
solltest du unbedingt unbedingt selber versuchen, genauer analysieren was du alles herausfinden kannst, wo du am Ende nicht weiterkommst!

habe ich vielleicht nicht geschafft, aber nur mit besten Absichten für dich :wink:
ein Kind soll ja auch selber laufen statt bis zum 18. Lebensjahr getragen zu werden (und dann vielleicht zu spät, es noch zu lernen, Langzeitfolgen)

edit: der ganze Aufbau beider Schleifen ist vielleicht durcheinander, i, j, welche Dimension von welchen Arrays durchlaufen,
schreibe dir auch noch auf Papier auf, was genau alles einzeln zu rechnen ist für eine Beispiel-Multiplikation,
und gehe dann im Programm durch ob in der richtigen Reihenfolge dasselbe dran kommt

eine while-Schleife braucht es auch gar nicht, warum keine for-Schleife für i?
Ergebnis mag falsch bleiben, evtl. Exceptions, aber zumindest kann es dann nicht ewig laufen

edit:
und bei while: wieso überhaupt ein if für das j? darf der Fall vorkommen dass sich j nicht erhöht? für welchen Zweck?
so viele einfache Ansatzpunkte, das Problem zu klären

3

Warum mischst Du denn die Schleifenform?
benutze einfach 2 for und es kann gar nicht shief gehen.if( matrix1.length == matrix2.length) { for( i = 0; i < matrix1.length-1; i++) { for( j = 0; j < matrix1**.length-1; j++) { matrix3**[j] = matrix1**[j] * matrix2**[j]; } } }
[edit] Achja: du iterierst in beide Richtungen ein mal zu wenig… (habe ich NICHT korrigiert)
bye
TT

4

Könnte es eventuell daran liegen das j niemals größergleich matrix1.length wird?
Ich schätze mal bei einer nicht quadratischen Matrix kann das auftreten, denn du erhöst j nur solange wie es kleiner ist als die Anzahl der Zeilen der Matrix, i wird aber nur erhöht wenn j größergleich die Anzahl Spalten der Matrix ist.

*Edit: Und so stürzten sie sich alle zugleich auf die Anfänger Array-Frage :smiley:

5

Abgesehen von den von meinen Vorpostern genannten Punkten möchte ich noch anmerken, dass du die Regeln zur Matrixmultiplikation nicht umsetzt.

6

@Tmothy_Truckle
dies funktioniert so nicht, sonst hätte ich auch 2 Schleifen genutzt

7

Verurteilen tut hier keiner was, aber

matrix3**[j] = matrix1**[j] * matrix2**[j];

ist natürlich harter Tobak. Richtig wäre

du musst über einen Index summieren - jeweils matrix1**[k]*matrix2[k][j] aufsummieren über k, usw.

dazu muss Spaltenzahl(matrix1)==Zeilenzahl(matrix2)

int[][] matrix3 = new int[matrix1.length][matrix1.length];
//
        if( matrix1.length == matrix2.length)

kann so nicht funktionieren. Bevor du so ein Programm schreibst, musst du natürlich die Matrizenmultiplikation verstanden haben

du brauchst 3 Schleifen

über i
über j
ergebnis**[j] berechnet sich über eine summe über k

8

Das Programm soll die Matrix so lösen : {2,2} {2,2} {4,4}
{2,2} * {3,3} = {6,6} das soll dabei rauskommen. Es geht hier nicht um allgemeine Regeln der Matrix!

9

[quote=luke01]Das Programm soll die Matrix so lösen : {2,2} {2,2} {4,4}
{2,2} * {3,3} = {6,6} das soll dabei rauskommen. Es geht hier nicht um allgemeine Regeln der Matrix![/quote]

Warum schreibst du dann: ** geht es darum 2 Matrizen miteinander zu multiplizieren**

da denkt doch jeder sofort an die Matrizenmultiplikation?

[quote=luke01;121277]Das Programm soll die Matrix so lösen : {2,2} {2,2} {4,4}
{2,2} * {3,3} = {6,6} das soll dabei rauskommen.[/quote]

Mal ein weiterer Tipp: das kann man nicht verstehen, wo ist da “die” Matrix (warum der bestimmte Artikel?), woher kommt plötzlich {3,3}

10

[quote=luke01]@Tmothy_Truckle
dies funktioniert so nicht, sonst hätte ich auch 2 Schleifen genutzt[/quote]
schreibe doch auch, warum das nicht funktioniert,

wie gesagt, eine von meinen Fragen: wieso das i++ in einem if versteckt?,
gibt es einen Schleifendurchlauf bei dem i nicht erhöht werden soll, und was ist dann mit dem nächsten Schleifendurchlauf,
soll sich j dann weiter erhöhen? wäre eine Möglichkeit, passiert nach Code aber nicht, j startet immer wieder bei 0 → eine Korrekturmöglichkeit

oder wenn i in jedem Schleifendurchlauf erhöht werden soll, dann nimm das if weg und die Endlosschleife dürfte auch beendet sein,
deine Frage unter Ignorierung aller tausend wichtigen Punkte wohl nicht genauer zu beantworten

für alles andere könntest du dich vielleicht doch herablassen, ein paar mehr Sätze Erklärung und Beispielverläufe zu posten :wink:

[quote=luke01;121277]Das Programm soll die Matrix so lösen : {2,2} {2,2} {4,4}
{2,2} * {3,3} = {6,6} das soll dabei rauskommen. Es geht hier nicht um allgemeine Regeln der Matrix![/quote]
zeichnet sich auch durch Einsilbigkeit (Ein-Satz-igkeit) und wenig Nachvollziehbarkeit aus,
was ist {2,2}, eine eigene Matrix? oder gehören mehrere davon zusammen? …

11

Ich vermute, dass mit {2,2} {2,2} {4,4} das gemeint ist: {2,2} * {2,2} = {4,4}.
Was das allerdings mit Matrizen zu tun hat, selbst wenn man sie nicht im mathematischen, sondern im “2D-Array-Sinne” meint, weiß ich immer noch nicht. Das sind zumindest eindimensionale “Matrizen”.
Alles ziemlich konfus…

12

sollte vielleicht untereinanderstehen:


|a, b|    |c, d|   |a*c, b*d|
|e, f| x  |g, h| = |e*g, f*h|


->

|2, 2|    |2, 2|   |4, 4|
|2, 2| x  |3, 3| = |6, 6|

man muss sich nur Mühe geben für ausführliche eindeutige Postings und Beispiele,
so viel sinnvolles zu lernen :wink:

13

Auf welche unterschiedliche Arten werden denn zwei Matrizen miteinander “multipliziert”? Kreuzprodukt fände ich auch genial, aber das geht nicht mit jeder Form.

14

Tatsache, wenn man den Beitrag mal zitiert, sieht man auch die ganzen Leerzeichen am Anfang der zweiten Zeile.

15

@luke01 : Als ‘ganz einfaches’ KSCKB könntest du nehmen:


     public static void main(String []args){
        System.out.println(java.util.Arrays.deepToString(multiply1(
            new int[][] {
                {1,2},
                {3,4}
            },
            new int[][] {
                {8,7},
                {6,5}
            })));
     }
     
     public static int[][] multiply1(int[][] ia1, int[][] ia2) {
         int x = ia1.length;
         int y = ia1[0].length;
         int[][] ia3 = new int[ia1.length][ia1[0].length];
         for (int i = 0; i < x; i++) {
             for (int j = 0; j < y; j++) {
                 for (int k = 0; k < 4; k++) {
                     ia3**[j] = ia1**[j] * ia2**[j];
                 }
             }
         }
         return ia3;
     }

}

Das sollte eigentlich das Beschriebene machen, und man muss kopieren.

16

@CyborgBeta
Was macht „k“? Warum wird die gleiche Rechnung 4 mal durchgeführt?
Und wo wird überprüft ob es sich um eine legitime Matrix handelt? :stuck_out_tongue:

17

Es gibt kein Kreuzprodukt von Matrizen.

Nur:

  1. Das Tensorprodukt (Kronecker-Produkt)

  2. die stinknormale Matrizenmultiplikation, die 99% aller Beteiligten meinen, wenn sie davon reden, dass Matrizen multipliziert werden

18

[QUOTE=TMII]@CyborgBeta
Was macht “k”? Warum wird die gleiche Rechnung 4 mal durchgeführt?
Und wo wird überprüft ob es sich um eine legitime Matrix handelt? [emoji14][/QUOTE]

  1. k ist, falls man Zeilen und Spalten ‘zusätzlich’ ‘erweitern’ multiplizieren möchte,
  2. eine ‘sehr strenge’ Validitätsprüfung wurde abgelehnt, lediglich eine ‘AIOOBE’,
  3. schönen Abend.
19

Wie weit bist du momentan?

Kannst du mit,

         int x = ia1.length;
         int y = ia1[0].length;
         int[][] ia3 = new int[x][y];
         for (int i = 0; i < x; i++) {
             for (int j = 0; j < y; j++) {
//                 for (int k = 0; k < 4; k++) {
                     ia3**[j] = ia1**[j] * ia2**[j];
//                 }
             }
         }
         return ia3;
     }```

, etwas anfangen?

Wo liegen deine Schwierigkeiten,

 @luke01  ?
20

Ich stehe vor der Aufgabe, dass ich zwei Matrizen, die beliebig vom Benutzer eingegeben werden sollen, multiplizieren soll.
Dafür muss der Benutzer ja zuerst einmal eingeben, wie viele Zeilen und Spalten die erste Matrix haben soll und wie viele Spalten die Matrix haben soll.

Im Moment versuche ich erstmal, dass mir eine einzige Matrix, die vom Benutzer eingegeben wird, angezeigt wird. Dies habe ich mittels zwei for-Schleifen versucht. Allerdings funktioniert meine Programmierung nicht. Die Abfrage wird so oft wie angegeben ausgeführt, die Zeilen werden auch angezeigt. Allerdings wird die eingegebene Zeile immer direkt angezeigt und nicht erst, nachdem ich alle Zeilen eingegeben habe, als Matrix. Kann mir jemand weiterhelfen?