Come funziona la "Quarta dimensione" con le matrici?

Astratto:

Quindi, come ho capito (anche se ho una comprensione molto limitata), ci sono tre dimensioni con cui (di solito) lavoriamo fisicamente:

Il primo sarebbe rappresentato da una linea.
Il secondo sarebbe rappresentato da un quadrato.
Il terzo sarebbe rappresentato da un cubo.

Abbastanza semplice fino a quando non arriviamo al 4 ° - È un po 'difficile disegnare in uno spazio 3D, se sai cosa intendo ... Alcune persone dicono che ha qualcosa a che fare con il tempo .

La domanda:

Ora, anche se non ha molto senso, per me va benissimo. La mia domanda non riguarda questo, o lo farei su MathSO o PhysicsSO. La mia domanda è: come fa il computer a gestirlo con gli array?

So che puoi creare array 4D, 5D, 6D, ecc ... in molti linguaggi di programmazione diversi, ma voglio sapere come funziona.

Fortunatamente, i programmi non sono limitati dai vincoli fisici del mondo reale. Le matrici non sono memorizzate nello spazio fisico, quindi il numero di dimensioni della matrice non ha importanza. Sono appiattiti nella memoria lineare. Ad esempio, un array monodimensionale con due elementi potrebbe essere strutturato come:

(0) (1)

Un array dimensionale 2x2 potrebbe quindi essere:

(0,0) (0,1) (1,0) (1,1)

Un array tridimensionale 2x2x2 potrebbe essere:

(0,0,0) (0,0,1) (0,1,0) (0,1,1) (1,0,0) (1,0,1) (1,1,0) (1,1,1)

Spero che tu possa vedere dove sta andando. Quattro dimensioni potrebbero essere:

(0,0,0,0) (0,0,0,1) (0,0,1,0) (0,0,1,1) (0,1,0,0) (0,1,0,1) (0,1,1,0) (0,1,1,1)
(1,0,0,0) (1,0,0,1) (1,0,1,0) (1,0,1,1) (1,1,0,0) (1,1,0,1) (1,1,1,0) (1,1,1,1)

Non è necessario immaginarlo in grandi dimensioni spaziali, basta pensarlo come una foglia di felce.

Il gambo principale è il tuo primo array, con ogni ramo che è un elemento che sta memorizzando. Se guardiamo un ramo questa è la tua seconda dimensione. Ha una struttura simile di rami più piccoli che ne arrivano rappresentando i suoi dati. Questi a loro volta hanno i loro piccoli rami che continuano fino a quando non arriviamo alle minuscole foglie che rappresentano i dati dell'array di dimensioni più interne o più alte.

Puoi vederlo crescere se dichiari ogni livello con il suo nome. Qui sto riutilizzando ogni livello possibile per minimizzare il codice:

leaf = 2;
tinyBranch = [leaf, leaf, leaf];
middleBranch = [tinyBranch, tinyBranch, tinyBranch];
bigBranch = [middleBranch, middleBranch, middleBranch];
mainBranch = [bigBranch, bigBranch, bigBranch];

Le dimensioni sono qualunque cosa tu voglia essere, la quarta dimensione non deve necessariamente essere il tempo. Se pensi a tre dimensioni come a un cubo, puoi pensare a 4 dimensioni come a una fila di cubi. 5 dimensioni, una griglia di cubi e così via.

Potresti anche avere una collezione 3d di voxel, con una quarta dimensione che è colore, densità, o qualche altra proprietà.

Quando si alloca la memoria per l'array multidimensionale, alloca semplicemente il prodotto di ciascuna dimensione massima per il tipo di dati. Se hai una matrice 3d o un "cubo" di 10 elementi in ogni dimensione, avrai 1.000 elementi assegnati. Se si crea un array 4d con 10 elementi nella 4a dimensione, il computer ne assegnerà solo 10.000. Aumenta fino a 5 dimensioni e ne assegnerà 100.000.

Al computer non interessa alcun tipo di significato su ciò che rappresenta ogni dimensione. Per selezionare dove si trova un elenco di elementi nell'elenco, è sufficiente moltiplicare per selezionare un indirizzo di memoria.

Immagina di fare ricerca e sviluppo su alcuni nuovi dispositivi medici, una serie di sensori che metti lungo le braccia di un paziente. Hai sette volontari in fila per i test. Ogni sensore riporta letture a bassa, media e alta frequenza, che si prendono una volta ogni 100 ms per circa un minuto.

Come archiviare tutti quei dati in memoria per l'analisi e la stampa?

Un array, ovviamente. Sembrerebbe così (usando lo pseudocodice generico inventato):

npatients = 7
nsensors = 4     // number of sensors on an arm
nchannels = 3
nsamples = 60.0 / 0.1
sensordata = Array[ npatients, nsensors, 2, nchannels, nsamples ]

È un array a cinque dimensioni e non c'è nulla di complicato, misterioso o sconcertante. Non c'è motivo di provare ad associarlo allo spazio euclideo a 5 dimensioni. Per ottenere qualsiasi valore di dati, utilizziamo un'espressione like

x = sensordata[6, 5, 1, 2, 338)

È come eseguire una query su un database relazionale in cui è presente un record per ciascun valore di dati, con cinque colonne che contengono l'ID paziente, l'ID sensore e così via e una colonna con il valore. Per ottenere un punto dati si usano cinque termini in WHERE: SELEZIONARE il valore DA SensorData DOVE (patientid = 6) e (sensorid = 5) e (arm = "left") e (channel = "midfreq") e (sampleindex = 338 ).

Non c'è nulla di mistico in una tabella di database con cinque o più colonne, vero?

(Sto usando l'indicizzazione in base 1 anche se nella vita reale, in base 0 è molto più comune.)

Nota che sono un ragazzaccio a causa della codifica del numero di armi. Se mi viene mai dato un finanziamento per indagare su questi sensori su un polipo, sono nei guai!

Un array è solo un blocco di memoria continua. L'indirizzamento della memoria è monodimensionale, puoi andare avanti o indietro. Quindi supponendo di avere un array con 5 elementi, saranno riservati 5 blocchi di memoria. Se si dispone di un array bidimensionale con 5 elementi in ciascuna dimensione, verranno riservati 25 blocchi di memoria.

... o lo chiederei su MathSO ...

Bene, in effetti i matematici non assocerebbero mai (o almeno non di solito) una quarta dimensione a qualcosa di simile al tempo. Né assocerebbero i primi tre a qualcosa di simile allo spazio: i matematici semplicemente definiscono la dimensione come una proprietà astratta, tipicamente, di uno spazio vettoriale (spesso questo sarà generalizzato a molteplici o addirittura spazi di ). E questa definizione astratta non si preoccupa di quante dimensioni abbia lo spazio fisico in cui ci muoviamo. Il concetto di dimensioni si applica agli spazi che non assomigliano nemmeno allo spazio fisico. In effetti i matematici (e in effetti i fisici) usano molto spesso la dimensione infinita spazi metrici , come gli spazi di Hilbert della meccanica quantistica .

Con questo chiarito, parliamo di array: non è necessario comprendere gli spazi vettoriali, poiché qui la definizione astratta è in realtà molto più semplice.

Un array di dimensioni ( ℓ ₀ × ℓ ₁ × ℓ ₂ × ... × ℓ _{n −1} ) (cioè della dimensione n ) è semplicemente una raccolta di ℓ ₀ ⋅ ℓ ₁ ⋅ ... ⋅ ℓ _{n −1} numeri ( o qualunque tipo di oggetto popoli l'array). L'unica differenza con una matrice unidimensionale di quella lunghezza è che hai un modo particolarmente utile di indicizzare le dimensioni separatamente, vale a dire

i _lin = i _{n −1} + ℓ _{n −1} ⋅ ( i _{n −2} + ℓ _{n −1} ⋅ (... ℓ ₂ ⋅ ( i ₁ + ℓ ₁ ⋅ i ₀ ) ...))

Nella programmazione, le matrici sono abbastanza facili da implementare, ma forse non da capire.

In generale, ogni livello di array significa avere il contenuto n-pold. Questo significa

• int x[4]sono 4 blocchi, ognuno contenente un int.
• int x[5][4]sono 5 blocchi, ognuno contenente un int[4].
• int x[3][5][4]sono 3 blocchi, ognuno contenente un int[5][4].
• int x[2][3][5][4]sono 2 blocchi, ognuno contenente un int[3][5][4].

Il modo in cui ti riferisci a loro dipende da te, ma per una migliore comprensione, hai qualcosa di simile

• COLUMN per l'ultimo
• ROW per il penultimo
• PAGE per il terzo

Fino a qui, l'ho letto da qualche parte. Per rimanere qui, possiamo anche definire

• BOOK per il quarto
• e forse SHELFper il quinto ultimo. (O, se preferisci, in SHELFROWmodo che possiamo continuare.)

Detto questo, non ho mai visto array con più di 4 o forse 5 dimensioni in "vita selvaggia".

In questo modo, puoi definire e immaginare int x[6][2][3][5][4]una raccolta di 6 "scaffali", ciascuno con 2 libri, ognuno con 3 pagine, ognuna con 5 righe, ognuna con 4 colonne.

Pensa a una matrice unidimensionale come una cassettiera:

Ogni cassetto è un indice dell'array. Puoi mettere quello che vuoi in ogni cassetto e, per molti scopi, ogni cassetto conterrà solo un singolo elemento (che è un array unidimensionale).

Questa cassettiera è magica, quindi non è limitata dallo spazio fisico. Ciò significa che puoi inserire un'altra cassettiera all'interno di ciascun cassetto della prima cassettiera. Le cassettiere interne possono quindi contenere tutto ciò che desideri. Questa è una matrice bidimensionale.

Quindi puoi dire qualcosa come "aprire il primo cassetto del primo cassettone, estrarre il cassettone da quel cassetto, quindi aprire il cassetto inferiore di quel secondo cassettone". Sarebbe come accedere a un indice di un array 2D: myArray [0] [3];

E, naturalmente, le cassettiere all'interno della cassettiera più esterna possono esse stesse contenere cassettiere. Questa è una matrice tridimensionale.

Quindi, la tua domanda è: cos'è una matrice quadridimensionale? È una cassettiera di cassettiere di cassettiere di cassettiere, ovviamente!

Sono i cassetti fino in fondo.

La maggior parte degli aspetti di questa domanda sono già stati considerati, ma penso che sarà utile se si considera la natura di una dimensione. Non tutte le dimensioni sono spaziali. Una dimensione è un contesto per la misurazione. Ecco alcuni esempi:

• Frequenza: colore o tonalità
• Massa
• Valenza
• Colore (su quark, giù su quark, strano quark, quark incantato ecc.)
• Direzione di rotazione
• Angolo
• rumorosità
• Calore (di peperoncino)

La "quarta" dimensione è solo quarta perché ci sono tre dimensioni spaziali. Lo spazio e il tempo sembrano grandi perché, beh, sembrano grandi. Molto in faccia. Ma qualsiasi qualità quantificabile e misurabile può essere una dimensione se la si misura.

Ad esempio, i reggiseni hanno tre dimensioni: dimensione della tazza, dimensione del torace e interstiziale (non so come lo chiamano voi ragazze, ma intendo la distanza tra le tazze).

In fisica, assumiamo che ogni dimensione spaziale sia infinita, il che rende piuttosto difficile trovare spazio per nuove dimensioni.

Quando si ha a che fare con array finiti, è facile trovare spazio.

Immagina un foglio di carta con una griglia stampata su di esso; puoi scrivere alcune informazioni in ogni cella della griglia. Questo è un array 2D: riga e colonna.

Metti diversi di quei fogli di carta in una cartella di file; questo è un array 3D: pagina, riga e colonna.

Metti diverse di quelle cartelle in una casella di file. Matrice 4D: cartella, pagina, riga, colonna.

Disporre le scatole in una griglia rettangolare su un pallet di legno. 6D array: box-row, box-column, cartella, pagina, riga, colonna.

Impila più griglie di scatole sopra a quelle. Array 7D: box-depth, box-row, box-column, cartella, pagina, riga, colonna.

Inizia a riempire i pallet in un container: array 9D. (Supponendo che ogni pila sia alta come l'interno del contenitore, quindi puoi ottenere solo altre 2 dimensioni qui.)

Impilare i container sul ponte di una nave portacontainer: array 12D.

La tua flotta di navi portacontainer è ora un array 13D.

Nel sistema di coordinate cartesiane, hai gli assi xey su un piano. Puoi rappresentare qualsiasi numero sul piano come (x, y).

In tre "spazi" (altrimenti noto come cubo), puoi avere gli assi x, ye z. Puoi rappresentare qualsiasi elemento del cubo come (x, y, z).

Nello spazio multivariato, puoi avere gli assi x, y, z e, w (dove l'asse w è "immaginario"). Puoi rappresentare qualsiasi elemento di quello spazio come (x, y, z, w).

Tutti questi punti nello spazio sono indicati da vettori. In quattro spazi, puoi avere due vettori, dove v1 = (x1, y1, z1, w1) e v2 = (x2, y2, z2, w2). Quindi manipoli questi vettori come faresti con i numeri. Ad esempio, la somma dei due vettori, v1 + v2 sarebbe (x1, y1, z1, w1) + (x2, y2, z2, w2). Quindi aggiungi questi vettori termine per termine come faresti con i numeri, per ottenere: (x1 + x2, y1 + y2, z1 + z2, w1 + w2).

Il programma definirà i vettori utilizzando array appropriati e quindi eseguirà operazioni aritmetiche su di essi nell'ordine appropriato.