✔ Matrix-Multiplikation

Z

zueu

Grünschnabel
Morgen :)
Ich hab ein Problem bei dem ich einfach nicht weiter komme.
Ich soll eine 3x3 Matrix Multiplizieren und in eine neue Array speichern.
Der Code war soweit vorgegeben und kann nicht verändert werden nur die Methode sollte ich schreiben.
Und hier kommt mein Problem:
Ich habe zwei Arrays vom Typ double. Meine Methode klappt soweit nur das sie statt double einen int wert zurück gibt. Wie löse ich das?

Code ist wie folgt:
Java: 
public class MatrixMultiplication3x3 {
    
    public static double[][] mult3x3(double[][] A, double[][] B) {

      
        if (A.length != 3 || A[0].length != 3 || B.length != 3 || B[0].length!= 3) {
            System.out.println("ERROR: Check your dimension! \n");
            return new double[0][0];
        }
      
        double [] [] C = new double[3][3];
------------------------------------------------------
        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < B[0].length; j++) {                Dieser Block darf verändert werden.
                C[i][I][j] = 0;
                for (int k = 0; k < A[0].length; k++) {
                C[i][I][j] += A[i][I][k] * B[k][j];
                    return C;
        }}}}
       ----------------------------------------------
        public static void draw(double[][] M) {
            for (int i = 0; i < M.length; i++)
                for(int j = 0; j < M[0].length; j++)
                    System.out.print((j == 0 ? "|" : "") + M[I][j] + (j == M[0].length-1 ? "|\n" : "\t"));
            System.out.println();
        }
       
       
        public static void main(String args[]) {
           
            double [] [] A = {{ 0.0, -1.0, 0.0},
                             { 1.0,  0.0, 0.0},
                             { 0.0,  0.0, 1.0}};
           
            double [] [] B = {{ 0.0,  1.0, 0.0},
                             {-1.0,  0.0, 0.0},
                             { 0.0,  0.0, 1.0}};
           
            double [] [] C = mult3x3(A, B);
           
            draw(A);
            System.out.println("*\n");
            draw(B);
            System.out.println("=\n");
            draw(C);
           
        }
       
    }
 
Zuletzt bearbeitet von einem Moderator:
Um das Ganze etwas dynamischer zu gestalten überprüfe die Dimensionen nur auf Gleichheit nicht auf 3.

Du arbeitest mit 2-Dimensionalen Arrays dann behandel diese auch so also mit zwei Indexen.

Die Draw Methode ist falsch diese gibt nicht die Werte aus..

Java: 
public class MatrixMultiplication3x3 {

    public static double[][] mult3x3(double[][] A, double[][] B) {

        if (A.length != B.length || A[0].length != B[0].length) {
            System.out.println("ERROR: Check your dimension! \n");
            return new double[0][0];
        }

        double[][] C = new double[A.length][A[0].length];

        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < A[0].length; j++) {
                C[i][j] = A[i][j] * B[i][j];
            }
        }
        return C;
//        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++) {
//                    C += A[k] * B[k];
//                    return C;
//                }
//            }
//        }
    }

    public static void draw(double[][] M) {
        for (int i = 0; i < M.length; i++)
            for (int j = 0; j < M[0].length; j++)
                System.out.print((j == 0 ? "|" : "") + M[i][j]
                        + (j == M[0].length - 1 ? "|\n" : "\t"));
        System.out.println();
    }

    public static void main(String args[]) {

        double[][] A = { { 0.0, -1.0, 0.0 , 0.1}, { 1.0, 0.0, 0.0 , 1.0},
                { 0.0, 0.0, 1.0, 2.0 },{ 0.0, 0.0, 1.0, 2.0 } };
     
        double[][] B = { { 0.0, 1.0, 0.0 , 3.0}, { -1.0, 0.0, 0.0 , 2.0},
                { 0.0, 0.0, 1.0 , 4.0 } ,{ 0.0, 0.0, 1.0, 2.0 }};

        double[][] C = mult3x3(A, B);

        draw(A);
        System.out.println("*\n");
        draw(B);
        System.out.println("=\n");
        draw(C);

    }

}

Viele Grüße
Youza
 
Danke für die Antwort aber leider löst sie mein Porblem nicht da ich die von dir Angesprochen Programm Codes nicht veränderbar sind nur der markierte Block.

Viele grüße
Zueu
 
Noch eine Kleinigkeit ist mir gerade aufgefallen du rechnest hier mit Double werten also musst du runden. Fließkommazahlen können nicht mit unendlicher Genauigkeit dargestellt werden. Daher rechnet man mit BigDezimal (am genauesten).

Java: 
import java.math.BigDecimal;

public class MatrixMultiplication3x3 {

    public static double[][] mult3x3(double[][] A, double[][] B) {

        if (A.length != B.length || A[0].length != B[0].length) {
            System.out.println("ERROR: Check your dimension! \n");
            return new double[0][0];
        }

        double[][] C = new double[A.length][A[0].length];

        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < A[0].length; j++) {
                C[i][j] = round((A[i][j] * B[i][j]),1);
            }
        }
        return C;
//        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++) {
//                    C += A[k] * B[k];
//                    return C;
//                }
//            }
//        }
    }
    public static double round(double value, int scale) {
        if (scale < 0) throw new ArithmeticException("scale is negative");
        BigDecimal d = new BigDecimal(Double.toString(value));
        return d.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
    public static void draw(double[][] M) {
        for (int i = 0; i < M.length; i++)
            for (int j = 0; j < M[0].length; j++)
                System.out.print((j == 0 ? "|" : "") + M[i][j]
                        + (j == M[0].length - 1 ? "|\n" : "\t"));
        System.out.println();
    }

    public static void main(String args[]) {

        double[][] A = { { 0.0, -1.0, 0.0 , 0.1}, { 1.0, 0.0, 0.0 , 1.0},
                { 0.0, 0.0, 1.0, 2.0 },{ 0.0, 0.0, 1.0, 2.0 } };
      
        double[][] B = { { 0.0, 1.0, 0.0 , 3.0}, { -1.0, 0.0, 0.0 , 2.0},
                { 0.0, 0.0, 1.0 , 4.0 } ,{ 0.0, 0.0, 1.0, 2.0 }};

        double[][] C = mult3x3(A, B);

        draw(A);
        System.out.println("*\n");
        draw(B);
        System.out.println("=\n");
        draw(C);

    }

}

Zu deiner gerade gegebenen Antwort kann ich nur sagen die Ausgabe ist falsch... da wird immer nur das Objekt ausgegeben Die gegebene Lösung ist richtig kannst ja nur deine Funktion rauskopieren...
 
Vielen Dank für die ganzen Tipps aber leider kann ich den Programm Code dort nicht verändern da er schon so vor gegeben ist :/
 
Okay dann probier ich es nochmal Einfacher:
Java: 
        double[][] C = new double[A.length][A[0].length];

        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < A[0].length; j++) {
                C[i][j] = A[i][j] * B[i][j];
            }
        }
        return C;
 
Danke sieht schon mal besser aus :)
Mich verwirrt nur das in der Aufgabe steht das ich 3 verschachtelte for schleifen brauchen.
 
@youza: Programmiermäßig ist das zwar ok, aber mathematisch nicht :p
Pro Zelle die Summe von Zeile*Spalte, um es schnell und ungenau auszudrücken
(leider grad keine Zeit für Ausführliches)
 
Weil ich hier dir grad den totalen quatsch erzählt hab Matrizen löst man ganz anderes ^^

Java: 
double[][] C = new double[A.length][A[0].length];

        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < B[0].length; j++) {
                C[i][j] = 0;
                for (int k = 0; k < A[0].length; k++) {
                 C[i][j] += A[i][k] * B[k][j];
                }
            }
        }
 
Danke :)
Der zeigt das hier leider nicht richtig an aber oben habe ich das eigentlich so auch stehen aber er meckert jetzt das er keinen int in double umwandeln kann
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück