# Addition von 2 Matrizen



## Guest (6. Dez 2006)

Hallo,

ich bin dabei eine Klasse zu schreiben, mit der ich zwei matrizen addieren kann. ich habe nur ein problem mit ner "methode out" und zwar verstehe ich diese methode nicht so ganz oder weiß auch nicht, wie ich die ausgabe der matrix anderst gestallten kann und vielleicht sogar einfacher! weiß jemand wie ich das anderst lösen kann, oder kann mir jemand diese methode erklären?


```
class matrizentest
{
        //Addiert, s.d. c = a+b
       public static void add(int[]c, int[]a, int[]b)
        {
                for (int i=0; i<c.length; i++)
                        c[i] = a[i] + b[i];
        }
        
        //zur schönen Ausgabe
        public static void out(int[]matrix)
        {
                for (int i=0; i<matrix.length; i++)
                {
                        if ( i % (int)Math.sqrt(matrix.length) == 0 )
                                System.out.println();
                        System.out.print(matrix[i]+" ");
                }
                System.out.println();
        }



        public static void main (String args[])
        {
                int[] matrixa = {5,4,1,-3,1,3,5,2,-3,1,4,9} ;
                int[] matrixb = {5,6,9,13,9,7,5,8,13,9,6,1} ;
                int[] matrixc = new int[12];
    
                System.out.println();
                System.out.println("Matrix A:");
                out(matrixa);
                
                System.out.println();
                System.out.println("Matrix B:");
                out(matrixb);
                
                System.out.println();
                System.out.println("Summe S=A+B:");

                add(matrixc, matrixa, matrixb);
                
                out(matrixc);
        }
}
```


----------



## para_ (6. Dez 2006)

Hi


```
public static void out(int[]matrix)
        {
                // durchläuft die matrix ;)
                for (int i=0; i<matrix.length; i++)
                {
                        // (int).Math.sqrt(matrix.length) bleibt immer gleich, da sich die Größe der Matrix ja nicht ändert (hat hier eine Länge von 12)
                        // mit Math.sqrt(matrix.length) wird hier also die Wurzel aus 12 berechnet und Nachkommastellen durch den Typecast zu int abgeschnitten
                        // Im falle einer Länge von 12 steht dann also da:  if (i%3 == 0) 
                        // das bedeutet, dass immer wenn i ein vielfaches von 3 ist eine neue zeile begonnen wird (also immer nach der Ausgabe von 3 Zahlen der Matrix 
                        // wenn die Größe der Matrix mal nicht 12 ist, kann sich unter umständen diese Anzahl der Zahlen pro Zeile ändern, bei einer Länge von 25 würde alle 5 Zahlen eine neue Zeile begonnen werden
                        if ( i % (int)Math.sqrt(matrix.length) == 0 )
                                System.out.println();
                        System.out.print(matrix[i]+" ");
                }
                System.out.println();
        }
```


----------



## SlaterB (6. Dez 2006)

viel anders machen kann man da nicht, die ist so wie sie da steht recht nützlich,

zum Verständnis: formuliere Fragen, beschreibe deine Verständnisprobleme,
welche Zeile, welche Formulierung in der Zeile verstehst du nicht,
was ist anders als erwartet?

wenn dir natürlich Grundlagen wie for-Schleifen unbekannt sind,
dann kommst du schwerlich weiter


----------



## h4nnes (6. Dez 2006)

hey, danke für die schnelle antwort! die erklärung ist perfekt, danke para

ich habe jetzt mal weiter programmiert und zwar kommt noch noch differenz und produkt hinzu! die differenz ist kein problem, aber wie kann ich das produkt erstellen?

ich sollte ja dann die matrizen verschachteln oder?

also wenn ich die matrix a * b nehmen will, sollten diese dann so aussehen?

                int[] matrixa = { {5,4,1},{-3,1,3},{5,2,-3},{1,4,9}  } ;     //Matrix A
                int[] matrixb = { {3,1,5,7},{-2,6,-3,1},{-3,2,1,9} } ;    //Matrix B

und die größe der matrix wär dann ja 16 oder?



```
class matrizentest
{
        //Addiert, s.d. c = a+b
       public static void add(int[]s, int[]a, int[]e)
        {
                for (int i=0; i<s.length; i++)
                        s[i] = a[i] + e[i];
        }

        public static void diff(int[]d, int[]e, int[]f)
        {
                for (int i=0; i<d.length; i++)
                        d[i] = e[i] - f[i];
        }

       public static void pro(int[]p, int[]a, int[]b)
        {
                for (int i=0; i<p.length; i++)
                        p[i] = a[i] * b[i];
        }

        //zur schÃ¶nen Ausgabe
        public static void out(int[]matrix)
        {
                for (int i=0; i<matrix.length; i++)
                {
                        if ( i % (int)Math.sqrt(matrix.length) == 0 )
                                System.out.println();
                        System.out.print(matrix[i]+" ");
                }
                System.out.println();
        }



  public static void main (String args[])
        {
                int[] matrixa = {5,4,1,-3,1,3,5,2,-3,1,4,9 } ;     //Matrix A
                int[] matrixb = {3,1,5,7,-2,6,-3,1,-3,2,1,9} ;    //Matrix B
                int[] matrixe = {5,6,9,13,9,7,5,8,13,9,6,1} ;     //Matrix E
                int[] matrixf = {4,5,8,12,8,6,4,7,12,8,5,0} ;     //Matrix F

                int[] matrixs = new int[12];                      //Matrix S = A+E
                int[] matrixd = new int[12];                      //Matrix D = E-F
                int[] matrixp = new int[16];                      //Matrix P = A*B


                System.out.println();
                System.out.println("Matrix A:");
                out(matrixa);

                System.out.println();
                System.out.println("Matrix B:");
                out(matrixb);

                System.out.println();
                System.out.println("Matrix E:");
                out(matrixe);


                System.out.println();
                System.out.println("Matrix F:");
                out(matrixf);

                System.out.println();
                System.out.println("Summe S=A+E:");

                add(matrixs, matrixa, matrixe);        //Addition Matrix S = A+E

                out(matrixs);                          //Ausgabe Matrix S

                System.out.println();
                System.out.println("Differenz D = E - F:");

                diff(matrixd, matrixe, matrixf);       //Differenz Matrix D = E - F

                out (matrixd);                         //Ausgabe Matrix d

                System.out.println();
                System.out.println("Produkt P = A * B:");

                pro(matrixp, matrixa, matrixb);       //Produkt Matrix P = A * B

                out (matrixp);                         //Ausgabe Matrix p
        }
}
```


----------



## SlaterB (6. Dez 2006)

ich weiß nicht wieweit das festgelegt ist,
aber normalerweise sollte der Aufrufer keinen dritten Paramter für das Ergebnis mitgeben müssen,
schon gar nicht wenn wie beim Produkt noch die Dimensionen vorher geklärt werden müssen,

das kann doch die Operation pro machen und das fertige Objekt als Rückgabewert liefern?
matrixp = pro(matrixa, matrixb);  

-------

ist dir denn die mathematische Vorgehensweise der Multiplikation bekannt?
male dir auf Papier auf, was bei einem möglichst einfachen Beispiel passieren muss
(also besser mit kleinen Dimensionen wie 2 und 3 arbeiten)


----------



## h4nnes (6. Dez 2006)

wie meinst du ? also wie die matrix multiplikation geht, das weiß ich...


----------



## SlaterB (6. Dez 2006)

wenn jemand sagt 'überlege dir wie man eine Autotür aufmacht und mache es dann',
dann ist 'wie meinst du?' eine seltsame Rückfrage

ich meine damit: dann mache es so,
denn die bisherige pro-Operation hat damit wenig zu tun


----------



## h4nnes (7. Dez 2006)

aber ich komme einfach nicht weiter und ich weiß nicht, wie du es meinst... tut mir leid, aber ich bin noch blutiger java anfänger...


----------



## SlaterB (7. Dez 2006)

dann fange mal bitte damit an,
zwei Matrizen per Hand zu multiplizieren

z.B.

```
(1 2)  *  (5  7)
(3 4)
```
was kommt da raus?

und was dein Programm stattdessen macht kannst du nicht erkennen?
zwei Zeilen Code?

Tipp:
http://www.learn-line.nrw.de/angebote/selma/foyer/projekte/hammproj3/definitionen/matmult.htm


----------



## h4nnes (7. Dez 2006)

(1 2)  *  (5  7)
(3 4)

geht doch gar nicht oder?

wenn dann

```
(5  7) * (1 2)
            (3 4)
```
und das wäre

(26 38)

nur weiß ich nicht, wie ich das umsetzen soll


----------



## SlaterB (7. Dez 2006)

hast du den Link da gelesen?
sagt dir 'Spalte * Zeile' irgendwas?

ich bin der Meinung das meine Version richtig ist,
hab aber keine Lust dich davon zu überzeugen,
schaue in dein Mathe-Buch nach Beispielen 

naja, auch bei deiner Vorgehensweise ist dir ja nun schon aufgefallen,
dass du da was addieren musst,

cij = ai1 . b1j + ai2 . b2j + . . . . . + ain . bpj
(siehe Link)


also hier geht es um Positionen, i-te Zeile, j-te Spalte,
das ist bei der Darstellung einer Matrix als eindimensionales Array ein kräftiges Problem,
kann man aber natürlich umrechnen,

und wie sieht die dann die pro-Operation aus?
eine Schleife für alle Felder des Produktes ist schon richtig,
aber um dann einen einzelnen solchen Wert zu berechnen brauchst du eine innere Schleife, 
die dir ai1 . b1j + ai2 . b2j + . . . . . + ain . bpj errechnet,

------

fange vielleicht erstmal einfacher an,
schreibe eine Operation nur mit der Regel cij = ai1 . b1j, ohne innere Schleife, das wäre schon schwierig genug,
dann kannst du erst mal ein wenig knobeln was i/j in den drei unterschiedlich großen Matrizen ist,

vielleicht anfangs besser auch nur mit gleichgroßen Matrizen arbeiten

--------

wie du siehst versuche ich nur dir beim Selber-Bauen zu helfen,
bei deinen derzeitigen Kenntnissen kann das sehr lange dauern 

wenn ich einfach die Klappe halten soll und du (jemand anderen) nach der fertigen Lösung fragen willst,
dann sag Bescheid, ist mir egal 

dann evtl. neuer Thread, falls hier keiner mehr reagiert,
Überschrift 'Multiplikation zweier Matrizen'


----------



## SlaterB (7. Dez 2006)

übrigens, wie unterscheidest du bei der eindimensionalen Darstellung eigentlich zwischen einer 2x3 und einer 3x2 Matrix?

vielleicht solltest du zu einem int[][] überwechseln,
das macht auch das Rechnen mit i und j einfacher


----------



## Azrahel (7. Dez 2006)

> Ist A eine (m,n)-Matrix und B eine (n,p)-Matrix, dann heißt die (m,p)-Matrix C das Produkt der Matrizen A und B genau dann, wenn für die Elemente der Matrix C gilt:


 Was Bitte??? Ich hab in meinem Leben noch nie ne Matrize multipliziert und wüsst auch echt nicht wie das gehen soll, auch nicht nach Studium des Links, und um ehrlich zu sein hört sich das auch echt unanständig an...


----------



## h4nnes (7. Dez 2006)

ne, du sollst nicht deine "klappe" halten, ganz im gegenteil, ich bin dir sehr dankbar! mein problem ist nur, dass ich noch anfänger bin und wie heißt es so schön, jeder anfang ist schwer 
also ich werd mir jetzt mal dein geschriebenes zu herzen nehmen und mich nochmals hinsetzen und es versuchen!

@azrahel

die matrizenmultiplikation ist im prinzip nicht schwer. das bsp von oben:


```
(5  7) * (1 2)
            (3 4)
```

= ( (7*3+5*1)  (7*4+5*2) = (26 38)


edit: also das (3 4) sol direkt unter (1  2) stehen


----------



## SlaterB (7. Dez 2006)

schaue lieber noch mal nach mit der Reihenfolge der Multiplikation,
so wie du es machst ist es meiner Meinung nach falsch rum


----------



## h4nnes (7. Dez 2006)

ich habs mitm taschenrechner überprüft, der sagt das selbe 

ich bekomme das mit dem int [][] nicht hin


----------



## SlaterB (7. Dez 2006)

ich meinte das von der Logikseite her,
welche (n,m)-Matrix lässt sich mit welcher anderen multiplizieren,
aber da liegst du wohl doch richtig,
in der ersten von mir gelinkten Seite wars etwas falsch dargestellt,
heir besser:
http://statmath.wu-wien.ac.at/~leydold/MOK/HTML/node17.html

vielleicht hilft dir das Beispiel dort auch bei der Umsetzung,
wenn du an mich eine Frage hast, dann muss die schon anders als 'bekomme ich nicht hin' lauten 

Code, Fehlermeldungen, Schwierigkeiten beschreiben


----------



## h4nnes (7. Dez 2006)

ich habe es jetzt einmal anderst versucht, ich weiß nicht, ob es so umständlicher oder sonst was ist ?


```
class matrix
{
  public static void MatrixA()
   {

    int[ ][ ]  MatrixA = {{1,2,3},{4,5,6},{4,5,-6}};
    for (int i = 0; i < MatrixA.length; i++)
     {

      for (int j=0;j<MatrixA[i].length;j++)
      System.out.print(MatrixA[i][j]+ " ");
      System.out.println();
     }
   }

  public static void MatrixB()
   {

    int[ ][ ]  MatrixB = {{1,1,1},{1,1,1},{1,1,1}};
    for (int i = 0; i < MatrixB.length; i++)
    {
      for (int j=0;j<MatrixB[i].length;j++)
      System.out.print(MatrixB[i][j]+ " ");
      System.out.println();
    }
   }


  public static void main(String[] args)
  {
     System.out.println("Matrix A:");
     MatrixA();
     System.out.println();
     System.out.println("Matrix B:");
     MatrixB();
     System.out.println();

  }
}
```

und wie könnte dann die addition der beiden matrizen aussehen?
so wie ich es gedacht habe, funktioniert es leider nicht 


```
public static void add(int[][]MatrixC, int[][]MatrixA, int[][]MatrixB)
        {
                for (int i=0; i<s.length; i++)
                        MatrixC[i] = MatrixA[i] + MatrixB[i];
        }
```


----------



## SlaterB (7. Dez 2006)

Variablen und Operationen schreibt man immer klein, Klassen groß!

und du hat da ein etwas seltsames Vorgehen,
du definierst die Variablen in Operationen,

die müssen in der main stehen:
int[ ][ ]  matrixB = {{1,1,1},{1,1,1},{1,1,1}};

und dann reicht EINE Operation zur Ausgabe:
System.out.println("Matrix B:");
ausgabe(matrixB); 

diese Operation bekommt die Matrix als Parameter und gibt sie aus

---------

deine add-Operation ist noch auf dem alten eindimensionalen Stand,
du kannst nicht einfach zwei Zeilen addieren falls du das dachtest
(könntest natürlich eine Operation dafür definieren)

wie bei der Ausgabe brauchst du eine Doppel-Schleife und musst
matrixC_[j] = matrixA[j] + matrixB[j]; 
setzen

wie früher die dringende Empfehlung:
die Ergebnis-Matrix erzeugt add selber, nicht als Parameter mitangeben,
wird dann als Rückgabewert an den Aufrufer geliefert_


----------



## h4nnes (7. Dez 2006)

hast recht, war wirklich nen bisschen dumm programmiert 

könntest du mir mit der methode add weiterhelfen? ich weiß nicht, wie ich das machen soll, hab es hier mal versucht, wie ich es dachte, aber so will es nicht  


```
class matrix
{
      public static void add(int[][]c, int[][]a, int[][]b)
        {
                for (int i=0; i<matrixc.length; i++)
                    {
                     for (int j=0;j<matrixc[i].length;j++)
                     matrixs[i][j] = matrixc[i][j] + matrixb[i][j];
                    }
        }


  //Ausgabe der Matrizen
  public static void out(int[][]matrix)
   {

    for (int i = 0; i < matrix.length; i++)
     {

      for (int j=0;j<matrix[i].length;j++)
      System.out.print(matrix[i][j]+ " ");
      System.out.println();
     }
   }


  public static void main(String[] args)
  {
     int[ ][ ]  matrixa = {{1,2,3},{4,5,6},{4,5,-6}};
     int[ ][ ]  matrixb = {{1,1,1},{1,1,1},{1,1,1}};
     
     int[ ][ ]  matrixc = new int[12][12];                      //Matrix S = A+E

     System.out.println("Matrix A:");
     out(matrixa);
     System.out.println();
     System.out.println("Matrix B:");
     out (matrixb);
     System.out.println();
     add(matrixc, matrixa, matrixb);
  }
}
```


----------



## h4nnes (7. Dez 2006)

okay, meine überlegung war quatsch, er muss zuerst i addieren und dann j oder ?


----------



## SlaterB (7. Dez 2006)

sieht schon ganz gut aus,
wieso aber definierst du matrixc mit 12x12? das ist zu groß, 
mit 3x3 sollte es funktionieren, wenn du auch noch die Variablen richtig benennen würdest...

ansonsten immer die Fehlermeldung nennen oder das falsche Verhalten beschreiben,

-----
so wie ich mir das denke kann so ein Fehler praktischweise gar nicht auftreten:


```
public static void add(int[][]a, int[][]b)  {
                int[][]c = new int[a.length][a[0].length];
                for (int i=0; i<c.length; i++)
                {
                     for (int j=0;j<c[i].length;j++)
                     c[i][j] = a[i][j] + b[i][j];
                }
                return c;   
        } 


main:
matrixc = add(matrixa, matrixb);
```


----------



## h4nnes (7. Dez 2006)

oh man, das ist immer leichter, als es ausschaut!

also wenn ich das jetzt so mache, mit der methode add, dann bekomm ich zwei fehler


```
class matrix
{
         public static void add(int[][]a, int[][]b)  {
                int[][]c = new int[a.length][a[0].length];
                for (int i=0; i<c.length; i++)
                {
                     for (int j=0;j<c[i].length;j++)
                     c[i][j] = a[i][j] + b[i][j];
                }
                return c;
        }


  //Ausgabe der Matrizen
  public static void out(int[][]matrix)
   {

    for (int i = 0; i < matrix.length; i++)
     {

      for (int j=0;j<matrix[i].length;j++)
      System.out.print(matrix[i][j]+ " ");
      System.out.println();
     }
   }


  public static void main(String[] args)
  {
     int[ ][ ]  matrixa = {{1,2,3},{4,5,6},{4,5,-6}};
     int[ ][ ]  matrixb = {{1,1,1},{1,1,1},{1,1,1}};
     
     int[ ][ ]  matrixc = new int[3][3];                      //Matrix C = A+B

     System.out.println("Matrix A:");
     out(matrixa);
     System.out.println();
     System.out.println("Matrix B:");
     out (matrixb);
     System.out.println();
     matrixc = add(matrixa, matrixb);
     //add(matrixc, matrixa, matrixb);
  }
}
```



und die fehler lauten:


```
matrix.java:10:24: cannot return a value from method whose result type is void
                return c;
                            ^
matrix.java:41:19: incompatible types
found   : void
required: int[][]
     matrixc = add(matrixa, matrixb);
                               ^
2 errors
```


----------



## SlaterB (7. Dez 2006)

jo,
muss natürlich
public static int[][] add(int[][]a, int[][]b)  { 
statt 
public static void add(int[][]a, int[][]b)  { 
heißen, den Rückgabewert muss man angeben,
sowas sehe ich auch nicht immer


----------



## h4nnes (7. Dez 2006)

ah, das hätt ich auch selbst sehen müssen! für heute raucht mein kopf genug, ich werde mich am wochenende an die differenz und an das produkt wenden und mich dann hier zurückmelden!

vielen dank für deine große hilfe, du kannst dir gar nicht vorstellen, wie schwer das ist, wenn man noch blutiger anfänger ist...

ps: ich habe dich mal in icq geaddet 

gute nacht


----------



## h4nnes (8. Dez 2006)

so, ich hab mal wieder weitergemacht und zwar will die out methode noch etwas abändern. er soll nämlich bei der ausgabe der matrizen vor alle werte, die zwischen 0 und 9 liegen ein leerzeichen einfügen, damit es in einer reihe steht wenn z.b. eine negative zahl kommt

hier mal der code: kann ich das so mit einer if...else konstruktion machen?


```
//Ausgabe der Matrizen
  public static void out(int[][]matrix)
   {
     DecimalFormat f = new DecimalFormat(" #");
     for (int i = 0; i < matrix.length; i++)
     {

      for (int j=0;j<matrix[i].length;j++)
      if (matrix >0<=9) {

             System.out.print(f.format(matrix[i][j])+ " ");

      } else {

            System.out.print(matrix[i][j] + " ");

      }

      //System.out.print(f.format(matrix[i][j])+ " ");
      System.out.println();

     }
   }
```


ein fehler kommt nämlich und zwar geht der operator nicht vom typ int, wie muss ich das dann machen ?


```
matrix.java:39:18: operator > cannot be applied to int[][],int
      if (matrix >0<=9) {
                       ^
1 error
```


----------



## SlaterB (8. Dez 2006)

tja, Java lernen ist so eine Sache, wie wärs mit einem Lehrbuch statt live in einem Forum?
if (matrix_[j] > 0 && matrix[j] <= 9) {


übrigens rate ich von der Vorgehensweise ab,
schreibe dir ein allgemeine Operation 

public static String getFormattedStringToIntWithLengthTwo(int k) {
   return the right string for all kind of k;
}

dann musst du nicht dein Leben lang bei jeder Ausgabe nach der Zahl unterscheiden sondern hast einen festen Operationsaufruf,
in dieser Operation muss dann natürlich die Unterscheidung EINMAL stehen

erzeuge aber in der Opration nicht ständig neue Format-Objekte,
da reicht EINS, was statisch gespeichert wird

naja, vielleicht zu kompliziert gedacht für den Anfang,
lasse es vielleicht erstmal so wie du denkst, 
das ist schon ganz gut_


----------



## h4nnes (14. Dez 2006)

so, ich hab mal wieder zeit gefunden, an dem prog weiterzumachen (es ist was anderes dazwischen gekommen) also anversich läuft alles, nur stimmt die produktbildung noch nicht so ganz, ich habe mir das ganze so gedacht:


```
// Produkt der Matrizen P = A * B
  public static int[][] pro(int[][]a, int[][]b)
        {
          int summe = 0;
          int[][]p = new int[a.length][b[0].length];
                for (int i=0; i<a.length; i++)
                for (int j=0; j<b[0].length; j++)
                {
                    for (int k=0; k<a[0].length; k++)
                    summe +=a[i][k] * b[k][j];
                    p[i][j] = summe;

                }
                return p;
        } //end method pro
```


ausgabe:


```
System.out.println("\nMatrix P = A*B:");
     matrixp = pro(matrixa, matrixb);
     out(matrixp);
```


stimmt das so nicht ?[/code]


----------



## SlaterB (14. Dez 2006)

was kommt denn raus?
vergleiche die Ergebnissen mit denen die du per Hand ausrechnen würdest, 
stimmen manche Werte überein, kann man Abweichungen erkennen?

sowas musst du selber rausfinden, irgendwann jedenfalls

du hast nur einen kleinen Fehler:
summe wird nicht für jedes Feld wieder auf 0 gesetzt,
sondern es wird munter weiteraddiert


----------



## Gast (14. Dez 2006)

wie muss es denn dann richtig heißen ?


----------



## SlaterB (14. Dez 2006)

```
public static int[][] pro(int[][] a, int[][] b) {

		int[][] p = new int[a.length][b[0].length];
		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < b[0].length; j++) {
				int summe = 0;
				for (int k = 0; k < a[0].length; k++) {
					summe += a[i][k] * b[k][j];
				}
				p[i][j] = summe;
			}

		}
		return p;
	} //end method pro
```

es ginge wohl auch ganz ohne summe:

for (int k = 0; k < a[0].length; k++) {
					p_[j]+= a[k] * b[k][j];
				}_


----------



## h4nnes (14. Dez 2006)

Matrix A:
 5  4  1
-3  1  3
 5  2 -3
 1  4  9

Matrix B:
 3  1  5  7
-2  6 -3  1
-3  2  1  9


Ergibt mit der methode von oben:

 Matrix P = A*B:
 4   35   49   97
77  86   71   78
98  109 125 135
103 146 148 240


und wenn ich das von hand rechne komm raus:

4      31     14    48
-20    9     -15    7
20    11    16      10
-32   43     2      92

und das solle eigentlich stimmen, wie muss ich das dann machen, dass er die summe immer wieder auf 0 setzt?


edit:

perfekt, wenn ich es ohne summe mache, dann passt es! super, danke!!!


----------

