Matrix Vektor Multiplikation

Java-Forum Java-Grundlagen
1

Hallo Leute, habe eine Aufgabe, und zwar soll ich eine symmetrische, quadratische Matrix und einen Vektor erstellen, die Einträge habe ich.
desweitern sollen die Klassen SymMatrix und Vektor über eine Methode zum Setzen und Holen eines Koeffizienten verfügen.
Zum Schluss soll ich die Matrix noch mit dem Vektor multiplizieren.
Bisher habe ich das hier gemacht, bekomme aber keine Ausgabe, was mache ich falsch? Bitte helft mir :(((


public class SymMatrix {

public double [][] Matrix = null; 
    
public double i , j;    

     public SymMatrix(double [][] Matrix) {
    	 
    	 for(int j=1; j< Matrix.length + 1; j++){
    	 for(int i=1; i< Matrix.length + 1; i++){
    		 
    	 if (j <= i){
          this.Matrix = new double**[j];
    	 }
    	 else{
          Matrix**[j] = Matrix [j]**;
          }
    	 }
    	 }
          }
    
    public double get(int zeile, int spalte) {
        return Matrix [zeile][spalte];
    }
    
    public void set(int zeile, int spalte, double wert){
        this.Matrix [zeile][spalte] = wert;
    }
    
    
    
}

import mathe.SymMatrix;

public class Vektor {

	

	public double [][] Vektor = null; 
	public double [][] Vektor2 = null;
	
	public int i;
	public int j ;

	     public Vektor(double [][] Vektor) {
	    	 
	    	 for(int i=1; i < Vektor.length +1; i++){
	    	 this.Vektor = new double **[1];
	         }
	     }
	     public void Vektor2(double [][] Vektor2) {
		    	 
		    	 for(int j=1; j < Vektor2.length +1; j++){
		    	 this.Vektor2 = new double **[1] ;
		    	 }
	    	 
	          }
	    
	    public double get( int zeile) {
	        return Vektor [zeile][1];
	    }
	    
	    public void set(int zeile, double wert){
	        this.Vektor [zeile][1] = wert;
	     
	    }     
	     
	    
	    
	    double multiMatVek(int [][] Vektor, int [][] Vektor2){
	    	
	    
        for(int i = 0; i < Vektor.length; i++);
        {
        	for(int j = 0; j < Vektor2.length; j++);
        	
        	{
        		
				
				Vektor2** += this.Matrix**[j]*this.Vektor[j];
        		
        	
        	}
        }
        return i;
        
}
	
	
}


import mathe.*;


public class Test {

	public static void main(String args[]) {
		double[][] Matrix = {
	    { 1.0, -1.0, 0.0, 0.0},
        { -1.0, 2.0, -1.0, 0.0},
	    { 0.0, -1.0, 2.0, -1.0},
        { 0.0, 0.0, -1.0, 2.0}		
		
		};
	}
	
		public static void main1(String args[]) {
			double[][] Vektor = {
					{0.3},
					{0.2},
					{0.1},
					{0.0}
			};
	}	

}
2

Dass dort keine Ausgabe kommt, ist nicht sonderlich verwunderlich - es gibt ja auch keine einzige Zeile, bei der etwas ausgegeben wird (System.out.println).
Abgesehen davon gibt es viele Stellen, an denen du etwas anderes geschrieben als gedacht hast.

    { 1.0, -1.0, 0.0, 0.0},
    { -1.0, 2.0, -1.0, 0.0},
    { 0.0, -1.0, 2.0, -1.0},
    { 0.0, 0.0, -1.0, 2.0}
};```
Das erzeugt keine Instanz der Matrix-Klasse, sondern ein zweidimensionales double-Array. Ein Instanz mit dem Namen `matrix` könntest du so erzeugen:
```Matrix matrix = new Matrix({
    { 1.0, -1.0, 0.0, 0.0},
    { -1.0, 2.0, -1.0, 0.0},
    { 0.0, -1.0, 2.0, -1.0},
    { 0.0, 0.0, -1.0, 2.0}
});```

Eine Methode mit dem Namen `main1` wird niemals ausgeführt, da du sie nicht aufrufst.
Selbiges gilt auch für die Multiplikationsmethode, du muss sie aufrufen, damit sie ausgeführt wird.
3

mal von allem anderen abgesehen:

  public double [][] Vektor = null;
    public double [][] Vektor2 = null;

ist mir völlig schleierhaft - warum ist ein Vector nicht einfach ein double[]?

*** Edit ***

und auch im Konstruktor von SymMatrix

if (j <= i){
          this.Matrix = new double**[j];
         }
         else{
          Matrix**[j] = Matrix [j]**;
          }

ist absolut fehlerhaft. Wie genau soll man denn aus einer Matrix eine symmetrische machen - vermutlich ist die Summe aus der Matrix und der transponierten Matrix gemeint?

4

Ohne demotivierend wirken zu wollen, würde ich vorschlagen, nochmal ganz von vorne anzufangen.

Welche Aufgabenstellung gibt es genau?

Als ersten Schritt würde ich vorschlagen, die Klasse Vektor zu implementieren (ohne Multiplikationsmethode). Wenn du damit soweit bist oder noch Nachfragen hast, poste den Code hier und wir werden dir dann helfen.

5 
import mathe.SymMatrix;
 
public class Vektor {
 
   
 
    public double [][]Vektor = null;
   
    public int i;
 
         public Vektor(double [][]Vektor) {
             
             for(int i=1; i < Vektor.length +1; i++){
             this.Vektor = new double **[1];
             }
        public double get( int zeile) {
            return Vektor [zeile][1];
        }
       
        public void set(int zeile, double wert){
            this.Vektor [zeile][1] = wert;
         
        }    
         }
      ```

Ich soll eine Klasse Vektor entwickeln, in der die Koeffizienten eines Vektors in einem Feld gespeichert werden. Außerdem soll die Klasse eine Methode zum setzen eines Koeffizienten und zum holen eines Koeffizienten haben.
6

Ok, dann mal Schritt für Schritt.
Grundlegend:
Eine ordentliche Formatierung hilft ungemein, zusammengehörige Codeblöcke zu erkennen (Einrückung, Zeilenumbrüche).

Warum hast du dich entschieden, als Datentyp vom Feld Vektor double[][] zu nehmen?*
Felder und Variablennamen beginnen per Konvention mit einem Kleinbuchstaben (siehe Java Code Conventions), also statt Vektor eher vektor. Du solltest aber besser noch einen passenderen Namen wie koeffizienten wählen.
Felder sind grundsätzlich erst einmal private und nicht public.

  • (das ist nicht unbedingt die beste Wahl)
7

Wozu die Doppelindizes?

public class Vector {

	private final double[] koeffs;

	public Vector(double[] init) {
		this.koeffs = init;
	}

	public double getKoeff(int i) {
		return koeffs**;
	}

	public void setKoeff(int i, double val) {
		koeffs** = val;
	}
}

ohne Fehlerbehandlung etc. Ein Vector ist doch nie und nimmer ein double[][]

8

Naja man könnte einen Vektor als Speziellfall einer Matrix ansehen, daher eine Dimension der Matrix =1

9

Okay also ist das der richtige Code?

public class Vector {
 
    private final double[] koeffs;
 
    public Vector(double[] init) {
        this.koeffs = init;
    }
 
    public double getKoeff(int i) {
        return koeffs**;
    }
 
    public void setKoeff(int i, double val) {
        koeffs** = val;
    }
}```

Brauche ich nicht noch was im die Länge des Vektors zu erzeugen?
Und was genau bedeute init?
10

[QUOTE=Unregistered]Okay also ist das der richtige Code?

Brauche ich nicht noch was im die Länge des Vektors zu erzeugen?
Und was genau bedeute init?[/QUOTE]

Richtig nicht unbedingt, eher rudimentär.

Sollst du mit einer festen Länge arbeiten - oder soll ein Vektor bei dir 3, 5 oder 374 Zahlen enthalten können.

Macht einen gewissen Unterschied…

Edit: oder meinst du die Länge (aka Norm) des Vektors, d.h. die Wurzel aus Summe der Quadrate der Koeffs - muss du halt schreiben, so eine Methode

11

Ich habe eine 4x4 Matrix und eine 4x1 Matrix gegeben, also den Vektor. Die Soll ich aber erst nachher anwenden wenn ich den Test beginne, weil ich ja eine Multiplikation starten soll.
Aber dann muss ich ja trotzdem die Länge der matritzen irgendwie begrenzen, deshalb hatte ich das vorher so gemacht

             
             for(int i=1; i < Vektor.length +1; i++){
             this.Vektor = new double **[1];
             }```

Und dann brauche ich ja noch einen Ergebnisvektor für die spätere Rechnung
12

@Bleiglanz : ich glaube, Code posten war nicht unbedingt zielführend. :wink:

Meckerstunde

Entweder englisch oder deutsch - Vector mit getKoeff sieht komisch aus. Da würd ich dann den sparsamen Weg gehen und das K gegen ein C tauschen. Dann passt das auch mit val.
Außerdem sind die Daten in diesem Fall nicht vernünftig gekapselt. Im Konstruktor sollte eine Kopie erstellt werden (am einfachsten mit [japi]Arrays#copyOf[/japi]).

@Unregistered: Du sollst versuchen, den Code selbst zu entwickeln und nicht per C&P woanders holen. @Bleiglanz ’ Lösung kann man 1:1 so verwenden, aber das hilft dir nicht weiter.
Daher noch einmal die Frage:

Nein, die Länge steht implizit im Array mit drin (init.length).

init ist ein beliebiger Parametername und steht in diesem Fall für etwas wie „initialization-Value“ oder „Initialisierungswert“ oder so.

13

Ich will hier niemanden irgendeinen Code abluchsen,deswegen habe ich ja jenen geschrieben und hoffte das jemand mit hilft ihn richtig zu stellen. Sonst hätte ich hier ohne alles gefragt

Ich dachte mit Double bin ich einfach auf der sicheren Seite und Vektor [][] für sollte und Zeile! in dem Fall ja eigentlich **[1] mit i für die Zeilen menge und 1 weils nur eine Spalte ist

14

Darum geht es auch gar nicht. Es geht darum, dass du den größtmöglichen Lerneffekt hast. Selbst Code vorliegen zu haben, ist auch immer gut. In diesem Fall ist es aber schwieriger auf die Defizite des geposteten Codes einzugehen, als gezielt zu gutem Code hinzuführen.

Den Satz verstehe ich nicht so ganz. Die Begründung zum double ist in Ordnung, double ist eine geeignete Wahl für die Koeffizienten.
Wie viele Dimensionen hat ein Vektor in der Mathematik denn für gewöhnlich? Diese Anzahl an Dimensionen sollte dein Array auch haben.

15

Naja die Dimension eines Vektors gibt die Anzahl in dem Vektor enthaltenen Zahlen an. Sprich 4
Wenn ich das übertrage sieht das dann so aus? Vektor [][][][]?

16

Autsch, mein Fehler - du hast natürlich Recht.
Das passt hier nicht. Sinnvoller Weise nimmt man ein eindimensionales Array. Also so wie @Bleiglanz es schon geschrieben hat: double[] koeffizienten.
Vektor [] wäre ein eindimensionales Array von Vektoren. Du möchtest aber ein Array von double, deshalb double[].

17

Aber steht dann überhaupt noch die Länge im array mit drin wenn ich es eindimensional lasse?

18

Du kannst von Arrays die Länge mittels meinArray.length ermitteln. Das entspricht in @Bleiglanz ’ Code koeffs.length.
Folgende Methode wäre also denkbar:

    return koeffs.length;
}```
19

[QUOTE=Unregistered]Naja die Dimension eines Vektors gibt die Anzahl in dem Vektor enthaltenen Zahlen an. Sprich 4
Wenn ich das übertrage sieht das dann so aus? Vektor [][][][]?[/QUOTE]

Das wäre ein Tensor vom Typ 4, etwas ganz anderes - du hast nur “eine Dimension”, eine Zahl, bei dir 4

d.h. dein Vektor besteht aus 4 doubles, die man in ein einfaches double[] array packt - die 4 koeffizienten / koordinaten / komponenten sprichst du dann mit v[0],v[1],v[2],v[3] an.

Lies mal nochmal nach, was ein array ist

20 
public class Vector {
 
    private final double[] koeffs;
 
    public Vector(double[] init) {
        this.koeffs = init;
    }
 
    public int getDimension() {
    return koeffs.length;
 
    }

    public double getKoeff(int i) {
        return koeffs**;
    }
 
    public void setKoeff(int i, double val) {
        koeffs** = val;
    }
}```

In etwa so?
Kann man das gleiche Prinzip auf eine Matrix anwenden, also auf meine 4x4 matrix?



package mathe;
 
public class Symmatrix {

  private final double[][] koeffs;
 
    public Symmatrix(double[][] init) {
        this.koeffs = init;
    }
 
    public int getDimension() {
    return koeffs.length;
 
    }

    public double getKoeff(int i, int j) {
        return koeffs**, koeffs[j];
    }
 
    public void setKoeff(int i, int j, double val) {
        koeffs**[j] = val;
    }