F
Nur ein Tip, wie man vielleicht etwas strukturierter an dieses Problem herangehen kann. Zunächst mal eine kurze Veranschaulichung:
Allgemein sieht deine grosse Matrix so aus:
M=[a00a01⋯a0na10a11⋯a1n⋮⋮⋱⋮am0am1⋯a(m−1)(n−1)]M = \begin{bmatrix}
a_{00} & a_{01} & \cdots & a_{0n} \\
a_{10} & a_{11} & \cdots & a_{1n} \\
\vdots & \vdots & \ddots & \vdots \\
a_{m0} & a_{m1} & \cdots & a_{(m-1)(n-1)}
\end{bmatrix}M=⎣⎢⎢⎡a00a10⋮am0a01a11⋮am1⋯⋯⋱⋯a0na1n⋮a(m−1)(n−1)⎦⎥⎥⎤
Wenn du diese in Untermatrizen unterteilst, z.B. in 3×33\times33×3-Matrizen sieht das so aus:
MU=[[a00a01a02a10a11a12a20a21a22]⋯⋮⋱]M_U = \begin{bmatrix}
\begin{bmatrix}
a_{00} & a_{01} & a_{02} \\
a_{10} & a_{11} & a_{12} \\
a_{20} & a_{21} & a_{22}
\end{bmatrix} & \cdots \\\\
\vdots & \ddots
\end{bmatrix}MU=⎣⎢⎢⎢⎢⎡⎣⎡a00a10a20a01a11a21a02a12a22⎦⎤⋮⋯⋱⎦⎥⎥⎥⎥⎤
oder allgemeiner:
MU=[U00U01⋯U10U11⋯⋮⋮⋱]M_U = \begin{bmatrix}
U_{00} & U_{01} & \cdots \\
U_{10} & U_{11} & \cdots \\
\vdots & \vdots & \ddots
\end{bmatrix}MU=⎣⎡U00U10⋮U01U11⋮⋯⋯⋱⎦⎤
Wobei UijU_{ij}Uij deine nU×nUn_U \times n_UnU×nU (z.B. 3×33\times33×3)-Untermatrizen sind, die bei der Unterteilung entstehen.
Ich würde zunächst einmal zwei Funktionen* schreiben, welche für jeweils die Zeilen und die Spalten die Koordinaten (iii und jjj) von der Unterteilungs-Darstellung in die Koordinaten der grossen Matrix überführt. Diese könnten z.B. folgende Signaturen haben:
int zu_m_i(int n_u, int i_u, int i);
int zu_m_j(int n_u, int j_u, int j);
Wobei der Rückgabewert der Funktionen, jeweils die iii/jjj-Koordinaten in deiner grossen Matrix sind. Die Parameter haben dabei folgende Bedeutung:
n_u: Wie gross die kleine, quadratische Matrix ist. Also 10 in deinem Beispiel, oder 3 wie bei meinem Beispiel. In deinem Code hast du diesen Wert Dimension genannt.
i_u und j_u: Die Koordinaten der Untermatrix selbst in der unterteilten Matrix MUM_UMU, also z.B. 1 und 2 für die Untermatrix U12U_{12}U12. Mit diesen Koordinaten wird die Untermatrix indentifiziert, auf die du dich beziehst.
i und j: Die Koordinaten innerhalb der Untermatrix.
Willst du nun z.B. die Untermatrix in der zweiten Zeile (i_u = 1) und dritten Spalte (i_j = 2) ausgeben, könnte der Code dafür z.B. so aussehen:
for (int i=0; i < Dimension; i++)
{
for (int j=0; j < Dimension; j++)
{
int m_i = zu_m_i(Dimension, 1, i);
int m_j = zu_m_j(Dimension, 2, j);
assert(m_i >= 0 && m_i < GROSSE_MATRIX_M);
assert(m_j >= 0 && m_j < GROSSE_MATRIX_N);
cout << setw(20) << GrosseMatrix[m_i][m_j];
}
cout << "\n";
}
Die Funktionen zu_m_i() und zu_m_j() zu schreiben ist nicht besonders schwer, und in dieser Form ist dein Problem auch einfacher zu handhaben, wie ich finde.
Die Vorteile:
die Übersetzungen der Matrix-Koordinaten erfolgen an einer einzigen, zentralen Stelle, eben diesen Funktionen.
die Untermatrix muss nicht kopiert werden.
Die Funktionen sind "Bausteine", die es erleichtern den Code in einem anderen Kontext wiederzuverwenden und zu erweitern.
Hinweis: Ich bin hier nicht auf Bereichs-Prüfungen eingegangen. Du solltest natürlich sicherstellen, dass bei deinen umgerechneten Koordinaten, die Größe der Matrizen immer berücksichtigt wird, und keine Schreib- oder Lesezugriffe außerhalb der Matrix stattfinden. In meinem Beispiel-Code oben habe ich das mithilfe eines assert() gemacht. GROSSE_MATRIX_M und GROSSE_MATRIX_N stehen hier für die Matrix-Grösse, also 963 und 672.
* Da die Funktionen in dieser Form wahrscheinlich die selbe Berechnung ausführen, geht das natürlich auch mit einer Funktion. Packt man diese später vielleicht in eine Klasse, wo diese Funktionen dann intern auf die nnn- und mmm-Grössen der Matrizen zugreifen, landet man dann aber wahrscheinlich wieder bei zwei separaten Funktionen (aus dieser Richtung kommt mein Vorschlag).
