conv

Faltung und polynomiale Multiplikation

Syntax

w = conv(u,v)

w = conv(u,v,shape)

Beschreibung

w = conv(u,v) gibt die Faltung der Vektoren u und v zurück. Wenn u und v Vektoren polynomialer Koeffizienten sind, ist deren Faltung äquivalent zur Multiplikation der beiden Polynome.

w = conv(u,v,shape) gibt einen Unterabschnitt der Faltung zurück, wie durch shape angegeben. Beispielsweise gibt conv(u,v,"same") nur den zentralen Teil der Faltung zurück, mit derselben Größe wie u, und conv(u,v,"valid") gibt nur den Teil der Faltung zurück, der ohne die mit Nullen aufgefüllten Kanten berechnet wurde.

Beispiele

Polynomiale Multiplikation per Faltung

Erstellen Sie die Vektoren u und v, die die Koeffizienten der Polynome $$x^2+1$$ und $$2x+7$$ enthalten.

u = [1 0 1];
v = [2 7];

Verwenden Sie Faltung, um die Polynome zu multiplizieren.

w = conv(u,v)

w = 1×4

     2     7     2     7

w enthält die polynomialen Koeffizienten für $$2x^3+7x^2+2x+7$$.

Vektorfaltung

Erstellen Sie zwei Vektoren und falten Sie diese.

u = [1 1 1];
v = [1 1 0 0 0 1 1];
w = conv(u,v)

w = 1×9

     1     2     2     1     0     1     2     2     1

Die Länge von w ist length(u)+length(v)-1, in diesem Beispiel also 9.

Zentraler Teil der Faltung

Erstellen Sie zwei Vektoren. Ermitteln Sie den zentralen Teil der Faltung von u und v, der dieselbe Größe aufweist wie u.

u = [-1 2 3 -2 0 1 2];
v = [2 4 -1 1];
w = conv(u,v,"same")

w = 1×7

    15     5    -9     7     6     7    -1

w hat eine Länge von 7. Die vollständige Faltung hätte eine Länge von length(u)+length(v)-1, in diesem Beispiel also 10.

Eingabeargumente

u,v — Eingabevektoren

Vektoren

Eingabevektoren, angegeben als Zeilen- oder Spaltenvektoren. Die Vektoren u und v können unterschiedliche Längen oder Datentypen aufweisen.

Wenn u oder v den Typ single aufweisen, weist die Ausgabe den Typ single auf. Anderenfalls konvertiert conv Eingaben in den Typ double und gibt den Typ double zurück.

Datentypen: double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical
Unterstützung komplexer Zahlen: Ja

shape — Unterabschnitt der Faltung

"full" (Standardeinstellung) | "same" | "valid"

Unterabschnitt der Faltung, angegeben als "full", "same" oder "valid".

"full"	Vollständige Faltung (Standard).
"same"	Zentraler Teil der Faltung mit derselben Größe wie u.
"valid"	Nur die Teile der Faltung, die ohne die mit Nullen aufgefüllten Kanten berechnet werden. Wenn Sie diese Option verwenden, ist length(w) gleich max(length(u)-length(v)+1,0), es sei denn, length(v) ist gleich null. Wenn length(v) = 0, dann length(w) = length(u).

Ausgabeargumente

w — Gefalteter Vektor

Vektor

Gefalteter Vektor, zurückgegeben als Zeilen- oder Spaltenvektor.

Mehr über

Faltung

Die Faltung zweier Vektoren, u und v, stellt den Überlappungsbereich unter den Punkten dar, wenn v durch u gleitet. Algebraisch ist Faltung dieselbe Operation wie die Multiplikation von Polynomen, deren Koeffizienten die Elemente von u und v sind.

Nehmen wir an, dass m = length(u) und n = length(v). Dann ist w der Vektor mit der Länge m+n-1, dessen k. Element

$$w(k)={\displaystyle \sum _{j}u}(j)v(k-j+1).$$

ist.

Die Summe entspricht allen Werten von j, die zu zulässigen Indexzeichen für u(j) und v(k-j+1) führen, insbesondere j = max(1,k+1-n):1:min(k,m). Wenn m = n, ergibt dies

w(1) = u(1)*v(1)
w(2) = u(1)*v(2)+u(2)*v(1)
w(3) = u(1)*v(3)+u(2)*v(2)+u(3)*v(1)
...
w(n) = u(1)*v(n)+u(2)*v(n-1)+ ... +u(n)*v(1)
...
w(2*n-1) = u(n)*v(n)

Mithilfe dieser Definition berechnet conv die direkte Faltung zweier Faktoren statt der FFT-basierten Faltung.

Erweiterte Fähigkeiten

Tall Arrays

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

Die Funktion conv unterstützt Tall-Arrays mit folgenden Verwendungshinweisen und Einschränkungen:

• Die Eingaben u und v müssen Spaltenvektoren sein.

• Wenn shape gleich "full" ist (Standard), kann nur entweder u oder v ein Tall-Array sein.

• Wenn shape gleich "same" oder "valid" ist, kann v kein Tall-Array sein.

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 shape, so verwendet, muss zum Zeitpunkt der Codegenerierung eine Konstante sein.

• Für die Eingabeargumente u und v gilt:

  • Sie müssen zum Zeitpunkt der Codegenerierung den Eingabevektor als Vektor mit fester Größe oder variabler Länge angeben. Entweder die erste oder die zweite Dimension des Vektors können eine variable Größe aufweisen. Alle anderen Dimensionen müssen die feste Größe 1 aufweisen.

• Die Eingabevektoren u und v müssen dieselbe Ausrichtung aufweisen.

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 conv 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 conv 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 conv 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

R2026a: Bei einer vollständigen Faltung ist die Ausgabe ein Zeilenvektor, es sei denn, beide Eingabevektoren sind Spaltenvektoren.

Wenn Sie mithilfe von w = conv(u,v) oder w = conv(u,v,"full") eine vollständige Faltung berechnen, ist die Ausgabe w ein Zeilenvektor, es sei denn, die Eingabevektoren u und v sind beide Spaltenvektoren.

Wenn Sie zum Beispiel einen Zeilenvektor und einen Spaltenvektor falten, ist die Ausgabe ein Zeilenvektor.

u = [1 0 1];
v = [2; 7; 4];
w = conv(u,v)

w =
     2     7     6     7     4

Wenn Sie zwei Spaltenvektoren falten, ist die Ausgabe ein Spaltenvektor.

u = [1; 0; 1];
v = [2; 7; 4];
w = conv(u,v)

w =
     2
     7
     6
     7
     4

Zum Vergleich: Bei der Berechnung einer vollständigen Faltung in früheren Versionen gab die Funktion conv je nach Ausrichtung und Länge von u und v entweder einen Zeilen- oder einen Spaltenvektor zurück.

In früheren Versionen gab conv zum Beispiel die vollständige Faltung eines 1x3-Zeilenvektors und eines 3x1-Spaltenvektors als 5x1-Spaltenvektor zurück.

u = [1 0 1];
v = [2; 7; 4];
w = conv(u,v)

w =
     2
     7
     6
     7
     4

Allerdings gab conv die vollständige Faltung eines 1x3-Zeilenvektors und eines 2x1-Spaltenvektors als 1x4-Zeilenvektor zurück.

u = [1 0 1];
v = [2; 7];
w = conv(u,v)

w =
     2     7     2     7

Die Ausgabe von w = conv(u,v,"same") und w = conv(u,v,"valid") bleibt unverändert und folgt weiterhin der Orientierung des ersten Eingabevektors, u.

Siehe auch

conv2 | convn | deconv | filter | convmtx (Signal Processing Toolbox) | xcorr