Member bei Aufruf deklarieren

Schlangenmensch

Nein, du erhältst so keine quadratische Matrix, sondern tatsächlich einen Vektor von Vektoren. Wobei die inneren Vektoren unabhängig sind und sogar unterschiedliche Längen haben können.

Quadratisch wird das zum Beispiel so:

const int N=10;
vector<vector<int> > cost (N, vector<int>(N,0));

Dann hast du einen Vektor, gefüllt mit 10 Vektoren die jeweils 10 0en enthalten.

Progressive

Ist es empfehlenswerter z.B. Eigen explizit für Matrizzen zu nehmen oder kann ich prinzipiell einfachen einen Vektor in einen Vektor schreiben ?

Im Grunde will ich ja nur naiv vorgehen, als hätte ich int array[x][y].

PS: Ahso, danke übrigens! Ich denke, ich versuche es erstmal mit einem Vektor im Vektor

Für

lx[x] = max(lx[x], cost.max());

erhalte ich nun

error: invalid types ‘<unresolved overloaded function type>[int]’ for array subscript
  lx[x] = max(lx[x], cost.max());

Ich vermute, max lässt sich bei einem verschachtelten Vektor nicht einfach so anwenden ?

HarteWare

Kleiner Tipp: Einfach die Fehlermeldungen aufs wesentliche reduzieren und googeln, so kommt man meistens schneller ans Ziel.

Progressive

Tue ich ja bzw. versuche ich..

Eigentlich habe ich gerade nicht sonderlich viel mehr als einen Vektor und einen Vektor-Vektor und möchte das max_element von denen haben.

PS: Ah, ja.. da ist wohl vorher noch was..

Schlangenmensch

Ne, max auf ein verschachtelten Vektor schmeißen ist jetzt nicht ganz so einfach. Was soll denn das für ein Maximum sein?? Die Standartbibliothek bietet hier verschiedene Möglichkeiten (e.g. std::max_element pro innerem Vektor, dann musst du nur noch von den Ergebnissen das Maximum finden...), aber einfach das größte Element aus einer "Matrix" gibt es nicht.

Ob du mit Eigen besser bedient bist kann ich dir nicht sagen, dass kommt auf deine Anwendung an. Wenn du viel mit Matritzen und Vektoren rechnen musst, also wirklich Rechenoperationen ausführen willst, bist du damit wahrscheinlich auf der richtigen Seite.

Progressive

Ok, nochmal danke!

Ich habe den ersten Part soweit umgewandelt und es scheint probeweise auch zu stimmen

const int m_N=3;
		vector<vector<int> > cost (m_N, vector<int>(m_N,0));
		vector<int> lx(m_N);
		vector<int> ly(m_N);

		// initialize labels:
		for(size_t i = 0; i < lx.size(); ++i)
		{
			lx[i]+=0;
		}
		for(size_t i = 0; i < ly.size(); ++i)
		{
			ly[i]+=0;
		}
		for(size_t i = 0; i < cost.size(); ++i)
		{
			cost[i][i]=+2;
		}

		cout << "Size of vectors:" << lx.size() << endl;

		for(size_t i = 0; i < lx.size(); i++)
		{
			for(size_t j = 0; j < ly.size(); j++)
			{
				lx[i] = max(lx[i], cost[i][j]);	
				//cout << "ly["<<j<<"]: " << ly[j] << endl; 
				//cout << "cost["<<i<<"]["<<j<<"] " << cost[i][j] << endl; 				
			}
		}

Das soll jetzt gar nicht Korrektur gelesen werden, nur der Vollständigkehit halber und falls sich jemand mit denselben Fragen hierher verirren sollte
Ansonsten werde ich den nächsten Part dann mal angehen
Mit max scheint es aber jedenfalls zu funktionieren.

PS: Cool, das Einlesen bzw. Festlegen der Vektoren klappt jetzt auch.
Wenn ich mit dem Ganzen durch bin, werde ich mal den ganzen Code bereitstellen. So in ein paar Wochen/Monaten..

HarteWare

Oder einfach einen 1D vector als 2D verwenden, man muss halt nur eine Spaltenzahl festlegen und dann ist der Index v[row*width + column]. Macht manches umständlicher, aber das Maximum zu finden wäre einfacher.

unskilled

// initialize labels: 
        for(size_t i = 0; i < lx.size(); ++i) 
        { 
            lx[i]+=0; 
        } 
        for(size_t i = 0; i < ly.size(); ++i) 
        { 
            ly[i]+=0; 
        }

aha?

HarteWare

unskilled schrieb:

// initialize labels: 
        for(size_t i = 0; i < lx.size(); ++i) 
        { 
            lx[i]+=0; 
        } 
        for(size_t i = 0; i < ly.size(); ++i) 
        { 
            ly[i]+=0; 
        }

aha?

Lässt sich auch geschickt einfacher schreiben:

Edit: Soll heißen, auf alle Elemente 0 dazu addieren ist vermutlich nicht was du wolltest.

Swordfish

// edit: rem: ein edit mal am Anfang. Ist auch was feines.
// edit: Zusammenfassung:
// edit: rem: Mann, ich sollte threads vielleicht doch öfter lesen, bevor ich meinen Senf dazugebe.

Was ist das Ding? Ist das eine echte matrix? oder ein vector<vector>?

Abbilden:

std::size_t const columns{ 4 }; // 4 
std::vector< int > foo( 12 );  // x 3

foo[ y * 4 + x ];  // ... oder anders rum - da gibts Geschmacksrichtungen ...

... und über Cache-Effizienz kann man dabei auch diskutieren. Kommt auch auf die Daten an.

Dann das Ganze schön Kapseln und funstuff::matrix_2d_t (oder so) nennen und passt schon.

Ich hab aber gehört, daß es das irgendwo im internet schon fix-fertig und bugfree^tm gibt.

~edit 2: teutsch und so~

Progressive

unskilled schrieb:

// initialize labels: 
        for(size_t i = 0; i < lx.size(); ++i) 
        { 
            lx[i]+=0; 
        } 
        for(size_t i = 0; i < ly.size(); ++i) 
        { 
            ly[i]+=0; 
        }

aha?

HarteWare schrieb:

unskilled schrieb:
// initialize labels: 
        for(size_t i = 0; i < lx.size(); ++i) 
        { 
            lx[i]+=0; 
        } 
        for(size_t i = 0; i < ly.size(); ++i) 
        { 
            ly[i]+=0; 
        }
aha?
Lässt sich auch geschickt einfacher schreiben:

Edit: Soll heißen, auf alle Elemente 0 dazu addieren ist vermutlich nicht was du wolltest.

Richtig
ohne "+"..

Swordfish schrieb:

// edit: rem: ein edit mal am Anfang. Ist auch was feines.
// edit: Zusammenfassung:
// edit: rem: Mann, ich sollte threads vielleicht doch öfter lesen, bevor ich meinen Senf dazugebe.

Was ist das Ding? Ist das eine echte matrix? oder ein vector<vector>?

Abbilden:
std::size_t const columns{ 4 }; // 4 
std::vector< int > foo( 12 );  // x 3

foo[ y * 4 + x ];  // ... oder anders rum - da gibts Geschmacksrichtungen ...
... und über Cache-Effizienz kann man dabei auch diskutieren. Kommt auch auf die Daten an.

Dann das Ganze schön Kapseln und funstuff::matrix_2d_t (oder so) nennen und passt schon.

Ich hab aber gehört, daß es das irgendwo im internet schon fix-fertig und bugfree^tm gibt.

~edit 2: teutsch und so~

Den Beitrag verstehe ich nicht
Ist das rhetorisch, akademisch oder tatsächlich direkt an mich gerichtet ?

Was gibt es denn schon fertig/bugfree ?