Matrix mit Vektor multiplizieren

[ElifÖzt]

Hallo Leute,

ich weiß das Thema gibt es unendlich mal im Internet, aber daraus kann ich einfach keine Lehre ziehen.
Ich muss eine 3x3 Matrix mit einem 3dim Vektor multiplizieren bzw. wenn das geschafft ist eine Mathode implementieren, mit der man eine beliebige Matrix mit einem beliebigen Vektor multiplizieren kann und dabei soll auch abgeprüft werden, ob es überhaupt möglich ist.

Mein Quellcode:

public class Matrixmultiplikation {
public static double[] multiply(double[][] A, double[] x) {
        int m = A.length;
        int n = A[0].length;
        if (x.length != n) throw new RuntimeException("Illegal matrix dimensions.");
        double[] y = new double[m];
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
                y[i] += A[i][j] * x[j];
        return y;
    }
   
   
    public static void main(String[] args){
       
        double [] x = {-1,1,1};
        double [][] A = {    {1, 2, 3},
                            {3, 2, 1},
                            {0, 1, 2}};
       
        System.out.println(Matrixmultiplikation.multiply(A, x));
       
        }
}
}

Als Ausgabe kommt eine Referenz und kein Vektor. Ich weiß einfach nicht wo mein Fehler liegt.
Könnte mir jemand bitte mein Fehler sagen?
Danke im Voraus
lg ElifÖzt

 

[Tarrew]

Du musst das Array einmal durchlaufen und dann die Werte einzeln ausgeben:

        double[] d = Matrixmultiplikation.multiply(A, x);
        for(double value : d){
            System.out.println(value);
        }

 

[ElifÖzt]

Danke für die Antwort,
kannst du eventuell mir auch verraten, wie ich die for-Schleife auf alte Weise schreiben kann, um das gleiche zu erreichen. Habe nämlich nicht die neueste Version

 

[Tarrew]

Nicht die neuste Version? Die for-each Schleife gibts schon seit dem JDK 1.5 und das ist 2004 erschienen ;o Du musst aber echt auf einer ganz alten Version arbeiten ...

Aber so ist die 'alte' Schreibweise:

        for(int i=0; i<d.length; i++){
            System.out.println(d[i]);
        }

 

[ElifÖzt]

Okay danke, jetzt kommt nicht mehr eine Referenz sondern ein Vektor, aber die Lösung sollte (2,1,0) sein und es kommt bei mir (4,0,3) raus.

 

[Tarrew]

Du multiplizierst diese Matrix:

1 2 3
3 2 1
0 1 2

mit dem Vektor
-1
1
1

Und wenn mein Mathe nicht ganz eingerostet ist kommt da (4,0,3) raus. Also das stimmt schon.
Vermutlich denkst du an die Matrix:
1 3 0
2 2 1
3 1 2
Da würde dann tatsächlich (2,1,0) rauskommen. Wenn du das erreichen willst musst du aber auch nur 2 Zeichen ändern.

Kann es sein, dass du den Code irgendwo kopiert hast? Wenn der Code wirklich von dir kommen würde, dann dürftest du ja auch keine Probleme haben ein Array mit einer normalen for-Schleife auszugeben, vor allem weil du in deiner multiply-Funktion ja mehrere for-Schleifen benutzt.

 

[strußi]

hatte das ganze mal zum Spass programmiert

Spoiler: Matrix

public class MatrixRechnung {

  // Anfang Attribute
  // Ende Attribute



  // Matrizenaddition

  // Anfang Methoden
  public static void matrixAddition (double[][]m1, double[][]m2){
    double[][]ergebnis = new double[m1.length][m1.length];
    if(m1.length!=m2.length) System.out.println("Matrizen sind unterschiedlich groß");
    else if( m1.length==m2.length) {

      ergebnis = new double[m1.length][m1.length];
      for(int i =0; i<m1.length; ++i){
        for(int j =0; j<m1.length; ++j) {
          ergebnis[i][j] = m1[i][j] + m2[i][j];
          System.out.println(ergebnis[i][j]);
        }
      }
    }
  }

  // Matrizensubtraktion
  public static void matrixSubtraktion (double[][]m1, double[][]m2){
    double[][]ergebnis = new double[m1.length][m1.length];
    if(m1.length!=m2.length) System.out.println("Matrizen sind unterschiedlich groß");
    else if( m1.length==m2.length) {

      ergebnis = new double[m1.length][m1.length];
      for(int i =0; i<m1.length; ++i){
        for(int j =0; j<m1.length; ++j) {
          ergebnis[i][j] = m1[i][j] - m2[i][j];
          System.out.println(ergebnis[i][j]);
        }
      }
    }
  }

  // Multiplikation einer Matrix mit einem Vektor
  public static void multiplikation( int matrix[][], int vektor[]) {
    for(int i=0; i<matrix.length; i++) {
      int result[] = new int[vektor.length];
      for( int j=0; j<vektor.length; j++) {
        result[i] = result[i]+matrix[i][j]*vektor[j];
      }
      System.out.println(result[i]);
    }
  }

  // Inverse einer 2 X 2 Matrix
  public static void inverse(double matrix[][]) {
    double result[][] = new double[matrix.length][matrix.length];
    double det = ( matrix[0][0]* matrix[1][1]) - (matrix[0][1]*matrix[1][0]);
  
    double x = matrix[0][0];
    matrix [0][0] = matrix[1][1];
    matrix [1][1] = x;
  
    matrix[0][1] = matrix[0][1]*(-1);
    matrix[1][0] = matrix[1][0]*(-1);
  
    for( int i=0; i<matrix.length; i++) {
      for( int j=0; j<matrix.length; j++){
        result[i][j]= (1/det)*matrix[i][j];
        System.out.println(result[i][j]);
      }
    }
  }

  //Matrix mal Matrix
  public static void multiplikation( double matrix1[][], double matrix2[][]){
     for( int i=0; i<matrix1.length; i++) {
       double result[][] = new double[matrix1.length][matrix1.length];
       for( int j=0; j<matrix1.length; j++){
         for( int k=0; k<matrix1.length; k++){
           result[i][j] = result[i][j]+matrix1[i][k]*matrix2[k][j];
         }
         System.out.println(result[i][j]);
       }
     }
  }

  // determinate einer 2x2 Matrix
  public static void det( double matrix[][]){
    double det1 = matrix[0][0]*matrix[1][1];
    double det2 = matrix[0][1]*matrix[1][0];
    double result = det1 - det2;
  
    System.out.println(result);
  }

  // determinate einer 3x3 Matrix
  public static void det2( double matrix[][]){
    double pdet1 = matrix[0][0]*matrix[1][1]*matrix[2][2];
    double pdet2 = matrix[0][1]*matrix[1][2]*matrix[2][0];
    double pdet3 = matrix[0][2]*matrix[1][0]*matrix[2][1];

    double ndet1 = matrix[2][0]*matrix[1][1]*matrix[0][2];
    double ndet2 = matrix[2][1]*matrix[1][2]*matrix[0][0];
    double ndet3 = matrix[2][2]*matrix[1][0]*matrix[0][1];

    double result = pdet1 + pdet2 + pdet3 - ndet1 - ndet2 - ndet3;

    System.out.println(result);
  }


  public static void main(String[] args) {
    double [][] matrix1 = {{1.0, 2.0, 3.0 },
                           {4.0, 5.0, 6.0 },
                           {7.0, 8.0, 9.0 },
                          };
                        
    double [][] matrix2 = {{9.0, 8.0, 7.0 },
                           {6.0, 5.0, 4.0 },
                           {3.0, 2.0, 1.0 },
                          };

    double[][] ergebnis = new double[3][3];
                        
    matrixAddition(matrix1, matrix2);
    System.out.println(" ");
  
    matrixSubtraktion(matrix1, matrix2);
    System.out.println(" ");
  
    det(matrix1);
    System.out.println(" ");
  
    det2(matrix2);
    System.out.println(" ");
  }
  // Ende Methoden
}

Spoiler: Vektor

public class Vektorrechnung {

  // Anfang Attribute
  // Ende Attribute



  // Anfang Methoden
  public static double[] vektorAddition( double[]a, double[]b) {
    double[]result = new double[3];
  
    for(int i = 0; i<a.length; i++){
      result[i] = a[i]+ b[i];
    }
    return result;
  }

  public static double[] vektorSubtraktion( double[]a, double[]b) {
    double[]result = new double[3];

    for(int i = 0; i<a.length; i++){
      result[i] = a[i]- b[i];
    }
    return result;
  }

  public static double[] kreuzprodukt(double[]a, double[]b) {
    double[]result = new double[3];
    result[0]= a[1]*b[2] - a[2]*b[1];
    result[1]= a[2]*b[0] - a[0]*b[2];
    result[2]= a[0]*b[1] - a[1]*b[0];
  
    return result;
  }

  public static double skalarprodukt(double[]a, double[]b) {
    double resultSkalar= 0.0d;
    for(int i = 0; i<a.length; i++) {
      resultSkalar = resultSkalar + a[i]*b[i];
    }
    return resultSkalar;
  }

  public static double[] skalarMultiplikation(double[]a, double skalar) {
    double [] result= new double[3];
    for(int i = 0; i<a.length; i++) {
      result[i] = skalar*a[i];
    }
    return result;
  }

  public static double vektorLaenge(double[]a) {
    double result = 0.0d;
    for(int i = 0; i<a.length; i++) {
      result= result+ a[i]*a[i];
    }
    result = Math.sqrt(result);
    return result;
  }

  public static void main(String[] args) {
    double [] vektor1 = {1.0, 7.8, 9.0 };
    double [] vektor2 = {2.3, 6.5, 8.7 };
    double [] ergebnis;
    double result;


    result = vektorLaenge(vektor1);
    System.out.println(result);
  }
  // Ende Methoden
}

Fehler dürfen behalten werden, aber auch gerne an mich weitergereicht werden

 

[ElifÖzt]

Okay danke für die Antwort
Nein kopiert ist der ganz klar nicht, ich hatte aber von jemand anderes Hilfe beim Implementieren. Aber nachdem ich seit mehreren Stunden an mehreren Aufgaben saß, lässt die Konzentration zu wünschen übrig leider.
Danke strußi für deinen Beitrag