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

Если вы хотите интерполировать данные достаточно общим и быстрым способом, сплайны или полиномы очень полезны. В 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)

Это должно быть значительно быстрее, чем ваша исходная реализация.

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

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

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

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

Вот минимальный пример 1d-интерполяции с помощью scipy - не так весело, как изобретать заново, но.
Сюжет имеет вид sinc , что не случайно: попробуйте повторную выборку сплайна Google "приблизительный 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 г .: см. также basic-spline-interpolation-in-a-few-lines-of-numpy

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

Ниже приводится аннотация:

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

Я не совсем уверен то, что вы пытаетесь сделать, но есть некоторые ускорения, которые вы можете сделать для создания матрицы. Предложение Брэйнкора использовать 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

Хитрость в том, что, индексируя aranges с помощью numpy.newaxis, numpy преобразует массив с формой i в массив с формой ix 1, а массив с формой j в форму 1 х j. На этапе вычитания numpy будет "транслировать" каждый ввод, чтобы действовать как массив в форме aixj, и выполнять вычитание. ("Трансляция" - термин numpy, отражающий тот факт, что не создается дополнительная копия для растягивания ix 1 до ix j.)

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

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

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

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