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 elementi adiacenti di X. Per impostazione predefinita, diff opera 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 lungo la prima dimensione dell'array la cui grandezza non è uguale a 1.

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 = 1×4 datetime
   09-Aug-2025 12:09:38   09-Aug-2025 12:11:08   09-Aug-2025 12:12:38   09-Aug-2025 12:14:08

dt = diff(t)

dt = 1×3 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

1 (predefinito) | scalare intero positivo | []

Ordine di differenza, specificato come scalare intero positivo o come []. Il valore predefinito di n è 1. Quando n è superiore rispetto alla dimensione su cui si opera, 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 si considera la prima dimensione dell'array la cui grandezza non è uguale a 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 la dimensione di X su cui opera diff ha una grandezza maggiore di n, questa dimensione viene ridotta di n nell'output. Se questa dimensione è inferiore a n, viene ridotta a zero e l'output è vuoto.

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 utilizzato, l'argomento dim deve essere costante al momento della generazione di codice.

• Per l'argomento di input X:

  • Se non si specifica una dimensione, il generatore di codice opera lungo la prima dimensione dell'array di input che ha grandezza variabile o la cui grandezza non è uguale a 1. Se questa dimensione ha grandezza variabile al momento della generazione di codice ed è pari a 1 in fase di esecuzione, può verificarsi un errore di runtime. Per evitare il verificarsi di tale errore, specificare la dimensione.

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

La funzione diff 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

R2025a: La sintassi a due input calcola le differenze solo lungo la prima dimensione la cui grandezza è maggiore di 1

La sintassi a due input diff(X,n) della funzione diff ora opera solo lungo la prima dimensione la cui grandezza è maggiore di 1 per tutti i valori di n. Se n è superiore rispetto a tale dimensione, diff restituisce un array vuoto. In precedenza, quando n era superiore rispetto alla prima dimensione la cui grandezza era maggiore di 1, diff(X,n) riduceva la grandezza di tale dimensione a 1, quindi calcolava le differenze lungo la dimensione successiva la cui grandezza era maggiore di 1.

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