? Matrix / Matrizen ?

[sascha123]

hallo zusammen! habe schon gegoogelt und auch hier die suche benutzt, aber leider nicht das gefunden, was ich haben wollte. und das ist eine grundlegende erklärung, was eigentlich matrix und matrizen sind, wofür man sie verwendet usw... das einzige, was ich bis jetzt zu verstehen meine ist, das eine matrix immer aus einem mind. 2-dimensionalen array aufgebaut. ich wäre sehr dankbar dafür, wenn mir von euch jemand das mal erklären oder mir einen guten link geben kann!

vielen dank schonmal im vorraus für eure bemühnungen!

gruß sascha

 

[dotlens]

wikipedia
auch matrix(mathematik) zu empfehlen ;-)

eine Matrix ist eigentlich eine Tabelle:

In der linearen Algebra ist eine Matrix (Pl.: Matrizen) eine Anordnung von Zahlenwerten (aber auch anderen Objekten wie Operatoren) in Tabellenform.

 

[sascha123]

ok, dafür schonmal danke!

also mit int a[10][10] , z.bsp., erstelle ich dann eine 10x10 -matrix, und kann dann die felder mit werten füllen?!

 

[Bert Brenner]

Damit erstellst du ein 2 Dimensionales Array das mit int Werten gefüllt werden kann.

Kannst du wie eine Tabelle mit 10 Spalten und 10 Zeilen sehen.

 

[dotlens]

hier ein codebeispiel:

int wert = 0;
int[][] a = new int[10][10];
for(int i = 0; i < 10; i++){
	for(int j = 0; j < 10; j++){
		a[i][j] = wert++;
		System.out.println(a[i][j]);
	}
}

in java schreibt man beim deklarieren nicht a[][] sondern int[][]. Auch wenn neuerdings auch a[][] funktioniert.

 

[meez]

in java schreibt man beim deklarieren nicht a[][] sondern int[][]. Auch wenn neuerdings auch a[][] funktioniert.

Hallo?? Hähh? :autsch:

 

[sascha123]

das hab ich jetzt mal versucht. allerdings gibt das programm mir kein feld aus, sondern untereinander die zahlen von 1 bis 99???

public class matrix1 {
   public static void main(String[] args) {

int wert = 0;
int[][] a = new int[10][10];
for(int i = 0; i < 10; i++){
   for(int j = 0; j < 10; j++){
      a[i][j] = wert++;
      System.out.println(a[i][j]);
   }
}
}
}

 

[Wildcard]

public class matrix1 { 
   public static void main(String[] args) { 

int wert = 0; 
int[][] a = new int[10][10]; 
for(int i = 0; i < 10; i++){ 
   for(int j = 0; j < 10; j++){ 
      a[i][j] = wert++; 
      System.out.print(a[i][j]); 
   } 
    System.out.println();
} 
} 
}

Klassennamenen werden groß geschrieben!

 

[meez]

das hab ich jetzt mal versucht. allerdings gibt das programm mir kein feld aus, sondern untereinander die zahlen von 1 bis 99???

Das steht ja auch in den Feldern drin...

 

[sascha123]

Klassennamenen werden groß geschrieben!

da muss ich mal mit meinem prof schimpfen, der schreibst auch immer klein. ist doch fürs programm egal, oder???

ABER: mein eigentliches problem besteht jetzt immer noch!!!!!

 

[Bleiglanz]

Willst du die mathematische Definition oder wissen, wie man eine Matrix in Java implementiert?

mathematisch (vereinfacht):

eine Matrix ist eine Abbildung A von einer IndexMenge I in die Menge der (reellen/ganzzahligen/sonstigen) Zahlen

wenn die Indexmenge I = {1,2,3}, dann schreibt man die Abbildung einfach hin, indem man die Werte aufzählt

A = (a_1, a_2, a_3)

(das wär dann ein Sonderfall, nämlich ein Vektor aus 3 Zahlen, manchmal auch als 1x3 Matrix bezeichnet); dabei schreibt man a_i = A(i) = Wert der Abbildung am Index i (das ist nur eine Notation)


wenn die Indexmenge I = {(1,1,),(1,2),(2,1),(2,2)} aus Paaren (i,j) natürlicher Zahlen besteht, dann hast du den "Normalfall" einer Matrix, die kann man dann als rechteckiges Schema hinschreiben, wobei man a_ij = A(i,j) schreibt

A = ( a_11, a_12 
        a_21, a_22)

= die Abbildung, die (1,1) den Wert a_11 zuordnet usw.

In Java macht man sowas mit Arrays (wobei aber die indices bei 0 anfangen)

 

[sascha123]

@ meez:
das weiß ich auch. aber ich dachte, die matrix wird dann auch in der form einer 10x10 tabelle ausgegeben und nicht einfach untereinander?

 

[meez]

Das liegt am System.out .... Schau dir mal an, was Wildcard gepostet hat...

 

[dotlens]

in java schreibt man beim deklarieren nicht a[][] sondern int[][]. Auch wenn neuerdings auch a[][] funktioniert.

Hallo?? Hähh? :autsch:

http://www.galileocomputing.de/openbook/javainsel4/javainsel_03_005.htm#Rxx365java03005040000F81F03C106[/url]]Eine Array-Variablendeklaration ähnelt einer gewöhnlichen Deklaration, nur dass nach dem Datentyp oder den Variablen die Zeichen »[« und »]« gesetzt werden müssen. Uns ist es freigestellt, welche Schreibweise wir wählen. Hauptsache, es werden überhaupt Klammern gesetzt. Wie bei der gesamten Programmierung, so sollte auch hier konsistent vorgegangen werden – einmal so, einmal so, behindert die schnelle Wahrnehmung von Programmquelltext.

ich hab es in meinem buch so gelernt dass man die klammern zum Datentyp setzt

 

[meez]

Ich hab mehr gemeint wegen den "neuerdings" !!
Das andere ist sowieso Geschmackssache, wie die anderen Klammern...

 

[dotlens]

in meinem Buch stand auch, dass es das andere noch nicht lange gibt, und übernommen wurde für die vielen umsteiger von c++

 

[sascha123]

äh....ja! also die erklärung von wildcard scheint gut zu sein, ist aber ein bißchen schwierig für mich zu verstehen. um die mathematische definition gehts mir weniger, sondern wirklich um die implementierung in java. und was man dann alles machen kann, wie zum bsp. matrixaddition/-multiplikation/usw

 

[Wildcard]

äh....ja! also die erklärung von wildcard scheint gut zu sein, ist aber ein bißchen schwierig für mich zu verstehen.

Sieh dir einfach den Code an den du verwendet hast:

public class matrix1 { 
   public static void main(String[] args) { 

int wert = 0; 
int[][] a = new int[10][10]; 
for(int i = 0; i < 10; i++){ 
   for(int j = 0; j < 10; j++){ 
      a[i][j] = wert++; 
      System.out.println(a[i][j]); 
   } 
} 
} 
}

Das heißt:
gehe jede Zeile und jede Spalte durch, inkrementiere den Wert, und mach ein System.out.println();

public class matrix1 { 
   public static void main(String[] args) { 

int wert = 0; 
int[][] a = new int[10][10]; 
for(int i = 0; i < 10; i++){ 
   for(int j = 0; j < 10; j++){ 
      a[i][j] = wert++; 
      System.out.print(a[i][j]); 
   } 
    System.out.println(); 
} 
} 
}

Der Code macht folgendes:
Laufe die Spalten durch, inkremtiere den Wert und gib die werte mit System.out.print (also ohne Zeilenumbruch) aus.
Wenn du in die nächste Zeile kommst mach ein println.
Besser verständlich?

 

[mic_checker]

Wenn du Matrizenaddition etc. machen willst könnte eine eigene Klasse "Matrix" vielleicht sinnvoll sein. In dieser könntest du dann diverse Methoden implementieren, wie addiere(),transponiere(),multipliziere() etc.

Die Addition zweier Matrizen ist äussert simpel, die transponierte Matrix aufzustellen ist auch nicht viel schwerer, bei der Matrizen-Multiplikation musst du ein-zwei Dinge beachten....

Du kannst ja immer noch posten wenn du dich dadran probierst und damit Probleme hast, ich möchte dich aber nicht "verunsichern"....

 

[Illuvatar]

In Java3D gibts auch das javax.vecmath - Paket, das kann man glaub auch irgendwo seperat runterladen, da gibts u.a. ein paar Matrix - Klassen.

 

[sascha123]

danke an wildcard, mic_checker und alle anderen.
hab das mit dem ausgeben die ganze zeit falsch gehabt, weil ich das "ln" immer hab stehen lassen....
aber jetzt hab ichs kapiert. ich meld mich dann nochmal, wenn ich mit der addition/multipliaktion probs haben sollte.

gruß sascha

 

[sascha123]

hallo! ich hab mich dann ma grade an der addition versucht:

public class matrix1 {
	public static void main(String[] args) {
		
		int wert=0;
		int wert2=0;
		int[][] a = new int[3][3];
		int[][] b = new int[3][3];
		
		for(int i = 0; i<3; i++){
			for(int j = 0; j<3; j++){
				a[i][j] = wert++;				
				System.out.print(a[i][j] + " ");
		
			}
			System.out.println();
				
		}
		System.out.println();
		
		for(int i = 0; i < 3; i++) {
			for(int j = 0; j < 3; j++){
				b[i][j] = wert2++;
				System.out.print(b[i][j] + " ");
			}
			System.out.println();		
		}	
			System.out.println();
		
		
		int[][] c = new int[3][3]; 
		for(int i = 0; i < 3; i++) {
			for(int j = 0; j < 3; j++) {
				c[i][j] = a[i][j] + b[i][j];
				System.out.print(c[i][j] + " ");
			}
			System.out.println();		
		}	
	
	}
}

So funktioniert das auch. würde nur gerne wissen, wie man das vll noch übersichtlicher, vereinfachter oder so machen kann?

gruß sascha

 

[dotlens]

'wet2' benötigst du eigentlich nicht, du kannst einfach 'wert' wieder auf 0 setzen.
Schön programmiert würdes du konstanten für die grösse der Array verwenden. diese kannst du dann auch in den vorschleifen benutzen. und wenn du einmal die Array vergrössen möchtest, brauchst du blos eine Zahl zu ändern.

private final int arrayGroesse= 3;

 

[sascha123]

hi dotlens!
wenn ich deinen code verwende, bekomme ich die fehlermeldung
"illegal start of expression"

warum?

 

[mic_checker]

Er meint es (wahrscheinlich so):

public class Matrix1 {
   private static int zeilen = 3;
   private static int spalten = 3;
   public static void main(String[] args) {
      
      int wert=0;
      int wert2=0;
      int[][] a = new int[zeilen][spalten];
...

Btw. Klassennamen schreibt man groß.

 

[mic_checker]

Noch ein Tipp:
Ich würde eine extra Klasse "Matrix" schreiben, später noch eine Testklasse.
Die klasse Matrix könnte dann so anfangen z.B.:

public class Matrix
{
	final private int spalten;
	final private int zeilen;
	private int[][] elemente;
	
	public Matrix(int z,int s)
	{
		if(z <= 0 || s <= 0)
			throw new RuntimeException("Ungültige Parameter im Konstruktor");
		
		elemente = new int[z][s];
		
		zeilen = z;
		spalten = s;
	}
...
	public void pruefeIndizes(int z,int s)
	{
		if(z < 0 || s < 0 || z >= zeilen || s >= spalten)
			throw new RuntimeException("Ungültige Indizes -> Über/Unterschreitung");
	}
	
	public int get(int z,int s)
	{
		pruefeIndizes(z,s);
		
		return elemente[z][s];
	}
	
	public void set(int z,int s,int wert)
	{
		pruefeIndizes(z,s);
		
		elemente[z][s] = wert;
	}
...

Das Erfragen und Setzen von Werten erfolgt über die getter/setter Methoden. In diesen wird anfangs überprüft ob die Werte im zulässigen Bereich liegen.

Dann könntest du noch Methoden definieren wie:

	public Matrix addiere(Matrix add)
	{
....
	}
	
	public Matrix transponiere()
	{
.....	
        }
	
	public Matrix inverse()
	{
        }

Methoden zur Matrizenmultiplikation natürlich nicht weglassen!

 

[Guest]

hi mic_checker, danke für deine bemühungen.
werd mir das jetzt mal in ruhe reinziehen. sieht aber alles logisch aus :wink:

gruß sascha

 

[Guest]

ich schreib einfach mal hier rein
ich hab probleme damit eine methode zum transponieren einer matrix zu schreiben. Bei quadratischen Matrizzen ist das auch kein Problem, wenn ich aber z.b. eine 2x3 zu einer 3x2 Matrix transponieren will, ändert sich ja das Format meines Matrix Objektes bzw. das dahinter stehende mehrdimensinale Feld.
Wie kann ich also das über einen Matrix Konstruktor erzeugte Feld ändern?

mein Konstruktor und paar ausgewählte Methoden aus der Klasse siehe unten:

class Matrix
{
	double [][] mat;
	int zeilen,spalten;
	
	public Matrix(double [][] m) //Konstruktor für leere mxn Matrix
	{
		mat = m;
		zeilen = m.length;
		spalten = m[0].length;
	}
.......
public void belegeMatrix(int bereich) 
	//Erzeugen einer Matrix mit zufälligen Einträgen in einem ZahlenBereich
	{
		for (int i=0;i<zeilen;i++)
		{
			for (int j=0;j<spalten;j++)
			{
				mat[i][j] = Math.random()*bereich;
			}	
		}	
	}

public String toString() 
	{
		String ausgabeString = new String();
		ausgabeString = "\t";
		for (int i=0;i<this.zeilen;i++)
		{
			for (int j=0;j<this.spalten;j++) 
			{
				ausgabeString += (int) getValueAt(i,j)+"  ";
			}
			if (i != zeilen)// letzte zeile?
			{
				ausgabeString +="\n\t";
			}
		}

		return ausgabeString;
	}

public static void main(String [] args)
	{
		Matrix xx = new Matrix(new double [2][3]);
		int SKALAR = 3;
		
		xx.belegeMatrix(100); //belege leere mXn Matrix mit Einträgen im Bereich 0 bis 100
                  xx.add(xx);
                  xx.multiply(SKALAR);
	}

ich habe also in der main methode eine 2x3 Matrix erzeugt. Wie kann ich nun in einer transpose() Methode, das mat Feld auf [3][2] ändern, ohne, dass er rummeckert?
plz help.

 

[mic_checker]

Allgemein kannst du so vorgehen:
Die transponierte Matrix hat so viele Zeilen wie die alte Spalten und so viele Spalten wie die alte Zeilen.

Nachdem du eine entsprechende Matrix erzeugt hast kannst du in ner for-Schleife das ganze praktisch umsetzen.

Hab hier mal alten Code ausgekramt, der sich auch damit befasste:

public class Matrix
{
	final private int spalten;
	final private int zeilen;
	private int[][] elemente;
	
	public Matrix(int z,int s)
	{
		if(z <= 0 || s <= 0)
			throw new RuntimeException("Ungültige Parameter im Konstruktor");
		
		elemente = new int[z][s];
		
		zeilen = z;
		spalten = s;
	}
....
public void pruefeIndizes(int z,int s)
	{
		if(z < 0 || s < 0 || z >= zeilen || s >= spalten)
			throw new RuntimeException("Ungültige Indizes -> Über/Unterschreitung");
	}
	
	public int get(int z,int s)
	{
		pruefeIndizes(z,s);
		
		return elemente[z][s];
	}
	
	public void set(int z,int s,int wert)
	{
		pruefeIndizes(z,s);
		
		elemente[z][s] = wert;
	}
.....
	public Matrix transponiere()
	{
		Matrix t = new Matrix(spalten,zeilen);
		
		for(int i = 0;i < zeilen;i++)
			for(int j = 0;j < spalten;j++)
				t.set(j,i,this.get(i,j));
		
		return t;
	}
....

Habs lang nicht mehr getestet, falls noch Code fehlt poste ich den auch noch....solltest du an deine Variante anpassen können.

 

[Guest]

danke das funktioniert sehr gut.
Warum ich das nicht gleich über ne Matrix methode gemacht habe.
Nein ich versteif mich in ne void methode...

:toll: :toll: :toll:

 

[mos]

Geschmackssache ist es eigentlich nicht. In C wird es mit int a[] gemacht, Java ist da anders, obwohl einfachheitshalber beides geht.

 

[mic_checker]

Auf was bezieht sich dein Posting? Konnte nirgendwo die Frage sehen ob man "int[] a" oder "int a[]" schreiben muss - darauf beziehst du dich ja (oder ?).

Falls ich einfach nur blind bin nehm ich alles zurück und behaupte das gegenteil

 

[mos]

tut mir sehr leid, war ein früheres posting, hab nicht gesehen dass es noch ne weitere seite hat... :-(
sorry!