Diese Seite wurde mithilfe maschineller Übersetzung übersetzt. Klicken Sie hier, um das englische Original zu sehen.

buffer

Puffern eines Signalvektors in eine Matrix von Datenframes.

alle in Seite reduzieren

Syntax

y = buffer(x,n)
y = buffer(x,n,p)
y = buffer(x,n,p,opt)
[y,z] = buffer(___)
[y,z,opt] = buffer(___)

Beschreibung

y = buffer(x,n) unterteilt ein Signal x der Länge L in nicht überlappende Datensegmente (Frames) der Länge n.

y = buffer(x,n,p) überlappt oder unterlappt aufeinanderfolgende Frames in der Ausgabematrix um p Abtastwerte.

y = buffer(x,n,p,opt) gibt einen Vektor von Abtastwerten an, die x(1) in einem überlappenden Puffer vorausgehen sollen, oder die Anzahl der zu überspringenden Anfangsabtastwerte in einem unterlappenden Puffer.

Beispiel

[y,z] = buffer(___) unterteilt ein Signal x der Länge L in Frames der Länge n und gibt nur die vollständigen Frames in y aus. Der Vektor z enthält die restlichen Abtastwerte. Diese Syntax kann beliebige Kombinationen von Eingabeargumenten aus den vorherigen Syntaxen enthalten.

Beispiel

[y,z,opt] = buffer(___) gibt die letzten p Abtastwerte eines überlappenden Puffers in Ausgabe opt zurück.

Beispiele

alle reduzieren

Live Script öffnen

Erstellen Sie einen Puffer mit 100 Frames, jedes mit 10 Abtastwerten.

data = buffer(1:1000,10);

Betrachten wir die Frames (Spalten) in der Matrix data als die sequenziellen Ausgänge einer Datenerfassungskarte, die ein physikalisches Signal abtastet: data(:,1) ist der erste A/D-Ausgang, der die ersten 11 Signalabtastwerte enthält, data(:,2) ist der zweite Ausgang, der die nächsten 11 Signalabtastwerte enthält, und so weiter.

Sie möchten dieses Signal von der erfassten Framegröße von 11 auf eine Framegröße von 4 mit einer Überlappung von 1 neu puffern. Rufen Sie buffer auf, um jeden nachfolgenden Eingabe-Frame zu bearbeiten, wobei der Parameter opt die Konsistenz der Überlappung von einem Puffer zum nächsten gewährleistet.

Die Pufferparameter festlegen. Geben Sie für y(1) den Wert –5 an. Der Übertragsvektor ist anfänglich leer.

n = 4;
p = 1;
opt = -5;
z = [];

Rufen Sie nun wiederholt buffer auf und übergeben Sie dabei jedes Mal einen neuen Signalframe (eine neue Spalte) von data. Überlaufwerte (die in z zurückgegeben werden) werden übernommen und dem Input beim nachfolgenden Aufruf von buffer vorangestellt.

Für die ersten vier Iterationen zeigen Sie den Eingabeframe [z;x]', die Eingabe- und Ausgabewerte von opt, den Ausgabepuffer y und den Überlauf z an. Die Größe der Ausgabematrix y kann von einer Iteration zur nächsten um eine einzige Spalte variieren. Dies ist typisch für Pufferungsvorgänge mit Überlappung oder Unterlappung.

for i = 1:size(data,2)
    x = data(:,i);
    [y,z,oppt] = buffer([z;x],n,p,opt);
    if i <= 4
        disp("Iteration " + i)
        ifrm = [z;x]'
        opts = [opt oppt]
        y
        z
        disp("-----------")
    end
    opt = oppt;
end
Iteration 1

ifrm = 1×11

    10     1     2     3     4     5     6     7     8     9    10


opts = 1×2

    -5     9


y = 4×3

    -5     3     6
     1     4     7
     2     5     8
     3     6     9


z = 
10

-----------

Iteration 2

ifrm = 1×12

    19    20    11    12    13    14    15    16    17    18    19    20


opts = 1×2

     9    18


y = 4×3

     9    12    15
    10    13    16
    11    14    17
    12    15    18


z = 2×1

    19
    20


-----------

Iteration 3

ifrm = 1×10

    21    22    23    24    25    26    27    28    29    30


opts = 1×2

    18    30


y = 4×4

    18    21    24    27
    19    22    25    28
    20    23    26    29
    21    24    27    30


z =

  0×1 empty double column vector

-----------

Iteration 4

ifrm = 1×11

    40    31    32    33    34    35    36    37    38    39    40


opts = 1×2

    30    39


y = 4×3

    30    33    36
    31    34    37
    32    35    38
    33    36    39


z = 
40

-----------
Live Script öffnen

Erstellen Sie einen Puffer mit 100 Frames, von denen jeder 9 Abtastwerte enthält.

data = buffer(1:900,9);

Nehmen Sie data(:,1) als ersten A/D-Ausgang, der die ersten 11 Signalabtastwerte enthält, data(:,2) als zweiten Ausgang, der die nächsten 11 Signalabtastwerte enthält, und so weiter.

Sie möchten dieses Signal von der erfassten Framegröße von 11 auf eine Framegröße von 4 mit einer Unterlappung von 2 neu puffern. Dazu rufen Sie wiederholt buffer auf, um jeden nachfolgenden Eingabe-Frame zu bearbeiten, wobei Sie den Parameter opt verwenden, um die Konsistenz der Unterlappung von einem Puffer zum nächsten zu gewährleisten.

Die Pufferparameter festlegen. Legen Sie eine neue Framegröße von 4 und eine Unterlappung von –2 fest. Das erste Eingabeelement, x(1), wird übersprungen, indem opt auf 1 gesetzt wird. Der Übertragsvektor ist anfänglich leer.

n = 4;
p = -2;
opt = 1;
z = [];

Rufen Sie nun wiederholt buffer auf und übergeben Sie dabei jedes Mal einen neuen Signalframe (eine neue Spalte) von data. Überlaufwerte (die in z zurückgegeben werden) werden übernommen und dem Input beim nachfolgenden Aufruf von buffer vorangestellt.

Für die ersten drei Iterationen werden der Eingabeframe [z';x]', die Eingabe- und Ausgabewerte von opt, der Ausgabepuffer y und der Überlauf z angezeigt. Die Größe der Ausgabematrix y kann von einer Iteration zur nächsten um eine einzige Spalte variieren. Dies ist typisch für Pufferungsvorgänge mit Überlappung oder Unterlappung.

for i = 1:size(data,2)
   x = data(:,i);
   [y,z,oppt] = buffer([z';x],n,p,opt);
   if i <= 3
       disp("Iteration "+ i)
       ifrm = [z';x]'
       opts = [opt oppt]
       y
       z
       disp("-----------")
   end
   opt = oppt;
end
Iteration 1

ifrm = 1×11

     8     9     1     2     3     4     5     6     7     8     9


opts = 1×2

     1     0


y = 4×1

     2
     3
     4
     5


z = 1×2

     8     9


-----------

Iteration 2

ifrm = 1×9

    10    11    12    13    14    15    16    17    18


opts = 1×2

     0     1


y = 4×2

     8    14
     9    15
    10    16
    11    17


z =

  1×0 empty double row vector

-----------

Iteration 3

ifrm = 1×11

    26    27    19    20    21    22    23    24    25    26    27


opts = 1×2

     1     0


y = 4×1

    20
    21
    22
    23


z = 1×2

    26    27


-----------

Eingabeargumente

alle reduzieren

Eingangssignal, angegeben als Vektor.

Framelänge, angegeben als positive ganzzahlige Skalargröße.

Anzahl der überlappenden oder unterlappenden Abtastwerte, angegeben als ganzzahliger Skalar.

  • Für 0 <lt; p <lt; n (Überlappung) wiederholt buffer die letzten p Abtastwerte jedes Frames am Anfang des folgenden Frames. Wenn beispielsweise x = 1:30 und n = 7 gilt, sieht eine Überlappung von p = 3 folgendermaßen aus.

    Der erste Frame beginnt mit p Nullen (der Standard-Anfangszustand), und die Anzahl der Spalten in y beträgt ceil(L/(n-p)).

  • Für p < 0 (Unterlappung) überspringt buffer p Abtastwerte zwischen aufeinanderfolgenden Frames. Wenn beispielsweise x = 1:30 und n = 7 gilt, sieht ein Puffer mit Unterlappung von p = -3 folgendermaßen aus.

    Die Anzahl der Spalten in y beträgt ceil(L/(n-p)).

Option, angegeben als Vektor oder Ganzzahl.

  • Für 0 < p < n (Überlappung) gibt opt einen Vektor der Länge p an, der vor x(1) im Puffer eingefügt werden soll. Dieser Vektor kann als Anfangsbedingung betrachtet werden, die benötigt wird, wenn es sich bei der aktuellen Pufferungsoperation um eine von mehreren aufeinanderfolgenden Pufferungsoperationen handelt. Um die gewünschte Frame-Überlappung von einem Puffer zum nächsten aufrechtzuerhalten, sollte opt die letzten p Abtastwerte des vorherigen Puffers in der Sequenz enthalten. Siehe Kontinuierliche Pufferung unten.

    Standardmäßig ist opt gleich zeros(p,1) für einen überlappenden Puffer. Setzen Sie opt auf "nodelay", um die Anfangsbedingung zu überspringen und den Puffer sofort mit x(1) zu füllen. In diesem Fall muss L mindestens length(p) lang sein. Wenn beispielsweise x = 1:30 und n = 7 gilt, sieht ein Puffer mit Überlappung von p = 3 folgendermaßen aus.

  • Für p < 0 (Unterlappung) ist opt ein ganzzahliger Wert im Bereich [0,-p], der die Anzahl der anfänglichen Eingangsabtastwerte x(1:opt) angibt, die übersprungen werden sollen, bevor Abtastwerte zum Puffer hinzugefügt werden. Der erste Wert im Puffer ist daher x(opt+1). Standardmäßig ist opt bei einem unterlappenden Puffer null.

    Diese Option ist besonders nützlich, wenn es sich bei dem aktuellen Puffervorgang um einen von mehreren aufeinanderfolgenden Puffervorgängen handelt. Um die gewünschte Frame-Unterlappung von einem Puffer zum nächsten aufrechtzuerhalten, sollte opt der Differenz zwischen der Gesamtzahl der zwischen den Frames zu überspringenden Punkte (p) und der Anzahl der Punkte entsprechen, die im vorherigen Input für buffer zum Überspringen verfügbar waren. Falls die vorherige Eingabe weniger als p Punkte enthielt, die nach dem Füllen des letzten Frames dieses Puffers übersprungen werden konnten, müssen die verbleibenden opt Punkte aus dem ersten Frame des aktuellen Puffers entfernt werden. Siehe Kontinuierliche Pufferung für ein Beispiel, wie dies in der Praxis funktioniert.

Ausgabeargumente

alle reduzieren

Datenframe, zurückgegeben als Matrix. Jeder Datenframe belegt eine Spalte von y, das n Zeilen und ceil(L/n) Spalten hat. Wenn L nicht durch n teilbar ist, wird die letzte Spalte mit Nullen auf die Länge n aufgefüllt.

  • Wenn y ein überlappender Puffer ist, hat er n Zeilen und m Spalten, wobei m = floor(L/(n-p)) wenn length(opt) = p oder m = ceil((L-p)/(n-p)) wenn opt = "nodelay".

  • Wenn y ein unterlappender Puffer ist, hat er n Zeilen und m Spalten, wobei m = floor((L-opt)/(n-p)) + (rem((L-opt),(n-p)) >= n).

Die verbleibenden Abtastwerte werden als Vektor zurückgegeben. Wenn die Anzahl der Abtastwerte im Eingangsvektor (nach den entsprechenden Überlappungs- oder Unterlappungsoperationen) die Anzahl der im Puffer n-by-m verfügbaren Plätze überschreitet, werden die verbleibenden Abtastwerte in x im Vektor z ausgegeben, der bei einem überlappenden Puffer die Länge L - m*(n-p) hat, wenn length(opt) = p oder L - ((m-1)*(n-p)+n), wenn opt = "nodelay", und bei einem unterlappenden Puffer die Länge (L-opt) - m*(n-p).

  • Wenn y ein überlappender Puffer oder ein nicht überlappender Puffer ist, dann hat z die gleiche Ausrichtung (Zeile oder Spalte) wie x.

  • Wenn y ein unterlappender Puffer ist, dann wird z als Zeilenvektor zurückgegeben.

Wenn nach dem Füllen des Puffers mit der angegebenen Unterlappung oder Unterlappung keine weiteren Abtastwerte im Eingabedatensatz vorhanden sind, ist z ein leerer Vektor.

Die letzten p Abtastwerte werden als Vektor zurückgegeben. In einem unterlappenden Puffer ist opt die Differenz zwischen der Gesamtzahl der zwischen den Frames zu überspringenden Punkte (-p) und der Anzahl der Punkte in x, die nach dem Füllen des letzten Frames noch zum Überspringen zur Verfügung standen. In einer Abfolge von Pufferoperationen sollte der opt-Ausgang jeder Operation als opt-Eingang für die nachfolgende Pufferoperation verwendet werden. Dadurch wird sichergestellt, dass die gewünschte Frame-Überlappung oder -Unterlappung sowohl von Puffer zu Puffer als auch von Frame zu Frame innerhalb desselben Puffers erhalten bleibt. Siehe Kontinuierliche Pufferung für ein Beispiel, wie dies in der Praxis funktioniert.

  • Für 0 <lt; p <lt; n (Überlappung) enthält opt (als Ausgabe) die letzten p Abtastwerte im letzten Frame des Puffers. Dieser Vektor kann als Anfangsbedingung für einen nachfolgenden Puffervorgang in einer Sequenz aufeinanderfolgender Puffervorgänge verwendet werden. Dadurch kann die gewünschte Frame-Überlappung von einem Puffer zum nächsten beibehalten werden.

  • Für p < 0 (Unterlappung) ist opt (als Ausgabe) die Differenz zwischen der Gesamtzahl der zwischen den Frames zu überspringenden Punkte (p) und der Anzahl der Punkte in x, die nach dem Füllen des letzten Frames noch zum Überspringen verfügbar waren: opt = m*(n-p) + opt - L. Dabei ist opt rechts das Eingabeargument für buffer und opt links das Ausgabeargument. z ist der leere Vektor. Hierbei ist m die Anzahl der Spalten im Puffer, mit m = floor((L-opt)/(n-p)) + (rem((L-opt),(n-p))>=n).

    Beachten Sie, dass bei einem unterlappenden Pufferausgang opt immer Null ist, wenn der Ausgang z Daten enthält.

    Der opt-Ausgang für einen unterlappenden Puffer ist besonders nützlich, wenn es sich bei der aktuellen Pufferoperation um eine von mehreren aufeinanderfolgenden Pufferoperationen handelt. Der opt-Ausgang jedes Puffervorgangs gibt die Anzahl der Abtastwerte an, die zu Beginn des nächsten Puffervorgangs übersprungen werden müssen, um die gewünschte Frame-Unterlappung von einem Puffer zum nächsten aufrechtzuerhalten. Falls nach dem Füllen des letzten Frames des aktuellen Puffers weniger als p Punkte zum Überspringen zur Verfügung stehen, müssen die verbleibenden opt Punkte aus dem ersten Frame des nächsten Puffers entfernt werden.

Diagnostik

Fehlermeldungen werden angezeigt, wenn p ≥ n oder length(opt) ≠ length(p) in einem Fall überlappender Puffer gilt:

Die Frame-Überlappung P muss kleiner als die Puffergröße N sein.
Anfangsbedingungen müssen als Vektor der Länge P angegeben werden.

Mehr über

alle reduzieren

Erweiterte Fähigkeiten

alle erweitern

Versionsverlauf

Eingeführt vor R2006a

alle erweitern

Siehe auch