DOMANDA FOLLE: matrici multidimensionali (>3)

[frank8085]

stavo lavorando con una matrice tridimensionale in C#, e mi è venuto il dubbio:
come sarebbe una con 4 o più dimensioni? :sofico:
come avverrebbe il caricamento dei dati? e quale sarebbe il modo più efficiente per riempirla e conseguentemente per fare una ricerca?
ovviamente tutte queste considerazioni le voglio fare senza prendere un linguaggio in particolare...

[marco.r]

stavo lavorando con una matrice tridimensionale in C#, e mi è venuto il dubbio:
come sarebbe una con 4 o più dimensioni? :sofico:
come avverrebbe il caricamento dei dati? e quale sarebbe il modo più efficiente per riempirla e conseguentemente per fare una ricerca?
ovviamente tutte queste considerazioni le voglio fare senza prendere un linguaggio in particolare...


Ci sono diversi modi con cui si puo' rappresentare una matrice, questo vale indifferentemente per le matrici a due dimensioni come per quelle a dimensione maggiore. Ognuna di queste ha caratteristiche diverse per quel che riguarda l'uso di memoria e performance, e quindi a seconda di come devi usarle puo' essere piu' vantaggioso usarne un tipo piuttosto che un altro.

Alcuni esempi

Il metodo piu' classico e' quello "piatto".
In questo caso i dati sono mantenuti in un blocco contiguo di memoria; in pratica tieni i dati in un unico array dove le righe sono memorizzate una alla volta (o le colonne una alla volta).
Ad esempio la matrice

+--+--+--+
| 1 | 2 | 3 |
+--+--+--+
| 4 | 5 | 6 |
+--+--+--+

Potrebbe venire memorizzato nel seguente array

+--+--+--+--+--+--+
| 1 | 2 | 3 | 4 | 5 | 6 |
+--+--+--+--+--+--+

O anche per colonna

+--+--+--+--+--+--+
| 1 | 4 | 2 | 5 | 3 | 6 |
+--+--+--+--+--+--+

Se la matrice ha dimensione MxN, per ottenere il valore alle coordinate (x,y) (0-based) andrai a prendere l'elemento alla posizione x+M*y oppure N*x + y, a seconda dell'approccio che hai usato sopra.
Se la matrice e' a tre dimensioni (MxNxO) l'approccio e' analogo, il conto per individuare la cella (x,y,z) diventa N*M*z + M*y + x (o varianti, a seconda di con che ordine salvi i dati) e cosi' via per dimensioni maggiori.
Questo e' l'approccio tipicamente usato nei linguaggi come il C quando dichiari un array bidimensionale.

Un approccio diverso puo' essere quello di usare un array di array [di array etc]. Prima indicizzi per una coordinata (ad esempio la x) ed ottieni un array corrispondente alla riga, poi indicizzi per l'altra coordinata ed ottieni l'elemento che volevi.
Questo e' un approccio che ha solo svantaggi rispetto al precedente, sia in termini di memoria usata che di performance, lo cito perche' e' piu' semplice da implementarselo "in casa" per cui e' piu' usato dai principianti.

In ogni caso questi due approcci vanno bene se la matrice e' densa (ovvero quasi tutti i valori sono diversi da 0).
Se la maggior parte dei valori sono 0, non vale la pena stare li' a tenere conto di tutte le celle della matrice, per cui si puo' usare un approccio dove si tengono conto solo delle caselle con un valore non banale
L'array seguente ad esempio

+--+--+--+
| 0 | 1 | 0 |
+--+--+--+
| 0 | 0 | 4 |
+--+--+--+

Puo' essere rappresentato dalla seguente lista di valori (riga,colonna,valore)

[ [0,1,1] , [1,2,4] ]

Nel caso di una matrice a 4 dimensioni avro' 5-pla invece che una 3-pla: quattro coordinate e il valore.

Spero di aver chiarito e non creato confusione :D

[frank8085]

quindi se una matrice tridimensionale può essere dichiarata così:
int[, ,] matrice3d = new int[10, 10, 10];
una con 4 dimensioni sarebbe così:
int[, , ,] matrice4d = new int[10, 10, 10, 10];


il linea generale ho capito il tuo discorso...se volessi determinare quante
allocazioni int ha la matrice 3d di prima, basterebbe fare 10^3 in quanto parliamo di un "cubo", se le dimensioni sono 4 il calcolo sarebbe 10^4 o cambierebbe?
io ho visto la cosa guardando la quaterna [10,10,10,10] come se dovessi applicare un calcolo combinatorio nel quale voglio determinare le disposizioni, credo che si rientri nel caso delle disposizioni con ripetizione di 10 oggetti di classe 4.
si andrebbe da [0,0,0,0], [0,0,0,1].........., [10,10,10,10]


per le 4 dimensioni in pratica se ho capito bene ogni "cella" dell'oggetto 4D è quindi identificata da una quaterna come quelle che ho detto prima...

ecco come si trasformerebbe questo calcolo per le matrici 3D N*M*z + M*y + x nel caso delle 4D?

[marco.r]

quindi se una matrice tridimensionale può essere dichiarata così:
int[, ,] matrice3d = new int[10, 10, 10];
una con 4 dimensioni sarebbe così:
int[, , ,] matrice4d = new int[10, 10, 10, 10];


il linea generale ho capito il tuo discorso...se volessi determinare quante
allocazioni int ha la matrice 3d di prima, basterebbe fare 10^3 in quanto parliamo di un "cubo", se le dimensioni sono 4 il calcolo sarebbe 10^4 o cambierebbe?

Il calcolo e' corretto: la dimensione occupata e' in generale il prodotto delle dimensioni (nel tuo caso appunto 10x10x10x10)



io ho visto la cosa guardando la quaterna [10,10,10,10] come se dovessi applicare un calcolo combinatorio nel quale voglio determinare le disposizioni, credo che si rientri nel caso delle disposizioni con ripetizione di 10 oggetti di classe 4.
si andrebbe da [0,0,0,0], [0,0,0,1].........., [10,10,10,10]


per le 4 dimensioni in pratica se ho capito bene ogni "cella" dell'oggetto 4D è quindi identificata da una quaterna come quelle che ho detto prima...

Esatto, la cosa si estende ad un arbitrario di dimensioni. Per una matrice a 10 dimensioni ogni cella sarebbe identificata da una tupla di 10 elementi.


ecco come si trasformerebbe questo calcolo per le matrici 3D N*M*z + M*y + x nel caso delle 4D?
Devi considerare una dimensione in piu'
quindi qualcosa tipo

w*N*M*O + N*M*z + M*y + x;

nel tuo caso siccome i lati sono tutti 10 la cosa diventerebbe semplicemente

w*1000 + z*100 + y*10 + x


Tieni presente che si tratta di conti che nel caso di C# se usi la sintassi new int[10,10,10,10], si arrangia il compilatore a fare