fonction lamdify de sympy

Version imprimable

Bonjour
Je dois résoudre une équation différentielle de la forme dx/dt=vx avec vx=gradient(S(x,y)par rapport a x (idem pour y). S est la phase d'une fonction d'onde compliquée. Donc je commence par écrire la fonction, sa phase et la dérivée avec sympy.
Ensuite pour résoudre l'équation je dois créer une fonction python de vx car l'équa_diff est trop compliquée pour être résolue en symbolique. J'utilise donc lambdify. Le problème est qu'il reste des dérivées symbolique dans vx et donc lamdify ne marche pas, python me dit qu'il manque un argument (j'imagine que c'est la dérivée.
voilà vx:

- (re(sin(x)*sin(2*y)) + im(sin(2*x)*sin(y)))*|--(re(sin(2*x)*sin(y))) - --(im
                                              \dx                        dx   
------------------------------------------------------------------------------
                                                                              
                                                    (re(sin(x)*sin(2*y)) + im(

                  \                                               /d          
(sin(x)*sin(2*y)))| + (re(sin(2*x)*sin(y)) - im(sin(x)*sin(2*y)))*|--(re(sin(x
                  /                                               \dx         
------------------------------------------------------------------------------
                 2                                              2             
sin(2*x)*sin(y)))  + (re(sin(2*x)*sin(y)) - im(sin(x)*sin(2*y)))              

               d                      \
)*sin(2*y))) + --(im(sin(2*x)*sin(y)))|
               dx                     /
---------------------------------------

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
from matplotlib import *
from matplotlib.pyplot import *
from numpy import *
from  sympy import *
from sympy.plotting import plot3d
init_printing()
 
def part_2d (L,n,m,x,y):
    z=sin(n*pi*x/L)*sin(m*pi*y/L)
    return z
 
x,y,t= symbols('x y t')
X=Function('X')
Y=Function('Y')
 
L=pi
 
psi=part_2d(L,2,1,x,y)+I*part_2d(L,1,2,x,y)
S=arg(psi)
mod_psi=abs(psi)
 
plot3d(mod_psi, (x, -pi, pi), (y, -pi, pi))
 
 
 
vx=S.diff(x)
vy=S.diff(y)
Vx=vx.subs([(x,X(t)),(y,Y(t))])
Vy=vy.subs([(x,X(t)),(y,Y(t))])
Vx_n=lambdify([X(t),Y(t)],Vx)
Vy_n=lambdify([X(t),Y(t)],Vy)

Quelqu'un aurait il une idée pour résoudre ce problème
Merci d'avancd

Rien ne vaut une bonne lecture de la doc, pour savoir si on l'utilise comme il faut ou non...
https://docs.sympy.org/latest/module.../lambdify.html

Ensuite procrit les import *. Encore plus dans ton code : plot3d est aussi une fonction de pyplot. Et à cette fonction tu n'y as plus du tout accès puisque tu l'as écrasé bien silencieusement avec sympy. Et donc si par exemple j'échange l'ordre des lignes d'import, là ca va nettement moins bien se passer...

Il faut avoir des import comme cela, avec des alias qui sont ici des conventions très largement partagés :
Code:

1 2 3 4 5 6 import matplotlib as mpl from matplotlib import pyplot import plt import numpy as np from sympy import plotting,symbols,Function ### etc, vous faites la liste complète de ce dont vous avez besoin ## Voire meme dans votre cas, le code serait plus clair avec import sympy as sp
Et dans le corps de votre code, toute les fonctions non natives, vous les préfixez du petit alias de la bibliothèque de laquelle elle provient. Comme ça tous vos lecteurs (n'oubliez pas que le premier lecteur de votre code, c'est vous même), savent précisémment d'où viennent les fonctions que vous utilisez.

08/07/2019, 10h43
dveissi

bonjour
merci pour ces informations mais je reviens à ma question initiale.
Après avoir lu la doc, lambdify s'utilise sur des fonctions sympy pour les transformer en fonction utilisable par d'autre module (numpy ...).
Mais pour que cette conversion puisse se faire il faut que dans l'expression de la fonction il n'y ait que des symboles prédéfinis (x, y, t, X(t), Y(t)). Le problème ici c'est que quand j'utilise la commande sp.diff(S,x), celle-ci ne dérive pas complètement la fonction S et laisse des dérivée symboliques dans l'expression finale (par exemple sous matlab la même commande dérive complètement la fonction et l'expression final ne contient plus de dérivée). Comme il reste des dérivées symbolique la commende lambdify n'arrive pas à faire 'son travail'.
Donc (après ce développement un peu long) la question est existe-t-il une méthode plus puissante que sp.diff qui calculerait complétement la dérivée de S sans laissé de dérivée symbolique dans l'expression finale ou alors simplement python n'est pas assez puissant (ce qui m'obligerait à rester sous matlab alors que j'aimerai migré vers python).
10/07/2019, 11h19
lg_53
La remarque que je vous fait aurait été utile cependant à prendre en compte pour m'aider à vous éclairer sur la question initiale.

Quand je vois votre fonction définie comme cela
Code:

1 2 3 def part_2d (L,n,m,x,y): z=sin(n*pi*x/L)*sin(m*pi*y/L) return z
puis

Code:

psi=part_2d(L,2,1,x,y)+I*part_2d(L,1,2,x,y)

Je me dis que L doit etre aussi un symbole sympy.
Et si pour vous c'est plus un paramètre qu'une variable, alors garder peut etre simplement L en global comme vous le faite, et enlevez le des paramètres de la fonction.

Ensuite, définir une fonction comme ca :
Code:

1 2 psi=part_2d(L,2,1,x,y)+I*part_2d(L,1,2,x,y) S=arg(psi)
est peut etre aussi un peu dangereux. Vis à vis de sympy je ne sais pas s'il sait se débrouiller avec cela, par rapport à une fonction proprement définie :
Code:

1 2 3 def S(x,y): #### L is defined as global parameter return(arg(part_2d(L,2,1,x,y)+I*part_2d(L,1,2,x,y)))
Ensuite vous dites

Citation:

lambdify s'utilise sur des fonctions sympy pour les transformer en fonction utilisable par d'autre module (numpy ...).

mais dans la doc de sympy, je vois que lambdify prend un troisieme argument, optionnel, qui peut etre justement la chaine de caractère "numpy". Donc à priori ca transforme en python pure, et si vous voulez qqch de compatible avec une certaine librairie (ici numpy), il y a des chances qu'il faille le dire explicitement à sympy.

Vous avez essayer un code semblable avec une fonction moins compliquée ? Car c'est la première chose à faire : faire fonctionner le tout avec des choses très simple, et après on complexifie pas à pas.
11/07/2019, 17h26
dveissi

Bonjour
Merci pour vos réponse.
J'ai trouvé le problème. Quand j'ai déclaré x, y et t j'ai oublié de les déclarer en réel (propriété real) donc sympy les considérait comme complexe et donc ne pouvait pas dériver correctement la fonction S(x,y).
En prenant x et y réel il n'y a plus de problème et sympy fait la dérivée complète