Matrizen Erzeugen

Hallo zusammen,

ich möchte für eine Simulation $n\times n$ -Matrizen erzeugen, die die Elemente 0,1 und -1 als Einträge enthalten.

Die Matrizen sollen zunächst Systematisch alle $3^{n^2}$ Möglichkeiten durchlaufen (n liegt zwischen mindestens 2 und maximal 5).

Weiß jemand einen Algorithmus um diese Matrizen so zu erzeugen, dass man am Ende sicher ist jede Möglichkeit einmal erzeugt zu haben (für's erste dürfen sie auch mehrfach erzeugt werden).

Vielen Dank
foxx

Hi, irgendwie wird der Latex-Code nicht angezeigt...

es handelt sich um n x n-Matrizen und 3^{n*n} Möglichkeiten

Grüße
foxx

SeppJ

Ja LaTeX funktioniert derzeit nicht.

Wo hast du ein Problem? Einfach alle Kombinationen in einer Schleife durchlaufen. Meinetwegen auch mehrere geschachtelte Schleifen, wenn du die Verbindung zu 3-adischen Zahlen nicht herstellen kannst. Irgendwie ist mir ein Rätsel, wo du da überhaupt eine Schwierigkeit haben kannst, vielleicht magst du das erläutern? Könnte nämlich sein, dass ich irgendeine Verkomplizierung in deiner Problemstellung übersehen habe.

Hallo,

ja nur welche Indices werden dann durchlaufen?
Ich möchte n erstmal nicht Festlegen.
Wenn ich die Matrizenindices durchlaufe, woher weiß ich dann wo welche Zahl stehen muss?
Meine Idee bisher war, einen Index k zu nehmen, der die Anzahl der von 0 verschiedenen Elemente darstellt. Diesen dann durchlaufen. Die nächste, innere, Schleife durchläuft dann von 0 bis 2^k*(n2 über k), dass sind die Anzahl der möglichkeiten k von 0 verschiedene Elemente in einer n x n Matrix zu positionieren.
Ich komme aber jetzt nicht weiter, weil ich nicht weiß ob und wie man aus diesen Beiden Indices die Tatsächlichen Positionen für jeden der k Einträge berechnen kann. Vielleicht ist auch der Ansatz mist

Grüße
foxx

otze

du fängst mit der matrix an, deren Elemente alle -1 sind. Dann beginnst du beim letzten Element und addierst +1. das machst du solange, bis das Element den Wert 2 hat. Dnan setzt du es wieder auf -1 und addierst +1 auf das Nächste Element. Und nun führst du das iterativ so weiter. immer wenn du einen Überlauf hast, einfach das nächste Element erhöhen.

ist fast wie mit triadischen zahlen rechnen:

Vielen Dank für die Antwort.

Ich hab's jetzt mal getestet und die ersten 10 Matrizen stimmen.
Ich gehe einfach mal davon aus, dass es so bleibt

Hier meine Implementierung in C++:

bool systematic_run(ModelMatrix * matrix,long number){
	int n = (*matrix).get_dimension();
	long max = pow(3,n*n);

	if(number == 0){
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				(*matrix).set_Element(i,j,-1);
			}
		}
		return true;
	}
	if(number>=max) return false;

	short first = (*matrix).get_Element(0,0);
	if(first<1) (*matrix).set_Element(0,0,first+1);
	else if(first==1) (*matrix).set_Element(0,0,-1);
	if(first==1){
		int i=1;
		while((*matrix).get_Element(i%n,i/n)==1){
			(*matrix).set_Element(i%n,i/n,-1);
			i++;
		}
		(*matrix).set_Element(i%n,i/n,(*matrix).get_Element(i%n,i/n)+1);
	}
	return true;
}