La traduzione di questa pagina non è aggiornata. Fai clic qui per vedere l'ultima versione in inglese.

diff

Differenze e derivate approssimate

Sintassi

Y = diff(X)

Y = diff(X,n)

Y = diff(X,n,dim)

Descrizione

Y = diff(X) calcola le differenze tra gli elementi adiacenti di X lungo la prima dimensione dell'array la cui grandezza non è uguale a 1:

• Se X è un vettore di lunghezza m, Y = diff(X) restituisce un vettore di lunghezza m-1. Gli elementi di Y sono le differenze tra gli elementi adiacenti di X.

  Y = [X(2)-X(1) X(3)-X(2) ... X(m)-X(m-1)]

• Se X è una matrice p x m non vuota e non vettoriale, Y = diff(X) restituisce una matrice di grandezza (p-1) x m, i cui elementi sono le differenze tra le righe di X.

  Y = [X(2,:)-X(1,:); X(3,:)-X(2,:); ... X(p,:)-X(p-1,:)]

• Se X è una matrice vuota 0x0, Y = diff(X) restituisce una matrice vuota 0x0.

• Se X è una tabella o un orario p x m, Y = diff(X) restituisce una tabella o un orario di grandezza (p-1) x m, i cui elementi sono le differenze tra le righe di X. Se X è una tabella o un orario 1 x m, la grandezza di Y sarà 0 x m. (da R2023a)

Y = diff(X,n) calcola l'ennesima differenza applicando ricorsivamente l'operatore diff(X) per n volte. In sostanza, questo significa che diff(X,2) è uguale a diff(diff(X)).

Y = diff(X,n,dim) è l'ennesima differenza calcolata lungo la dimensione specificata da dim. L'input dim è uno scalare intero positivo.

Esempi

Differenze tra gli elementi del vettore

Creare un vettore, quindi calcolare le differenze tra gli elementi.

X = [1 1 2 3 5 8 13 21];
Y = diff(X)

Y = 1×7

     0     1     1     2     3     5     8

Si noti che Y ha un elemento in meno rispetto a X.

Differenze tra le righe della matrice

Creare una matrice 3x3, quindi calcolare la prima differenza tra le righe.

X = [1 1 1; 5 5 5; 25 25 25];
Y = diff(X)

Y = 2×3

     4     4     4
    20    20    20

Y è una matrice 2x3.

Differenze multiple

Creare un vettore e calcolare la differenza di secondo ordine tra gli elementi.

X = [0 5 15 30 50 75 105];
Y = diff(X,2)

Y = 1×5

     5     5     5     5     5

Differenze tra le colonne della matrice

Creare una matrice 3x3, quindi calcolare la differenza di primo ordine tra le colonne.

X = [1 3 5;7 11 13;17 19 23];
Y = diff(X,1,2)

Y = 3×2

     2     2
     4     2
     2     4

Y è una matrice 2x3.

Derivate approssimate con differenza

Utilizzare la funzione diff per approssimare le derivate parziali con la sintassi Y = diff(f)/h, dove f è un vettore di valori della funzione valutati su un dominio X e h è una grandezza appropriata di passo.

Ad esempio, la derivata prima di sin(x) rispetto a x è cos(x) e la derivata seconda rispetto a x è -sin(x). È possibile utilizzare diff per approssimare queste derivate.

h = 0.001;       % step size
X = -pi:h:pi;    % domain
f = sin(X);      % range
Y = diff(f)/h;   % first derivative
Z = diff(Y)/h;   % second derivative
plot(X(:,1:length(Y)),Y,'r',X,f,'b', X(:,1:length(Z)),Z,'k')

In questo grafico, la linea blu corrisponde alla funzione originale sin. La linea rossa corrisponde alla derivata prima calcolata cos e la linea nera corrisponde alla derivata seconda calcolata -sin.

Differenze tra i valori di data e ora

Creare una sequenza di valori di data e ora equidistanti e trovare le differenze di tempo tra loro.

t1 = datetime('now');
t2 = t1 + minutes(5);
t = t1:minutes(1.5):t2

t = 1x4 datetime
   19-Aug-2023 14:40:25   19-Aug-2023 14:41:55   19-Aug-2023 14:43:25   19-Aug-2023 14:44:55

dt = diff(t)

dt = 1x3 duration
   00:01:30   00:01:30   00:01:30

diff restituisce un array duration.

Argomenti di input

X — Array di input

vettore | matrice | array multidimensionale | tabella | orario

Array di input, specificato come vettore, matrice, array multidimensionale, tabella o orario. X può essere un array numerico, un array logico, un array di data e ora, un array di durata, o una tabella o un orario le cui variabili hanno uno di questi tipi di dati.

Supporto numeri complessi: Sì

n — Ordine di differenza

scalare intero positivo | []

Ordine di differenza, specificato come scalare intero positivo o come []. Il valore predefinito di n è 1.

Il comportamento di diff quando n è maggiore della dimensione su cui si opera dipende dalla sintassi utilizzata:

• Con diff(X,n), dove n è maggiore della prima dimensione non singolare, diff riduce la grandezza di tale dimensione a 1, quindi continua a considerare le differenze lungo la dimensione successiva non singolare.

• Con diff(X,n,dim), dove n >= size(X,dim), diff restituisce un array vuoto.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

dim — Dimensione lungo la quale operare

scalare intero positivo

Dimensione lungo la quale operare, specificata come scalare intero positivo. Se non si specifica la dimensione, per impostazione predefinita viene considerata la prima dimensione dell'array la cui grandezza è maggiore di 1.

Considerare un array di input a due dimensioni p x m, A:

• diff(A,1,1) lavora sugli elementi successivi nelle colonne di A e restituisce una matrice di differenza (p-1) x m.

• diff(A,1,2) lavora sugli elementi successivi nelle righe di A e restituisce una matrice di differenza p x (m-1).

Tipi di dati: double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Argomenti di output

Y — Array di differenza

scalare | vettore | matrice | array multidimensionale | tabella | orario

Array di differenza, restituito come scalare, vettore, matrice, array multidimensionale, tabella o orario. Se X è un array non vuoto, la dimensione di X operata da diff viene ridotta in grandezza da n nell'output.

Funzionalità estese

Tall array

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

Questa funzione supporta i tall array con le seguenti limitazioni:

È necessario utilizzare la sintassi a tre input Y = diff(X,N,dim).

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 forniti, gli argomenti che rappresentano il numero di volte in cui applicare diff e la dimensione lungo la quale calcolare la differenza devono essere costanti.

• Vedere Variable-Sizing Restrictions for Code Generation of Toolbox Functions (MATLAB Coder).

• La generazione di codice non supporta input di matrici sparse per questa funzione.

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™.

Questa funzione supporta completamente gli array di GPU. 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

R2023a: Esecuzione di calcoli direttamente su tabelle e orari

La funzione diff può eseguire calcoli su tutte le variabili all’interno di una tabella o di un orario senza dover eseguire indicizzazioni per accedere a tali variabili. Tutte le variabili devono avere tipi di dati che supportino il calcolo. Per maggiori informazioni, vedere Direct Calculations on Tables and Timetables.

R2022a: Migliori prestazioni con un numero elevato di elementi

La funzione diff mostra migliori prestazioni quando opera su vettori con almeno 10⁵ elementi o quando opera lungo la prima o la seconda dimensione di matrici e array multidimensionali con almeno 5x10⁵ elementi.

Ad esempio, questo codice costruisce un doppio con 2,5x10⁷ elementi e calcola le differenze tra gli elementi adiacenti. Il codice è circa 2,4 volte più veloce rispetto alla release precedente:

function timingDiff
rng default
N = 5000;
A = rand(N);

tic
for k = 1:40
   D = diff(A);
end
toc
end

I tempi di esecuzione approssimativi sono:

R2021b: 2,43 s

R2022a: 1,00 s

Il codice è stato cronometrato su un sistema di test Windows^® 10, Intel^® Xeon^® CPU E5-1650 v4 @ 3.60 GHz chiamando la funzione timingDiff.

Vedi anche

gradient | prod | cumsum | sum