[C++/nonperforza] Trasposizione di una matrice

[vendettaaaaa]

Ciao,
sto scrivendo classi per vettori e matrici, a scopo di studiare l'algebra lineare, e ho scritto questo algoritmo (mi sembra scontato) per la trasposizione:
for (int i = 1; i <= ret.n_rows(); ++i) {
for (int j = i + 1; j <= ret.n_columns(); ++j) {
double temp = ret[i][j];
ret[i][j] = ret[j][i];
ret[j][i] = temp;
}
}

avendo immagazzinato la matrice per righe.

Qualcuno sa darmi qualche consiglio? O meglio, visto che sono cose che si trovano su tantissimi libri/siti, avete link a letture interessanti? E magari ai source code di qualche libreria matematica open source, così vado a tirar fuori idee senza annoiare voi con argomenti basilari? :D

[bender86]

Perché i cicli for vanno da 1 a n invece che da 0 a n-1? Nel sorgente nel thread sul memory leak vedo che per la struttura interna allochi n+1 elementi invece che n. Probabilmente vuoi che la matrice sia acceduta con indici che partono da 1, ma allora dovresti semplicemente sottrarre 1 quando accedi alla struttura dati interna.

Una buona libreria per l'algebra lineare è questa (http://eigen.tuxfamily.org/index.php?title=Main_Page), ma non so quanto possa essere comprensibile il sorgente.

Inoltre la tua implementazione funziona solo per matrici quadrate. Per matrici qualsiasi:

matrix trasposed() const
{
matrix t(colonne, righe);
for (int i = 0; i < right; ++i) {
for (int j = 0; j < colonne; ++j) {
t.ret[j][i] = ret[i][j];
}
}
return t;
}

[vendettaaaaa]

Perché i cicli for vanno da 1 a n invece che da 0 a n-1? Nel sorgente nel thread sul memory leak vedo che per la struttura interna allochi n+1 elementi invece che n. Probabilmente vuoi che la matrice sia acceduta con indici che partono da 1, ma allora dovresti semplicemente sottrarre 1 quando accedi alla struttura dati interna.

Una buona libreria per l'algebra lineare è questa (http://eigen.tuxfamily.org/index.php?title=Main_Page), ma non so quanto possa essere comprensibile il sorgente.

Inoltre la tua implementazione funziona solo per matrici quadrate. Per matrici qualsiasi:

matrix trasposed() const
{
matrix t(colonne, righe);
for (int i = 0; i < right; ++i) {
for (int j = 0; j < colonne; ++j) {
t.ret[j][i] = ret[i][j];
}
}
return t;
}
Grazie! Sì per ora faccio la trasposta solo di matrici quadrate, per quelle rettangolari devo ancora pensarci sopra. L'algoritmo che hai scritto è ovviamente efficacie ma vorrei capire se è fattibile in modo più efficiente.

Riguardo agli indici, all'inizio sottraevo 1 come dici, ma poi ho implementato questo:
double* operator[](int k) { return myMatrix[k]; }
const double* operator[](int k) const { return myMatrix[k]; }

per distinguere: operator() fa il range check, operator[] no (per risparmiarmi un if, anche se non so quanto possa influire sulle performance...) e mi son reso conto che così facendo, [] restituisce un puntatore ad array classico, il cui indice parte da 0...quindi per consistenza immagazzino tutto a partire da 1 :D

[[Kendall]]

Grazie! Sì per ora faccio la trasposta solo di matrici quadrate, per quelle rettangolari devo ancora pensarci sopra. L'algoritmo che hai scritto è ovviamente efficacie ma vorrei capire se è fattibile in modo più efficiente.

Riguardo agli indici, all'inizio sottraevo 1 come dici, ma poi ho implementato questo:
double* operator[](int k) { return myMatrix[k]; }
const double* operator[](int k) const { return myMatrix[k]; }

per distinguere: operator() fa il range check, operator[] no (per risparmiarmi un if, anche se non so quanto possa influire sulle performance...) e mi son reso conto che così facendo, [] restituisce un puntatore ad array classico, il cui indice parte da 0...quindi per consistenza immagazzino tutto a partire da 1 :D

L'algoritmo di Bender non ha nulla che non va. Come potrebbe essere più efficiente un algoritmo che semplicemente copia elemento per elemento le righe di una matrice nelle colonne di un nuova matrice? Ovviamente a seconda delle necessità puoi creare quella nuova matrice dinamicamente e restituirla come puntatore