1
votes

Comment évaluer cette intégrale de ligne (Python-Sympy)

L'idée est de calculer l'intégrale de ligne du champ vectoriel et de la courbe suivants:

Voici le code que j'ai essayé:

import numpy as np
from sympy import *
from sympy import Curve, line_integrate
from sympy.abc import x, y, t
C = Curve([cos(t) + 1, sin(t) + 1, 1 - cos(t) - sin(t)], (t, 0, 2*np.pi))
line_integrate(y * exp(x) +  x**2 + exp(x) + z**2 * exp(z), C, [x, y, z])

Mais l'argument ValueError: Function devrait être (x (t), y (t )) mais obtenu [cos (t) + 1, sin (t) + 1, -sin (t) - cos (t) + 1] apparaît.

Comment puis-je calculer cette intégrale de ligne alors ?

Je pense que cette intégrale de ligne contient peut-être des intégrales qui n'ont pas de solution exacte. Cela convient également si vous fournissez une méthode d'approximation numérique.

Merci

python numeric numerical-methods sympy numerical-integration

2 commentaires

Si vous regardez le code source de la fonction de courbe, il ne prend en charge que les courbes paramétriques 2D, ce qui explique votre valueError.

Oh je vois, alors comment puis-je évaluer une intégrale de ligne pour une courbe 3D? Si Sympy ne peut pas, vous pouvez fournir une alternative (avec Python comme langage s'il vous plaît)

3 Réponses :

1
votes

L'erreur de valeur que vous recevez ne provient pas de votre appel à la fonction line_integrate ; cela vient parce que selon le code source pour le Curve , seules les fonctions de l'espace euclidien 2D sont prises en charge. Cette intégrale peut encore être calculée sans utiliser sympy selon ce blog de recherche que j'ai trouvé en recherchant simplement une méthode viable sur Google.

Le code dont vous avez besoin ressemble à ceci:

import autograd.numpy as np
from autograd import jacobian
from scipy.integrate import quad

def F(X):
    x, y, z = X
    return [y * np.exp(x), x**2 + np.exp(x), z**2 * np.exp(z)]

def C(t):
    return np.array([np.cos(t) + 1, np.sin(t) + 1, 1 - np.cos(t) - np.sin(t)])

dCdt = jacobian(C, 0)

def integrand(t):
    return F(C(t)) @ dCdt(t)

I, e = quad(integrand, 0, 2 * np.pi)

La variable I stocke alors la solution numérique de votre question.

0 commentaires

1
votes

Dans ce cas, vous pouvez calculer l'intégrale en utilisant line_integrate car nous pouvons réduire l'intégrale 3d à une intégrale 2D. Je suis désolé de dire que je ne connais pas assez bien python pour écrire le code, mais voici l'exercice: Si nous écrivons

z = 3 - x - y

alors la chose à noter est que

t -> x(t), y(t)

et ainsi

G = (Fx-Fz)*i + (Fx-Fz)*j

Donc, nous pouvons écrire

F.dr = Fx*dx + Fy*dy + Fz*dz
     = (Fx-Fz)*dx + (Fy-Fz)*dy

Nous avons donc réduit le problème à un problème 2d: nous intégrons

dz = -dx - dy

round

z(t) = 3 - x(t) - y(t)

Notez que dans G nous devons nous débarrasser de z en remplaçant

C(t) = x(t),y(t),z(t)

0 commentaires

0
votes

Vous pouvez définir une fonction:

 f = [x**2*z**2,y**2*z**2,x*y*z]
 C = [2*cos(t),2*sin(t),4,0,2*sp.pi]

Utilisez ensuite l'exemple:

import sympy as sp
from sympy import *
def linea3(f,C):
 P = f[0].subs([(x,C[0]),(y,C[1]),(z,C[2])])
 Q = f[1].subs([(x,C[0]),(y,C[1]),(z,C[2])])
 R = f[2].subs([(x,C[0]),(y,C[1]),(z,C[2])])
 dx = diff(C[0],t)
 dy = diff(C[1],t)
 dz = diff(C[2],t)
 m = integrate(P*dx+Q*dy+R*dz,(t,C[3],C[4]))
 return m

0 commentaires