передискретизация, интерполирующая матрица

Это повышение частоты дискретизации. См. Помощь с передискретизацией/апсемплингом для некоторых примеров решений.

Быстрый способ сделать это (для автономных данных, таких как ваше графическое приложение) — использовать БПФ. Это то, что делает нативная функция SciPy resample(). . Однако он предполагает периодический сигнал, , так что это не совсем то же самое. См. эту ссылку:

Если вы хотите интерполировать данные довольно общим и быстрым способом, сплайны или полиномы очень полезны. В Scipy есть очень полезный модуль scipy.interpolate. Вы можете найти множество примеров на официальных страницах.

Ваш вопрос не совсем ясен; вы пытаетесь оптимизировать код, который вы разместили, верно?

Переписывание sinc должно значительно ускорить его. Эта реализация избегает проверки того, что математический модуль импортируется при каждом вызове, не выполняет доступ к атрибуту три раза и заменяет обработку исключений условным выражением:

from math import sin, pi
def sinc(x):
    return (sin(pi * x) / (pi * x)) if x != 0 else 1.0

Вы также можете попробовать избежать создания матрицы дважды (и дважды удерживать ее параллельно в памяти), создав numpy.array напрямую (а не из списка списков):

def resampleMatrix(Tso, Tsf, o, f):
    retval = numpy.zeros((f, o))
    for i in xrange(f):
        for j in xrange(o):
            retval[i][j] = sinc((Tsf*i - Tso*j)/Tso)
    return retval

(замените xrange на range в Python 3.0 и выше)

Наконец, вы можете создавать строки с помощью numpy.arange, а также вызывать numpy.sinc для каждой строки или даже для всей матрицы:

def resampleMatrix(Tso, Tsf, o, f):
    retval = numpy.zeros((f, o))
    for i in xrange(f):
        retval[i] = numpy.arange(Tsf*i / Tso, Tsf*i / Tso - o, -1.0)
    return numpy.sinc(retval)

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

Я не совсем уверен, что вы пытаетесь сделать, но есть некоторые ускорения, которые вы можете сделать для создания матрицы. Предложение Braincore использовать numpy.sinc — это первый шаг, но второй — осознать, что numpy функции хотят работать с массивами numpy, где они могут выполнять циклы на скорости C и могут делать это быстрее, чем с отдельными элементами.

def resampleMatrix(Tso, Tsf, o, f):
    retval = numpy.sinc((Tsi*numpy.arange(i)[:,numpy.newaxis]
                         -Tso*numpy.arange(j)[numpy.newaxis,:])/Tso)
    return retval

Хитрость заключается в том, что, индексируя диапазоны с помощью numpy.newaxis, numpy преобразует массив с формой i в массив с формой i x 1, а массив с формой j — в форму 1 x j. На этапе вычитания numpy будет «транслировать» каждый вход, чтобы он действовал как массив в форме i x j, и выполнял вычитание. ("Broadcast" - это термин numpy, отражающий тот факт, что не делается никакой дополнительной копии, чтобы растянуть i x 1 до i x j.)

Теперь numpy.sinc может перебирать все элементы в скомпилированном коде намного быстрее, чем любой цикл for, который вы могли бы написать.

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

Единственным недостатком является то, что теперь вы платите за дополнительный массив Nx10*N для хранения разницы. Это может нарушить сделку, если N велико, а память является проблемой.

В противном случае вы сможете написать это, используя numpy.convolve. Из того немногого, что я только что узнал о sinc-интерполяции, я бы сказал, что вам нужно что-то вроде numpy.convolve(orig,numpy.sinc(numpy.arange(j)),mode="same"). Но я, наверное, ошибаюсь в деталях.

Если вас интересует только «создание «гладкого» графика», я бы просто выбрал простую полиномиальную сплайновую кривую:

Для любых двух соседних точек данных коэффициенты полиномиальной функции третьей степени могут быть вычислены из координат этих точек данных и двух дополнительных точек слева и справа от них (без учета граничных точек). Это создаст точки на красивой гладкой кривой с непрерывная первая дивизна. Существует прямая формула для преобразования 4 координат в 4 полиномиальных коэффициента, но я не хочу лишать вас удовольствия от ее поиска ;o).

Вот минимальный пример одномерной интерполяции с помощью scipy — не так весело, как заново изобретать, но.
Сюжет выглядит как sinc, что не случайно: попробуйте сплайн-сплайн гугл передискретизировать "приблизительно sinc".
(Предположительно, менее локальный / больше нажатий, лучшее приближение, но я понятия не имею, насколько локальны UnivariateSplines.)

""" interpolate with scipy.interpolate.UnivariateSpline """
from __future__ import division
import numpy as np
from scipy.interpolate import UnivariateSpline
import pylab as pl

N = 10 
H = 8
x = np.arange(N+1)
xup = np.arange( 0, N, 1/H )
y = np.zeros(N+1);  y[N//2] = 100

interpolator = UnivariateSpline( x, y, k=3, s=0 )  # s=0 interpolates
yup = interpolator( xup )
np.set_printoptions( 1, threshold=100, suppress=True )  # .1f
print "yup:", yup

pl.plot( x, y, "green",  xup, yup, "blue" )
pl.show()

Добавлено в феврале 2010 г.: см. также базовая сплайн-интерполяция в нескольких строках numpy

Небольшое улучшение. Используйте встроенную функцию numpy.sinc(x), которая запускается в скомпилированном коде C.

Возможное большее улучшение: можете ли вы выполнять интерполяцию на лету (по мере построения графика)? Или вы привязаны к библиотеке графиков, которая принимает только матрицу?

Я рекомендую вам проверить ваш алгоритм, так как это нетривиальная задача. В частности, я предлагаю вам ознакомиться со статьей Hu and Pavlidis (1991) «Построение графиков функций с использованием конических сплайнов» (Компьютерная графика и приложения IEEE). Реализация их алгоритма позволяет выполнять адаптивную выборку функции, так что время рендеринга меньше, чем при подходах с регулярными интервалами.

Резюме следует:

Представлен метод, при котором по заданному математическому описанию функции строится конический сплайн, аппроксимирующий график функции. Конические дуги были выбраны в качестве примитивных кривых, потому что существуют простые алгоритмы пошагового построения коник, уже включенные в некоторые драйверы устройств, а также простые алгоритмы локальной аппроксимации кониками. Введен алгоритм разделения и слияния для адаптивного выбора узлов по анализу формы исходной функции на основе ее производных первого порядка.