Aus meiner SymPy-Ausgabe habe ich die unten gezeigte Matrix, die ich in 2D integrieren muss. Momentan mache ich es elementweise wie unten gezeigt. Diese Methode funktioniert, wird aber zu langsam (für beide)sympy.mpmath.quad undscipy.integrate.dblquad) für meinen wirklichen Fall (in demA und seine Funktionen sind viel größer (siehe unten bearbeiten):

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]

Ich habe darüber nachgedacht, es auf einmal zu machen, bin mir aber nicht sicher, ob dies der richtige Weg ist:

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]

EDIT: Der reale Fall wurde in zur Verfügung gestelltdieser Link. Einfach entpacken und ausführenshadmehri_2012.py (ist der Autor, von dem dieses Beispiel stammt:Shadmehri et al. 2012). Ich habe ein Kopfgeld von 50 für denjenigen ausgegeben, der Folgendes kann:

machen es einigermaßen schneller als die vorgeschlagene Frage
verwalten, ohne Speicherfehler auch mit einer Reihe von Begriffen zu führenm=15 undn=15 im code) habe ich es geschafft bis zum=7 undn=7 in 32-Bit

Der aktuelle Zeitpunkt kann im Folgenden zusammengefasst werden (gemessen mit m = 3 und n = 3). Von dort ist zu sehen, dass die numerische Integration der Engpass ist.

Testfunktionen erstellen = 0%
Differentialgleichungen auswerten = 2%
lambdifying k1 = 22%
Integrieren von k1 = 74%
lambdifizieren und integrieren von k2 = 2%
Extrahieren von Eigenwerten = 0%

Verwandte Fragen:über lambdify