3. Große Arrays

Große Arrays

  • C

    Gib mal in die MinGW Konsole ein:
    mingw-get install g++

    0
  • R

    C:\MinGW\bin>mingw-get install g++
    install: gcc-c++-4.6.1-2-mingw32-bin.tar.lzma
    installing gcc-c++-4.6.1-2-mingw32-bin.tar.lzma
    mingw-get: *** ERROR *** package gcc-c++-4.6.1-2-mingw32-bin.tar.lzma is already
    installed

    Edit:
    Eine Frage noch zu array:
    muss die Größe von array (also der 2. template-parameter) bereits zur Compilezeit feststehen oder kann das auch eine beliebige Variable sein. Wenn es nämlich ersteres ist, ist array für mich ungeeignet.

    Edit^2:
    ich poste hier mal ein kurzes konkretes Stück Code. Vllt könnte mir das jemand mal mit vector (etc.) formulieren:

    Matrix<T> Matrix<T>::multiplyNaiveUnchecked(const Matrix<T>* matrix) const {
	// [...]

	T** datA = new T*[dim1_];
	for (int i = 0; i < dim1_; i++) {
		datA[i] = new T[dim2_];
		for (int j = 0; j < dim2_; j++)
			datA[i][j] = getEntry(i,j);
	}

	// [...]

	for (int i = 0; i < dim1_; i++) delete[] datA[i];
	delete[] datA;

	// [...]
}
    0
  • E

    Ramanujan schrieb:

    C:\MinGW\bin>mingw-get install g++
    install: gcc-c++-4.6.1-2-mingw32-bin.tar.lzma
    installing gcc-c++-4.6.1-2-mingw32-bin.tar.lzma
    mingw-get: *** ERROR *** package gcc-c++-4.6.1-2-mingw32-bin.tar.lzma is already
    installed

    Eine Frage noch zu array:
    muss die Größe von array (also der 2. template-parameter) bereits zur Compilezeit feststehen oder kann das auch eine beliebige Variable sein. Wenn es nämlich ersteres ist, ist array für mich ungeeignet.

    Ja, dann musst du std::vector nehmen.
    std::array ist nämlich der Ersatz für ruhe Arrays.

    Trotzdem finde ich es merkwürdig dass es bei dir nicht klappt, aber keine Ahnung was nicht stimmt.

    0
  • C

    @Ramanujan Mit GCC 4.6.1 sollte -std=c++0x kein Problem sein. Ja, bei std::array muss die Größe eine Compiletime-Konstante sein. (Wie auch bei normalen Arrays, die du ja am Anfang präsentiert hast..)
    Für eine Matrixklasse mit dynamischer Größe siehe den Link von krümelkacker.

    0
  • R

    cooky451 schrieb:

    @Ramanujan Mit GCC 4.6.1 sollte -std=c++0x kein Problem sein. Ja, bei std::array muss die Größe eine Compiletime-Konstante sein. (Wie auch bei normalen Arrays, die du ja am Anfang präsentiert hast..)

    Also ich konnte normale Arrays auch mit variabler Größe erstellen. Am Anfang dieses Threads hab ich was mit konstanten werten präsentiert, da jene Kombination (100000*4) Probleme gemacht hatte.

    0
  • C

    Das sind VLAs, und C++ kennt keine VLAs. Die gibt's nur in C. (std >= C99)

    0
  • R

    hm, jedenfalls hat mein Compiler nicht gemeckert.

    Das kam vllt unter, weil der Edit nach dem nächsten Post kam:

    Edit^2:
    ich poste hier mal ein kurzes konkretes Stück Code. Vllt könnte mir das jemand mal mit vector (etc.) formulieren:

    Matrix<T> Matrix<T>::multiplyNaiveUnchecked(const Matrix<T>* matrix) const {
	// [...]

	T** datA = new T*[dim1_];
	for (int i = 0; i < dim1_; i++) {
		datA[i] = new T[dim2_];
		for (int j = 0; j < dim2_; j++)
			datA[i][j] = getEntry(i,j);
	}

	// [...]

	for (int i = 0; i < dim1_; i++) delete[] datA[i];
	delete[] datA;

	// [...]
}
    0
  • C

    Nein, das ging nicht unter. Aber das hier ignorierst du offenbar konsequent:

    cooky451 schrieb:

    Für eine Matrixklasse mit dynamischer Größe siehe den Link von krümelkacker.

    Und dein Compiler meckert vermutlich nicht, weil du nicht std=c++0x nutzt. 🤡

    0
  • K

    Ramanujan schrieb:

    muss die Größe von array (also der 2. template-parameter) bereits zur Compilezeit feststehen oder kann das auch eine beliebige Variable sein. Wenn es nämlich ersteres ist, ist array für mich ungeeignet.

    Sagte ich doch.

    Ramanujan schrieb:

    Edit^2:
    ich poste hier mal ein kurzes konkretes Stück Code. Vllt könnte mir das jemand mal mit vector (etc.) formulieren:

    Matrix<T> Matrix<T>::multiplyNaiveUnchecked(const Matrix<T>* matrix) const {
	// [...]

	T** datA = new T*[dim1_];
	for (int i = 0; i < dim1_; i++) {
		datA[i] = new T[dim2_];
		for (int j = 0; j < dim2_; j++)
			datA[i][j] = getEntry(i,j);
	}

	// [...]

	for (int i = 0; i < dim1_; i++) delete[] datA[i];
	delete[] datA;

	// [...]
}

    siehe Link von mir ... und dann so ungefähr

    matrix operator*(matrix const& a, matrix const& b)
{
   const int z = a.zeilen();
   const int s = b.spalten();
   const int k = std::min(a.spalten(),b.zeilen()); // oder Ungleichheit abfangen

   matrix c (z,s);
   for (int i=0; i<z; ++i) {
     for (int j=0; j<s; ++j) {
       double summe = 0;
       for (int t=0; t<k; ++t) {
         summe += a(i,t)*b(t,j);
       }
       c(i,j) = summe;
     }
   }
   return c;
}

    (ungetestet)

    0
  • R

    Ja, den Link hab ich mir angeguckt, dort ging es um eine Matrix-Klasse, dessen Datenfeld als eindimensionaler vector realisiert wurde. Ich könnte nun auch in meinem Code das temporäre Datenfeld als 1D-vector implementieren, wobei ich die Index-Rumrechnerei jetzt nicht so schön finde. Ich muss zugeben das Datenfeld meiner Matrix-Klasse als T**-Array realisiert zu haben. Ich möchte das jetzt allerdings nicht mehr ändern, da ich sonst sehr viel Code umschreiben müsste. Problematisch ist vor allem, dass sich zwei Matrizen ein Array teilen können, um Zeit bei manchen Operationen zu sparen. Dazu hab ich ein Attribut angelegt, das angibt, wem das Array nun "gehört". Dass sowas fehleranfällig ist, gebe ich zu. Sicherlich kann man das auch mit vector realisieren, nur das würde mir zu viel Arbeit bedeuten. Und direkt nach dem Umstellen hätte ich 100%-ig deutlich mehr Fehler als vorher. In der konkreten Methode werden zwei Matrizen (auf die naive Art und Weise) multipliziert. Da Matrizen implizit (!) transponiert sein können, schreibe ich die Daten in ein temporäres Array, um nicht immer wieder getEntry() aufrufen zu müssen. getEntry() überprüft, ob der bool-Wert transponiert_ gesetzt ist und gibt dann entweder entries_[i][j] oder entries_[j][i] zurück. Nun möchte ich in der innersten Schleife möglichst wenig Code haben, von daher schreibe ich mir die Daten so in ein Array/vector, dass sie hintereinander im Speicher liegen (d.h. wenn ich A*B berechne, so brauche ich die Daten von A nicht-transponiert und die Daten von B transponiert). Ok, das ist natürlich auch wunderbar mit einem temporären 1D-vector möglich. Bei kleinem k (also wenn A = (i x k) und B = (k x j)) ist das natürlich ein ziemlicher Overhead, aber das ist eine andere Geschichte.

    Ich wollte jetzt eigentlich nur kurz schreiben, was meine Matrizen können bzw. machen und was hinter dem temporären Array steckt.

    0
Anmelden zum Antworten