Methoden Matrix Multiplikation

domme5599

Mitglied
Hallo,

ich hab ein Programm geschrieben, dass drei Matrizen erstellt und die Ergebnismatrix definiert. In einer weiteren Methode wird ohne Fehler Matrix A und B zu D addiert. In der Methode für die Multiplikation kompiliert er diese zwar ohne zu meckern, aber das Ergebnis ist völlig falsch.

Fehlerbeschreibung im Code

Java:
public class MatrixDouble {

        //Addiert, D = A+B
       public static void add(int[]D, int[]A, int[]B)    //übergeben der notwendigen Matrizen
        {
                for (int i=0; i<D.length; i++)       //Ergebnismatrix soll nicht länger sein als die definierte Länge
                        D[i] = A[i] + B[i];         //Addition von A und B
        }

    public static void mul(int[]D, int[]C, int[]B)   //übergeben der notwendigen Matrizen
        {
                for (int i=0; i<D.length; i++)         //Ergebnismatrix soll nicht länger sein als die definierte Länge
                        D[i] = C[i] * B[i];         //Multiplikation von C und B und genau hier glaube ich ist der Fehler oder in der Schleife darüber, da manuell ausgerechnet die Matrix lautet {36,40,68,76,100,112}
        }                         //und ausgeben wird die Matrix {8,10,10,13,15,13}
     
     
        //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[] A = {1,2,3,4,5,6};             //Matrix A 3x2 wird erstellt
                int[] B = {7,8,9,10,11,12 };         //Matrix B 3x2 wird erstellt
        int[] C = {1,2,1,3,4,1,5,6,1};         //Matrix C 3x3 wird erstellt
                int[] D = new int[6];             //Ergebnismatrix D 3x2 wird definiert
 
                System.out.println();                 //A anzeigen
                System.out.println("Matrix A:");
                out(A);
             
                System.out.println();
                System.out.println("Matrix B:");     //B anzeigen
                out(B);

        System.out.println();
                System.out.println("Matrix C:");     //C anzeigen
                out(C);

                   System.out.println();
                System.out.println("Summe S=A+B:");  //Summe aus A und B anzeigen


        add(D, A, B);
             
                out(D);

      
                System.out.println();
                System.out.println("Produkt P=C*B:");        //Produkt aus C und B anzeigen


         add(D, C, B);
             
                out(D);
        }
}
 

domme5599

Mitglied
Ich dachte dass die Multiplikation in Java relativ ähnlich umgesetzt werden kann wie Addition.

Java:
public static void mul(int[]D, int[]C, int[]B)  {
                            for (int i=0; i<D.length; i++)
                                         D[i] = C[i] * B[i];
                                                  }
 

domme5599

Mitglied
Oh danke, dass habe ich mal völlig übersehen :)
Jetzt kommt die Matrix {7,16,9,30,44,12} raus, dass ist
schon ein besseres Ergebnis aber leider noch nicht richtig.

Java:
    System.out.println();
                System.out.println("Produkt P=C*B:");      //Produkt aus C und B anzeigen


         mul(D, C, B);
             
                out(D);
 
Zuletzt bearbeitet:

Thallius

Top Contributor
Es ist viele Jahre her dass ich Matrixenrechnung gelernt habe aber ich meine mich erinnern zu können, dass eine Multiplikation eben nicht einfach das Multipilizieren der einzelnen Werte ist oder?
 

domme5599

Mitglied
Matrixmultiplikation ist nach dem Falkschema: erste Zeile A * erste Spalte B
erste Zeile A * zweite Spalte B
zweite Zeile A * erste Spalte B
zweite Zeile A * zweite Spalte B
dritte Zeile A * erste Spalte B
dritte Zeile A * zweite Spalte B

(In meinen Fall)

Ich denke aber mal, dass die Multiplikation nach Falk anders im Quellcode geschrieben werden muss.

Ich denke ich muss hier für die Multiplikation Spalte und Zeile einzeln definieren.
 
Zuletzt bearbeitet:

Thallius

Top Contributor
Matrixmultiplikation ist nach dem Falkschema: erste Zeile A * erste Spalte B
erste Zeile A * zweite Spalte B
zweite Zeile A * erste Spalte B
zweite Zeile A * zweite Spalte B
dritte Zeile A * erste Spalte B
dritte Zeile A * zweite Spalte B

(In meinen Fall)

Ich denke aber mal, dass die Multiplikation nach Falk anders im Quellcode geschrieben werden muss.

Ich denke ich muss hier für die Multiplikation Spalte und Zeile einzeln definieren.

Du must halt nur die entsprechenden Indizes verwenden. Wenn du immer i nimmst bekommst du natuerlich nur ein erste zeile * erste zeile und zweite zeile mal zweite zeile.
In diesem Fall müßtest du sowas haben wie

D = A[i+0] * B[i+1]

aber so einfach geht das natürlich nicht wenn du das für beliebig viele Dimensionen machen willst. Dann must Du die eine Formal dafür ausdenken.

Gruß

Claus
 

domme5599

Mitglied
So ich hab jetzt ein bisschen weiter programmiert und den Code so geändert, dass die notwenigen Matrizen für die Multiplikation richtig definiert sind. Aus Zeitmangel habe ich nur die Multiplikation neu definiert und deswegen auch drei neue Matrizen definiert. Das letzte was denke ich fehlt ist die Abänderung in der main Methode, da dort c und d in Out noch als double[] definiert sind. Allerdings fehlt mir dazu noch die Idee.

Java:
public class MatrixDouble {

       public static void add(double[]D, double[]A, double[]B) {   //übergeben der notwendigen Matrizen
           
                for(int i=0; i<D.length; i++)       //Ergebnismatrix soll nicht länger sein als die definierte Länge

                        D[i] = A[i] + B[i];         //Addition von A und B
                }

    public static double[][] mul(double[][]d, double[][] c, double[][] b) {  //übergeben der notwendigen Matrizen
        for(int i=0; i<c.length; i++)
            for(int j=0; j<c.length; j++)         //Ergebnismatrix soll nicht länger sein als die definierte Länge
                d[i][j] = c[i][j] * b[j][i];     //Produkt von c und b
         return d;
            }
       
        public static void out(double[]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[]) {
       
                double[] A = {1,2,3,4,5,6};                     //Matrix A 3x2 wird erstellt
                double[] B = {7,8,9,10,11,12};                  //Matrix B 3x2 wird erstellt
                double[] D = new double[6];                      //Ergebnismatrix D 3x2 wird definiert
                double c[][] = {{1,2,1}, {3,4,1}, {5,6,1}};  //Matrix c 3x3 wird erstellt
                double b[][] = {{7,8,9}, {10,11,12}};        //Matrix b 3x2 wird erstellt
                double[][] d = new double[c.length][b[0].length]; //Matrix d 3x2 wird definiert
   
                System.out.println();                 //A anzeigen
                System.out.println("Matrix A:");
                out(A);
               
                System.out.println();
                System.out.println("Matrix B:");     //B anzeigen
                out(B);

                System.out.println();
                System.out.println("Matrix c:");     //c anzeigen
                out(c);

                   System.out.println();
                System.out.println("Summe S=A+B:");  //Summe aus A und B anzeigen

                add(D, A, B);
               
                out(D);

        
                System.out.println();
                System.out.println("Produkt P=c*b:");        //Produkt aus c und b anzeigen

                mul(d, c, b);

                out(d);

        }
}
 

MoxxiManagarm

Top Contributor
Code:
 double[] A = {1,2,3,4,5,6};                    //Matrix A 3x2 wird erstellt
Genau genommen ist das nicht richtig. Du hast hier einen Vector der Länge 6, keine 3x2 Matrix
 

domme5599

Mitglied
Ja die Matrizen für die Addition sind natürlich keine wirklichen, ich hab erstmal nur Vektoren erstellt.
In dem Fall passte das aber, da die Vektoren hier als die geplanten Matrizen auch ausgegeben werden.
Später schreibe ich auch diese zu richtigen Matrizen um.
 

mihe7

Top Contributor
Das Problem ist, dass Du eine Matrix einmal als 1D- und einmal als 2D-Array darstellst. Dabei nimmst Du in der out-Methode implizit an, dass im 1D-Fall für die nxm-Matrix gilt, dass die Zahl der Spalten der größten ganzen Zahl entspricht, die kleiner oder gleich der Wurzel aus n*m ist. Das ist ... suboptimal.

Du müsstest also add und out auf double[][] umschreiben.

Besser wäre es aber, Du würdest das Thema objekt-orientierter angehen.
 

domme5599

Mitglied
So hab jetzt versucht alles auf double[][] umzuschreiben, dass funktioniert so weit auch, aber jetzt kommt das Problem, dass ich die Reihenfolge in der out Methode noch richtig hinkriegen muss, dass er auch wirklich alle Matrizenzeilen so ausgibt; 1,0 2,0
3,0 4,0
5,0 6,0

Aktuell haut er mir halt dadurch noch raus "Index 2 out of bounds for length 2"

Java:
public class MatrixDouble {

       public static void add(double[][]D, double[][]A, double[][]B) {   //übergeben der notwendigen Matrizen
           
                for(int i=0; i<D.length; i++)      
                    for(int j=0; j<D.length; j++)    //Ergebnismatrix soll nicht länger sein als die definierte Länge
                    D[i][j] = A[i][j] + B[i][j];         //Addition von A und B
                }

    public static double[][] mul(double[][]d, double[][] c, double[][] B) {  //übergeben der notwendigen Matrizen
        for(int i=0; i<c.length; i++)
            for(int j=0; j<c.length; j++)         //Ergebnismatrix soll nicht länger sein als die definierte Länge
                d[i][j] = c[i][j] * B[j][i];     //Produkt von c und b
         return d;
            }
       
        public static void out(double[][]matrix) {
       
                for(int i=0; i<matrix.length; i++) {
                     for(int j=0; j<matrix.length; j++) {
                        if( i % (int)Math.sqrt(matrix.length) == 0 )
                            if( j % (int)Math.sqrt(matrix.length) == 0 )
                           
                                System.out.println();
                        System.out.print(matrix[i][j]+" ");
                    }
                System.out.println();
            }
        }



        public static void main (String args[]) {
       
                double A[][] = {{1,2}, {3,4}, {5,6}};                     //Matrix A 3x2 wird erstellt
                double B[][] = {{7,8}, {9,10}, {11,12}};                  //Matrix B 3x2 wird erstellt
                double D[][] = new double[3][2];                      //Ergebnismatrix D 3x2 wird definiert
                double c[][] = {{1,2,1}, {3,4,1}, {5,6,1}};          //Matrix c 3x3 wird erstellt
                double d[][] = new double[3][2];     //Matrix d 3x2 wird definiert
   
                System.out.println();                 //A anzeigen
                System.out.println("Matrix A:");
                out(A);
               
                System.out.println();
                System.out.println("Matrix b:");     //b anzeigen
                out(B);

                System.out.println();
                System.out.println("Matrix c:");     //c anzeigen
                out(c);

                   System.out.println();
                System.out.println("Summe S=A+B:");  //Summe aus A und B anzeigen

                add(D, A, B);
               
                out(D);

        
                System.out.println();
                System.out.println("Produkt P=c*B:");        //Produkt aus c und b anzeigen

                mul(d, c, B);

                out(d);

        }
}
 

domme5599

Mitglied
Ja ich nehme an du meinst diesen Teil und meinst Math.sqrt und der muss geändert werden.

Java:
if( i % (int)Math.sqrt(matrix.length) == 0 )
if( j % (int)Math.sqrt(matrix.length) == 0 )
 

mihe7

Top Contributor
Nicht nur hier, sondern z. B. auch hier
Java:
for(int i=0; i<D.length; i++)      
    for(int j=0; j<D.length; j++)    //
 

domme5599

Mitglied
So jetzt der richtige Code wird alles ausgerechnet und ist alles auf double umgestellt.
Hat mich jz 2 Stunden gekostet zusätzlich um die richtige Ausgabe und mul Methode zu finden.
Das nächste was ich jetzt noch versuche ist die Multiplikation von Matrix A mit der konstanten Zahl 2.

Java:
class MatrixDouble{
    //Addition der Matrizen   
    public static double[][] add(double[][]a, double[][]b)  {        //Übergeben der notwenigen Matrizen
        double[][]d = new double[a.length][a[0].length];            //Ergebnismatrix erstellen
            for (int i=0; i<d.length; i++){                                   //Schleifen für die richtige Addition
                for (int j=0;j<d[i].length;j++)
                     d[i][j] = a[i][j] + b[i][j];                                 //Rechenoperation
                        }
                return d;
                }
    //Multiplikation der Matrizen   
    public static double[][] mul(double[][]a, double[][]c) {        //Übergeben der notwenigen Matrizen
        double[][] e = new double[a.length][c[0].length];            //Ergebnismatrix erstellen
            for(int i = 0; i < a.length; i++){                                 //Schleifen für die Matrixmultiplikation ich brauchte                                                                                                 drei Schleifen da Java sonst bei mir mit den                                                                                                         Spalten und Zeilen durcheinander kam
                for(int j = 0; j < c[0].length; j++) {               
                    for(int k = 0; k < a[0].length; k++) {
                        e[i][j] += a[i][k] * c[k][j];                           //Rechenoperation
                                }
          
                            }
                        }
                return e;
                }
               
  //Ausgabe der Matrizen
    public static void out(double[][]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) {
 
     double[ ][ ]  matrixa = {{1,2,3},{4,5,6}};                    //Erstellen der Matrix A               
     double[ ][ ]  matrixb = {{7,8,9},{10,11,12}};              //Erstellen der Matrix B
     double[ ][ ]  matrixc = {{1,2,1},{3,4,1},{5,6,1}};       //Erstellen der Matrix C
     double[ ][ ]  matrixd = new double[3][2];                    //Matrix D = A+B
     double[ ][ ]  matrixe = new double[3][2];                    //Matrix E = A*C

     System.out.println("Matrix A:");                   
     out(matrixa);                                                //Aufrufen der Methode out für Matrix A
     System.out.println();
     System.out.println("Matrix B:");
     out (matrixb);                                                //Aufrufen der Methode out für Matrix B
     System.out.println();
     System.out.println("Matrix C:");
     out (matrixc);                                                //Aufrufen der Methode out für Matrix C
     System.out.println();
     System.out.println("D = A+B:");
     matrixd = add(matrixa, matrixb);                            //Definition D = A+B
     out(matrixd);                                                //Aufrufen der Methode out für Matrix D
     System.out.println();
     System.out.println("E = A*C:");
     matrixe = mul(matrixa, matrixc);                            //Definition E = A*C
     out(matrixe);                                                //Aufrufen der Methode out für Matrix E

 
  }
}
 

domme5599

Mitglied
Die Multiplikation eines Skalars mit einer Matrix läuft ja eigentlich so ab:

Skalar = 2
Matrix A
/2*1 2*2 2*3\
\2*4 2*5 2*6/

Meine Überlegung ist hier, dass ich nicht drei Schleifen brauche wie bei der normalen Multiplikation, sondern nur noch max 2.
Der Code ist noch falsch da hier noch eine Nullmatrix rauskommt.
Ich muss halt überlegen wie ich richtig den festen Wert in diese Multiplikation einfüge.

Java:
public static double[][] skalmul(double[][]a, double skalar) {
                  double[][] f = new double[a.length][a [0].length];
                           for(int i = 0; i < a.length; i++){
                               for(int j = 0; j < a[0].length; j++)
                                    f[i][j] = a[i][j] * skalar;
                                       }
                           return f;
                         }
 

domme5599

Mitglied
Der Vollständigkeit her kommt hier jetzt der funktionierende Code noch rein.
Danke für die Hilfe.

Java:
class MatrixDouble{
    //Addition der Matrizen   
    public static double[][] add(double[][]a, double[][]b)  {        //Übergeben der notwenigen Matrizen
        double[][]d = new double[a.length][a[0].length];            //Ergebnismatrix erstellen
            for (int i=0; i<d.length; i++){                            //Schleifen für die richtige Addition
                for (int j=0;j<d[i].length;j++)
                     d[i][j] = a[i][j] + b[i][j];                    //Rechenoperation
                        }
                return d;
                }
    //Multiplikation der Matrizen   
    public static double[][] mul(double[][]a, double[][]c) {        //Übergeben der notwenigen Matrizen
        double[][] e = new double[a.length][c[0].length];            //Ergebnismatrix erstellen
            for(int i = 0; i < a.length; i++){                        //Schleifen für die Matrixmultiplikation ich brauchte drei Schleifen da Java sonst bei mir mit den Spalten und Zeilen durcheinander kam
                for(int j = 0; j < c[0].length; j++) {               
                    for(int k = 0; k < a[0].length; k++) {
                        e[i][j] += a[i][k] * c[k][j];                //Rechenoperation
                                }
                            }
                        }
                return e;
                }
               
    public static double[][] skalmul(double[][]a, double[][]f) {    //Übergeben der notwenigen Matrizen
        for(int i = 0; i < a.length; i++){                            //Schleifen für die richtige Länge und die Ergebnismatrix
            for(int j = 0; j < a[0].length; j++)
                f[i][j] = a[i][j] * 2;                                //Rechenoperation mit dem festen Wert 2
                        }
                return f;
                }
                  
  //Ausgabe der Matrizen
    public static void out(double[][]matrix) {
        for (int i = 0; i < matrix.length; i++) {                    //Schleifen, dass alle Matrizen auch die richtigen Maße haben
            for (int j=0;j<matrix[i].length;j++)                   
                System.out.print(matrix[i][j]+ " ");                //Ausgabe der Matrix und zwischen jeder Matrixkomponente ein Leerzeichen
                System.out.println();
                }
            }

    public static void main(String[] args) {
 
     double[ ][ ]  matrixa = {{1,2,3},{4,5,6}};                    //Erstellen der Matrix A               
     double[ ][ ]  matrixb = {{7,8,9},{10,11,12}};                 //Erstellen der Matrix B
     double[ ][ ]  matrixc = {{1,2,1},{3,4,1},{5,6,1}};            //Erstellen der Matrix C
     double[ ][ ]  matrixd = new double[2][3];                  //Matrix D = A+B
     double[ ][ ]  matrixe = new double[2][3];                    //Matrix E = A*C
     double[ ][ ]  matrixf = new double[2][3];                    //Matrix F = A*2

     System.out.println("Matrix A:");                   
     out(matrixa);                                                //Aufrufen der Methode out für Matrix A
     System.out.println();
     System.out.println("Matrix B:");
     out (matrixb);                                                //Aufrufen der Methode out für Matrix B
     System.out.println();
     System.out.println("Matrix C:");
     out (matrixc);                                                //Aufrufen der Methode out für Matrix C
     System.out.println();
     System.out.println("D = A+B:");
     matrixd = add(matrixa, matrixb);                            //Definition D = A+B
     out(matrixd);                                                //Aufrufen der Methode out für Matrix D
     System.out.println();
     System.out.println("E = A*C:");
     matrixe = mul(matrixa, matrixc);                            //Definition E = A*C
     out(matrixe);                                                //Aufrufen der Methode out für Matrix E
     System.out.println();
     System.out.println("F = A*2:");
     matrixe = skalmul(matrixa, matrixf);                        //Definition F = A*2
     out(matrixf);                                                //Aufrufen der Methode out für Matrix F


 
  }
}
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
F Matrix Multiplikation Java Basics - Anfänger-Themen 3
Z Matrix Klasse mit Mehrdimensionalen Array (Addition, Multiplikation, to String) Java Basics - Anfänger-Themen 57
U Ist diese Methode zur Matrix Vektor Multiplikation korrekt ? Java Basics - Anfänger-Themen 5
R Matrix-Vektor-Multiplikation Java Basics - Anfänger-Themen 13
M Matrix Matrix Multiplikation Java Basics - Anfänger-Themen 6
I matrix aufgabe Java Basics - Anfänger-Themen 22
L Zweidimensionaler Array; n x m - Matrix überprüfuen Java Basics - Anfänger-Themen 35
C Matrix mit Array ausgeben Java Basics - Anfänger-Themen 6
idontknow707 Matrix nach z.B. Variable durchsuchen Java Basics - Anfänger-Themen 4
F Adjunkte Matrix erstellen Java Basics - Anfänger-Themen 3
M Matrix Java Basics - Anfänger-Themen 3
B Dünn besetzte Matrix Java Basics - Anfänger-Themen 7
Al3xand3r01 Matrix, Nachbarelemente Java Basics - Anfänger-Themen 16
E Rückwärtsmultiplikation einer invertierten matrix Java Basics - Anfänger-Themen 2
U Dreiecks-Matrix mit Array Java Basics - Anfänger-Themen 3
E 2D Array - char durch die Matrix "wandern" lassen Java Basics - Anfänger-Themen 7
M Matrix auf 4 Elemente untersuchen mit offenen Enden Java Basics - Anfänger-Themen 8
B Diskrete Faltung (Matrix) Randfälle Java Basics - Anfänger-Themen 8
M Matrix Elemente vergleichen Java Basics - Anfänger-Themen 11
N Quadratische Matrix inkl Summe Java Basics - Anfänger-Themen 8
J Methoden Moving a n integer matrix Java Basics - Anfänger-Themen 3
O Matrix, Vektor Java Basics - Anfänger-Themen 9
H 2D Array, Symmetrische Matrix Java Basics - Anfänger-Themen 12
S Matrix spaltenweise befüllen Java Basics - Anfänger-Themen 1
T Zufällige Matrix in neue Matrix schreiben Java Basics - Anfänger-Themen 6
C Matrix-Werte werden nicht wie erwartet ausgegeben Java Basics - Anfänger-Themen 7
C Matrix erstellen Spaltensumme, Zeilensumme, Diagonale Java Basics - Anfänger-Themen 1
S Methoden Transponierte Matrix Java Basics - Anfänger-Themen 3
N Vererbung Submatrix mit Verweis auf Matrix erstellen Java Basics - Anfänger-Themen 9
J Matrix erstellen Java Java Basics - Anfänger-Themen 7
B Transponiertes Matrix Java Basics - Anfänger-Themen 12
J Überprüfen, ob eine 2D Matrix ein Baum ist Java Basics - Anfänger-Themen 5
C Matrix transponieren - Hilfe Java Basics - Anfänger-Themen 1
D Ausgabe einer Matrix mit System.out.println Java Basics - Anfänger-Themen 6
T Art 4 Felder Matrix Memory Java Basics - Anfänger-Themen 2
L Matrix(Array) minimieren... Java Basics - Anfänger-Themen 9
E Matrix mit Vektor multiplizieren Java Basics - Anfänger-Themen 7
S eingegebene Matrix anzeigen Java Basics - Anfänger-Themen 4
J Matrix für Schachbrett Java Basics - Anfänger-Themen 6
G tga Datei lesen und in eine matrix umwandeln Java Basics - Anfänger-Themen 1
G Bilddaten in Matrix umwandeln Java Basics - Anfänger-Themen 1
T Eine String Matrix erstellen die eine boolean Funtion verwendet Java Basics - Anfänger-Themen 10
O Matrix Multiplizieren Java Basics - Anfänger-Themen 4
S LWJGL - Matrix vom Matrixstack laden Java Basics - Anfänger-Themen 3
T Matrix auf Symmetrie überprüfen Java Basics - Anfänger-Themen 6
V Matrix Transponieren Java Basics - Anfänger-Themen 3
V Methoden Matrix als 1D Array mit Werten füllen Java Basics - Anfänger-Themen 12
W Zweidimensionale Arrays als Matrix ausgeben Java Basics - Anfänger-Themen 8
O Matrix ordnen Java Basics - Anfänger-Themen 4
M Symmetrische Matrix Java Basics - Anfänger-Themen 2
W Methoden Rang von einer Matrix mit Gauss Java Basics - Anfänger-Themen 0
U Matrix Subtrahieren Java Basics - Anfänger-Themen 12
E Input/Output convert string to two dimensional char and output = matrix Java Basics - Anfänger-Themen 2
A daten vom 1d array in 2d matrix speichern Java Basics - Anfänger-Themen 3
I Matrix überprüfen Java Basics - Anfänger-Themen 8
Z Matrix mit Vektor multiplizieren Java Basics - Anfänger-Themen 13
K Methoden Einlesen einer unbegrenzten Matrix über Konsole Java Basics - Anfänger-Themen 6
O Einlesen einer Matrix von der Console Java Basics - Anfänger-Themen 18
N Matrix/Vektoren Java Basics - Anfänger-Themen 3
N Matrix Java Basics - Anfänger-Themen 14
T Methode, die eine 2 dimensionale Matrix kopiert. Java Basics - Anfänger-Themen 16
J Matrix Java Java Basics - Anfänger-Themen 3
D 2 mehrdimensionale Matrix einlesen Java Basics - Anfänger-Themen 2
A N*N Matrix Determinante berechnen Java Basics - Anfänger-Themen 47
K Quadratische Matrix um 90° drehen Java Basics - Anfänger-Themen 5
C Programm zur Berechnung der Spur einer Matrix Java Basics - Anfänger-Themen 4
B Zeilenumbruch (zweidim. Matrix) Java Basics - Anfänger-Themen 2
O Java Matrix mal Matrix über while Schleife... Java Basics - Anfänger-Themen 10
O Transponieren einer Matrix per While-Schleife Java Basics - Anfänger-Themen 3
M Matrix - Probelm Java Basics - Anfänger-Themen 7
O 2D Matrix befüllen mit geraden Zahlen!? Java Basics - Anfänger-Themen 14
J Java Matrix befüllen Java Basics - Anfänger-Themen 5
F Matrix Java Basics - Anfänger-Themen 11
E Array als Matrix Java Basics - Anfänger-Themen 21
G OOP Parameter Matrix Java Basics - Anfänger-Themen 2
N Matrix Klasse Java Basics - Anfänger-Themen 4
B Maske an eine Matrix anpassen Java Basics - Anfänger-Themen 5
W Matrix übergeben Java Basics - Anfänger-Themen 7
T Matrix transponieren Java Basics - Anfänger-Themen 17
W Eine Methode schreiben, ob eine Matrix eine Diagonalmatrix ist.? Java Basics - Anfänger-Themen 3
M String Datei in Float-Matrix umwandeln Java Basics - Anfänger-Themen 8
D Problem: Werte eine Matrix vergleichen! Java Basics - Anfänger-Themen 5
B Matrix Java Basics - Anfänger-Themen 2
Semox Matrix multiplizieren Java Basics - Anfänger-Themen 4
N Matrix an toString Java Basics - Anfänger-Themen 7
C Diagonale in einem NxN Matrix Java Basics - Anfänger-Themen 6
F Einträgen von Matrix zu sotieren Java Basics - Anfänger-Themen 2
D JUnit auf Matrix anwenden Java Basics - Anfänger-Themen 5
J Spezielle Matrix ausgeben ! Java Basics - Anfänger-Themen 8
S Problem bei Matrix Addition Java Basics - Anfänger-Themen 5
F matrix werte übergeben Java Basics - Anfänger-Themen 5
M Hauptdiagonale Matrix berechnen Java Basics - Anfänger-Themen 6
M Klassenerstellung für Matrix mit Rechenopperationen Java Basics - Anfänger-Themen 42
D Matrix .bat datei erstellen und öffnen Java Basics - Anfänger-Themen 2
J Matrix ausgeben Java Basics - Anfänger-Themen 9
N Matrix Matrix Produkt Java Basics - Anfänger-Themen 7
N prüfe ob etwas in einer Matrix steht... Java Basics - Anfänger-Themen 14
L rechtecke zeichnen anhand von matrix Java Basics - Anfänger-Themen 27
J Matrix aus Datei einlesen mit StreamTokenizer Java Basics - Anfänger-Themen 3
K Transponiere Matrix Java Basics - Anfänger-Themen 4

Ähnliche Java Themen

Neue Themen


Oben