[.NET] Generics und Operatorüberladung

[Medium]

Tatsache, das klingt sinnvoll. Ich fummel da mal was.
Edit: Hm, dafür müsste ich aber schon zum Zeitpunkt der Erzeugung der Matrizen wissen, welchen Typ ein späterer Multiplikationspartner haben wird oder? Das weiss ich nämlich leider nicht.
Edit2: Ausserdem fällt mit mit einem 2. Typ die Klamotte mit den Delegates wie ein Kartenhaus zusammen, zumindest wenn ich es nicht völlig missverstanden habe. Wat mach ich denn nu? Ich bin ja schon fast wieder so weit meine alte 2-Matrixtypen Lösung zu reaktivieren

[Dax]

Ich kann dir nicht ganz folgen - was willst du eigentlich tun?

[Medium]

Ich versuche mal eine Formel die ich hier habe mit meinen ASCII Art Künsten *hust* hier zu präsentieren:

Code:

/  1  \T  /  1  0  0  0 \   / (0,0) (1,0) (0,0) (1,0) \   /  1  0  0  0 \T  /  1  \
|  v  |   |  0  0  1  0 |   | (0,1) (1,1) (0,1) (1,1) |   |  0  0  1  0 |   |  u  |
| v^2 | * | -3  3 -2 -1 | * | (0,0) (1,0) (0,0) (0,0) | * | -3  3 -2 -1 | * | u^2 | = (x, y)
\ v^3 /   \ -2  2  1  1 /   \ (0,1) (1,1) (0,0) (0,0) /   \ -2  2  1  1 /   \ u^3 /

  VT    *        C        *              Q              *        CT       *    U    = P(u, v)

Das ist eine Formel für ein Splinepatch. Rein gehen Koordinaten u, v | u,v=(0..1), und raus kommen die Bildkoordinaten des resultierenden Punktes auf dem Patch. Q beinhaltet die Eck- und Kontrollpunkte des Patches. Und diese Rechnung muss ich einige Male machen, brauche aber die Matrix Klasse im selben Projekt auch noch in anderen Zusammenhängen. Das hier ist jedoch die einzige Stelle an der (bisher) eine Matrix<Matrix<>> vorkommt.

[Dax]

Was da nun passieren soll, ist mir immer noch völlig unklar Welcher Typ soll C * Q haben? Daran scheinst du ja vermutlich zu hängen.

[Medium]

C ist ein Matrix<double> und Q ist ein Matrix<Matrix<double>>. Heraus kommt dabei von Hand ein Matrix<Matrix<double>> mit Dimensionen 1x4, und inneren Matrizen der Dimension 1x2. Das Problem ist, dass der Compiler nicht C*Q, sondern C*Q[x,y] versucht, was knallen muss da die Matrizen Q[x,y] die Dimension 1x2 haben (und auch wenn es 4x1 wäre, immernoch zum falschen Ergebnis führen würde).


Edit: Halt mal! Das Ergebnis aus VT*C wird ja mit Q multipliziert. Deswegen kommt am Ende eine 1x4 Matrix heraus, weil VT*C ergibt ebenfalls eine 1x4 Matrix. Ändert nix am Problem an sich, sonst ist aber nicht ganz klar wie ich zu 1x4 komme.

[Dax]

Ah, jetzt sehe ich, was du meinst. Dazu müsstest du wohl noch einen Operator Matrix<T> * Matrix<Matrix<T>> implementieren (der sollte dann benutzt werden, immerhin matcht der besser), oder direkt die Matrizen mit variabler Dimension bauen.

[Medium]

Zitat von Dax:

Ah, jetzt sehe ich, was du meinst. Dazu müsstest du wohl noch einen Operator Matrix<T> * Matrix<Matrix<T>> implementieren (der sollte dann benutzt werden, immerhin matcht der besser)

Nicht die schlechteste Idee. hat lediglich den Beigeschmack, dass man neue Operatoren für jede neue Verschachtelungstiefe bräuchte, ich erwarte aber dass es nicht schlimmer als Matrix<Matrix<>> wird. Das wäre auch schon ein Monster-Konstrukt dann
Das werd ich gleich mal probieren!

Zitat:

oder direkt die Matrizen mit variabler Dimension bauen.

Den versteh ich nun nicht. Sind sie doch

[Dax]

Zitat von Medium:

Nicht die schlechteste Idee. hat lediglich den Beigeschmack, dass man neue Operatoren für jede neue Verschachtelungstiefe bräuchte

Wenn es darum geht, M<T> * M<M<T>>, M<T> * M<M<M<T>>>, ... zu haben, bei denen die Komponenten der zweiten Matrix mit den Komponenten der ersten multipliziert werden, würde dafür eine Methode ausreichen. Diese Methode würde bei M<T> * M<M<T>> die entsprechende Multiplikation durchführen und bei tieferen Schachtelungen die Methode für die erste Matrix und jedes Element der zweiten Matrix aufrufen. Zumindest denke ich, dass das das ist, was du willst.

Zitat von Medium:

Den versteh ich nun nicht. Sind sie doch

Sein. Sie sind fester Dimension (2), aber variabler Größe. Du hast bei VT * C * Q eine 2^1|4 * 2^4|4 * 3^4|4|2-Konfiguration Aber dafür entsprechende Strukturen zu definieren und die Multiplikation so umzusetzen, dass sie immer tut, was du willst, ist wohl nicht mehr ganz so einfach wie der Weg oben.

[Medium]

HEUREKA!

Ich hab zwar noch immer nicht kapiert was du im 2. Absatz meintest, aber mit Operatoren für M<T> * M<M<T>> und umgekehrt funktionniert es!

Und dass diese schon ausreichen sollten um tiefere Verschachtelungen abzuhandeln leuchtet auch ein, zumindest so lange die beiden Multiplikanden sich nur um eine Verschachtelungstiefe unterscheiden. Und so arg wird's schon nicht mehr werden hier.

Gaaaaaaaaaaaaaaanz großen Dank!