find

Trovare indici e valori di elementi diversi da zero

Sintassi

k = find(X)

k = find(X,n)

k = find(X,n,direction)

[row,col] = find(___)

[row,col,v] = find(___)

Descrizione

k = find(X) restituisce un vettore contenente gli indici lineari di ciascun elemento diverso da zero nell’array X.

• Se X è un vettore, find restituisce un vettore con lo stesso orientamento di X.

• Se X è un array multidimensionale, find restituisce un vettore colonna degli indici lineari del risultato.

k = find(X,n) restituisce i primi indici n corrispondenti agli elementi diversi da zero in X.

k = find(X,n,direction), dove direction è 'last', trova gli ultimi indici n corrispondenti agli elementi diversi da zero in X. L’impostazione predefinita per direction è 'first', che trova i primi indici n corrispondenti agli elementi diversi da zero.

[row,col] = find(___) restituisce i pedici di riga e di colonna per ciascun elemento diverso da zero nell’array X utilizzando uno qualsiasi degli argomenti di input delle sintassi precedenti.

[row,col,v] = find(___) restituisce anche il vettore v, che contiene gli elementi diversi da zero di X.

Esempi

Elementi pari a zero e diversi da zero nella matrice

Trovare gli elementi diversi da zero in una matrice 3x3.

X = [1 0 2; 0 1 1; 0 0 4]

X = 3×3

     1     0     2
     0     1     1
     0     0     4

k = find(X)

k = 5×1

     1
     5
     7
     8
     9

Utilizzare l'operatore logico not su X per individuare gli zeri.

k2 = find(~X)

k2 = 4×1

     2
     3
     4
     6

Elementi che soddisfano una condizione

Trovare i primi cinque elementi minori di 10 in una matrice 4x4 con quadrato magico.

X = magic(4)

X = 4×4

    16     2     3    13
     5    11    10     8
     9     7     6    12
     4    14    15     1

k = find(X<10,5)

k = 5×1

     2
     3
     4
     5
     7

Visualizzare gli elementi corrispondenti di X.

X(k)

ans = 5×1

     5
     9
     4
     2
     7

Elementi uguali a valori specifici

Per trovare un valore intero specifico, utilizzare l'operatore ==. Ad esempio, trovare l'elemento uguale a 13 in un vettore di numeri interi dispari di 1x10.

x = 1:2:20

x = 1×10

     1     3     5     7     9    11    13    15    17    19

k = find(x==13)

k = 
7

Per trovare un valore non intero, utilizzare un valore di tolleranza basato sui dati. Diversamente, il risultato è talvolta una matrice vuota a causa di un errore di arrotondamento in virgola mobile.

y = 0:0.1:1

y = 1×11

         0    0.1000    0.2000    0.3000    0.4000    0.5000    0.6000    0.7000    0.8000    0.9000    1.0000

k = find(y==0.3)

k =

  1×0 empty double row vector

k = find(abs(y-0.3) < 0.001)

k = 
4

Ultimi svariati elementi diversi da zero

Creare una matrice 6x6 con quadrato magico con tutti gli elementi dispari indicizzati uguali a zero.

X = magic(6);
X(1:2:end) = 0

X = 6×6

     0     0     0     0     0     0
     3    32     7    21    23    25
     0     0     0     0     0     0
     8    28    33    17    10    15
     0     0     0     0     0     0
     4    36    29    13    18    11

Individuare gli ultimi quattro elementi diversi da zero.

k = find(X,4,'last')

k = 4×1

    30
    32
    34
    36

Elementi che soddisfano più condizioni

Trovare i primi tre elementi di una matrice 4x4 che siano maggiori di 0 e minori di 10. Specificare due output per restituire i pedici di riga e di colonna agli elementi.

X = [18 3 1 11; 8 10 11 3; 9 14 6 1; 4 3 15 21]

X = 4×4

    18     3     1    11
     8    10    11     3
     9    14     6     1
     4     3    15    21

[row,col] = find(X>0 & X<10,3)

row = 3×1

     2
     3
     4

col = 3×1

     1
     1
     1

La prima istanza è X(2,1), ossia 8.

Pedici e valori per elementi diversi da zero

Trovare gli elementi diversi da zero in una matrice 3x3. Specificare tre output per restituire i pedici di riga, i pedici di colonna e i valori degli elementi.

X = [3 2 0; -5 0 7; 0 0 1]

X = 3×3

     3     2     0
    -5     0     7
     0     0     1

[row,col,v] = find(X)

row = 5×1

     1
     2
     1
     2
     3

col = 5×1

     1
     1
     2
     3
     3

v = 5×1

     3
    -5
     2
     7
     1

Pedici dell’array multidimensionale

Trovare gli elementi diversi da zero in un array 4x2x3. Specificare due output, row e col, per restituire i pedici di riga e di colonna degli elementi diversi da zero. Quando l’input è un array multidimensionale (N > 2), find restituisce col come un indice lineare sulle dimensioni finali N-1 di X.

X = zeros(4,2,3);
X([1 12 19 21]) = 1

X = 
X(:,:,1) =

     1     0
     0     0
     0     0
     0     0


X(:,:,2) =

     0     0
     0     0
     0     0
     1     0


X(:,:,3) =

     0     1
     0     0
     1     0
     0     0

[row,col] = find(X)

row = 4×1

     1
     4
     3
     1

col = 4×1

     1
     3
     5
     6

Argomenti di input

X — Array di input

scalare | vettore | matrice | array multidimensionale

Array di input, specificato come scalare, vettore, matrice o array multidimensionale.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical | char
Supporto numeri complessi: Sì

n — Numero di elementi diversi da zero da trovare

scalare intero positivo

Numero di elementi diversi da zero da trovare, specificati come scalare intero positivo. Per impostazione predefinita, find(X,n) cerca i primi elementi n diversi da zero in X.

direction — Direzione di ricerca

'first' (predefinito) | 'last'

Direzione di ricerca, specificata come la stringa 'first' o 'last'. Cerca gli ultimi elementi n diversi da zero in X utilizzando find(X,n,'last').

Argomenti di output

k — Indici agli elementi diversi da zero

vettore

Indici agli elementi diversi da zero, restituiti come un vettore.

• Se X e un vettore riga, anche k è un vettore riga. In caso contrario, k è un vettore colonna.

• k è un vettore riga vuoto o un vettore colonna vuoto quando X è un array vuoto o non contiene alcun elemento diverso da zero.

• find utilizza la convenzione che k è una matrice vuota [] quando X è una matrice vuota [].

È possibile restituire i valori diversi da zero in X utilizzando X(k).

row — Pedici di riga

vettore

Pedici di riga, restituiti come un vettore. row e col specificano insieme i pedici di X(row,col) corrispondenti agli elementi diversi da zero in X.

col — Pedici di colonna

vettore

Pedici di colonna, restituiti come un vettore. row e col specificano insieme i pedici di X(row,col) corrispondenti agli elementi diversi da zero in X.

Se X è un array multidimensionale con N > 2, col è un indice lineare sulle dimensioni finali N-1 di X. Questo conserva la relazione X(row(i),col(i)) == v(i).

v — Elementi di X diversi da zero

vettore

Elementi di X diversi da zero, restituiti come un vettore.

Ulteriori informazioni

Indici lineari

Un indice lineare consente di utilizzare un singolo pedice per indicizzare un array, come A(k). MATLAB^® tratta l'array come un vettore colonna singolo, con ciascuna colonna aggiunta alla parte inferiore della colonna precedente. Pertanto, l'indicizzazione lineare numera gli elementi delle colonne dall'alto verso il basso, da sinistra a destra.

Ad esempio, si consideri una matrice 3x3. È possibile fare riferimento all’elemento A(2,2) con A(5) e all’elemento A(2,3) con A(8). L'indice lineare cambia a seconda delle dimensioni dell’array; A(5) restituisce un elemento posizionato diversamente per una matrice 3x3 rispetto a una matrice 4x4.

Le funzioni sub2ind e ind2sub sono utili per la conversione tra pedici e indici lineari.

Suggerimenti

• Per trovare gli elementi dell’array che soddisfano una condizione, utilizzare find in combinazione con un'espressione relazionale. Ad esempio, find(X<5) restituisce gli indici lineari agli elementi in X che sono minori di 5.

• Per trovare direttamente gli elementi in X che soddisfano la condizione X<5, utilizzare X(X<5). Evitare di chiamare funzioni come X(find(X<5)), che utilizzano inutilmente find su una matrice logica.

• Quando si esegue find con un'operazione relazionale come X>1, è importante ricordare che il risultato dell'operazione relazionale è una matrice logica di uno e di zeri. Ad esempio, il comando [row,col,v] = find(X>1) restituisce un vettore colonna di valori logici 1 (true) per v.

• I pedici di riga e colonna, row e col, sono correlati agli indici lineari in k x k = sub2ind(size(X),row,col).

Funzionalità estese

Tall array

Esegui calcoli con array che hanno più righe di quelle allocabili in memoria.

La funzione find supporta i tall array con le seguenti note su utilizzo e limitazioni:

• X deve essere un vettore colonna tall.

Per maggiori informazioni, vedere Tall Array.

Generazione di codice C/C++

Genera codice C e C++ con MATLAB® Coder™.

Note su utilizzo e limitazioni:

• Se un input di dimensione variabile diventa un vettore riga in fase di esecuzione, la generazione di codice termina con un errore. Questa limitazione non si applica quando l’input è scalare o è un vettore riga di lunghezza variabile.

• Per gli input di dimensione variabile, la forma degli output vuoti (0x0, 0x1 o 1x0) dipende dai limiti superiori delle dimensioni di input. Quando l’array di input è uno scalare o [] in fase di esecuzione, l’output potrebbe non essere compatibile per MATLAB. Se l’input è un vettore riga di lunghezza variabile, la dimensione di un output vuoto è 1x0. Diversamente, la dimensione è 0x1.

• Il codice generato restituisce sempre un vettore di lunghezza variabile. Anche quando viene fornito il vettore k di output, l’output non presenta dimensioni fisse poiché può contenere meno di k elementi. Ad esempio, find(x,1) restituisce un vettore di lunghezza variabile con uno o zero elementi.

Ambiente basato su thread

Esegui il codice in background usando MATLAB® backgroundPool oppure accelera il codice con Parallel Computing Toolbox™ ThreadPool.

Questa funzione supporta completamente gli ambienti basati su thread. Per maggiori informazioni, vedere Run MATLAB Functions in Thread-Based Environment.

Array GPU

Accelera il codice mediante esecuzione su un’unità di elaborazione grafica (GPU) con Parallel Computing Toolbox™.

La funzione find supporta completamente gli array di GPU. Per eseguire la funzione su una GPU, specificare i dati di input come un gpuArray (Parallel Computing Toolbox). Per maggiori informazioni, vedere Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Array distribuiti

Partiziona array di grandi dimensioni nella memoria combinata del cluster con Parallel Computing Toolbox™.

Questa funzione supporta completamente gli array distribuiti. Per maggiori informazioni, vedere Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Cronologia versioni

Introduzione prima di R2006a

Vedi anche

ind2sub | nonzeros | strfind | sub2ind | Short-Circuit AND | Short-Circuit OR | ismember

Argomenti

• Identificazione degli elementi dell'array che soddisfano le condizioni
• Indicizzazione di array
• Operazioni relazionali
• Matrici rade