Matrix-Vektor-Multiplikation

[Rock'n]

Hey Leute,

also ich muss ein Programm schreiben, welches das Produkt einer Symmetrischen Matrix und eines Vektors berechnet. Bis jetzt hab ich folgendes geschrieben:

	package algebra;
	 
	public class SymmetrischeMatrix {
	    
	    private double [][] koeffizientenFeld = null; 
	    
	    
	    private int anzahlZeilenUndSpalten;
	    
	     public SymmetrischeMatrix(int groesse) {
	          
	    	 this.anzahlZeilenUndSpalten = groesse;
	    	 
	    	 this.koeffizientenFeld = new double[groesse][];
	            
	    	 for (int j = 0; j < groesse; j++){
	    		 koeffizientenFeld[j] = new double[j+1];
	    	 }
	            
	          }
	    public int getGroesse (){
	    	return anzahlZeilenUndSpalten;
	    }
	     
	    public double getKoeffizient(int row, int col) {
	      
	        if (row >= col){
	        	return koeffizientenFeld [row][col];
	        }
	        else{
	        	 return koeffizientenFeld [col][row];
	        }
	    }
	    
	    public void setKoeffizient(int row, int col, double value){
	        if (row >= col){
	        	 koeffizientenFeld [row][col]=value;
	        }
	        else{
	        	  koeffizientenFeld [col][row]=value;
	        }
	    	
	    	
	    }
	    
	    
	    
	

}

package algebra;

public class Vektor {

	private double [] vektor;
	private int groesse;
	
	public Vektor(int groesse) {
		this.groesse = groesse;
		vektor = new double[groesse];
	}
	
	public void setKoeffizient(double wert, int stelle){
		vektor[stelle] = wert;
	}

	public double getKoeffizient(int stelle){
		return vektor[stelle];
	}
	@Override
	public String toString() {
		String ausgabe;
		ausgabe = "Vektor(";

		for (int i = 0; i < groesse; i++) {
		ausgabe += vektor[i];

		if (i < groesse-1) {
		ausgabe += ",";
		}
		}

		ausgabe += ")";
		return ausgabe;
		}

	public Vektor multiplizieren(SymmetrischeMatrix matrix) throws Exception {
		Vektor Ergebnisvektor;
		Ergebnisvektor = new Vektor (groesse);
			if (matrix.getGroesse() != groesse){
			throw new Exception("Größe nicht kompatibel");
		}
		for (int j = 0; j < groesse; j++){
			for (int i = 0; i < groesse; i++) {
				double Zwischenwert;
				Zwischenwert = Ergebnisvektor.getKoeffizient(j);
				Zwischenwert += matrix.getKoeffizient(j, i)*this.getKoeffizient(i);
				Ergebnisvektor.setKoeffizient(Zwischenwert, j);
			} 
			
		}
	
	
		
		return Ergebnisvektor;
	}
	
	
}

package programme;

import algebra.SymmetrischeMatrix;
import algebra.Vektor;

public class Prüfklasse {
	public static void main(String args[]) {
		
		SymmetrischeMatrix prüfmatrix1 = new SymmetrischeMatrix(4);
		Vektor prüfvektor1 = new Vektor(4);
		
		prüfvektor1.setKoeffizient(0.3, 0);
		prüfvektor1.setKoeffizient(0.2, 1);
		prüfvektor1.setKoeffizient(0.1, 2);
		prüfvektor1.setKoeffizient(0.0, 3);
		
		
		prüfmatrix1.setKoeffizient(0, 0, 1.0);
		prüfmatrix1.setKoeffizient(1, 0, -1.0);
		prüfmatrix1.setKoeffizient(1, 1, 2.0);
		prüfmatrix1.setKoeffizient(2, 0, 0.0);
		prüfmatrix1.setKoeffizient(2, 1, -1.0);
		prüfmatrix1.setKoeffizient(2, 2, 2.0);
		prüfmatrix1.setKoeffizient(3, 0, 0.0);
		prüfmatrix1.setKoeffizient(3, 1, 0.0);
		prüfmatrix1.setKoeffizient(3, 2, -1.0);
		prüfmatrix1.setKoeffizient(3, 3, 2.0);
		
		

		 try {
	    		System.out.println("Prüfmatrix1 * Vektor1 = ");
		    
	    		System.out.println(prüfvektor1.multiplizieren(prüfmatrix1));
		    } catch (Exception e) {
		      System.out.println(e);
		    }
		
	
	
	
	
}

leider stimmt das Ergebnis nicht. Könnt ihr mir vielleicht einen Hinweis geben was falsch ist?!

Danke!

 

[Gucky]

Erstmal: Wozu der Doppelpost?

Zum Zweiten hatten wir fast genau den gleichen Thread schon einmal. Bitte ließ dir erst den durch und versuch die dortigen Lösungswege zu benutzen und melde dich danach wieder 😉
http://www.java-forum.org/allgemeine-java-themen/161415-matrix-vektor-multiplikation.html

 

[Rock'n]

Oh entschuldige ! Hatte nicht vor zweimal zu posten. Beim ersten Post hat sich mein PC aufgehangen und ich dachte es hätte gar nicht geklappt. Werde den einen nachher löschen.
Danke erstmal für den Link. Ich guck ihn mir an und versuche daraus schlau zu werden.

 

[Rock'n]

Also ich hab mir den Link durch gelesen und den Quellcode wie folgt geändert:

package algebra;

public class Vektor {

	private double [] vektor;
	private int groesse;
	
	public Vektor(int groesse) {
		this.groesse = groesse;
		vektor = new double[groesse];
	}
	
	public void setKoeffizient(double wert, int stelle){
		vektor[stelle] = wert;
	}

	public double getKoeffizient(int stelle){
		return vektor[stelle];
	}
	@Override
	public String toString() {
		String ausgabe;
		ausgabe = "Vektor(";

		for (int i = 0; i < groesse; i++) {
		ausgabe += vektor[i];

		if (i < groesse-1) {
		ausgabe += ",";
		}
		}

		ausgabe += ")";
		return ausgabe;
		}


	
	public Vektor multiplizieren(SymmetrischeMatrix matrix) throws Exception {
		Vektor Ergebnisvektor;
		Ergebnisvektor = new Vektor (groesse);
			if (matrix.getGroesse() != groesse){
			throw new Exception("Größe nicht kompatibel");
		}
		for (int i = 0; i < this.groesse; i++){
			double Zwischenwert=0;
			for (int j = 0; j < Ergebnisvektor.groesse; j++) {
				
				Zwischenwert += matrix.getKoeffizient(i, j)*this.getKoeffizient(j);
			}
				Ergebnisvektor.setKoeffizient(Zwischenwert, i);
			 
			
		}
	
	
	
	
		
		return Ergebnisvektor;
	}
	
	
}

Das Ergebnis bleibt falsch.

 

[VfL_Freak]

Moin,

Das Ergebnis bleibt falsch

wie wäre es, wenn Du dies mal näher erläuterst :autsch:

Gruß
Klaus

 

[Rock'n]

Ja klar… also ich hab die symmetrische matrix gegeben:

1 -1 0 0
-1 2 -1 0
0 -1 2 -1
0 0 -1 2

und den vektor:
0,3
0,2
0,1
0

wenn ich jetzt die Prüfklasse ausführen lasse kommt als Ergebnis dieser Vektor raus
Vektor(0.09999999999999998,2.7755575615628914E-17,0.0,-0.1)

aber meinen Berechnungen nach müsste eigentlich folgendes rauskommen:
(0.1, 0, 0, -0.1)


Jetzt hab ich leider gar keine Ahnung woran es liegt. Ist was bei der Methode zum multiplizieren falsch, bei der Klasse der Symmetrischen Matrix oder in der Prüfklasse oder ...?

 

[trez]

Wo ist das Problem, dein Resultat stimmt ja.

Das hat nicht direkt mit Java zu tun, sonder mit der Tatsache, dass float-Werte nicht präzise abgebildet werden können.

 

[Rock'n]

Entschuldige wenn ich jetzt so doof frage, aber ich hab leider nicht so viel Ahnung vom Programmieren.
Wieso meinst du, dass das Ergebnis richtig ist?
Vektor(0.09999999999999998,2.7755575615628914E-17,0.0,-0.1) ist doch nicht das gleiche wie
(0.1, 0, 0, -0.1). und vor allem was soll dieses "E" bei 2.7755575615628914E-17 ?

 

[njans]

2.7755575615628914E-17 ist das selbe, wie 2.7755575615628914 * 10 ^(-17 ). E für Exponent.
Trez hat Recht für die 0.09999999999999998, diese entspricht 0.1, da die mathematische Genauigkeit von Gleitkommazahlen limitiert ist. Die 2,7... ist wohl definitiv falsch, ergo gibt es noch einen Fehler in deinem Programm.

 

[Rock'n]

okay, danke erstmal für die Erklärung… Aber wie du ja gesagt hast, scheint noch irgendwas falsch zu sein. Hat jemand vielleicht ne Idee was?

 

[Gucky]

Du könntest alle Ergebnisse auf drei Nachkommastellen runden. Dann müsste das Richtige raus kommen. Zumindest da, wo die Genauigkeit am Fehler schuld ist.

Hast du schon mal debugged? Lass dir mal sämtliche Schritte mit Sysouts ausgeben oder verfolg die Schritte nach mit dem Debugger oder beides.

 

[Rock'n]

Was debugged ist weiß ich leider nicht 😳
aber ich hab mir das alles als Sys.out geben lassen. Demnach scheint der Fehler hier:

Zwischenwert += matrix.getKoeffizient(i, j)*this.getKoeffizient(j);

zu sein.
Aber was ist daran falsch?

 

[Rock'n]

Entschuldige habe mir gerade nochmal nur die Variable "Zwischenwert" ausgeben lassen und hier scheint der Fehler zu liegen es wird folgendes ausgegeben:
0.0
0.3
0.09999999999999998
0.09999999999999998
0.0
-0.3
0.10000000000000003
2.7755575615628914E-17
0.0
0.0
-0.2
0.0
0.0
0.0
0.0
-0.1

aber eigentlich hatte ich den Zwischenwert ja gleich null gesetzt… wie kommt es dann dazu?

 

[Gucky]

Woher sollen wir das wissen? 😀 Es ist dein Code. 😉

Statt eines Fisches gebe ich dir jetzt die Fähigkeit zu fischen.
Weißt du, was ein Bug ist? Debuggen ist die Tätigkeit, die man durchführt, um einen Bug zu entfernen.

Benutz mal den Debugger, um den Prozess nachzuvollziehen. Führ den Code zeilenweise aus und lass dir sämtliche Variablenbelegungen anzeigen und überprüf sie mit dem Wert, der darin stehen müsste.