buffer

신호 벡터를 데이터 프레임으로 구성된 행렬로 변환

구문

y = buffer(x,n)

y = buffer(x,n,p)

y = buffer(x,n,p,opt)

[y,z] = buffer(___)

[y,z,opt] = buffer(___)

설명

y = buffer(x,n)은 길이가 L인 신호 x를 길이가 n인 겹치지 않는 데이터 세그먼트(프레임)로 분할합니다.

y = buffer(x,n,p)는 연속된 프레임을 p개 샘플만큼 겹치거나(오버랩) 떨어뜨려(언더랩) 출력 행렬에 배치합니다.

y = buffer(x,n,p,opt)는 오버랩 버퍼에서 x(1) 앞에 올 샘플 벡터를 지정하거나, 언더랩 버퍼에서 건너뛸 초기 샘플 개수를 지정합니다.

[y,z] = buffer(___)는 길이가 L인 신호 x를 길이가 n인 프레임으로 분할하고, 전체 프레임만 y로 출력합니다. 벡터 z는 나머지 샘플을 포함합니다. 이 구문은 위에 열거된 구문에 사용할 수 있습니다.

[y,z,opt] = buffer(___)는 오버랩 버퍼의 마지막 p개 샘플을 출력값 opt로 반환합니다.

예제

연속 오버랩 버퍼

각각 10개 샘플을 갖는 100개 프레임을 포함하는 버퍼를 생성합니다.

data = buffer(1:1000,10);

행렬 data의 프레임(열)을 물리 신호를 샘플링하는 데이터 수집 보드의 순차적 출력값이라고 가정하겠습니다. 즉, data(:,1)은 처음 11개 신호 샘플을 포함하는 첫 번째 A/D 출력값이고, data(:,2)는 다음 11개 신호 샘플을 포함하는 두 번째 출력값이 되는 식입니다.

획득한 프레임 크기가 11인 이 신호에 오버랩 값 1을 적용하여 프레임 크기가 4가 되도록 리버퍼링한다고 가정하겠습니다. buffer를 호출하여 연속된 각 입력 프레임에 대해 연산을 하되, opt 파라미터를 사용하여 버퍼 간 오버랩을 일관되게 유지합니다.

버퍼 파라미터를 설정합니다. y(1)의 값을 –5로 지정합니다. 이월 벡터(z)는 처음에는 빈 값으로 설정합니다.

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

이제 buffer를 반복적으로 호출하되, 매번 data의 새로운 신호 프레임(열)을 전달하도록 합니다. 넘치는 샘플(z로 반환됨)은 이월되며, 이 샘플은 이후 buffer 호출 시 입력값 앞쪽에 추가됩니다.

처음 4회 반복에 대해 입력 프레임 [z;x]', opt의 입력값과 출력값, 출력 버퍼 y, 오버플로 z를 표시합니다. 출력 행렬 y의 크기는 반복 간에 한 열씩 달라질 수 있습니다. 이는 오버랩 또는 언더랩을 적용하는 버퍼 연산의 전형적인 특성입니다.

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

-----------

연속 언더랩 버퍼

각각 9개 샘플을 갖는 100개 프레임을 포함하는 버퍼를 생성합니다.

data = buffer(1:900,9);

data(:,1)이 처음 11개 신호 샘플을 포함하는 첫 번째 A/D 출력값이고, data(:,2)가 다음 11개 신호 샘플을 포함하는 두 번째 출력값이 되는 식이라고 가정하겠습니다.

획득한 프레임 크기가 11인 이 신호에 언더랩 값 2를 적용하여 프레임 크기 4가 되도록 리버퍼링한다고 가정하겠습니다. 이를 위해, buffer를 반복적으로 호출하여 연속된 각 입력 프레임에 대해 연산을 하되, opt 파라미터를 사용하여 버퍼 간 언더랩을 일관되게 유지합니다.

버퍼 파라미터를 설정합니다. 새 프레임 크기를 4로, 언더랩을 –2로 지정합니다. opt를 1로 설정하여 첫 번째 입력 요소 x(1)을 건너뜁니다. 이월 벡터(z)는 처음에는 빈 값으로 설정합니다.

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

이제 buffer를 반복적으로 호출하되, 매번 data의 새로운 신호 프레임(열)을 전달하도록 합니다. 넘치는 샘플(z로 반환됨)은 이월되며, 이 샘플은 이후 buffer 호출 시 입력값 앞쪽에 추가됩니다.

처음 3회 반복에 대해 입력 프레임 [z';x]', opt의 입력값과 출력값, 출력 버퍼 y, 오버플로 z를 표시합니다. 출력 행렬 y의 크기는 반복 간에 한 열씩 달라질 수 있습니다. 이는 오버랩 또는 언더랩을 적용하는 버퍼 연산의 전형적인 특성입니다.

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

-----------

입력 인수

x — 입력 신호

벡터

입력 신호로, 벡터로 지정됩니다.

n — 프레임 길이

양의 정수 스칼라

프레임 길이로, 양의 정수 스칼라로 지정됩니다.

p — 오버랩 또는 언더랩 샘플 수

0 (디폴트 값) | 정수 스칼라

오버랩 또는 언더랩 샘플 수로, 정수 스칼라로 지정됩니다.

• 0 < p < n(오버랩)인 경우, buffer는 각 프레임의 마지막 p개 샘플을 다음 프레임의 시작 부분에 반복합니다. 예를 들어, x = 1:30이고 n = 7인 경우 p = 3인 오버랩은 다음과 같습니다.

  첫 번째 프레임은 p개의 0으로 시작하며(디폴트 초기 조건), y의 열 개수는 ceil(L/(n-p))입니다.

• p < 0(언더랩)인 경우 buffer는 연속된 프레임 사이의 p개 샘플을 건너뜁니다. 예를 들어, x = 1:30이고 n = 7인 경우 p = -3인 언더랩의 버퍼는 다음과 같습니다.

  y의 열 개수는 ceil(L/(n-p))입니다.

opt — 옵션

zeros(p,1) (디폴트 값) | "nodelay" | 벡터 | 정수

옵션으로, 벡터 또는 정수로 지정됩니다.

• 0 < p < n(오버랩)인 경우 opt는 버퍼에서 x(1) 앞에 삽입할, 길이가 p인 벡터를 지정합니다. 초기 조건으로 간주할 수 있는 이 벡터는 현재 버퍼 연산이 일련의 연속된 버퍼 연산 중 하나일 때 필요합니다. 버퍼 간의 프레임 오버랩을 유지하려면 opt는 일련의 연속된 버퍼 연산 중 이전 버퍼의 마지막 p개 샘플을 포함해야 합니다. 아래의 연속 버퍼 연산 항목을 참조하십시오.

  기본적으로, opt는 오버랩 버퍼의 경우 zeros(p,1)입니다. 초기 조건을 주지 않고 바로 x(1)로 버퍼를 채우려면 opt를 "nodelay"로 설정하십시오. 이 경우 L의 길이는 length(p) 이상이어야 합니다. 예를 들어, x = 1:30이고 n = 7인 경우 p = 3인 오버랩의 버퍼는 다음과 같습니다.

• p < 0(언더랩)인 경우 opt는 범위 [0,-p] 내에 있는 정수 값으로, 샘플을 버퍼에 추가하기 전에 건너뛸 초기 입력 샘플 개수(x(1:opt))를 지정합니다. 따라서 버퍼의 첫 번째 값은 x(opt+1)이 됩니다. 기본적으로, opt는 언더랩 버퍼의 경우 0입니다.

  이 옵션은 현재 버퍼 연산이 일련의 연속된 버퍼 연산 중 하나일 때 특히 유용합니다. 버퍼 간의 프레임 언더랩을 유지하려면 opt는 프레임 간에 건너뛸 총 점 개수(p)에서, buffer에 대한 이전 입력값에서 건너뛸 수 있었던 점 개수를 뺀 값과 동일해야 합니다. 이전 입력값에서 해당 버퍼의 마지막 프레임을 채운 후 건너뛸 수 있는 점 개수가 p개보다 적었다면, 남아 있는 opt개 점을 현재 버퍼의 첫 번째 프레임에서 제거해야 합니다. 이에 관한 실제 예를 보려면 연속 버퍼 연산 항목을 참조하십시오.

출력 인수

y — 데이터 프레임

행렬

데이터 프레임으로, 행렬로 반환됩니다. 각 데이터 프레임은 n개 행과 ceil(L/n)개 열을 갖는 y에서 하나의 열을 차지합니다. L이 n으로 온전히 나누어지지 않으면, 길이가 n이 될 때까지 마지막 열이 0으로 채워집니다.

• y가 오버랩 버퍼인 경우 행 개수는 n, 열 개수는 m입니다. 여기서 length(opt) = p이면 m = floor(L/(n-p))이 됩니다. 또는 opt = "nodelay"이면 m = ceil((L-p)/(n-p))가 됩니다.

• y가 언더랩 버퍼인 경우 행 개수는 n, 열 개수는 m입니다. 여기서 m = floor((L-opt)/(n-p)) + (rem((L-opt),(n-p)) >= n)입니다.

z — 나머지 샘플

벡터

나머지 샘플로, 벡터로 반환됩니다. (알맞은 오버랩 또는 언더랩 연산 후에) 입력 벡터의 샘플 개수가 n×m 버퍼에서 사용 가능한 자리 개수를 초과하면, x에 남아 있는 샘플 개수가 벡터 z의 출력값이 됩니다. 이 벡터의 길이는 오버랩 버퍼의 경우 length(opt) = p이면 L - m*(n-p)가 됩니다. 또는 opt = "nodelay"이면 L - ((m-1)*(n-p)+n)이 됩니다. 언더랩 버퍼의 경우 벡터의 길이는 (L-opt) - m*(n-p)입니다.

• y가 오버랩 버퍼이거나 겹치지 않는 버퍼이면 z는 x와 방향(행 또는 열)이 동일합니다.

• y가 언더랩 버퍼이면 z는 행 벡터로 반환됩니다.

지정된 오버랩 또는 언더랩의 버퍼를 채운 후 입력값에 남아 있는 샘플이 없는 경우 z는 빈 벡터가 됩니다.

opt — 마지막 p개 샘플

벡터

마지막 p개 샘플로, 벡터로 반환됩니다. 언더랩 버퍼에서 opt는 프레임 간에 건너뛸 총 점 개수(-p)에서 마지막 프레임을 채운 후 건너뛸 수 있었던 x의 점 개수를 뺀 값입니다. 일련의 버퍼 연산에서, 각 연산의 opt 출력값은 후속 버퍼 연산에 대한 opt 입력값으로 사용해야 합니다. 이를 통해 동일한 버퍼 내의 프레임 간에서 뿐만 아니라 버퍼 간에도 원하는 프레임 오버랩이나 언더랩을 유지할 수 있습니다. 이에 관한 실제 예를 보려면 연속 버퍼 연산 항목을 참조하십시오.

• 0 < p < n(오버랩)인 경우 opt(출력값)에는 버퍼의 마지막 프레임에 있는 마지막 p개 샘플이 포함됩니다. 이 벡터는 일련의 연속된 버퍼 연산 중에서 후속 버퍼 연산에 대한 초기 조건으로 사용할 수 있습니다. 이를 통해 버퍼 간에 프레임 오버랩을 원하는 정도로 유지할 수 있습니다.

• p < 0(언더랩)인 경우 opt(출력값)는 프레임 간에 건너뛸 총 점 개수(p)에서 마지막 프레임을 채운 후 건너뛸 수 있었던 x의 점 개수를 뺀 값입니다. opt = m*(n-p) + opt - L에서 우변의 opt는 buffer에 대한 입력 인수이고, 좌변의 opt는 출력 인수입니다. z는 빈 벡터입니다. 여기서 m은 버퍼의 열 개수로, m = floor((L-opt)/(n-p)) + (rem((L-opt),(n-p))>=n)입니다.

  참고로, 언더랩 버퍼인 경우 출력값 z에 데이터가 포함되어 있으면 출력값 opt는 항상 0입니다.

  언더랩 버퍼에서 opt 출력값은 현재 버퍼 연산이 일련의 연속 버퍼 연산 중 하나일 때 특히 유용합니다. 각 버퍼 연산의 opt 출력값이 다음 버퍼 연산을 시작할 때 건너뛰어야 하는 샘플 개수를 지정하기 때문에 이를 통해 버퍼 간 프레임 언더랩을 유지할 수 있습니다. 현재 버퍼의 마지막 프레임을 채운 후 건너뛸 수 있는 점 개수가 p개보다 적으면, 다음 버퍼의 첫 번째 프레임에서 남아 있는 opt개 점을 제거해야 합니다.

진단

오버랩 버퍼의 경우 p ≥n 또는 length(opt)≠length(p)이면 다음과 같은 오류 메시지가 나타납니다.

Frame overlap P must be less than the buffer size N.
Initial conditions must be specified as a length-P vector.

세부 정보

연속 버퍼 연산

연속 버퍼 연산에서 buffer 함수에 대한 벡터 입력값은 이산 신호를 구성하는 일련의 프레임 중 한 프레임을 나타냅니다. 이러한 신호 프레임은 프레임 기반의 데이터 수집 과정, 혹은 FFT 같은 프레임 기반 알고리즘에서 발생할 수 있습니다.

예를 들어, A/D 카드에서 데이터를 64개 샘플로 구성된 프레임으로 수집한다고 가정하겠습니다. 가장 간단한 경우, 데이터를 16개 샘플로 구성된 프레임으로 리버퍼링할 수 있습니다. buffer에 n = 16을 적용하면, 64개 요소를 가진 각 입력 프레임으로부터 4개 프레임으로 구성된 버퍼가 생성됩니다. 결과적으로, 프레임 크기가 64인 신호가 프레임 크기가 16인 신호로 변환되었으며 아무런 샘플도 추가되거나 제거되지 않았습니다.

원래 신호 프레임 크기 L이 새 프레임 크기 n으로 온전히 나눠지지 않는 일반적인 경우에는, 마지막 프레임에서 넘치는 샘플을 포착해 다음 버퍼에 재사용해야 합니다. 이렇게 하려면 출력 인수 2개로 구성된 구문을 사용하여 입력값 x에 대해 buffer를 반복적으로 호출하면 됩니다.

[y,z] = buffer([z;x],n)     % x is a column vector.
[y,z] = buffer([z,x],n)     % x is a row vector.

그러면 z에서 넘친 버퍼가 포착되고, 이후 buffer 호출 시 후속 입력값 앞쪽에 이 데이터가 추가됩니다. 여기서도, 프레임 크기가 L인 입력 신호 x는 샘플 삽입이나 삭제 없이 샘플 크기 n의 신호로 변환되었습니다.

참고로, 단일 출력 구문 y = buffer(...)로는 연속 버퍼 연산을 수행할 수 없습니다. 이 경우 y의 마지막 프레임이 0으로 채워지고 그로 인해 신호에 새 샘플이 추가되기 때문입니다.

오버랩 및 언더랩이 존재하는 연속 버퍼 연산은 opt 파라미터로 처리되며, 이 파라미터는 buffer에 대한 입력값 겸 출력값으로 사용됩니다. 이 페이지의 두 예제에서는 opt 파라미터가 사용되는 방식을 보여줍니다.

확장 기능

C/C++ 코드 생성

MATLAB® Coder™를 사용하여 C 코드나 C++ 코드를 생성할 수 있습니다.

사용법 관련 참고 및 제한 사항:

• 컴파일할 때 입력값 p는 상수여야 합니다.

GPU 배열

Parallel Computing Toolbox™를 사용해 GPU(그래픽스 처리 장치)에서 실행하여 코드 실행 속도를 높일 수 있습니다.

이 함수는 GPU 배열을 완전히 지원합니다. 자세한 내용은 GPU에서 MATLAB 함수 실행하기 (Parallel Computing Toolbox) 항목을 참조하십시오.

버전 내역

R2006a 이전에 개발됨

R2023b: 비double형 입력 인수를 사용함

buffer 함수는 비double형 입력 인수를 지원합니다.

R2023a: C 및 C++ 코드 생성

buffer 함수에 대한 C 및 C++ 코드를 생성합니다. 이 기능을 사용하려면 MATLAB^® Coder™가 있어야 합니다.

참고 항목

reshape