mlab

matplotlib.mlab

Числовые функции Python, написанные для совместимости с командами MATLAB с одинаковыми именами.

Функции, совместимые с MATLAB

cohere(): Когерентность (нормализованная взаимная спектральная плотность)
csd(): Взаимная спектральная плотность с использованием усредненного периодограммы Уэлча
detrend(): Удаление среднего значения или линии наилучшей подгонки из массива
find(): Возвращает индексы, где выполняется некоторое условие; numpy.nonzero аналогичен, но более универсален.
griddata(): Интерполяция нерегулярно распределенных данных на регулярную сетку.
prctile(): Нахождение процентилей последовательности
prepca(): Анализ главных компонент
psd(): Плотность спектральной мощности с использованием усредненного периодограммы Уэлча
rk4(): Интегратор Рунге-Кутты 4-го порядка для 1D или ND систем
specgram(): Спектрограмма (спектр по сегментам времени)

Разные функции

Функции, которых нет в MATLAB, но которые все равно полезны:

cohere_pairs(): Когерентность по всем парам. Это не функция MATLAB, но в моей лаборатории мы часто вычисляем когерентность, и мы вычисляем ее для множества пар. Эта функция оптимизирована для эффективного выполнения этой задачи, кэшируя прямые преобразования Фурье.
rk4(): Интегратор обыкновенных дифференциальных уравнений (ОДУ) Рунге-Кутты 4-го порядка на случай, если вы окажетесь без scipy (и значительно более совершенных инструментов scipy.integrate)
contiguous_regions(): Возвращает индексы областей, охватываемых некоторой логической маской
cross_from_below(): Возвращает индексы, где одномерный массив пересекает порог снизу
cross_from_above(): Возвращает индексы, где одномерный массив пересекает порог сверху
complex_spectrum(): Возвращает комплекснозначный спектр частот сигнала
magnitude_spectrum(): Возвращает величину спектра частот сигнала
angle_spectrum(): Возвращает угол (упакованную фазу) спектра частот сигнала
phase_spectrum(): Возвращает фазу (неупакованный угол) спектра частот сигнала
detrend_mean(): Удаление среднего значения из линии.
demean(): Удаление среднего значения из линии. Эта функция такая же, как detrend_mean(), за исключением значения по умолчанию для параметра axis.
detrend_linear(): Удаление линии наилучшей подгонки из линии.
detrend_none(): Возвращение исходной линии.
stride_windows(): Получение всех окон в массиве с эффективным использованием памяти
stride_repeat(): Повторение массива с эффективным использованием памяти
apply_window(): Применение окна вдоль заданной оси

Вспомогательные функции для массивов записей

Набор вспомогательных методов для массивов записей NumPy

См. Примеры misc

rec2txt(): Красивый вывод массива записей
rec2csv(): Сохранение массива записей в файле CSV
csv2rec(): Импорт массива записей из файла CSV с проверкой типа
rec_append_fields(): Добавляет поле(я)/массив(ы) в массив записей
rec_drop_fields(): Удаление полей из массива записей
rec_join(): Объединение двух массивов записей по последовательности полей
recs_join(): Простой объединение нескольких массивов записей с использованием одного столбца в качестве ключа
rec_groupby(): Сводка данных по группам (аналогично SQL GROUP BY)
rec_summarize(): Вспомогательный код для фильтрации полей массива записей в новые поля

Для функций просмотра массивов записей (например, rec2csv) существует множество объектов Format, которые можно передавать в функции, чтобы, например, окрашивать отрицательные значения в красный цвет, задавать форматирование процентов и масштабирование и т.д.

Пример использования:

r = csv2rec('somefile.csv', checkrows=0)

formatd = dict(
    weight = FormatFloat(2),
    change = FormatPercent(2),
    cost   = FormatThousands(2),
    )


rec2excel(r, 'test.xls', formatd=formatd)
rec2csv(r, 'test.csv', formatd=formatd)
scroll = rec2gtk(r, formatd=formatd)

win = gtk.Window()
win.set_size_request(600,800)
win.add(scroll)
win.show_all()
gtk.main()

class matplotlib.mlab.FormatBool

Bases: matplotlib.mlab.FormatObj

fromstr(s)

toval(x)

class matplotlib.mlab.FormatDate(fmt)

Bases: matplotlib.mlab.FormatObj

fromstr(x)

toval(x)

class matplotlib.mlab.FormatDatetime(fmt='%Y-%m-%d %H:%M:%S')

Bases: matplotlib.mlab.FormatDate

fromstr(x)

class matplotlib.mlab.FormatFloat(precision=4, scale=1.0)

Bases: matplotlib.mlab.FormatFormatStr

fromstr(s)

toval(x)

class matplotlib.mlab.FormatFormatStr(fmt)

Bases: matplotlib.mlab.FormatObj

tostr(x)

class matplotlib.mlab.FormatInt

Bases: matplotlib.mlab.FormatObj

fromstr(s)

tostr(x)

toval(x)

class matplotlib.mlab.FormatMillions(precision=4): Bases: matplotlib.mlab.FormatFloat

class matplotlib.mlab.FormatObj

Bases: object

fromstr(s)

tostr(x)

toval(x)

class matplotlib.mlab.FormatPercent(precision=4): Bases: matplotlib.mlab.FormatFloat

class matplotlib.mlab.FormatString

Основы: matplotlib.mlab.FormatObj

tostr(x)

class matplotlib.mlab.FormatThousands(precision=4): Основы: matplotlib.mlab.FormatFloat

class matplotlib.mlab.GaussianKDE(dataset, bw_method=None)

Основы: object

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

Вызов: kde = GaussianKDE(dataset, bw_method='silverman')

Параметры:

Параметры:	dataset : array_like Точки данных для оценки. В случае одномерных данных это одномерный массив, в противном случае двумерный массив с формой (# измерений, # данных). bw_method : str, скаляр или вызываемый объект, необязательно Метод, используемый для вычисления ширины полосы оценивателя. Может быть 'scott', 'silverman', скалярная константа или вызываемый объект. Если скаляр, он будет использоваться непосредственно как `kde.factor`. Если вызываемый объект, он должен принимать экземпляр `GaussianKDE` в качестве единственного параметра и возвращать скаляр. Если None (по умолчанию), используется 'scott'.

dataset : array_like

Точки данных для оценки. В случае одномерных данных это одномерный массив, в противном случае двумерный массив с формой (# измерений, # данных).

bw_method : str, скаляр или вызываемый объект, необязательно

Метод, используемый для вычисления ширины полосы оценивателя. Может быть 'scott', 'silverman', скалярная константа или вызываемый объект. Если скаляр, он будет использоваться непосредственно как kde.factor. Если вызываемый объект, он должен принимать экземпляр GaussianKDE в качестве единственного параметра и возвращать скаляр. Если None (по умолчанию), используется 'scott'.

Атрибуты

dataset	(ndarray) Набор данных, с которым `gaussian_kde` был инициализирован.
dim	(int) Количество измерений.
num_dp	(int) Количество точек данных.
factor	(float) Коэффициент ширины полосы, полученный из `kde.covariance_factor`, с которым умножается матрица ковариаций.
covariance	(ndarray) Матрица ковариаций `dataset`, масштабированная вычисленной шириной полосы (`kde.factor`).
inv_cov	(ndarray) Обратная матрица `covariance`.

Методы

kde.evaluate(points)	(ndarray) Оценить плотность распределения по предоставленному набору точек.
kde(points)	(ndarray) То же, что и kde.evaluate(points)

covariance_factor()

evaluate(points)

Оценить плотность распределения по набору точек.

Параметры:

Параметры:	points : (# измерений, # точек)-массив В качестве альтернативы можно передать вектор (# измерений,), который будет обработан как единственная точка.
Возвращает:	values : (# точек,)-массив Значения в каждой точке.
Исключения:	ValueError : если размерность входных точек отличается от размерности KDE.

points : (# измерений, # точек)-массив

В качестве альтернативы можно передать вектор (# измерений,), который будет обработан как единственная точка.

Возвращает:

values : (# точек,)-массив

Значения в каждой точке.

Исключения:

ValueError : если размерность входных точек отличается

от размерности KDE.

scotts_factor()

silverman_factor()

class matplotlib.mlab.PCA(a, standardize=True)

Основы: object

вычисляет SVD a и хранит данные для PCA. Использует project для проекции данных на уменьшенное множество измерений

Входы:

a: массив numobservations x numdims standardize: True, если входные данные должны быть стандартизированы. Если False, будет выполнена только центровка.

Атрибуты:

a: центрированная и нормированная версия входного массива a

numrows, numcols: размеры a

mu: массив numdims средних значений a. Это вектор, который указывает на начало пространства PCA.

sigma: массив numdims стандартных отклонений a

fracs: доля дисперсии каждого из главных компонент

s: собственные значения разложения

Wt: вектор весов для проекции точки или массива numdims в пространство PCA

Y: проекция в пространство PCA

Вектор нагрузок находится в векторе Wt. Например, вектор нагрузок для первой главной компоненты определяется Wt[0]. Эта строка также является первым собственным вектором.

center(x): центровка и, при необходимости, стандартизация данных с использованием среднего и стандартного отклонения из обучающего набора a

project(x, minfrac=0.0): проектирует x на главные оси, отбрасывая оси, где доля дисперсии <minfrac

matplotlib.mlab.amap(function, sequence[, sequence, ...]) → array.: Работает как map(), но возвращает массив. Это просто удобное сокращение для numpy.array(map(...)).

matplotlib.mlab.angle_spectrum(x, Fs=None, window=None, pad_to=None, sides=None)

Вычисление угла спектра частот (спектра фаз) x. Данные дополняются до длины pad_to, и к сигналу применяется функция оконного преобразования window.

x: одномерный массив или последовательность: Массив или последовательность, содержащая данные

Ключевые аргументы:

Fs: скаляр: Частота дискретизации (образцов в единицу времени). Она используется для вычисления частот Фурье, freqs, в циклах за единицу времени. Значение по умолчанию равно 2.
window: вызываемый объект или одномерный массив: Функция или вектор длины NFFT. Для создания векторов окон см. window_hanning(), window_none(), numpy.blackman(), numpy.hamming(), numpy.bartlett(), scipy.signal(), scipy.signal.get_window(), и т. д. По умолчанию window_hanning(). Если в качестве аргумента передается функция, она должна принимать фрагмент данных в качестве аргумента и возвращать оконную версию фрагмента.
sides: [ ‘default’ | ‘onesided’ | ‘twosided’ ]: Определяет, какие стороны спектра возвращать. Значение по умолчанию обеспечивает поведение по умолчанию, которое возвращает односторонний спектр для вещественных данных и двусторонний для комплексных данных. ‘onesided’ принудительно возвращает односторонний спектр, а ‘twosided’ — двусторонний.

pad_to: целое число: Количество точек, до которых дополняются данные фрагмента при выполнении FFT. Хотя это не увеличивает фактическое разрешение спектра (минимальное расстояние между разрешаемыми пиками), это может обеспечить больше точек в графике, позволяя получить больше деталей. Это соответствует параметру n в вызове fft(). Значение по умолчанию — None, которое устанавливает pad_to равным длине входного сигнала (т. е. без заполнения).

Возвращает кортеж (spectrum, freqs):

spectrum: одномерный массив: Значения для углового спектра в радианах (вещественные)
freqs: одномерный массив: Частоты, соответствующие элементам в spectrum

См. также

complex_spectrum(): Эта функция возвращает значение угла complex_spectrum().
magnitude_spectrum(): angle_spectrum() возвращает значения амплитуд соответствующих частот.
phase_spectrum(): phase_spectrum() возвращает значения развёрнутой версии этой функции.
specgram(): specgram() может возвращать угловой спектр сегментов внутри сигнала.

matplotlib.mlab.apply_window(x, window, axis=0, return_window=None)

Применение заданного окна к заданному одномерному или двумерному массиву вдоль заданной оси.

Вызов:

  apply_window(x, window, axis=0, return_window=False)

*x*: 1D or 2D array or sequence
  Array or sequence containing the data.

*winodw*: function or array.
  Either a function to generate a window or an array with length
  *x*.shape[*axis*]

*axis*: integer
  The axis over which to do the repetition.
  Must be 0 or 1.  The default is 0

*return_window*: bool
  If true, also return the 1D values of the window that was applied

matplotlib.mlab.base_repr(number, base=2, padding=0): Возвращает представление числа в заданном основании.

matplotlib.mlab.binary_repr(number, max_length=1025)

Возвращает двоичное представление входного числа в виде строки.

Это более эффективно, чем использование base_repr() с основанием 2.

Увеличьте значение max_length для очень больших чисел. Обратите внимание, что на 32-битных машинах 2**1023 — это наибольшая целая степень двойки, которая может быть преобразована в число с плавающей точкой Python.

matplotlib.mlab.bivariate_normal(X, Y, sigmax=1.0, sigmay=1.0, mux=0.0, muy=0.0, sigmaxy=0.0)

Двумерное гауссовское распределение для массивов X и Y одинаковой формы.

См. двумерное нормальное распределение в mathworld.

matplotlib.mlab.center_matrix(M, dim=0)

Возвращает матрицу M, в которой каждая строка имеет среднее значение 0 и стандартное отклонение 1.

Если dim = 1, операции выполняются по столбцам вместо строк. (dim противоположен аргументу numpy axis).

matplotlib.mlab.cohere(x, y, NFFT=256, Fs=2, detrend=, window=, noverlap=0, pad_to=None, sides='default', scale_by_freq=None)

Когерентность между x и y. Когерентность — это нормированная кросс-спектральная плотность:

x, y: Массив или последовательность, содержащая данные

Ключевые аргументы:

Fs: скаляр: Частота дискретизации (образцов в единицу времени). Используется для вычисления частот Фурье, freqs, в циклах за единицу времени. Значение по умолчанию — 2.
window: вызываемый объект или массив: Функция или вектор длиной NFFT. Для создания векторов окон см. window_hanning(), window_none(), numpy.blackman(), numpy.hamming(), numpy.bartlett(), scipy.signal(), scipy.signal.get_window(), и т.д. По умолчанию используется window_hanning(). Если в качестве аргумента передается функция, она должна принимать сегмент данных в качестве аргумента и возвращать оконную версию сегмента.
sides: [ ‘default’ | ‘onesided’ | ‘twosided’ ]: Указывает, какие стороны спектра возвращать. По умолчанию используется поведение по умолчанию, которое возвращает односторонний спектр для вещественных данных и двусторонний для комплексных. ‘onesided’ принудительно возвращает односторонний спектр, а ‘twosided’ — двусторонний.

pad_to: целое число

Количество точек, до которых дополняется сегмент данных при выполнении FFT. Это может отличаться от NFFT, которое определяет количество точек данных, используемых. Хотя это не увеличивает фактическое разрешение спектра (минимальное расстояние между разрешимыми пиками), это может дать больше точек на графике, что позволит получить больше деталей. Это соответствует параметру n в вызове fft(). По умолчанию None, что устанавливает pad_to равным NFFT.

NFFT: целое число

Количество точек данных, используемых в каждом блоке для FFT. Мощность 2 наиболее эффективна. Значение по умолчанию — 256. Этого НЕ следует использовать для получения нулевого заполнения, иначе масштабирование результата будет неправильным. Для этого используйте pad_to.

detrend: [ ‘default’ | ‘constant’ | ‘mean’ | ‘linear’ | ‘none’] или

вызываемый объект

Функция, применяемая к каждому сегменту перед вычислением fft, предназначенная для удаления среднего значения или линейной тенденции. В отличие от MATLAB, где параметр detrend — это вектор, в matplotlib он — функция. Модуль pylab определяет detrend_none(), detrend_mean(), и detrend_linear(), но вы также можете использовать пользовательскую функцию. Вы также можете использовать строку для выбора одной из функций. ‘default’, ‘constant’, и ‘mean’ вызывают detrend_mean(). ‘linear’ вызывает detrend_linear(). ‘none’ вызывает detrend_none().

scale_by_freq: логическое значение

Определяет, должны ли возвращаемые значения плотности масштабироваться по частоте масштабирования, что дает плотность в единицах Hz^-1. Это позволяет интегрировать по возвращаемым значениям частоты. По умолчанию True для совместимости с MATLAB.

noverlap: целое число: Количество перекрывающихся точек между блоками. По умолчанию 0 (нет перекрытия).

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

См. также

psd() and csd(): Для получения информации о методах вычисления , и .

matplotlib.mlab.cohere_pairs(X, ij, NFFT=256, Fs=2, detrend=, window=, noverlap=0, preferSpeedOverMemory=True, progressCallback=, returnPxx=False)

Подпись вызова:

Cxy, Phase, freqs = cohere_pairs( X, ij, ...)

Вычисляет когерентность и фазу для всех пар ij в X.

X — массив numSamples * numCols

ij — список кортежей. Каждый кортеж — пара индексов в столбцах X, для которых необходимо вычислить когерентность. Например, если X имеет 64 столбца, и вы хотите вычислить все нередундантые пары, определите ij как:

ij = []
for i in range(64):
    for j in range(i+1,64):
        ij.append( (i,j) )

preferSpeedOverMemory — необязательный булевый параметр. По умолчанию true. Если False, ограничивает кеширование, создавая только один, а не два, комплексных массива кеша. Это полезно, если память становится критичной. Даже когда preferSpeedOverMemory равен False, cohere_pairs() по-прежнему обеспечит значительные преимущества производительности по сравнению с вызовом cohere() для каждой пары и будет использовать существенно меньше памяти, чем если preferSpeedOverMemory равен True. В моих тестах с массивом 43000x64 для всех нередундантых пар, preferSpeedOverMemory = True обеспечил прирост производительности на 33% на процессоре Athlon 1.7 ГГц с 512 МБ оперативной памяти по сравнению с preferSpeedOverMemory = False. Но оба решения были более чем в 10 раз быстрее, чем наивное вычисление всех возможных пар через cohere().

Возвращает:

(Cxy, Phase, freqs)

где:

Cxy: словарь кортежей (i, j) -> вектор когерентности для этой пары. Например, Cxy[(i,j) = cohere(X[:,i], X[:,j]). Количество ключей словаря равно len(ij).
Phase: словарь фаз кросс-спектральной плотности в каждой частоте для каждой пары. Ключи — (i, j).
freqs: вектор частот, равный по длине любому из векторов

когерентности или фаз для любого ключа (i, j).

например, для создания графика когерентности Bode:

subplot(211)
plot( freqs, Cxy[(12,19)])
subplot(212)
plot( freqs, Phase[(12,19)])

Для большого числа пар cohere_pairs() может быть намного эффективнее, чем просто вызов cohere() для каждой пары, потому что он кеширует большинство интенсивных вычислений. Если — количество пар, эта функция для большей части тяжелой работы, в то время как вызов cohere для каждой пары — . Однако из-за кеширования она также более требовательна к памяти, создавая 2 дополнительных комплексных массива примерно с таким же количеством элементов, как и X.

См. test/cohere_pairs_test.py в дереве src для примера скрипта, который показывает, что этот cohere_pairs() и cohere() дают одинаковые результаты для заданной пары.

См. также

psd(): Для получения информации о методах вычисления , и .

matplotlib.mlab.complex_spectrum(x, Fs=None, window=None, pad_to=None, sides=None)

Вычислить комплекснозначный спектр частот x. Данные заполняются до длины pad_to, и к сигналу применяется функция оконности window.

x: одномерный массив или последовательность: Массив или последовательность, содержащая данные

Ключевые аргументы:

Fs: скаляр: Частота дискретизации (образец в единицу времени). Она используется для расчета частот Фурье, freqs, в циклах в единицу времени. Значение по умолчанию равно 2.
window: вызываемая функция или массив: Функция или вектор длиной NFFT. Для создания векторов окон см. window_hanning(), window_none(), numpy.blackman(), numpy.hamming(), numpy.bartlett(), scipy.signal(), scipy.signal.get_window(), и т. д. Значение по умолчанию — window_hanning(). Если в качестве аргумента передается функция, она должна принимать в качестве аргумента сегмент данных и возвращать оконную версию сегмента.
sides: [ ‘default’ | ‘onesided’ | ‘twosided’ ]: Указывает, какие стороны спектра возвращать. Значение по умолчанию соответствует поведению по умолчанию, которое возвращает односторонний спектр для вещественных данных и оба для комплексных данных. ‘onesided’ принудительно возвращает односторонний спектр, а ‘twosided’ — двухсторонний.

pad_to: целое число: Количество точек, до которых заполняется сегмент данных при выполнении БПФ. Хотя это не увеличивает фактическое разрешение спектра (минимальное расстояние между разрешимыми пиками), это может дать больше точек на графике, что позволит получить больше деталей. Это соответствует параметру n в вызове fft(). Значение по умолчанию — None, что устанавливает pad_to равным длине входного сигнала (т. е. без заполнения).

Возвращает кортеж (spectrum, freqs):

spectrum: одномерный массив: Значения для комплексного спектра (комплекснозначные)
freqs: одномерный массив: Частоты, соответствующие элементам в spectrum

См. также

magnitude_spectrum(): magnitude_spectrum() возвращает абсолютное значение этой функции.
angle_spectrum(): angle_spectrum() возвращает угол этой функции.
phase_spectrum(): phase_spectrum() возвращает фазу (непрерывный угол) этой функции.
specgram(): specgram() может возвращать комплексный спектр сегментов внутри сигнала.

matplotlib.mlab.contiguous_regions(mask): возвращает список (ind0, ind1), такой что mask[ind0:ind1].all() равно True, и мы покрываем все такие области

matplotlib.mlab.cross_from_above(x, threshold)

возвращает индексы в x, где x пересекает некоторый порог снизу, например, i, где:

x[i-1]>threshold and x[i]<=threshold

См. также

cross_from_below() и contiguous_regions()

matplotlib.mlab.cross_from_below(x, threshold)

возвращает индексы в x, где x пересекает некоторый порог снизу, например, i, где:

x[i-1]<threshold and x[i]>=threshold

Пример кода:

import matplotlib.pyplot as plt

t = np.arange(0.0, 2.0, 0.1)
s = np.sin(2*np.pi*t)

fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(t, s, '-o')
ax.axhline(0.5)
ax.axhline(-0.5)

ind = cross_from_below(s, 0.5)
ax.vlines(t[ind], -1, 1)

ind = cross_from_above(s, -0.5)
ax.vlines(t[ind], -1, 1)

plt.show()

См. также

cross_from_above() и contiguous_regions()

matplotlib.mlab.csd(x, y, NFFT=None, Fs=None, detrend=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None)

Вычислить взаимную спектральную плотность.

Вызов:

csd(x, y, NFFT=256, Fs=2, detrend=mlab.detrend_none,
    window=mlab.window_hanning, noverlap=0, pad_to=None,
    sides='default', scale_by_freq=None)

Взаимная спектральная плотность методом усредненного периодограммы Уэлча. Векторы x и y делятся на сегменты длиной NFFT. Каждый сегмент обрабатывается функцией detrend и оконной функцией window. Произведение прямых БПФ x и y усредняется по каждому сегменту для вычисления , со шкалированием для исправления потерь мощности из-за окон.

Если len(x) < NFFT или len(y) < NFFT, они будут заполнены нулями до NFFT.

x, y: одномерные массивы или последовательности: Массивы или последовательности, содержащие данные

Ключевые аргументы:

Fs: скаляр: Частота дискретизации (образец в единицу времени). Она используется для расчета частот Фурье, freqs, в циклах в единицу времени. Значение по умолчанию равно 2.
window: вызываемая функция или массив: Функция или вектор длиной NFFT. Для создания векторов окон см. window_hanning(), window_none(), numpy.blackman(), numpy.hamming(), numpy.bartlett(), scipy.signal(), scipy.signal.get_window(), и т. д. Значение по умолчанию — window_hanning(). Если в качестве аргумента передается функция, она должна принимать в качестве аргумента сегмент данных и возвращать оконную версию сегмента.
sides: [ ‘default’ | ‘onesided’ | ‘twosided’ ]: Указывает, какие стороны спектра возвращать. Значение по умолчанию соответствует поведению по умолчанию, которое возвращает односторонний спектр для вещественных данных и оба для комплексных данных. ‘onesided’ принудительно возвращает односторонний спектр, а ‘twosided’ — двухсторонний.

pad_to: целое число

Количество точек, до которых заполняется сегмент данных при выполнении БПФ. Это может отличаться от NFFT, которое определяет количество используемых точек данных. Хотя это не увеличивает фактическое разрешение спектра (минимальное расстояние между разрешимыми пиками), это может дать больше точек на графике, что позволит получить больше деталей. Это соответствует параметру n в вызове fft(). Значение по умолчанию — None, которое устанавливает pad_to равным NFFT

NFFT: целое число

Количество точек данных, используемых в каждом блоке для БПФ. Степень двойки наиболее эффективна. Значение по умолчанию равно 256. Это не должно использоваться для получения заполнения нулями, иначе масштабирование результата будет неправильным. Используйте pad_to для этого вместо этого.

detrend: [ ‘default’ | ‘constant’ | ‘mean’ | ‘linear’ | ‘none’] или

функция

Функция, применяемая к каждому сегменту перед выполнением БПФ, предназначенная для удаления среднего или линейной тенденции. В отличие от MATLAB, где параметр detrend — вектор, в matplotlib он — функция. Модуль pylab определяет detrend_none(), detrend_mean(), и detrend_linear(), но вы также можете использовать пользовательскую функцию. Вы также можете использовать строку для выбора одной из функций. ‘default’, ‘constant’ и ‘mean’ вызывают detrend_mean(). ‘linear’ вызывает detrend_linear(). ‘none’ вызывает detrend_none().

scale_by_freq: булево значение

Указывает, следует ли масштабировать полученные значения плотности с помощью частоты масштабирования, что дает плотность в единицах Hz^-1. Это позволяет для интегрирования по возвращенным значениям частот. Значение по умолчанию — True для совместимости с MATLAB.

noverlap: целое число: Количество совпадающих точек между сегментами. Значение по умолчанию равно 0 (без перекрытия).

Возвращает кортеж (Pxy, freqs):

Pxy: одномерный массив: Значения для взаимного спектра P_{xy} до масштабирования (вещественные значения)
freqs: одномерный массив: Частоты, соответствующие элементам в Pxy

Справочные данные:: Bendat & Piersol – Random Data: Analysis and Measurement Procedures, John Wiley & Sons (1986)

См. также

psd(): psd() эквивалентно установке y=x.

matplotlib.mlab.csv2rec(fname, comments='#', skiprows=0, checkrows=0, delimiter=', ', converterd=None, names=None, missing='', missingd=None, use_mrecords=False, dayfirst=False, yearfirst=False)

Загрузка данных из файла с разделителями запятая/пробел/табуляция в fname в массив numpy с записями и возвращение массива записей.

Если names равно None, требуется строка заголовка для автоматического назначения имен recarray. Заголовки будут приведены к нижнему регистру, пробелы будут заменены на подчеркивания, а недопустимые символы имен атрибутов будут удалены. Если names не равно None, это последовательность имен для использования в качестве имён столбцов. В этом случае предполагается, что строки заголовка нет.

fname: может быть именем файла или файловым дескриптором. Поддержка сжатых файлов в формате .gz автоматическая, если имя файла заканчивается на ‘.gz’
comments: символ, используемый для обозначения начала комментария в файле, или None для отключения удаления комментариев
skiprows: количество строк сверху, которые нужно пропустить
checkrows: количество строк для проверки типа данных столбца. Если установлено в ноль, все строки проверяются.
converterd: если не равно None, словарь, сопоставляющий номер столбца или преобразованное имя столбца с функцией преобразования.
names: если не равно None, список имён заголовков. В этом случае заголовки из файла не будут читаться
missingd – словарь, сопоставляющий преобразованные имена столбцов со значениями полей, указывающими, что поле не содержит фактических данных и должно быть замаскировано, например, ‘0000-00-00’ или ‘unused’
missing: строка, значение которой сигнализирует об отсутствующем поле независимо от столбца, в котором оно появляется
use_mrecords: если True, возвращает массив записей mrecords.fromrecords, если какие-либо данные отсутствуют
dayfirst: по умолчанию False, поэтому MM-DD-YY имеет приоритет перед DD-MM-YY. Смотрите http://labix.org/python-dateutil#head-b95ce2094d189a89f80f5ae52a05b4ab7b41af47 для получения дополнительной информации.
yearfirst: по умолчанию False, поэтому MM-DD-YY имеет приоритет перед YY-MM-DD. Смотрите http://labix.org/python-dateutil#head-b95ce2094d189a89f80f5ae52a05b4ab7b41af47 для получения дополнительной информации.

Если строки не найдены, возвращается None – см. examples/loadrec.py

matplotlib.mlab.csvformat_factory(format)

matplotlib.mlab.demean(x, axis=0)

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

Вызов функции:

  demean(x, axis=0)

*x*: array or sequence
  Array or sequence containing the data
  Can have any dimensionality

*axis*: integer
  The axis along which to take the mean.  See numpy.mean for a
  description of this argument.

См. также

delinear()

denone(): delinear() и denone() - другие алгоритмы удаления тренда.
detrend_mean(): Эта функция идентична функции detrend_mean(), за исключением значения по умолчанию axis.

matplotlib.mlab.detrend(x, key=None, axis=None)

Возвращает x с удалённым трендом.

Вызов функции:

  detrend(x, key='mean')

*x*: array or sequence
  Array or sequence containing the data.

*key*: [ 'default' | 'constant' | 'mean' | 'linear' | 'none'] or function
    Specifies the detrend algorithm to use.  'default' is 'mean',
    which is the same as :func:`detrend_mean`.  'constant' is the same.
    'linear' is the same as :func:`detrend_linear`.  'none' is the same
    as :func:`detrend_none`.  The default is 'mean'.  See the
    corresponding functions for more details regarding the algorithms.
    Can also be a function that carries out the detrend operation.

*axis*: integer
  The axis along which to do the detrending.

См. также

detrend_mean(): detrend_mean() реализует алгоритм ‘mean’.
detrend_linear(): detrend_linear() реализует алгоритм ‘linear’.
detrend_none(): detrend_none() реализует алгоритм ‘none’.

matplotlib.mlab.detrend_linear(y)

Возвращает x минус линию наилучшей подгонки; удаление тренда «линейное».

Вызов функции:

  detrend_linear(y)

*y*: 0-D or 1-D array or sequence
  Array or sequence containing the data

*axis*: integer
  The axis along which to take the mean.  See numpy.mean for a
  description of this argument.

См. также

delinear(): Эта функция идентична функции delinear() за исключением значения по умолчанию axis.

detrend_mean()

detrend_none(): detrend_mean() и detrend_none() - это другие алгоритмы удаления тренда.
detrend(): detrend() - это оболочка вокруг всех алгоритмов удаления тренда.

matplotlib.mlab.detrend_mean(x, axis=None)

Возвращает x минус среднее значение(x).

Вызов функции:

  detrend_mean(x, axis=None)

*x*: array or sequence
  Array or sequence containing the data
  Can have any dimensionality

*axis*: integer
  The axis along which to take the mean.  See numpy.mean for a
  description of this argument.

См. также

demean(): Эта функция идентична функции demean(), за исключением значения по умолчанию axis.

detrend_linear()

detrend_none(): detrend_linear() и detrend_none() - это другие алгоритмы удаления тренда.
detrend(): detrend() - это оболочка вокруг всех алгоритмов удаления тренда.

matplotlib.mlab.detrend_none(x, axis=None)

Возвращает x: без удаления тренда.

Вызов функции:

  detrend_none(x, axis=None)

*x*: any object
  An object containing the data

*axis*: integer
  This parameter is ignored.
  It is included for compatibility with detrend_mean

См. также

denone(): Эта функция идентична функции denone() за исключением значения по умолчанию axis, которое не имеет эффекта.

detrend_mean()

detrend_linear(): detrend_mean() и detrend_linear() - это другие алгоритмы удаления тренда.
detrend(): detrend() - это оболочка вокруг всех алгоритмов удаления тренда.

matplotlib.mlab.dist(x, y): Возвращает расстояние между двумя точками.

matplotlib.mlab.dist_point_to_segment(p, s0, s1)

Получение расстояния от точки до отрезка.

p, s0, s1 - последовательности xy

Этот алгоритм взят из http://softsurfer.com/Archive/algorithm_0102/algorithm_0102.htm#Distance%20to%20Ray%20or%20Segment

matplotlib.mlab.distances_along_curve(X)

Вычисляет расстояние между набором последовательных точек в N измерениях.

Где X - массив или матрица размером M x N. Вычисляются расстояния между последовательными строками. Расстояние - это стандартное евклидово расстояние.

matplotlib.mlab.donothing_callback(*args)

matplotlib.mlab.entropy(y, bins)

Возвращает энтропию данных в y в единицах ната.

где - вероятность наблюдения y в бине из bins. bins может быть количеством бинов или диапазоном бинов; см. numpy.histogram()

Сравнение S с аналитическим вычислением для гауссиана:

x = mu + sigma * randn(200000)
Sanalytic = 0.5 * ( 1.0 + log(2*pi*sigma**2.0) )

matplotlib.mlab.exp_safe(x)

Вычисление показателей степени, которые безопасно обнуляются при переполнении.

Медленно, но удобно использовать. Обратите внимание, что numpy предоставляет надлежащую обработку исключений с плавающей точкой с доступом к оборудованию.

matplotlib.mlab.fftsurr(x, detrend=, window=): Вычисление случайного суррогата фазы FFT для x.

matplotlib.mlab.find(condition): Возвращает индексы, где ravel(condition) истинно

END_OF_DOCUMENT_MARKER

matplotlib.mlab.frange([start, ]stop[, step, keywords]) → array of floats

Возвращает массив NumPy, содержащий прогрессию чисел с плавающей точкой. Аналогично numpy.arange(), но по умолчанию использует замкнутый интервал.

frange(x0, x1) возвращает [x0, x0+1, x0+2, ..., x1]; start по умолчанию равен 0, а конечная точка включается. Это поведение отличается от поведения range() и numpy.arange(). Это сделано намеренно, так как frange() скорее всего, будет полезнее для генерации списков точек для оценки функций, и часто желательно включение конечных точек. Обычное поведение range() можно получить, установив ключевое слово closed = 0, в этом случае frange() фактически становится :func:numpy.arange`.

Если задан step, он задаёт шаг приращения (или убывания). Все аргументы могут быть числами с плавающей точкой.

frange(x0,x1,d) возвращает [x0,x0+d,x0+2d,...,xfin] , где xfin <= x1.

frange() также можно вызвать с ключевым словом npts. Это задаёт количество точек, которое должен содержать список (и переопределяет значение step, которое могло быть задано). numpy.arange() не предлагает этого варианта.

Примеры:

>>> frange(3)
array([ 0.,  1.,  2.,  3.])
>>> frange(3,closed=0)
array([ 0.,  1.,  2.])
>>> frange(1,6,2)
array([1, 3, 5])   or 1,3,5,7, depending on floating point vagueries
>>> frange(1,6.5,npts=5)
array([ 1.   ,  2.375,  3.75 ,  5.125,  6.5  ])

matplotlib.mlab.get_formatd(r, formatd=None): строит форматd, гарантирующий наличие ключа для каждого имени типа данных

matplotlib.mlab.get_sparse_matrix(M, N, frac=0.1): Возвращает разреженную матрицу размером M x N с frac элементами, заполненными случайным образом.

matplotlib.mlab.get_xyz_where(Z, Cond): Z и Cond — матрицы размером M x N. Z — данные, а Cond — булева матрица, где выполняется какое-то условие. Возвращаемое значение — (x, y, z), где x и y — индексы в Z, а z — значения Z в этих индексах. x, y и z — одномерные массивы.

matplotlib.mlab.griddata(x, y, z, xi, yi, interp='nn')

Интерполирует данные с неравномерной сетки на другую сетку.

Построение поверхности вида z = f(x, y) по данным в (обычно) неравномерно распределённых векторах (x, y, z), а затем интерполяция этой поверхности в точках, заданных (xi, yi) для получения zi.

Параметры:

Параметры:	x, y, z : 1d массив_подобный Координаты точек сетки, из которых нужно интерполировать. xi, yi : 1d или 2d массив_подобный Координаты точек сетки, на которые нужно интерполировать. interp : строковый ключ из {‘nn’, ‘linear’} Алгоритм интерполяции, либо ‘nn’ для интерполяции естественного соседа, либо ‘linear’ для линейной интерполяции.
Возвращает:	2d массив с плавающей точкой Массив значений, интерполированных в точках (`xi`, `yi`) . Массив будет замаскирован, если какие-либо из (`xi`, `yi`) находятся вне выпуклой оболочки (`x`, `y`).

x, y, z : 1d массив_подобный

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

xi, yi : 1d или 2d массив_подобный

Координаты точек сетки, на которые нужно интерполировать.

interp : строковый ключ из {‘nn’, ‘linear’}

Алгоритм интерполяции, либо ‘nn’ для интерполяции естественного соседа, либо ‘linear’ для линейной интерполяции.

Возвращает:

2d массив с плавающей точкой

Массив значений, интерполированных в точках (xi, yi) . Массив будет замаскирован, если какие-либо из (xi, yi) находятся вне выпуклой оболочки (x, y).

Примечания

Если interp равно ‘nn’ (по умолчанию), используется интерполяция естественного соседа на основе треугольной сетки Делоне. Этот вариант доступен только при наличии модуля mpl_toolkits.natgrid. Его можно загрузить с https://github.com/matplotlib/natgrid. Сетка (xi, yi должна быть регулярной и монотонно возрастающей в этом случае.

Если interp равно ‘linear’, используется линейная интерполяция через matplotlib.tri.LinearTriInterpolator.

Вместо использования griddata доступна более гибкая функциональность и другие варианты интерполяции с использованием matplotlib.tri.Triangulation и matplotlib.tri.TriInterpolator.

matplotlib.mlab.identity(n, rank=2, dtype='l', typecode=None)

Возвращает единичную матрицу формы (n, n, ..., n) (ранг r).

Для рангов выше 2 этот объект просто многоиндексная Кронекеровская дельта:

                    /  1  if i0=i1=...=iR,
id[i0,i1,...,iR] = -|
                    \  0  otherwise.

Можно дополнительно задать dtype (или тип кода) (по умолчанию ‘l’).

Поскольку ранг по умолчанию равен 2, эта функция в случае по умолчанию (когда задан только n) ведет себя как norm() — но, удивительно, намного быстрее.

matplotlib.mlab.inside_poly(points, verts)

points — последовательность точек x, y. verts — последовательность вершин многоугольника x, y.

Возвращаемое значение — последовательность индексов в points для точек, которые находятся внутри многоугольника.

matplotlib.mlab.is_closed_polygon(X): Проверяет, совпадают ли первая и последняя элементы в последовательности. Предполагается, что это координаты на полигональной кривой, в этом случае функция проверяет, является ли эта кривая замкнутой.

matplotlib.mlab.ispower2(n)

Возвращает логарифм по основанию 2 от n, если n является степенью двойки, в противном случае возвращает ноль.

Обратите внимание на возможную неоднозначность, если n == 1: 2**0 == 1, интерпретируйте соответственно.

matplotlib.mlab.isvector(X)

Аналогично одноимённой функции MATLAB, возвращает True, если предоставленный массив или матрица NumPy X похож на вектор, то есть имеет один неединичный ось (т. е. может иметь несколько осей, но все они должны иметь длину 1, за исключением одной из них).

Если вы хотите только проверить, имеет ли массив 1 ось, используйте X.ndim == 1.

matplotlib.mlab.l1norm(a)

Возвращает норму l1 от a, сжатую.

Реализована как отдельная функция (а не вызов norm(), для ускорения).

matplotlib.mlab.l2norm(a)

Возвращает норму l2 от a, сжатую.

Реализована как отдельная функция (а не вызов norm(), для ускорения).

matplotlib.mlab.less_simple_linear_interpolation(x, y, xi, extrap=False)

Эта функция обеспечивает простую (но несколько менее простую, чем cbook.simple_linear_interpolation()) линейную интерполяцию. simple_linear_interpolation() создаст список точек между началом и концом, в то время как эта функция выполняет истинную линейную интерполяцию в произвольном наборе точек.

Это очень неэффективная линейная интерполяция, предназначенная для использования только с небольшим количеством точек в относительно неинтенсивных случаях использования. Для реальной линейной интерполяции используйте scipy.

matplotlib.mlab.log2(x, ln2=0.6931471805599453)

Возвращает логарифм x по основанию 2.

Эта функция _медленная_, но гарантирует возврат правильного целого значения, если входное значение является целым точным числом, являющимся степенью 2.

matplotlib.mlab.logspace(xmin, xmax, N)

Возвращает N значений, логарифмически распределённых между xmin и xmax.

Вызов:

logspace(xmin, xmax, N)

matplotlib.mlab.longest_contiguous_ones(x): Возвращает индексы самой длинной последовательности непрерывных единиц в x, предполагая, что x — вектор нулей и единиц. Если есть две одинаково длинные последовательности, выбирается первая.

matplotlib.mlab.longest_ones(x): псевдоним для longest_contiguous_ones

matplotlib.mlab.magnitude_spectrum(x, Fs=None, window=None, pad_to=None, sides=None)

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

x: одномерный массив или последовательность: Массив или последовательность, содержащая данные

Ключевые аргументы:

Fs: скаляр: Частота дискретизации (образцов в единицу времени). Используется для вычисления частот Фурье, freqs, в циклах за единицу времени. Значение по умолчанию — 2.
window: вызываемая функция или массив: Функция или вектор длиной NFFT. Для создания векторов окна см. window_hanning(), window_none(), numpy.blackman(), numpy.hamming(), numpy.bartlett(), scipy.signal(), scipy.signal.get_window(), и т. д. Значение по умолчанию — window_hanning(). Если в качестве аргумента передаётся функция, она должна принимать сегмент данных и возвращать оконную версию сегмента.
sides: [ ‘default’ | ‘onesided’ | ‘twosided’ ]: Указывает, какие стороны спектра возвращать. Значение по умолчанию обеспечивает стандартное поведение, которое возвращает односторонний спектр для вещественных данных и оба для комплексных. ‘onesided’ принудительно возвращает односторонний спектр, а ‘twosided’ — двусторонний.

pad_to: целое число: Количество точек, до которого дополняется сегмент данных при выполнении БПФ. Хотя это не увеличивает фактическое разрешение спектра (минимальное расстояние между разрешаемыми пиками), это может обеспечить больше точек на графике, что позволит получить больше деталей. Это соответствует параметру n в вызове fft(). Значение по умолчанию — None, которое устанавливает pad_to равным длине входного сигнала (т. е. без заполнения).

Возвращает кортеж (spectrum, freqs):

spectrum: одномерный массив: Значения для спектра величин (вещественные значения)
freqs: одномерный массив: Частоты, соответствующие элементам в spectrum

См. также

psd(): psd() возвращает плотность спектральной мощности.
complex_spectrum(): Эта функция возвращает абсолютное значение complex_spectrum().
angle_spectrum(): angle_spectrum() возвращает углы соответствующих частот.
phase_spectrum(): phase_spectrum() возвращает фазу (непрерывно разворачиваемый угол) соответствующих частот.
specgram(): specgram() может возвращать спектр величин сегментов внутри сигнала.

matplotlib.mlab.movavg(x, n): Вычислить скользящее среднее len(n) для x.

matplotlib.mlab.norm_flat(a, p=2)

norm(a,p=2) -> норма l-p для a.flat

Возвращает норма l-p для a, рассматривая его как плоский массив. Это НЕ является истинной матричной нормой, так как массивы произвольного ранга всегда уплощаются.

p может быть числом или строкой ‘Infinity’, чтобы получить норму L-бесконечность.

matplotlib.mlab.normpdf(x, *args): Возвращает значение функции плотности нормального распределения, вычисленное в x; args предоставляет mu, sigma

matplotlib.mlab.offset_line(y, yerr)

Смещает массив y на +/- ошибку и возвращает кортеж (y - err, y + err).

Ошибка может быть:

Скаляром. В этом случае возвращаемый кортеж очевиден.
Вектором той же длины, что и y. Величины y +/- err вычисляются поэлементно.

Кортежем длины 2. В этом случае yerr[0] — ошибка ниже y, а yerr[1] — ошибка выше y. Например:

from pylab import *
x = linspace(0, 2*pi, num=100, endpoint=True)
y = sin(x)
y_minus, y_plus = mlab.offset_line(y, 0.1)
plot(x, y)
fill_between(x, ym, y2=yp)
show()

matplotlib.mlab.path_length(X)

Вычисляет пройденное расстояние вдоль полигональной кривой в N измерениях.

Где X — массив или матрица M x N. Возвращает массив длиной M, содержащий расстояние вдоль кривой в каждой точке (т. е. строки X).

matplotlib.mlab.phase_spectrum(x, Fs=None, window=None, pad_to=None, sides=None)

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

x: одномерный массив или последовательность: Массив или последовательность, содержащая данные

Ключевые аргументы:

Fs: скаляр: Частота дискретизации (образцов в единицу времени). Используется для вычисления частот Фурье, freqs, в циклах за единицу времени. Значение по умолчанию — 2.
window: вызываемая функция или массив: Функция или вектор длиной NFFT. Для создания векторов окна см. window_hanning(), window_none(), numpy.blackman(), numpy.hamming(), numpy.bartlett(), scipy.signal(), scipy.signal.get_window(), и т. д. Значение по умолчанию — window_hanning(). Если в качестве аргумента передаётся функция, она должна принимать сегмент данных и возвращать оконную версию сегмента.
sides: [ ‘default’ | ‘onesided’ | ‘twosided’ ]: Указывает, какие стороны спектра возвращать. Значение по умолчанию обеспечивает стандартное поведение, которое возвращает односторонний спектр для вещественных данных и оба для комплексных. ‘onesided’ принудительно возвращает односторонний спектр, а ‘twosided’ — двусторонний.

pad_to: целое число: Количество точек, до которого дополняется сегмент данных при выполнении БПФ. Хотя это не увеличивает фактическое разрешение спектра (минимальное расстояние между разрешаемыми пиками), это может обеспечить больше точек на графике, что позволит получить больше деталей. Это соответствует параметру n в вызове fft(). Значение по умолчанию — None, которое устанавливает pad_to равным длине входного сигнала (т. е. без заполнения).

Возвращает кортеж (spectrum, freqs):

spectrum: одномерный массив: Значения для фазового спектра в радианах (вещественные значения)
freqs: одномерный массив: Частоты, соответствующие элементам в spectrum

См. также

complex_spectrum(): Эта функция возвращает значение угла complex_spectrum().
magnitude_spectrum(): magnitude_spectrum() возвращает величины соответствующих частот.
angle_spectrum(): angle_spectrum() возвращает обёрнутую версию этой функции.
specgram(): specgram() может возвращать фазовый спектр сегментов внутри сигнала.

matplotlib.mlab.poly_below(xmin, xs, ys)

Учитывая последовательность xs и ys, возвращает вершины многоугольника, имеющего горизонтальную основу в xmin и верхнюю границу в ys. xmin — скаляр.

Предназначен для использования с matplotlib.axes.Axes.fill(), например:

xv, yv = poly_below(0, x, y)
ax.fill(xv, yv)

matplotlib.mlab.poly_between(x, ylower, yupper)

Учитывая последовательность x, ylower и yupper, возвращает многоугольник, заполняющий области между ними. ylower или yupper могут быть скалярами или итерируемыми. Если они итерируемые, их длина должна быть равна длине x.

Возвращаемое значение — массивы x, y для использования с matplotlib.axes.Axes.fill().

matplotlib.mlab.prctile(x, p=(0.0, 25.0, 50.0, 75.0, 100.0)): Возвращает процентили x. p может быть последовательностью значений процентилей или скаляром. Если p — последовательность, i-й элемент возвращаемой последовательности — p*(i)-й процентиль *x. Если p — скаляр, возвращается наибольшее значение x, меньшее или равное p-процентной точке в последовательности.

matplotlib.mlab.prctile_rank(x, p)

Возвращает ранг каждого элемента в x, возвращает ранг 0..len(p). Например, если p = (25, 50, 75), возвращаемое значение будет массивом длиной len(x) со значениями в [0,1,2,3], где 0 указывает, что значение меньше 25-го процентиля, 1 указывает, что значение больше или равно 25-му и меньше 50-го процентиля, ... и 3 указывает, что значение выше 75-го процентильного отсечения.

p — это либо массив процентилей в [0..100], либо скаляр, который указывает, сколько квантилей данных необходимо ранжировать.

matplotlib.mlab.psd(x, NFFT=None, Fs=None, detrend=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None)

Вычисляет плотность спектральной мощности.

Вызов:

psd(x, NFFT=256, Fs=2, detrend=mlab.detrend_none,
    window=mlab.window_hanning, noverlap=0, pad_to=None,
    sides='default', scale_by_freq=None)

Плотность спектральной мощности вычисляется методом усреднённой периодограммы Уэлча. Вектор x делится на сегменты длиной NFFT. Каждый сегмент обрабатывается функцией detrend и окончивается функцией window. noverlap определяет длину перекрытия между сегментами. каждого сегмента усредняются для вычисления .

Если len(x) < NFFT, данные дополняются нулями до NFFT.

x: одномерный массив или последовательность: Массив или последовательность, содержащая данные

Ключевые аргументы:

Fs: скаляр: Частота дискретизации (образцов в единицу времени). Она используется для вычисления частот Фурье, freqs, в циклах за единицу времени. Значение по умолчанию равно 2.
window: вызываемая функция или одномерный массив: Функция или вектор длины NFFT. Для создания векторов окна см. window_hanning(), window_none(), numpy.blackman(), numpy.hamming(), numpy.bartlett(), scipy.signal(), scipy.signal.get_window(), и т.д. По умолчанию используется window_hanning(). Если в качестве аргумента передаётся функция, она должна принимать сегмент данных и возвращать оконченную версию сегмента.
sides: [ ‘default’ | ‘onesided’ | ‘twosided’ ]: Указывает, какие стороны спектра возвращать. По умолчанию используется поведение по умолчанию, которое возвращает односторонний спектр для вещественных данных и двусторонний для комплексных. ‘onesided’ принудительно возвращает односторонний спектр, ‘twosided’ — двусторонний.

pad_to: целое число

Число точек, до которых дополняются данные сегмента при выполнении БПФ. Это может отличаться от NFFT, которое определяет количество используемых точек данных. Хотя это не увеличивает фактическое разрешение спектра (минимальное расстояние между разрешаемыми пиками), это может обеспечить больше точек на графике, позволяя получить больше деталей. Это соответствует параметру n в вызове fft(). Значение по умолчанию — None, которое устанавливает pad_to равным NFFT

NFFT: целое число

Число точек данных, используемых в каждом блоке для БПФ. Мощность двойки наиболее эффективна. Значение по умолчанию — 256. Не следует использовать для нулевого заполнения, так как это повлияет на масштабирование результата. Используйте pad_to вместо этого.

detrend: [ ‘default’ | ‘constant’ | ‘mean’ | ‘linear’ | ‘none’] или

вызываемая функция

Функция, применяемая к каждому сегменту перед БПФ, предназначенная для удаления среднего значения или линейной тенденции. В отличие от MATLAB, где параметр detrend — вектор, в matplotlib он является функцией. Модуль pylab определяет detrend_none(), detrend_mean(), и detrend_linear(), но можно использовать и пользовательскую функцию. Можно также использовать строку для выбора одной из функций. ‘default’, ‘constant’ и ‘mean’ вызывают detrend_mean(). ‘linear’ вызывает detrend_linear(). ‘none’ вызывает detrend_none().

scale_by_freq: булево значение

Указывает, следует ли масштабировать значения плотности с учётом масштабирующей частоты, что даёт плотность в единицах Hz^-1. Это позволяет интегрировать по возвращаемым частотным значениям. По умолчанию True для совместимости с MATLAB.

noverlap: целое число Число перекрывающихся точек между сегментами. Значение по умолчанию — 0 (без перекрытия).

Возвращает кортеж (Pxx, freqs).

Pxx: одномерный массив: Значения для спектральной мощности P_{xx} (вещественные)
freqs: одномерный массив: Частоты, соответствующие элементам в Pxx

Сноски:

Bendat & Piersol – Случайные данные: анализ и методы измерения, John Wiley & Sons (1986)

См. также

specgram(): specgram() отличается по умолчанию перекрытием; не возвращает среднее значение периодограмм сегмента; и возвращает моменты сегментов.
magnitude_spectrum(): magnitude_spectrum() возвращает спектр величины.
csd(): csd() возвращает спектральную плотность между двумя сигналами.

matplotlib.mlab.quad2cubic(q0x, q0y, q1x, q1y, q2x, q2y)

Преобразует квадратичную кривую Безье в кубическое приближение.

На вход подаются координаты x и y трёх контрольных точек квадратичной кривой, а на выходе возвращается кортеж координат x и y четырёх контрольных точек кубической кривой.

matplotlib.mlab.rec2csv(r, fname, delimiter=', ', formatd=None, missing='', missingd=None, withheader=True)

Сохраняет данные из массива r типа numpy recarray в файл с разделителями запятая/пробел/табуляция. Имена типов данных массива записей будут использованы в качестве заголовков столбцов.

fname: может быть именем файла или дескриптором файла. Автоматически поддерживается сжатие gzip,: если имя файла заканчивается на ‘.gz’
withheader: если withheader — False, не записывать имена атрибутов в первой строке

для формата типа FormatFloat, мы переопределяем точность, чтобы сохранить полную точность чисел с плавающей запятой в CSV-файле

См. также

csv2rec(): Для информации о missing и missingd, которые могут использоваться для заполнения пропущенных значений в вашем CSV-файле.

matplotlib.mlab.rec2txt(r, header=None, padding=3, precision=3, fields=None)

Возвращает текстовое представление массива записей.

r: массив numpy записей

header: список заголовков столбцов

padding: пробел между каждым столбцом

precision: количество десятичных знаков для чисел с плавающей запятой.: Установите целое число, чтобы применить его ко всем числам с плавающей запятой. Установите список целых чисел, чтобы применить точность индивидуально. Точность для нечисел с плавающей запятой просто игнорируется.

fields : если не None, список имён полей для печати. fields может быть списком строк, например, [‘field1’, ‘field2’], или одной строкой, разделённой запятыми, например, ‘field1,field2’

Пример:

precision=[0,2,3]

Вывод:

ID    Price   Return
ABC   12.54    0.234
XYZ    6.32   -0.076

matplotlib.mlab.rec_append_fields(rec, names, arrs, dtypes=None): Возвращает новый массив записей с именами полей, заполненными данными из массивов в arrs. Если добавляется одно поле, то names, arrs и dtypes не обязательно должны быть списками. Это могут быть просто сами значения.

matplotlib.mlab.rec_drop_fields(rec, names): Возвращает новый массив numpy записей с удалёнными полями в names.

matplotlib.mlab.rec_groupby(r, groupby, stats)

r — это массив numpy записей

groupby — последовательность имён атрибутов массива записей, которые вместе образуют ключ группировки. Например, (‘date’, ‘productcode’)

stats — последовательность кортежей (attr, func, outname), которые будут вызывать x = func(attr) и назначать x в результирующий массив записей с атрибутом outname. Например:

stats = ( ('sales', len, 'numsales'), ('sales', np.mean, 'avgsale') )

Результирующий массив записей содержит имена атрибутов для каждого имени атрибута в аргументе groupby, со связанными значениями групп, и для каждого имени outname в аргументе stats со связанными обобщающими результатами.

matplotlib.mlab.rec_join(key, r1, r2, jointype='inner', defaults=None, r1postfix='1', r2postfix='2')

Объединяет массивы записей r1 и r2 по key; key — кортеж имён полей; если key — строка, предполагается, что это имя одного атрибута. Если r1 и r2 имеют одинаковые значения по всем ключам в кортеже key, то их поля будут объединены в новый массив записей, содержащий пересечение полей r1 и r2.

r1 (также r2) не должен иметь дубликатов ключей.

Ключевое слово jointype может быть ‘inner’, ‘outer’, ‘leftouter’. Для выполнения правого внешнего объединения просто поменяйте местами r1 и r2.

Ключевое слово defaults — словарь, заполненный парами {column_name:default_value}.

Ключевые слова r1postfix и r2postfix добавляются как постфиксы к именам столбцов (кроме ключей), которые присутствуют как в r1, так и в r2.

matplotlib.mlab.rec_keep_fields(rec, names): Возвращает новый массив numpy записей, содержащий только поля, перечисленные в names

matplotlib.mlab.rec_summarize(r, summaryfuncs)

r — массив numpy записей

summaryfuncs — список кортежей (attr, func, outname), которые будут применять func к массиву r*[attr] и назначать результат новому имени атрибута *outname*. Возвращаемый массив записей идентичен r, с дополнительными массивами для каждого элемента в summaryfuncs.

matplotlib.mlab.recs_join(key, name, recs, jointype='outer', missing=0.0, postfixes=None)

Объединить последовательность массивов записей по ключу одного столбца.

Эта функция объединяет только один столбец нескольких массивов записей

ключ: имя столбца, используемого в качестве ключа
имя: имя столбца, который мы хотим объединить
recs: список массивов записей для объединения
jointype: строка ‘внутренний’ или ‘внешний’
missing: чем заполняются отсутствующие поля
postfixes: если не None, последовательность постфиксов длиной recs

Возвращает массив записей со столбцами [rowkey, name0, name1, ... namen-1]. или, если указаны постфиксы [PF0, PF1, ..., PFN-1], [rowkey, namePF0, namePF1, ... namePFN-1].

Пример:

r = recs_join("date", "close", recs=[r0, r1], missing=0.)

matplotlib.mlab.rk4(derivs, y0, t)

Интегрировать 1D или ND систему ОДУ с использованием четвёртого порядка Рунге-Кутты. Это пробная реализация, которая может быть полезна, если вы оказались в системе без scipy. В противном случае используйте scipy.integrate().

y0: вектор начального состояния
t: временные отсчёты
derivs: возвращает производную системы и имеет подпись dy = derivs(yi, ti)

Пример 1

## 2D system

def derivs6(x,t):
    d1 =  x[0] + 2*x[1]
    d2 =  -3*x[0] + 4*x[1]
    return (d1, d2)
dt = 0.0005
t = arange(0.0, 2.0, dt)
y0 = (1,2)
yout = rk4(derivs6, y0, t)

Пример 2:

## 1D system
alpha = 2
def derivs(x,t):
    return -alpha*x + exp(-t)

y0 = 1
yout = rk4(derivs, y0, t)

Если у вас есть доступ к scipy, вы, вероятно, должны использовать инструменты scipy.integrate вместо этой функции.

matplotlib.mlab.rms_flat(a): Возвращает среднеквадратичное отклонение всех элементов a, сжатых в одномерный массив.

matplotlib.mlab.safe_isinf(x): numpy.isinf() для произвольных типов

matplotlib.mlab.safe_isnan(x): numpy.isnan() для произвольных типов

matplotlib.mlab.segments_intersect(s1, s2)

Возвращает True, если s1 и s2 пересекаются. s1 и s2 определены как:

s1: (x1, y1), (x2, y2)
s2: (x3, y3), (x4, y4)

matplotlib.mlab.slopes(x, y)

slopes() вычисляет наклон y‘(x)

Наклон оценивается с использованием наклона параболы, проходящей через любые три последовательные точки.

Этот метод должен быть предпочтительнее метода, описанного в приложении к статье A CONSISTENTLY WELL BEHAVED METHOD OF INTERPOLATION Рассела У. Стайнемана (Creative Computing, июль 1980) по крайней мере в одном аспекте:

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

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

Норберт Немец, Институт теоретической физики, Университет Регенсбурга, апрель 2006 Norbert.Nemec at physik.uni-regensburg.de

(на основе первоначальной реализации Халдора Бьёрнссона, Исланская метеорологическая служба, март 2006 halldor at vedur.is)

matplotlib.mlab.specgram(x, NFFT=None, Fs=None, detrend=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None, mode=None)

Вычислить спектログラム.

Вызов:

specgram(x, NFFT=256, Fs=2,detrend=mlab.detrend_none,
        window=mlab.window_hanning, noverlap=128,
        cmap=None, xextent=None, pad_to=None, sides='default',
        scale_by_freq=None, mode='default')

Вычислить и отобразить спектログラム данных в x. Данные разбиваются на сегменты длиной NFFT, и вычисляется спектр каждого сегмента. К каждому сегменту применяется функция оконного фильтра window, а количество перекрытия каждого сегмента задаётся параметром noverlap.

x: одномерный массив или последовательность: Массив или последовательность, содержащая данные

Ключевые аргументы:

Fs: скаляр: Частота дискретизации (отсчёты за единицу времени). Используется для вычисления частот Фурье, freqs, в циклах за единицу времени. Значение по умолчанию равно 2.
window: вызываемая функция или массив: Функция или вектор длиной NFFT. Для создания векторов окон см. window_hanning(), window_none(), numpy.blackman(), numpy.hamming(), numpy.bartlett(), scipy.signal(), scipy.signal.get_window(), и т. д. Значение по умолчанию — window_hanning(). Если в качестве аргумента передаётся функция, она должна принимать сегмент данных в качестве аргумента и возвращать оконную версию сегмента.
sides: [ ‘default’ | ‘onesided’ | ‘twosided’ ]: Указывает, какие стороны спектра возвращать. Значение по умолчанию соответствует стандартному поведению, которое возвращает односторонний спектр для вещественных данных и двусторонний для комплексных данных. ‘onesided’ принудительно возвращает односторонний спектр, а ‘twosided’ — двусторонний.

pad_to: целое число

Количество точек, до которых дополняется сегмент данных при выполнении преобразования Фурье. Может отличаться от NFFT, которое определяет количество точек данных, используемых. Несмотря на то, что не увеличивает фактическое разрешение спектра (минимальное расстояние между разрешаемыми пиками), это может дать больше точек на графике, что позволит получить больше деталей. Соответствует параметру n в вызове fft(). Значение по умолчанию — None, что устанавливает pad_to равным NFFT

NFFT: целое число

Количество точек данных, используемых в каждом блоке для преобразования Фурье. Мощность 2 является наиболее эффективной. Значение по умолчанию равно 256. Не следует использовать для получения нулевого заполнения, иначе масштабирование результата будет неправильным. Для этого используйте pad_to.

detrend: [ ‘default’ | ‘constant’ | ‘mean’ | ‘linear’ | ‘none’] или

вызываемая функция

Функция, применяемая к каждому сегменту перед преобразованием Фурье, предназначенная для удаления среднего значения или линейной тенденции. В отличие от MATLAB, где параметр detrend является вектором, в matplotlib он является функцией. Модуль pylab определяет detrend_none(), detrend_mean(), и detrend_linear(), но вы можете использовать и пользовательскую функцию. Вы также можете использовать строку для выбора одной из функций. ‘default’, ‘constant’ и ‘mean’ вызывают detrend_mean(). ‘linear’ вызывает detrend_linear(). ‘none’ вызывает detrend_none().

scale_by_freq: boolean

Указывает, следует ли масштабировать возвращаемые значения плотности с учётом масштабирования частоты, что даёт плотность в единицах Hz^-1. Это позволяет интегрировать возвращаемые значения частоты. Значение по умолчанию True для совместимости с MATLAB.

mode: [ ‘default’ | ‘psd’ | ‘complex’ | ‘magnitude’: ‘angle’ | ‘phase’ ]
Какой тип спектра использовать. Значение по умолчанию — ‘psd’, которое возвращает плотность спектральной мощности. ‘complex’ возвращает комплекснозначный спектр частот. ‘magnitude’ возвращает спектр амплитуд. ‘angle’ возвращает спектр фаз без развязки. ‘phase’ возвращает спектр фаз с развязкой.
noverlap: целое число: Количество перекрывающихся точек между блоками. Значение по умолчанию — 128.

Возвращает кортеж (spectrum, freqs, t):

spectrum: двумерный массив: столбцы — периодограммы последовательных сегментов
freqs: одномерный массив: Частоты, соответствующие строкам в spectrum
t: одномерный массив: Времена, соответствующие серединам сегментов (т. е. столбцам в spectrum).

Примечание

detrend и scale_by_freq применяются только при mode = ‘psd’

См. также

psd(): psd() отличается по умолчанию перекрытия; при возвращении среднего значения периодограмм сегмента; и при отсутствии возвращаемых времен.
complex_spectrum(): Один спектр, аналогичный случаю с одним сегментом при mode = ‘complex’.
magnitude_spectrum(): Один спектр, аналогичный случаю с одним сегментом при mode = ‘magnitude’.
angle_spectrum(): Один спектр, аналогичный случаю с одним сегментом при mode = ‘angle’.
phase_spectrum(): Один спектр, аналогичный случаю с одним сегментом при mode = ‘phase’.

matplotlib.mlab.stineman_interp(xi, x, y, yp=None)

При заданных векторах данных x и y, векторе наклона yp и новом векторе абсцисс xi, функция stineman_interp() использует интерполяцию Стинемана для вычисления вектора yi, соответствующего xi.

Вот пример, который генерирует грубую синусоиду, а затем интерполирует по более мелкой абсциссе:

x = linspace(0,2*pi,20);  y = sin(x); yp = cos(x)
xi = linspace(0,2*pi,40);
yi = stineman_interp(xi,x,y,yp);
plot(x,y,'o',xi,yi)

Метод интерполяции описан в статье «КОНСИСТЕНТНО ХОРОШО ПОВЕДЕННЫЙ МЕТОД ИНТЕРПОЛЯЦИИ» Рэссела У. Стинемана. Статья была опубликована в июльском выпуске «Creative Computing» 1980 года с примечанием редактора, в котором отмечалось, что, хотя это и не академический журнал, время от времени появляются серьёзные и оригинальные статьи, добавляя, что это «по-видимому, действительно решение» известной проблемы.

Для yp = None, процедура автоматически определяет наклоны, используя функцию slopes().

Предполагается, что x отсортирован в порядке возрастания.

Для значений xi[j] < x[0] или xi[j] > x[-1], процедура пытается выполнить экстраполяцию. Соответствие полученных данных, конечно, под вопросом...

Исходная реализация Хольдором Бьёрнссоном, Исланская метеорологическая служба, март 2006 года halldor at vedur.is

Полностью переработана и оптимизирована для Python Норбертом Немецом, Институт теоретической физики, университет Регенсбурга, апрель 2006 года Norbert.Nemec at physik.uni-regensburg.de

matplotlib.mlab.stride_repeat(x, n, axis=0)

Повторяет значения в массиве с высокой эффективностью использования памяти. Массив x складывается вертикально n раз.

Предупреждение

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

Вызов функции:

  stride_repeat(x, n, axis=0)

*x*: 1D array or sequence
  Array or sequence containing the data.

*n*: integer
  The number of time to repeat the array.

*axis*: integer
  The axis along which the data will run.

Ссылок:: stackoverflaw: Повторение массива NumPy без дублирования данных?

matplotlib.mlab.stride_windows(x, n, noverlap=None, axis=0)

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

Предупреждение

Вызов функции:

  stride_windows(x, n, noverlap=0)

*x*: 1D array or sequence
  Array or sequence containing the data.

*n*: integer
  The number of data points in each window.

*noverlap*: integer
  The overlap between adjacent windows.
  Default is 0 (no overlap)

*axis*: integer
  The axis along which the windows will run.

Ссылок:: stackoverflaw: Окно скользящего среднего для одномерных массивов в Numpy? stackoverflaw: Использование сдвигов для эффективного фильтра скользящего среднего

matplotlib.mlab.vector_lengths(X, P=2.0, axis=None)

Находит длину набора векторов в n измерениях. Это похоже на функцию numpy.norm() для векторов, но имеет возможность работать с конкретной осью заданного массива или матрицы.

Вычисляет (sum((x_i)^P))^(1/P) для каждого {x_i} являющегося элементами X вдоль заданной оси. Если axis имеет значение None, вычисление выполняется по всем элементам X.

matplotlib.mlab.window_hanning(x)

Возвращает x умноженный на окно Ханнанг длины(x).

Вызов функции:

window_hanning(x)

См. также

window_none(): window_none() — это другой алгоритм окна.

matplotlib.mlab.window_none(x)

Функция окна отсутствует; просто возвращает x.

Вызов функции:

window_none(x)

См. также

window_hanning(): window_hanning() — это другой алгоритм окна.