Differences and approximate derivatives
Xis a vector of length
Y = diff(X)returns a vector of length
m-1. The elements of
Yare the differences between adjacent elements of
Y = [X(2)-X(1) X(3)-X(2) ... X(m)-X(m-1)]
Xis a nonempty, nonvector p-by-m matrix, then
Y = diff(X)returns a matrix of size (p-1)-by-m, whose elements are the differences between the rows of
Y = [X(2,:)-X(1,:); X(3,:)-X(2,:); ... X(p,:)-X(p-1,:)]
Xis a 0-by-0 empty matrix, then
Y = diff(X)returns a 0-by-0 empty matrix.
Xis a p-by-m table or timetable, then
Y = diff(X)returns a table or timetable of size (p-1)-by-m, whose elements are the differences between the rows of
Xis a 1-by-m table or timetable, then the size of
Yis 0-by-m. (since R2023a)
Differences Between Vector Elements
Create a vector, then compute the differences between the elements.
X = [1 1 2 3 5 8 13 21]; Y = diff(X)
Y = 1×7 0 1 1 2 3 5 8
Y has one fewer element than
Differences Between Matrix Rows
Create a 3-by-3 matrix, then compute the first difference between the rows.
X = [1 1 1; 5 5 5; 25 25 25]; Y = diff(X)
Y = 2×3 4 4 4 20 20 20
Y is a 2-by-3 matrix.
Create a vector and compute the second-order difference between the elements.
X = [0 5 15 30 50 75 105]; Y = diff(X,2)
Y = 1×5 5 5 5 5 5
Differences Between Matrix Columns
Create a 3-by-3 matrix, then compute the first-order difference between the columns.
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 is a 3-by-2 matrix.
Approximate Derivatives with diff
diff function to approximate partial derivatives with the syntax
Y = diff(f)/h, where
f is a vector of function values evaluated over some domain,
h is an appropriate step size.
For example, the first derivative of
sin(x) with respect to
cos(x), and the second derivative with respect to
-sin(x). You can use
diff to approximate these derivatives.
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 this plot the blue line corresponds to the original function,
sin. The red line corresponds to the calculated first derivative,
cos, and the black line corresponds to the calculated second derivative,
Differences Between Datetime Values
Create a sequence of equally-spaced datetime values, and find the time differences between them.
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 returns a
X — Input array
vector | matrix | multidimensional array | table | timetable
Input array, specified as a vector, matrix, multidimensional array, table, or timetable.
X can be a numeric array, logical array, datetime
array, or duration array, or a table or timetable whose variables have any
of these data types.
Complex Number Support: Yes
n — Difference order
positive integer scalar |
Difference order, specified as a positive integer scalar or
The default value of
n is 1.
The behavior of
larger than the dimension being operated on depends on the syntax being
nis larger than the first non-singleton dimension,
diffreduces the size of that dimension to 1 and then continues taking differences along the next non-singleton dimension.
n >= size(X,dim),
diffreturns an empty array.
dim — Dimension to operate along
positive integer scalar
Dimension to operate along, specified as a positive integer scalar. If you do not specify the dimension, then the default is the first array dimension of size greater than 1.
Consider a two-dimensional p-by-m input array,
diff(A,1,1)works on successive elements in the columns of
Aand returns a (p-1)-by-m difference matrix.
diff(A,1,2)works on successive elements in the rows of
Aand returns a p-by-(m-1) difference matrix.
Y — Difference array
scalar | vector | matrix | multidimensional array | table | timetable
Difference array, returned as a scalar, vector, matrix, multidimensional array, table, or
X is a nonempty array, then the dimension
X acted on by
diff is reduced in
n in the output.
Calculate with arrays that have more rows than fit in memory.
This function supports tall arrays with the limitations:
You must use the three-input syntax
Y = diff(X,N,dim).
For more information, see Tall Arrays.
C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.
Usage notes and limitations:
If supplied, the arguments representing the number of times to apply
diffand the dimension along which to calculate the difference must be constants.
See Variable-Sizing Restrictions for Code Generation of Toolbox Functions (MATLAB Coder).
Code generation does not support sparse matrix inputs for this function.
Run code in the background using MATLAB®
backgroundPool or accelerate code with Parallel Computing Toolbox™
This function fully supports thread-based environments. For more information, see Run MATLAB Functions in Thread-Based Environment.
Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.
This function fully supports GPU arrays. For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).
Partition large arrays across the combined memory of your cluster using Parallel Computing Toolbox™.
This function fully supports distributed arrays. For more information, see Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).
Version HistoryIntroduced before R2006a
R2023a: Perform calculations directly on tables and timetables
diff function can calculate on all variables within a table or
timetable without indexing to access those variables. All variables must have data types
that support the calculation. For more information, see Direct Calculations on Tables and Timetables.
R2022a: Improved performance with large number of elements
diff function shows improved performance when operating
on vectors with at least 105 elements or when operating
along the first or second dimension of matrices and multidimensional arrays with at
least 5 x 105 elements.
For example, this code constructs a double with 2.5 x 107 elements and calculates differences between adjacent elements. The code is approximately 2.4x faster than in the previous release:
function timingDiff rng default N = 5000; A = rand(N); tic for k = 1:40 D = diff(A); end toc end
The approximate execution times are:
R2021b: 2.43 s
R2022a: 1.00 s
The code was timed on a Windows® 10, Intel®
Xeon® CPU E5-1650 v4 @ 3.60 GHz test system by calling the