Tipi di array

Array multidimensionali

Gli array multidimensionali nell'ambiente di MATLAB^® sono array con oltre due pedici. Uno dei metodi per creare un array multidimensionale consiste nel richiamare zeros, ones, rand o randn con più di due argomenti. Ad esempio,

R = randn(3,4,5);

crea un array 3x4x5 con un totale di 3*4*5 = 60 elementi casuali distribuiti normalmente.

Un array tridimensionale può rappresentare dati fisici tridimensionali, come la temperatura di un ambiente campionata su una griglia rettangolare. Può anche rappresentare una sequenza di matrici, A^(k) o campioni di una matrice dipendente dal tempo, A(t). In questi ultimi casi, l'elemento (i, j)-esimo della matrice k-esima, o la matrice t_k-esima, sono denotati con A(i,j,k).

Le versioni di MATLAB e quelle di Dürer del quadrato magico di ordine 4 differiscono per lo scambio di due colonne. Scambiando tra loro le colonne è possibile generare numerosi quadrati magici diversi. La dichiarazione

p = perms(1:4);

genera le permutazioni 4! = 24 di 1:4. La k-esima permutazione è il vettore riga p(k,:). Quindi

A = magic(4);
M = zeros(4,4,24);

for k = 1:24
   M(:,:,k) = A(:,p(k,:));
end

memorizza la sequenza di 24 quadrati magici nell'array tridimensionale M. Le dimensioni di M sono

size(M)

ans =
     4     4    24

Nota

L'ordine delle matrici riportato in questa illustrazione potrebbe differire dai propri risultati ottenuti. La funzione perms restituisce sempre tutte le permutazioni del vettore di input, ma l'ordine di tali permutazioni potrebbe differire utilizzando versioni diverse di MATLAB.

La dichiarazione

sum(M,d)

calcola le somme variando il d-esimo pedice. Quindi

sum(M,1)

è un array 1x4x24 che contiene 24 copie del vettore riga

34    34    34    34

e

sum(M,2)

è un array 4x1x24 che contiene 24 copie del vettore colonna

34    
34    
34    
34

Infine,

S = sum(M,3)

aggiunge alla sequenza le 24 matrici. Il risultato presenta dimensioni 4x4x1 e il suo aspetto richiama un array 4x4:

S =
   204   204   204   204
   204   204   204   204
   204   204   204   204
   204   204   204   204

Array di celle

Gli array di celle in MATLAB sono array multidimensionali i cui elementi sono copie di altri array. È possibile creare un array di celle con matrici vuote tramite la funzione cell. Più di frequente, tuttavia, gli array di celle vengono creati racchiudendo un gruppo diversificato di elementi tra parentesi graffe, {}. Le parentesi graffe sono utilizzate anche con i pedici per accedere al contenuto di varie celle. Ad esempio,

C = {A sum(A) prod(prod(A))}

produce un array di celle 1x3. Le tre celle contengono il quadrato magico, il vettore riga della somma delle colonne e il prodotto di tutti i suoi elementi. Quando si visualizza C, si vede

C = 
    [4x4 double]    [1x4 double]    [20922789888000]

Questo accade perché le prime due celle sono troppo larghe per essere stampate in uno spazio così limitato, mentre la terza cella contiene un solo numero, 16!, quindi vi è spazio sufficiente per la stampa.

Sono due i punti importanti da ricordare. Per prima cosa, per richiamare il contenuto di una delle celle si utilizzano i pedici tra parentesi graffe. Ad esempio, C{1} richiama il quadrato magico e C{3} è 16!. In secondo luogo, gli array di celle contengono copie di altri array, non puntatori verso tali array. Se in un secondo momento si modifica A, l'operazione non ha effetto su C.

È possibile utilizzare array tridimensionali per memorizzare una sequenza di matrici delle medesime dimensioni. È possibile utilizzare array di celle per memorizzare una sequenza di matrici di dimensioni diverse. Ad esempio,

M = cell(8,1);
for n = 1:8
   M{n} = magic(n);
end
M

produce una sequenza di quadrati magici di ordine diverso:

M = 
    [           1]
    [ 2x2  double]
    [ 3x3  double]
    [ 4x4  double]
    [ 5x5  double]
    [ 6x6  double]
    [ 7x7  double]
    [ 8x8  double]

È possibile richiamare la matrice del quadrato magico 4x4 con

M{4}

Stringhe di caratteri e testo

Per immettere del testo in MATLAB utilizzare gli apici. Ad esempio,

s = 'Hello'

Il risultato non è lo stesso tipo di matrice numerica o array visti finora. Si tratta di un array di caratteri 1x5.

Internamente i caratteri vengono memorizzati come numeri, ma non in formato a punto mobile. La dichiarazione

a = double(s)

converte l'array di caratteri in matrice numerica contenente rappresentazioni a punto mobile dei codici ASCII per ciascun carattere. Il risultato è

a =
    72    101    108    108    111

La dichiarazione

s = char(a)

inverte la conversione.

La conversione da numeri a caratteri consente di esaminare i vari font disponibili nel proprio computer. I caratteri stampabili nel set di caratteri ASCII di base sono rappresentati dai numeri interi 32:127. I numeri interi inferiori a 32 rappresentano i caratteri di controllo non stampabili. Questi numeri interi sono disposti in array 6x16 appropriati con

F = reshape(32:127,16,6)';

I caratteri stampabili nel set di caratteri ASCII estesi sono rappresentati da F+128. Quando questi numeri interi vengono interpretati come caratteri, il risultato dipende dal font in uso. Digitare le dichiarazioni

char(F)
char(F+128)

e cambiare il font utilizzato per la finestra Comando. Per cambiare il font, dalla scheda Home nella sezione Environment fare clic su Preferences > Fonts. Se le righe di codice includono dei tabulatori, utilizzare un font a larghezza fissa, come Monospaced, per allineare le posizioni dei tabulatori su righe diverse.

La concatenazione con parentesi quadre riunisce le variabili di testo. La dichiarazione

h = [s, ' world']

riunisce orizzontalmente i caratteri e produce

h =
   Hello world

La dichiarazione

v = [s; 'world']

riunisce verticalmente i caratteri e produce

v =
   Hello
   world

Si noti che in h occorre inserire uno spazio vuoto prima di 'w' e che la lunghezza delle due parole in v deve essere uguale. Gli array risultanti sono entrambi array di caratteri; h è 1x11, mentre v è 2x5.

Per manipolare un corpo di testo contenente righe di lunghezze diverse si hanno due scelte: un array di caratteri di riempimento o un array di celle di vettori di caratteri. Quando si crea un array di caratteri, è necessario che tutte le righe dell'array siano della medesima lunghezza. La parte finale delle righe più corte viene riempita con spazi. La funzione char effettua automaticamente il riempimento con caratteri. Ad esempio,

S = char('A','rolling','stone','gathers','momentum.')

produce un array di caratteri 5x9:

S =
A        
rolling  
stone    
gathers  
momentum.

È anche possibile memorizzare il testo in un array di celle. Ad esempio,

C = {'A';'rolling';'stone';'gathers';'momentum.'}

crea un array di celle 5x1 che non richiede caratteri di riempimento perché ciascuna riga dell'array può presentare una lunghezza diversa:

C = 
    'A'
    'rolling'
    'stone'
    'gathers'
    'momentum.'

È possibile convertire un array con caratteri di riempimento in un array di celle di vettori di caratteri utilizzando

C = cellstr(S)

e invertire il processo utilizzando

S = char(C)

Strutture

Le strutture sono array multidimensionali di MATLAB con elementi a cui accedono designatori di campo testuali. Ad esempio,

S.name = 'Ed Plum';
S.score = 83;
S.grade = 'B+'

crea una struttura scalare con tre campi:

S = 
     name: 'Ed Plum'
    score: 83
    grade: 'B+'

Come ogni altro elemento nell'ambiente MATLAB, le strutture sono array ed è quindi possibile inserirvi ulteriori elementi. In questo caso ciascun elemento dell'array è una struttura con numerosi campi. È possibile aggiungere un campo per volta

S(2).name = 'Toni Miller';
S(2).score = 91;
S(2).grade = 'A-';

oppure aggiungere un intero elemento con un'unica dichiarazione:

S(3) = struct('name','Jerry Garcia',... 
               'score',70,'grade','C')

Ora la struttura è sufficientemente grande da consentire solo la stampa di un riepilogo:

S = 
1x3 struct array with fields:
    name
    score
    grade

Vi sono numerosi metodi per riassemblare i diversi campi in altri array di MATLAB. Per la maggior parte si basano sulla notazione di un elenco di elementi separati da virgole. Digitando

S.score

equivale a digitare

S(1).score, S(2).score, S(3).score

che è un elenco di elementi separati da virgole.

Racchiudendo tra parentesi quadre l'espressione che genera questo elenco, MATLAB memorizza ciascuna voce dell'elenco in un array. In questo esempio, MATLAB crea un vettore di righe numerico contenente il campo score di ciascun elemento dell'array della struttura S:

scores = [S.score]
scores =
    83    91    70

avg_score = sum(scores)/length(scores)
avg_score =
   81.3333

Per creare un array di caratteri da uno dei campi di testo, ad esempio name, richiamare la funzione char nell'elenco di elementi separati da virgole generato da S.name:

names = char(S.name)
names =
   Ed Plum    
   Toni Miller
   Jerry Garcia

Allo stesso modo è possibile creare un array di celle dai campi name racchiudendo tra parentesi graffe l'espressione che genera l'elenco:

names = {S.name}
names = 
    'Ed Plum'    'Toni Miller'    'Jerry Garcia'

Per assegnare i campi di ciascun elemento di un array della struttura a variabili distinte, esterne alla struttura, specificare ciascun output alla sinistra del segno di uguale, racchiudendo il tutto tra parentesi quadre:

[N1 N2 N3] = S.name
N1 =
   Ed Plum
N2 =
   Toni Miller
N3 =
   Jerry Garcia

Nomi dei campi dinamici

Il metodo più diffuso per accedere ai dati della struttura consiste nello specificare il nome del campo a cui si vuole fare riferimento. Un altro metodo per accede ai dati della struttura consiste nell'utilizzare nomi dei campi dinamici. Questi nomi esprimono il campo come espressione variabile che MATLAB valuta nel corso dell'esecuzione. La sintassi punto-parentesi qui illustrata rende expressionun nome del campo dinamico:

structName.(expression)

Per indicizzare questo campo utilizzare la sintassi di indicizzazione standard di MATLAB. Ad esempio, per valutare expression in un nome campo e ottenere i valori di questo campo nelle colonne da 1 a 25 della riga 7, utilizzare

structName.(expression)(7,1:25)

Esempi di nomi dei campi dinamici.  La funzione avgscore sotto illustrata calcola un punteggio di test medio, richiamando le informazioni dalla struttura testscores utilizzando nomi dei campi dinamici:

function avg = avgscore(testscores, student, first, last)
for k = first:last
   scores(k) = testscores.(student).week(k);
end
avg = sum(scores)/(last - first + 1);

È possibile eseguire questa funzione utilizzando valori diversi per il campo dinamico student. Per prima cosa inizializzare la struttura che contiene i punteggi per un periodo di 25 settimane:

testscores.Ann_Lane.week(1:25) = ...
  [95 89 76 82 79 92 94 92 89 81 75 93 ...
   85 84 83 86 85 90 82 82 84 79 96 88 98];

testscores.William_King.week(1:25) = ...
  [87 80 91 84 99 87 93 87 97 87 82 89 ...
   86 82 90 98 75 79 92 84 90 93 84 78 81];

Eseguire ora avgscore, fornendo i campi dei nomi degli studenti per la struttura testscores al momento dell'esecuzione utilizzando nomi dinamici dei campi:

avgscore(testscores, 'Ann_Lane', 7, 22)
ans = 
   85.2500

avgscore(testscores, 'William_King', 7, 22)
ans = 
   87.7500

Get Started with MATLABThe Language of Technical Computing

Avanti