diff

Differenzen und Näherungsableitungen

Syntax

Y = diff(X)

Y = diff(X,n)

Y = diff(X,n,dim)

Beschreibung

Y = diff(X) berechnet die Differenz zwischen benachbarten Elementen von X. Standardmäßig wird diff entlang der ersten Array-Dimension ausgeführt, deren Größe nicht 1 ist.

• Wenn X ein Vektor der Länge m ist, gibt Y = diff(X) einen Vektor der Länge m-1 zurück. Die Elemente von Y sind die Differenzen zwischen benachbarten Elementen von X.

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

• Wenn X eine nicht leere, nicht vektorielle p-mal-m-Matrix ist, gibt Y = diff(X) eine Matrix der Größe (p-1)-mal-m zurück, deren Elemente die Differenzen zwischen den Zeilen von X darstellen.

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

• Wenn X eine leere 0x0-Matrix ist, gibt Y = diff(X) eine leere 0x0-Matrix zurück.

• Wenn X eine Tabelle oder ein Timetable der Größe p-mal-m ist, gibt Y = diff(X) eine Tabelle oder einen Timetable der Größe (p-1)-mal-m zurück, deren bzw. dessen Elemente die Differenzen zwischen den Zeilen von X darstellen. Wenn X eine Tabelle oder ein Timetable der Größe 1-mal-m ist, weist Y die Größe 0-mal-m auf. (seit R2023a)

Y = diff(X,n) berechnet die n-te Differenz durch die rekursive n-malige Anwendung des diff(X)-Operators entlang der ersten Array-Dimension, deren Größe nicht 1 ist.

Y = diff(X,n,dim) ist die n-te Differenz, die entlang der mit dim festgelegten Dimension berechnet wird. Die dim-Eingabe ist ein positiver ganzzahliger Skalar.

Beispiele

Differenzen zwischen Vektorelementen

Erstellen Sie einen Vektor und berechnen Sie dann die Differenzen zwischen den Elementen.

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

Y = 1×7

     0     1     1     2     3     5     8

Beachten Sie, dass Y ein Element weniger aufweist als X.

Differenzen zwischen Matrixzeilen

Erstellen Sie eine 3x3-Matrix und berechnen Sie dann die erste Differenz zwischen den Zeilen.

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

Y = 2×3

     4     4     4
    20    20    20

Y ist eine 2x3 Matrix.

Mehrere Differenzen

Erstellen Sie einen Vektor und berechnen Sie die Differenz zweiter Ordnung zwischen den Elementen.

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

Y = 1×5

     5     5     5     5     5

Differenzen zwischen Matrixspalten

Erstellen Sie eine 3x3-Matrix und berechnen Sie dann die Differenz erster Ordnung zwischen den Spalten.

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 ist eine 3x2 Matrix.

Näherungsableitung mit „diff“

Verwenden Sie die diff-Funktion zur Annäherung an partielle Ableitungen mithilfe der Syntax Y = diff(f)/h, wobei f ein Vektor von Funktionswerten ist, die über einen Bereich X ausgewertet werden, und h eine geeignete Schrittgröße ist.

Zum Beispiel ist cos(x) die erste Ableitung von sin(x) nach x und -sin(x) die zweite Ableitung nach x. Sie können diese Ableitungen mithilfe von diff approximieren.

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 diesem Diagramm entspricht die blaue Linie der ursprünglichen Funktion, sin. Die rote Linie entspricht der berechneten ersten Ableitung, cos, und die schwarze Linie entspricht der berechneten zweiten Ableitung, -sin.

Differenzen zwischen Datums-/Uhrzeit-Werten

Erstellen Sie eine Folge abstandsgleicher Datums-/Uhrzeit-Werte und ermitteln Sie die Zeitdifferenzen zwischen ihnen.

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

t = 1×4 datetime
   24-Jan-2026 21:13:43   24-Jan-2026 21:15:13   24-Jan-2026 21:16:43   24-Jan-2026 21:18:13

dt = diff(t)

dt = 1×3 duration
   00:01:30   00:01:30   00:01:30

diff gibt ein duration-Array zurück.

Eingabeargumente

X — Eingabearray

Vektor | Matrix | mehrdimensionales Array | Tabelle | Timetable

Eingabearray, angegeben als Vektor, Matrix, mehrdimensionales Array, Tabelle oder Timetable. X kann ein numerisches Array, ein logisches Array, ein Datums-/Uhrzeit-Array oder ein Dauer-Array sein, oder eine Tabelle oder ein Timetable, deren bzw. dessen Variablen einen dieser Datentypen aufweisen.

Unterstützung komplexer Zahlen: Ja

n — Differenzreihenfolge

1 (Standardeinstellung) | positiver ganzzahliger Skalar | []

Differenzreihenfolge, angegeben als positiver ganzzahliger Skalar oder []. Der Standardwert von n ist 1. Wenn n größer als die Ausführungsdimension ist, gibt diff ein leeres Array zurück.

Datentypen: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

dim — Dimension, entlang der die Operation erfolgt

positiver ganzzahliger Skalar

Dimension, entlang der die Operation erfolgt, angegeben als positiver ganzzahliger Skalar. Wenn Sie die Dimension nicht angeben, wird standardmäßig die erste Array-Dimension verwendet, deren Größe nicht 1 ist.

Angenommen, es liegt ein zweidimensionales p-mal-m-Eingabearray, A, vor:

• diff(A,1,1) wird für aufeinanderfolgende Elemente in den Spalten von A ausgeführt und gibt eine (p-1)-mal-m-Differenzmatrix zurück.

• diff(A,1,2) wird für aufeinanderfolgende Elemente in den Zeilen von A ausgeführt und gibt eine p-mal-(m-1)-Differenzmatrix zurück.

Datentypen: double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Ausgabeargumente

Y — Differenzarray

Skalar | Vektor | Matrix | mehrdimensionales Array | Tabelle | Timetable

Differenzarray, zurückgegeben als Skalar, Vektor, Matrix, mehrdimensionales Array, Tabelle oder Timetable. Wenn die Dimension von X, auf die diff-Funktion angewendet wird, eine Größe von mehr als n aufweist, wird diese Dimension in der Ausgabe um n reduziert. Wenn diese Dimension kleiner als n ist, wird sie auf null reduziert und die Ausgabe ist leer.

Erweiterte Fähigkeiten

Tall Arrays

Rechnen mit Arrays, die mehr Zeilen haben, als in den Speicher passen.

Diese Funktion unterstützt Tall-Arrays mit folgenden Einschränkungen:

Sie müssen die Syntax mit drei Eingaben verwenden: Y = diff(X,N,dim).

Weitere Informationen finden Sie unter Tall-Arrays.

C/C++ Codegenerierung

Generieren Sie C und C++ Code mit MATLAB® Coder™.

Hinweise zur Verwendung und Einschränkungen:

• Das Argument dim, so verwendet, muss zum Zeitpunkt der Codegenerierung eine Konstante sein.

• Für das Eingabeargument X:

  • Wenn Sie keine Dimension angeben, wird der Codegenerator an der ersten Dimension des Eingabearrays ausgeführt, deren Größe variabel ist oder nicht 1 beträgt. Wenn diese Dimension zum Zeitpunkt der Codegenerierung eine variable Größe aufweist oder zur Laufzeit 1 beträgt, kann es zu einem Laufzeitfehler kommen. Geben Sie die Dimension an, um diesen Fehler zu vermeiden.

• Die Codegenerierung unterstützt für diese Funktion keine Eingaben dünn besetzter Matrizen.

GPU-Codegenerierung

Generieren von CUDA® Code für NVIDIA® Grafikprozessoren mit dem GPU Coder™.

Siehe die Verwendungshinweise und Einschränkungen im Abschnitt zur C/C++ Codegenerierung. Dieselben Verwendungshinweise und Einschränkungen gelten auch für die Grafikkarten-Codegenerierung.

Thread-Based Environment

Führen Sie mithilfe von MATLAB® backgroundPool den Code im Hintergrund aus oder machen Sie den Code mit der Parallel Computing Toolbox™ ThreadPool schneller.

Die Funktion diff bietet vollständige Unterstützung für Thread-basierte Umgebungen. Weitere Informationen finden Sie unter Run MATLAB Functions in Thread-Based Environment.

GPU-Arrays

Schnellere Codeausführung durch Ausführen auf einer Grafikkarte (GPU) mit der Parallel Computing Toolbox™.

Die Funktion diff bietet vollständige Unterstützung für Grafikkarten-Arrays. Zum Ausführen der Funktion auf einer Grafikkarte geben Sie die Eingabedaten als gpuArray (Parallel Computing Toolbox) an. Weitere Informationen finden Sie unter Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Verteilte Arrays

Partitionieren von großen Arrays über den kombinierten Speicher Ihres Clusters mit Parallel Computing Toolbox™.

Die Funktion diff bietet vollständige Unterstützung für verteilte Arrays. Weitere Informationen finden Sie unter Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Versionsverlauf

Eingeführt vor R2006a

R2025a: Die Syntax mit zwei Eingaben berechnet die Differenzen nur entlang der ersten Dimension, deren Größe mehr als 1 beträgt

diff(X,n), die Syntax mit zwei Eingaben der diff-Funktion, wird jetzt nur noch entlang der ersten Dimension angewendet, deren Größe für alle Werte von n mehr als 1 beträgt. Wenn n größer als diese Dimension ist, gibt diff ein leeres Array zurück. Wenn zuvor n größer als die erste Dimension war, deren Größe mehr als 1 beträgt, reduzierte diff(X,n) die Größe dieser Dimension auf 1 und berechnete dann die Differenzen entlang der nächsten Dimension, deren Größe mehr als 1 beträgt.

R2023a: Direkte Durchführung von Berechnungen für Tabellen und Timetables

Die Funktion diff kann die Berechnung mit allen Variablen in einer Tabelle oder einem Timetable ausführen, ohne für den Zugriff auf diese Variablen eine Indizierung zu benötigen. Alle Variablen müssen Datentypen aufweisen, die die Berechnung unterstützen. Weitere Informationen finden Sie unter Direct Calculations on Tables and Timetables.

R2022a: Verbesserte Leistung bei einer großen Anzahl von Elementen

Die Funktion diff liefert nun eine bessere Leistung, wenn sie auf Vektoren mit mindestens 10⁵ Elementen oder entlang der ersten oder zweiten Dimension von Matrizen und mehrdimensionalen Arrays mit mindestens 5 x 10⁵ Elementen angewendet wird.

Dieser Code baut zum Beispiel ein Double mit 2,5 x 10⁷ Elementen auf und berechnet die Differenz zwischen benachbarten Elementen. Der Code ist etwa 2,4-mal schneller als in der vorherigen Version:

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

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

Die ungefähren Ausführungszeiten sind:

R2021b: 2,43 s

R2022a: 1,00 s

Die Ausführungszeit des Codes wurde auf einem Testsystem unter Windows^® 10 mit einem Intel^® Xeon^®-Prozessor E5-1650 v4 bei 3,60 GHz mithilfe der Funktion timingDiff gemessen.

Siehe auch

gradient | prod | cumsum | sum