Численное интегрирование над Матрицей функций, SymPy и SciPy
из моего выхода SymPy у меня есть матрица, показанная ниже, которую я должен интегрировать в 2D. В настоящее время я делаю это элементарно, как показано ниже. Этот метод работает, но он становится слишком медленным (для обоих sympy.mpmath.quad и scipy.integrate.dblquad) для моего реального случая (в котором A и его функции намного больше (см. edit ниже):
from sympy import Matrix, sin, cos
import sympy
import scipy
sympy.var( 'x, t' )
A = Matrix([[(sin(2-0.1*x)*sin(t)*x+cos(2-0.1*x)*cos(t)*x)*cos(3-0.1*x)*cos(t)],
[(cos(2-0.1*x)*sin(t)*x+sin(2-0.1*x)*cos(t)*x)*sin(3-0.1*x)*cos(t)],
[(cos(2-0.1*x)*sin(t)*x+cos(2-0.1*x)*sin(t)*x)*sin(3-0.1*x)*sin(t)]])
# integration intervals
x1,x2,t1,t2 = (30, 75, 0, 2*scipy.pi)
# element-wise integration
from sympy.utilities import lambdify
from sympy.mpmath import quad
from scipy.integrate import dblquad
A_int1 = scipy.zeros( A.shape, dtype=float )
A_int2 = scipy.zeros( A.shape, dtype=float )
for (i,j), expr in scipy.ndenumerate(A):
tmp = lambdify( (x,t), expr, 'math' )
A_int1[i,j] = quad( tmp, (x1, x2), (t1, t2) )
# or (in scipy)
A_int2[i,j] = dblquad( tmp, t1, t2, lambda x:x1, lambda x:x2 )[0]
я рассматривал возможность сделать это за один выстрел, но я не уверен, что это путь:
A_eval = lambdify( (x,t), A, 'math' )
A_int1 = sympy.quad( A_eval, (x1, x2), (t1, t2)
# or (in scipy)
A_int2 = scipy.integrate.dblquad( A_eval, t1, t2, lambda x: x1, lambda x: x2 )[0]
изменить:
Реальный случай был сделан доступно в этой ссылке. Просто распакуйте и запустите shadmehri_2012.py (автор из Были этот пример взят из:Shadmehri et al. 2012).
Я начал баунти 50 для того, кто может сделать следующее:
- сделать это разумно быстрее, чем предлагаемый вопрос
- управление запустить без ошибки памяти даже с рядом терминов
m=15иn=15в коде), мне удалось доm=7иn=7in 32-бит
текущее время можно суммировать ниже (измерено с m=3 и n=3). Отсюда видно, что численное интегрирование является узким местом.
построить пробные функции = 0%
оценка дифференциальных уравнений = 2%
lambdifying k1 = 22%
интеграция К1 = 74%
лямбдификация и интегрирование k2 = 2%
извлечение собственных значений = 0%
вопросы: о lambdify
2 ответов
Я думаю, что вы можете избежать времени лямбдификации, переключившись на численную оценку на другом этапе расчета.
а именно, ваш расчет кажется диагональным в том смысле, что k1 и k2 оба вида k = g^T X g где X - некоторая матрица 5x5 (с дифференциальными ops внутри, но это не имеет значения), и g 5xM, с M большим. Поэтому k[i,j] = g.T[i,:] * X * g[:,j].
так что вы можете просто заменить
for j in xrange(1,n+1):
for i in xrange(1,m+1):
g1 += [uu(i,j,x,t), 0, 0, 0, 0]
g2 += [ 0,vv(i,j,x,t), 0, 0, 0]
g3 += [ 0, 0,ww(i,j,x,t), 0, 0]
g4 += [ 0, 0, 0,bx(i,j,x,t), 0]
g5 += [ 0, 0, 0, 0,bt(i,j,x,t)]
g = Matrix( [g1, g2, g3, g4, g5] )
С
i1 = Symbol('i1')
j1 = Symbol('j1')
g1 = [uu(i1,j1,x,t), 0, 0, 0, 0]
g2 = [ 0,vv(i1,j1,x,t), 0, 0, 0]
g3 = [ 0, 0,ww(i1,j1,x,t), 0, 0]
g4 = [ 0, 0, 0,bx(i1,j1,x,t), 0]
g5 = [ 0, 0, 0, 0,bt(i1,j1,x,t)]
g_right = Matrix( [g1, g2, g3, g4, g5] )
i2 = Symbol('i2')
j2 = Symbol('j2')
g1 = [uu(i2,j2,x,t), 0, 0, 0, 0]
g2 = [ 0,vv(i2,j2,x,t), 0, 0, 0]
g3 = [ 0, 0,ww(i2,j2,x,t), 0, 0]
g4 = [ 0, 0, 0,bx(i2,j2,x,t), 0]
g5 = [ 0, 0, 0, 0,bt(i2,j2,x,t)]
g_left = Matrix( [g1, g2, g3, g4, g5] )
и
tmp = evaluateExpr( B*g ) k1 = r*tmp.transpose() * F * tmp k2 = r*g.transpose()*evaluateExpr(Bc*g) k2 = evaluateExpr( k2 )
by
tmp_right = evaluateExpr( B*g_right ) tmp_left = evaluateExpr( B*g_left ) k1 = r*tmp_left.transpose() * F * tmp_right k2 = r*g_left.transpose()*evaluateExpr(Bc*g_right) k2 = evaluateExpr( k2 )
не тестировал (мимо am), но вы получаете идею.
теперь, вместо того, чтобы иметь огромную символическую матрицу, которая делает все медленным, у вас есть два матричных индекса для индексов пробных функций и свободных параметров i1,j1 и i2,j2 которые играют свою роль, и вы должны заменить целые числа в них в конце.
С матрицы lambdify только 5х5, и должен быть lambdified только один раз за все петли, lambdification и упрощение накладные ушел. Более того, проблема легко вписывается в память даже для больших m, n.
интеграция не быстрее, но так как выражения очень малы, вы можете легко, например сбросить их в Фортране или сделать что-то еще умное.
quadpy (мой проект) делает векторизовать численное интегрирование. Это
from numpy import sin, cos, pi
import quadpy
def f(X):
x, t = X
return [
[(sin(2-0.1*x)*sin(t)*x+cos(2-0.1*x)*cos(t)*x)*cos(3-0.1*x)*cos(t)],
[(cos(2-0.1*x)*sin(t)*x+sin(2-0.1*x)*cos(t)*x)*sin(3-0.1*x)*cos(t)],
[(cos(2-0.1*x)*sin(t)*x+cos(2-0.1*x)*sin(t)*x)*sin(3-0.1*x)*sin(t)]
]
x1 = 30
x2 = 75
t1 = 0
t2 = 2*pi
sol = quadpy.quadrilateral.integrate(
f,
[[x1, t1], [x2, t1], [x2, t2], [x1, t2]],
quadpy.quadrilateral.Product(quadpy.line_segment.GaussLegendre(5))
)
print(sol)
дает
[[ 1456.3701526 ]
[ 2620.60490653]
[ 5034.5831071 ]]
часы работы:
%timeit quadpy.quadrilateral.integrate(f, [[x1, t1], [x2, t1], [x2, t2], [x1, t2]], q)
1000 loops, best of 3: 219 µs per loop
это приводит к резкому ускорению в свой загружаемый пример:
import numpy
array2mat = [{'ImmutableMatrix': numpy.array}, 'numpy']
k1_lambda = lambdify( (x,t), k1, modules=array2mat)
print 'Finished lambdifying k1:', time.clock()
import quadpy
sol = quadpy.quadrilateral.integrate(
lambda X: k1_lambda(X[0], X[1]),
[[x1, t1], [x2, t1], [x2, t2], [x1, t2]],
quadpy.quadrilateral.Product(quadpy.line_segment.GaussLegendre(5))
)
выход:
Start: 0.040001
Finished trial functions: 0.379929
Finished evaluating differential equations: 2.669536
Finished lambdifying k1: 29.961808
Finished integrating k1: 30.106988
Finished lambdifying and integrating k2: 34.229007
Finished calculating eigenvalues and eigenvectors: 34.229924
отметим, что quadpy не делает адаптивную квадратуру, поэтому выбирайте свою схему с умом.