31 Обработка сигналов

В этой главе описаны функции обработки сигналов и быстрого преобразования Фурье, доступные в Octave. Быстрое преобразование Фурье вычисляется с помощью библиотек FFTW или FFTPACK в зависимости от способа сборки Octave.

: y = fft (x)

: y = fft (x, n)

: y = fft (x, n, dim)

Вычисляет дискретное преобразование Фурье x с помощью алгоритма быстрого преобразования Фурье (БПФ).

БПФ вычисляется вдоль первого измерения массива, размер которого не равен единице. Поэтому, если x — матрица, fft (x) вычисляет БПФ для каждого столбца x.

При вызове с двумя аргументами n должно быть целым числом, задающим количество элементов x, которые следует использовать, или пустой матрицей, указывающей, что это значение нужно игнорировать. Если n больше размера измерения, вдоль которого вычисляется БПФ, размер x изменяется, а массив дополняется нулями. Если же n меньше размера этого измерения, x усекается.

При вызове с тремя аргументами dim — целое число, задающее измерение матрицы, вдоль которого выполняется БПФ.

См. также: ifft, fft2, fftn, fftw.

: x = ifft (y)

: x = ifft (y, n)

: x = ifft (y, n, dim)

Вычисляет обратное дискретное преобразование Фурье y с помощью алгоритма быстрого преобразования Фурье (БПФ).

Обратное БПФ вычисляется вдоль первого измерения массива, размер которого не равен единице. Поэтому, если y — матрица, ifft (y) вычисляет обратное БПФ для каждого столбца y.

При вызове с двумя аргументами n должно быть целым числом, задающим количество элементов y, которые следует использовать, или пустой матрицей, указывающей, что это значение нужно игнорировать. Если n больше размера измерения, вдоль которого вычисляется обратное БПФ, размер y изменяется, а массив дополняется нулями. Если же n меньше размера этого измерения, y усекается.

При вызове с тремя аргументами dim — целое число, задающее измерение матрицы, вдоль которого выполняется обратное БПФ.

См. также: fft, ifft2, ifftn, fftw.

: B = fft2 (A)

: B = fft2 (A, m, n)

Вычисляет двумерное дискретное преобразование Фурье A с помощью алгоритма быстрого преобразования Фурье (БПФ).

Необязательные аргументы m и n позволяют задать количество используемых строк и столбцов A. Если любое из этих значений больше соответствующего размера A, размер A изменяется, а массив дополняется нулями.

Если A — многомерная матрица, каждая двумерная подматрица A обрабатывается отдельно.

См. также: ifft2, fft, fftn, fftw.

: A = ifft2 (B)

: A = ifft2 (B, m, n)

Вычисляет обратное двумерное дискретное преобразование Фурье B с помощью алгоритма быстрого преобразования Фурье (БПФ).

Необязательные аргументы m и n позволяют задать количество используемых строк и столбцов B. Если любое из этих значений больше соответствующего размера B, размер B изменяется, а массив дополняется нулями.

Если B — многомерная матрица, каждая двумерная подматрица B обрабатывается отдельно.

См. также: fft2, ifft, ifftn, fftw.

: B = fftn (A)

: B = fftn (A, size)

Вычисляет N-мерное дискретное преобразование Фурье A с помощью алгоритма быстрого преобразования Фурье (БПФ).

Необязательный векторный аргумент size позволяет задать размеры используемого массива. Если элемент size меньше соответствующего размера A, это измерение A усекается до выполнения БПФ. Если же элемент size больше соответствующего размера, размер A изменяется, а массив дополняется нулями.

См. также: ifftn, fft, fft2, fftw.

: A = ifftn (B)

: A = ifftn (B, size)

Вычисляет обратное N-мерное дискретное преобразование Фурье B с помощью алгоритма быстрого преобразования Фурье (БПФ).

Необязательный векторный аргумент size позволяет задать размеры используемого массива. Если элемент size меньше соответствующего размера B, это измерение B усекается до выполнения обратного БПФ. Если же элемент size больше соответствующего размера, размер B изменяется, а массив дополняется нулями.

См. также: fftn, ifft, ifft2, fftw.

Octave использует библиотеки FFTW для вычисления БПФ. При запуске Octave и инициализации библиотек FFTW они считывают общесистемный файл (в Unix-системах обычно /etc/fftw/wisdom), содержащий сведения, позволяющие ускорить вычисления БПФ. Эти сведения называются планами. Общесистемный файл позволяет совместно использовать планы во всех приложениях, работающих с библиотеками FFTW.

Для создания и сохранения планов используйте функцию fftw. С помощью утилит, предоставляемых вместе с библиотеками FFTW (fftw-wisdom в Unix-системах), можно даже добавить созданные Octave планы в общесистемный файл планов.

: method = fftw ("planner")

: fftw ("planner", method)

: wisdom = fftw ("dwisdom")

: fftw ("dwisdom", wisdom)

: nthreads = fftw ("threads")

: fftw ("threads", nthreads)

Управляет данными планов FFTW.

Данные планов позволяют значительно ускорить вычисление БПФ, но требуют первоначальных затрат на их создание. При инициализации библиотеки FFTW считывают общесистемный файл планов (обычно /etc/fftw/wisdom), что позволяет совместно использовать планы и с другими приложениями, помимо Octave. Кроме того, для импорта планов можно использовать функцию fftw. Например,

wisdom = fftw ("dwisdom")

сохраняет существующие планы, используемые Octave, в строку wisdom. Эту строку можно сохранить в файл, а затем восстановить с помощью команд save и load соответственно. Существующие планы можно повторно импортировать следующим образом:

fftw ("dwisdom", wisdom)

Если wisdom — пустая строка, используемые планы очищаются.

При вычислении преобразований Фурье создаются дополнительные планы. Способ их создания также задается функцией fftw. Доступны пять режимов работы с планами:

"estimate"

Указывает, что во время выполнения не измеряется оптимальный способ вычисления конкретного преобразования, а для выбора плана используется простая эвристика (вероятно, не оптимальная). Преимущество этого метода — небольшие или отсутствующие затраты на создание плана, что удобно для преобразования Фурье, которое будет вычислено один раз.

"measure"

В этом режиме рассматривается несколько алгоритмов преобразования, и лучший из них выбирается по времени выполнения.

"patient"

Подобен режиму "measure", но рассматривает больше алгоритмов.

"exhaustive"

Как и в режиме "measure", рассматриваются все возможные алгоритмы обработки преобразования.

"hybrid"

Поскольку измерение времени выполнения алгоритма может быть затратным, этот режим представляет собой компромисс: для преобразований размером до 8192 используется "measure", а для больших преобразований — метод "estimate".

По умолчанию используется метод "estimate". Текущий метод можно запросить командой

method = fftw ("planner")

или задать с помощью команды

fftw ("planner", method)

Обратите внимание: при перезапуске Octave созданные планы будут потеряны. Однако данные планов можно загрузить повторно, если предварительно сохранить их в файл, как описано выше. Сохраненные файлы планов не следует использовать на других платформах: они будут неэффективны, и цель вычисления планов будет утрачена.

Количество потоков, используемых для вычисления планов и выполнения преобразований, можно задать командой

fftw ("threads", NTHREADS)

Обратите внимание: для этой возможности Octave должна быть собрана с поддержкой многопоточности FFTW. По умолчанию используется меньшее из двух значений: количество (логических) процессоров, доступных текущему процессу, и 3.

См. также: fft, ifft, fft2, ifft2, fftn, ifftn.

: c = fftconv (x, y)

: c = fftconv (x, y, n)

Вычисляет свертку двух векторов с помощью БПФ.

c = fftconv (x, y) возвращает вектор длины, равной length (x) + length (y) - 1. Если x и y — векторы коэффициентов двух многочленов, возвращаемое значение является вектором коэффициентов произведения этих многочленов.

Вычисление выполняется с помощью БПФ посредством вызова функции fftfilt. Если задан необязательный аргумент n, используется БПФ длины N.

См. также: deconv, conv, conv2.

: y = fftfilt (b, x)

: y = fftfilt (b, x, n)

Фильтрует x с помощью КИХ-фильтра b, используя БПФ.

Если x — матрица, фильтруется каждый ее столбец.

Если задан необязательный третий аргумент n, fftfilt фильтрует x с помощью b методом перекрытия с накоплением, используя БПФ длины N. Размер БПФ должен быть степенью двойки и не меньше длины b. Если указанное значение n не соответствует этим условиям, оно автоматически заменяется ближайшим подходящим значением.

См. также: filter, filter2.

: y = filter (b, a, x)

: [y, sf] = filter (b, a, x, si)

: [y, sf] = filter (b, a, x, [], dim)

: [y, sf] = filter (b, a, x, si, dim)

Применяет к данным x одномерный цифровой фильтр.

filter возвращает решение следующего линейного уравнения в конечных разностях с постоянными коэффициентами:

N                   M
SUM a(k+1) y(n-k) = SUM b(k+1) x(n-k)    for 1<=n<=length(x)
k=0                 k=0

где N=length(a)-1 и M=length(b)-1. Результат вычисляется вдоль первого измерения x, размер которого не равен единице, или вдоль dim, если он задан.

Эквивалентная форма уравнения:

N                   M
y(n) = - SUM c(k+1) y(n-k) + SUM d(k+1) x(n-k)  for 1<=n<=length(x)
         k=1                 k=0

где c = a/a(1) и d = b/a(1).

Если задан четвертый аргумент si, он используется как начальное состояние системы, а конечное состояние возвращается в sf. Вектор состояния является столбцом, длина которого равна длине наиболее длинного вектора коэффициентов минус один. Если si не задан, начальный вектор состояния состоит из нулей.

В терминах Z-преобразования y является результатом прохождения дискретного сигнала x через систему, описываемую следующей рациональной передаточной функцией:

M
         SUM d(k+1) z^(-k)
         k=0
H(z) = ---------------------
            N
       1 + SUM c(k+1) z^(-k)
           k=1

См. также: filter2, fftfilt, freqz.

: y = filter2 (b, x)

: y = filter2 (b, x, shape)

Применяет к x двумерный КИХ-фильтр b.

Если задан аргумент shape, возвращается массив указанной формы. Возможны следующие значения:

"full"

Перед фильтрацией дополняет x нулями со всех сторон.

"same"

x без дополнения (значение по умолчанию)

"valid"

После фильтрации усекает x, чтобы исключить краевые эффекты.

Обратите внимание: это лишь вариант свертки с переставленными параметрами и поворотом b на 180 градусов.

См. также: conv2.

: [h, w] = freqz (b, a, n, "whole")

: [h, w] = freqz (b)

: [h, w] = freqz (b, a)

: [h, w] = freqz (b, a, n)

: h = freqz (b, a, w)

: [h, w] = freqz (…, Fs)

: freqz (…)

Возвращает комплексную частотную характеристику h рационального фильтра с бесконечной импульсной характеристикой (БИХ), коэффициенты числителя и знаменателя которого равны b и a соответственно.

Характеристика вычисляется для n угловых частот в диапазоне от 0 до 2*pi.

Выходное значение w — вектор частот.

Если a не задан, знаменатель считается равным 1 (это соответствует простому КИХ-фильтру).

Если n не задан, используется значение 512. Для максимальной скорости вычислений n должно раскладываться на небольшое количество малых простых множителей.

Если не задан четвертый аргумент, "whole", характеристика вычисляется для частот от 0 до pi.

freqz (b, a, w)

Вычисляет характеристику для заданных частот из вектора w. Значения w задаются в радианах.

[…] = freqz (…, Fs)

Возвращает частоты в герцах, а не в радианах, при частоте дискретизации Fs. Если характеристика вычисляется для заданных частот w, их следует задавать в герцах, а не в радианах.

freqz (…)

Строит графики амплитудной и фазовой характеристик h, а не возвращает их.

См. также: freqz_plot.

: freqz_plot (w, h)

: freqz_plot (w, h, freq_norm)

Строит графики амплитудной и фазовой характеристик h.

Если необязательный аргумент freq_norm равен true, вектор частот w задается в нормированных радианах. Если freq_norm равен false или не задан, w измеряется в герцах.

См. также: freqz.

: y = sinc (x)

Вычисляет функцию sinc.

Возвращает sin (pi*x) / (pi*x).

: b = unwrap (x)

: b = unwrap (x, tol)

: b = unwrap (x, tol, dim)

Устраняет скачки фаз в радианах, добавляя или вычитая кратные 2*pi значения, чтобы убрать скачки, превышающие tol.

По умолчанию tol равен pi.

unwrap выполняет обработку вдоль измерения dim. Если dim не задан, используется первое измерение, размер которого не равен единице.

unwrap игнорирует все входные значения, не являющиеся конечными (Inf, NaN, NA).

: [a, b] = arch_fit (y, x, p, iter, gamma, a0, b0)

Подбирает регрессионную модель ARCH для временного ряда y, используя алгоритм оценивания из оригинальной работы Энгла об ARCH.

Модель имеет вид

y(t) = b(1) * x(t,1) + ... + b(k) * x(t,k) + e(t),
h(t) = a(1) + a(2) * e(t-1)^2 + ... + a(p+1) * e(t-p)^2

где e(t) имеет распределение N(0, h(t)) при заданных векторе временного ряда y до момента времени t-1 и матрице обычных регрессоров x до момента t. Порядок регрессии остаточной дисперсии задается параметром p.

Если вызвать функцию как arch_fit (y, k, p) с положительным целым числом k, будет подобран процесс ARCH(k, p), то есть указанное выше действие выполняется, причем t-я строка x задается следующим образом:

[1, y(t-1), ..., y(t-k)]

Необязательно можно задать количество итераций iter, коэффициент обновления gamma и начальные значения a0 и b0 для алгоритма оценивания.

: y = arch_rnd (a, b, t)

Моделирует последовательность ARCH длины t с коэффициентами AR b и коэффициентами CH a.

Результат y(t) описывается моделью

y(t) = b(1) + b(2) * y(t-1) + ... + b(lb) * y(t-lb+1) + e(t),

где e(t) при заданном y до момента времени t-1 имеет распределение N(0, h(t)), причем

h(t) = a(1) + a(2) * e(t-1)^2 + ... + a(la) * e(t-la+1)^2

: [pval, lm] = arch_test (y, x, p)

Для линейной регрессионной модели

y = x * b + e

выполняет тест множителей Лагранжа (LM) для проверки нулевой гипотезы об отсутствии условной гетероскедастичности против альтернативной гипотезы CH(p).

То есть модель имеет вид

y(t) = b(1) * x(t,1) + ... + b(k) * x(t,k) + e(t),

при заданных y до момента t-1 и x до момента t; e(t) имеет распределение N(0, h(t)), причем

h(t) = v + a(1) * e(t-1)^2 + ... + a(p) * e(t-p)^2,

а нулевая гипотеза имеет вид a(1) == … == a(p) == 0.

Если второй аргумент — целое скалярное значение k, выполняется тот же тест для линейной авторегрессионной модели порядка k, то есть с

[1, y(t-1), ..., y(t-k)]

в качестве t-й строки x.

При нулевой гипотезе статистика LM приближенно имеет распределение хи-квадрат с p степенями свободы, а pval — это значение p (1 минус функция распределения для этого распределения в точке LM) для данного теста.

Если выходной аргумент не задан, выводится значение p.

: x = arma_rnd (a, b, v, t, n)

Возвращает результат моделирования модели ARMA.

Модель ARMA задается выражением

x(n) = a(1) * x(n-1) + ... + a(k) * x(n-k)
     + e(n) + b(1) * e(n-1) + ... + b(l) * e(n-l)

где k — длина вектора a, l — длина вектора b, а e — гауссовский белый шум с дисперсией v. Функция возвращает вектор длины t.

Необязательный параметр n задает количество фиктивных значений x(i), используемых для инициализации: генерируется последовательность длины t+n, а возвращается x(n+1:t+n). Если n не задан, используется значение n = 100.

: x = autoreg_matrix (y, k)

Для временного ряда (вектора) y возвращает матрицу, в первом столбце которой находятся единицы, а в остальных — первые k запаздывающих значений y.

Иными словами, при t > k [1, y(t-1), …, y(t-k)] является t-й строкой результата.

Полученную матрицу можно использовать как матрицу регрессоров в авторегрессионных моделях.

: c = bartlett (m)

Возвращает коэффициенты фильтра для окна Бартлетта (треугольного окна) длины m.

Определение окна Бартлетта см., например, в книге А. В. Оппенгейма и Р. У. Шафера Обработка дискретных сигналов.

: c = blackman (m)

: c = blackman (m, "periodic")

: c = blackman (m, "symmetric")

Возвращает коэффициенты фильтра для окна Блэкмана длины m.

Если задан необязательный аргумент "periodic", возвращается периодическая форма окна. Это эквивалентно окну длины m+1 с удалённым последним коэффициентом. Необязательный аргумент "symmetric" эквивалентен отсутствию второго аргумента.

Определение окна Блэкмана см., например, в книге A.V. Oppenheim & R. W. Schafer, Цифровая обработка сигналов во времени.

: y = detrend (x, p)

Если x — вектор, detrend (x, p) удаляет из данных x наилучшее приближение полиномом порядка p.

Если x — матрица, detrend (x, p) выполняет то же самое для каждого столбца x.

Второй аргумент p является необязательным. Если он не задан, предполагается значение 1. Это соответствует удалению линейного тренда.

Порядок полинома также можно задать строкой; в этом случае p должен быть равен "constant" (соответствует p=0) или "linear" (соответствует p=1).

См. также: polyfit.

: [d, dd] = diffpara (x, a, b)

Возвращает оценку d параметра дифференцирования интегрированного временного ряда.

Для оценки используются частоты из диапазона [2*pi*a/t, 2*pi*b/T]. Если b не задан, используется интервал [2*pi/T, 2*pi*a/T]. Если не заданы ни b, ни a, используются значения a = 0.5 * sqrt (T) и b = 1.5 * sqrt (T), где T — размер выборки. Если x — матрица, параметр дифференцирования оценивается для каждого столбца.

В dd возвращаются оценки для всех частот в описанных выше интервалах.

Значение d представляет собой среднее значение dd.

Источник: P.J. Brockwell & R.A. Davis. Временные ряды: теория и методы. Springer, 1987.

: [newphi, newv] = durbinlevinson (c, oldphi, oldv)

Выполняет один шаг алгоритма Дурбина — Левинсона.

Вектор c задаёт автоковариации [gamma_0, …, gamma_t] от лага 0 до t; oldphi задаёт коэффициенты, рассчитанные на основе c(t-1), а oldv задаёт соответствующую ошибку.

Если oldphi и oldv не заданы, выполняются все шаги алгоритма от 1 до t.

: y = fftshift (x)

: y = fftshift (x, dim)

Выполняет сдвиг вектора x, используемого с функциями fft и ifft, чтобы переместить частоту 0 в центр вектора или матрицы.

Если x — вектор из N элементов, соответствующих N отсчётам времени с интервалом dt, то fftshift (fft (x)) соответствует частотам

f = [ -(ceil((N-1)/2):-1:1), 0, (1:floor((N-1)/2)) ] * df

где df = 1 / (N * dt).

Если x — матрица, то то же самое относится к строкам и столбцам. Если x — массив, то то же самое выполняется вдоль каждого измерения.

Необязательный аргумент dim позволяет ограничить измерение, вдоль которого выполняется перестановка.

См. также: ifftshift.

: x = ifftshift (y)

: x = ifftshift (y, dim)

Отменяет действие функции fftshift.

Для x чётной длины fftshift является обратной самой себе, но для нечётной длины результат немного отличается.

См. также: fftshift.

: fd = fractdiff (x, d)

Вычисляет дробные разности (1-L)^d x, где L обозначает оператор лага, а d больше -1.

: c = hamming (m)

: c = hamming (m, "periodic")

: c = hamming (m, "symmetric")

Возвращает коэффициенты фильтра для окна Хэмминга длины m.

Если задан необязательный аргумент "periodic", возвращается периодическая форма окна. Это эквивалентно окну длины m+1 с удалённым последним коэффициентом. Необязательный аргумент "symmetric" эквивалентен отсутствию второго аргумента.

Определение окна Хэмминга см., например, в книге A.V. Oppenheim & R. W. Schafer, Цифровая обработка сигналов во времени.

: c = hanning (m)

: c = hanning (m, "periodic")

: c = hanning (m, "symmetric")

Возвращает коэффициенты фильтра для окна Ханна длины m.

Если задан необязательный аргумент "periodic", возвращается периодическая форма окна. Это эквивалентно окну длины m+1 с удалённым последним коэффициентом. Необязательный аргумент "symmetric" эквивалентен отсутствию второго аргумента.

Определение окна Ханна см., например, в книге A.V. Oppenheim & R. W. Schafer, Цифровая обработка сигналов во времени.

: H = hurst (x)

Оценивает параметр Хёрста выборки x с помощью статистики нормированного размаха.

Если x — матрица, параметр оценивается для каждого столбца.

: pp = pchip (x, y)

: yi = pchip (x, y, xi)

Возвращает кусочно-кубический интерполяционный полином Эрмита (pchip) для точек x и y.

При вызове с двумя аргументами возвращает кусочно-полиномиальное представление pp, которое можно использовать с ppval для вычисления значений полинома в заданных точках.

При вызове с третьим входным аргументом pchip вычисляет полином pchip в точках xi. Третья форма вызова эквивалентна ppval (pchip (x, y), xi).

Переменная x должна быть строго монотонным вектором (возрастающим или убывающим) длины n.

y может быть вектором или массивом. Если y — вектор, его длина должна совпадать с длиной n вектора x. Если y — массив, его размерность должна иметь вид [s1, s2, …, sk, n] Массив внутри преобразуется в матрицу, в которой ведущая размерность задаётся s1 * s2 * … * sk, а каждая строка этой матрицы затем обрабатывается отдельно. Обратите внимание, что это прямо противоположно interp1, но сделано для совместимости с MATLAB.

См. также: spline, ppval, mkpp, unmkpp.

: [Pxx, w] = periodogram (x)

: [Pxx, w] = periodogram (x, win)

: [Pxx, w] = periodogram (x, win, nfft)

: [Pxx, f] = periodogram (x, win, nfft, Fs)

: [Pxx, f] = periodogram (…, "range")

: periodogram (…)

Возвращает периодограмму (плотность спектральной мощности) x.

Возможные входные данные:

x

вектор данных. Если x содержит действительные значения, оценивается односторонний спектр. Если x содержит комплексные значения или "range" задаёт "twosided", оценивается полный спектр.

win

данные весовой функции окна. Если окно пустое или не задано, используется прямоугольное окно по умолчанию. В противном случае окно применяется к сигналу (x .* win) перед вычислением периодограммы. Данные окна должны быть вектором той же длины, что и x.

nfft

число частотных отсчётов. По умолчанию используется значение 256 или ближайшая большая степень 2, превышающая длину x (max (256, 2.^nextpow2 (length (x)))). Если nfft больше длины входных данных, x дополняется нулями до длины nfft.

Fs

частота дискретизации. По умолчанию равна 1.

range

диапазон спектра. "onesided" вычисляет спектр в диапазоне [0:nfft/2+1]. "twosided" вычисляет спектр в диапазоне [0:nfft-1].

Необязательный второй выходной аргумент w содержит нормированные угловые частоты. При одностороннем вычислении w находится в диапазоне [0, pi], если nfft чётно, и [0, pi), если nfft нечётно. Аналогично, при двустороннем вычислении w находится в диапазоне [0, 2*pi] или [0, 2*pi) в зависимости от nfft.

Если задана частота дискретизации Fs, выходные частоты f будут находиться в диапазоне [0, Fs/2] или [0, Fs/2) при односторонних вычислениях. При двусторонних вычислениях диапазон будет [0, Fs).

Если функция вызвана без выходных аргументов, периодограмма сразу отображается в текущем окне рисунка.

См. также: fft.

: y = sinetone (freq, rate, sec, ampl)

Возвращает синусоидальный сигнал частоты freq длительностью sec секунд, с частотой дискретизации rate и амплитудой ampl.

Аргументы freq и ampl могут быть векторами одинакового размера.

Значения по умолчанию: rate = 8000, sec = 1 и ampl = 64.

См. также: sinewave.

: y = sinewave (m, n, d)

Возвращает вектор из m элементов, у которого i-й элемент задан выражением sin (2 * pi * (i+d-1) / n).

По умолчанию значение d равно 0, а значение n равно m.

См. также: sinetone.

: sde = spectral_adf (c)

: sde = spectral_adf (c, win)

: sde = spectral_adf (c, win, b)

Возвращает оценку спектральной плотности по вектору автоковариаций c, имени окна win и полосе пропускания b.

Имя окна, например "triangle" или "rectangle", используется для поиска функции с именем win_lw.

Если win не задано, используется треугольное окно.

Если b не задано, используется 1 / sqrt (length (x)).

См. также: spectral_xdf.

: sde = spectral_xdf (x)

: sde = spectral_xdf (x, win)

: sde = spectral_xdf (x, win, b)

Возвращает оценку спектральной плотности по вектору данных x, имени окна win и полосе пропускания b.

Имя окна, например "triangle" или "rectangle", используется для поиска функции с именем win_sw.

Если win не задано, используется треугольное окно.

Если b не задано, используется 1 / sqrt (length (x)).

См. также: spectral_adf.

: savg = spencer (x)

Возвращает 15-точечное скользящее среднее Спенсера для каждого столбца x.

: y = stft (x)

: y = stft (x, win_size)

: y = stft (x, win_size, inc)

: y = stft (x, win_size, inc, num_coef)

: y = stft (x, win_size, inc, num_coef, win_type)

: [y, c] = stft (…)

Вычисляет кратковременное преобразование Фурье вектора x с num_coef коэффициентами, применяя окно из win_size точек данных и шаг в inc точек.

Перед вычислением преобразования Фурье применяется одно из следующих окон:

"hanning"

win_type = 1

"hamming"

win_type = 2

"rectangle"

win_type = 3

Имена окон можно передавать в виде строк или задавать номером win_type.

Для незаданных аргументов используются следующие значения по умолчанию: win_size = 80, inc = 24, num_coef = 64 и win_type = 1.

y = stft (x, …) возвращает абсолютные значения коэффициентов Фурье для num_coef положительных частот.

[y, c] = stft (x, …) возвращает всю матрицу STFT y и вектор из 3 элементов c, содержащий размер окна, шаг и тип окна, необходимые функции synthesis.

См. также: synthesis.

: x = synthesis (y, c)

Вычисляет сигнал по его кратковременному преобразованию Фурье y и вектору из 3 элементов c, задающему размер окна, шаг и тип окна.

Значения y и c можно получить с помощью

[y, c] = stft (x , ...)

См. также: stft.

: [a, v] = yulewalker (c)

Подбирает AR-модель порядка p по оценкам Юла — Уокера на основе вектора c автоковариаций [gamma_0, …, gamma_p].

Возвращает коэффициенты AR a и дисперсию белого шума v.