]> SALOME platform Git repositories - tools/eficas.git/blob - Extensions/interpreteur_formule.py
Salome HOME
ee956e89f4ae249f14681d18a3c7a4a520393a18
[tools/eficas.git] / Extensions / interpreteur_formule.py
1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2013   EDF R&D
3 #
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License.
8 #
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 # Lesser General Public License for more details.
13 #
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
17 #
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 #
20 from __future__ import absolute_import
21 from __future__ import print_function
22 try : 
23    from builtins import str
24    from builtins import object
25 except : pass
26
27 import re,sys,types
28
29 from Noyau.N_CR import CR
30 from Extensions.i18n import tr
31
32
33 #def group(*choices): return '(' + ''.join(choices, '|') + ')'
34 #def any(*choices): return apply(group, choices) + '*'
35 #def maybe(*choices): return apply(group, choices) + '?'
36
37 Intnumber = r'[1-9]\d*'
38 Exponent = r'[eEdD][-+]?\d+'
39 Expfloat = r'[1-9]\d*' + Exponent
40 #Pointfloat = group(r'\d+\.\d*', r'\.\d+') + maybe(Exponent)
41 #Floatnumber = group(Pointfloat, Expfloat)
42 Pointfloat=r'(\d+\.\d*|\.\d+)([eEdD][-+]?\d+)?'
43 Floatnumber=r'((\d+\.\d*|\.\d+)([eEdD][-+]?\d+)?|[1-9]\d*[eEdD][-+]?\d+)'
44
45
46 pat_number = re.compile(r'^([+-]?)([0-9]+)(\.\d*)?(.*)')
47 pat_number_complet = re.compile(r'^([+-]?)([0-9]+)(\.\d*)?([eEdD][+-]?\d+)(.*)')
48 pat_constante = re.compile(r'^([+-]?)([a-zA-Z][a-zA-Z_0-9]*\s*)(.*)')
49
50 def cmp_function(arg1,arg2):
51     """
52     Fonction de comparaison permettant de classer les listes de
53     fonctions unaires et binaires selon la longueur de leurs arguments
54     On classe les arguments les plus longs en premier
55     """
56     if len(arg1) > len(arg2):
57         return -1
58     elif len(arg1) == len(arg2):
59         return 0
60     else:
61         return 1
62     
63 class InterpreteurException(Exception):
64     """
65     Classe servant a definir les exceptions levees par l'interpreteur de formule
66     """
67     def __init__(self,args=None):
68         self.args = args
69
70     def __str__(self):
71         return str(self.args)
72
73 class Interpreteur_Formule(object):
74     """
75     Cette classe sert a construire un interpreteur de formules Aster
76     """
77     l_fonctions_binaires = ['+','-','*','/','**','=','MOD','MIN','MAX','ATAN2']
78     l_fonctions_unaires = ['+','-','INT','REAL','AIMAG','ABS','SQRT','EXP','LOG',
79                            'LOG10','SIN','COS','TAN','ASIN','ACOS','ATAN','SINH',
80                            'COSH','TANH','HEAVYSID']
81     l_constantes = ['PI','RD_RG','DG_RD']
82  
83     def __init__(self,formule=None,constantes=[],fonctions=[],parent=None):
84         """
85         Constructeur d'interpreteurs de formule Aster
86         - formule = tuple (nom,type,arguments,corps)
87         - constantes = liste des noms de constantes externes
88         - fonctions_unaires = dictionnaire {nom_fonction externe : nb arguments de cette fonction}
89         """
90         self.new_constantes = constantes
91         self.new_fonctions_unaires = fonctions
92         self.cr = CR()
93         self.l_operateurs = []
94         self.parent = parent
95         self.l_children = []
96         if formule :
97             self.set_formule(formule)
98         if self.parent :
99             self.parent.enregistre(self)
100
101     def set_formule(self,formule):
102         """
103         Stocke formule (tuple) dans l'attribut t_formule
104         Methode externe
105         """
106         #if type(formule) != types.TupleType:
107         if type(formule) != types.tuple:
108             raise InterpreteurException(tr("La formule passee a l'interpreteur doit etre sous forme de tuple"))
109         self.t_formule = formule
110         #self.init_cr()
111         self.modify_listes()
112         self.ordonne_listes()
113
114     def init_cr(self):
115         """
116         Initialise le cr,cad valorise les chaines debut et fin
117         """
118         nom = self.t_formule[0]
119         if nom :
120             if nom[0] in ('+','-') : nom = nom[1:]
121         self.cr.debut = tr("Debut Fonction %s", nom)
122         self.cr.fin = tr("Fin Fonction %s", nom)
123         
124     def str(self):
125         """
126         Retourne une liste de chaines de caracteres representant la formule
127         """
128         l_txt = []
129         l_txt.append(self.t_formule[0])
130         for oper in self.l_operateurs:
131             # oper est ici une liste decrivant oper
132             txt = []
133             for elem in oper:
134                 txt.append(str(elem))
135             l_txt.append(txt)
136         return l_txt
137
138     def report(self,decalage=1):
139         """
140         Retourne le rapport de FORMULE
141         """
142         txt = self.cr.report()
143         return txt
144     
145     def enregistre(self,fils):
146         """
147         Enregistre un operateur fils dans la liste des children
148         """
149         self.l_children.append(fils)
150         self.cr.add(fils.cr)
151         
152     def isvalid(self):
153         """
154         Booleenne qui retourne 1 si la formule est valide, 0 sinon
155         Methode externe
156         """
157         self.l_operateurs = []
158         self.cr.purge() # on vide le cr 
159         self.init_cr() # on initialise le cr
160         self.interprete_formule()
161         return self.cr.estvide()
162
163     def interprete_formule(self):
164         """
165         Realise l'interpretation du corps de la formule
166         """
167         texte = self.t_formule[3]
168         if not texte : return
169         if type(texte) != list:
170             texte = [texte,]
171         for text_arg in texte:
172             text_arg = text_arg.replace('\n','')
173             # Enleve les espaces
174             text_arg = text_arg.replace(' ','')
175             try:
176                 self.l_operateurs.append(self.split_operateurs(text_arg))
177             except InterpreteurException as e:
178                 self.cr.fatal(e.__str__())
179
180     def modify_listes(self):
181         """
182         Modifie la liste des constantes en lui ajoutant le nom des parametres
183         de la fonction a interpreter
184         """
185         args = self.t_formule[2]
186         # l'interpreteur de formule sert aussi a evaluer les EVAL
187         # dans ce cas il n'y a pas d'arguments puisque pas de fonction ...
188         if args :
189             args = args[1:-1] # on enleve les parentheses ouvrante et fermante
190             l_args = args.split(',')
191             for arg in l_args:
192                 typ,nom = arg.split(':')
193                 nom = nom.strip()
194                 self.l_constantes.append(nom)
195         # on considere que les fonctions unaires de base sont toutes a un seul argument :
196         l_f = []
197         self.d_fonctions_unaires = {}
198         for fct in self.l_fonctions_unaires:
199             self.d_fonctions_unaires[fct]=1
200         # on ajoute les constantes externes
201         for cte in self.new_constantes:
202             self.l_constantes.append(cte)
203         # on ajoute les fonctions unaires externes au dictionnaire des fonctions unaires
204         for new_fonc in self.new_fonctions_unaires:
205             self.d_fonctions_unaires[new_fonc[0]] = self.get_nb_args(new_fonc)
206         #self.d_fonctions_unaires.update(self.new_fonctions_unaires)
207         self.l_fonctions_unaires = list(self.d_fonctions_unaires.keys())
208         
209     def ordonne_listes(self):
210         """
211         Ordonne les listes de fonctions unaires et binaires
212         """
213         self.l_fonctions_binaires.sort(cmp_function)
214         self.l_fonctions_unaires.sort(cmp_function)
215         self.l_constantes.sort(cmp_function)
216         
217
218     def split_operateurs(self,texte):
219         """
220         Splite le texte passe en argument en operateurs plus elementaires.
221         N'analyse pas l'interieur des operateurs (ne fait qu'une passe)
222         """
223         l_operateurs = []
224         texte = texte.strip()
225         # on recherche un nombre en debut de texte
226         try:
227             oper,reste = self.cherche_nombre(texte)
228         except InterpreteurException as e:
229             raise InterpreteurException (e.__str__())
230         if not oper :
231             # on recherche une constante en debut de texte
232             try:
233                 oper,reste = self.cherche_constante(texte)
234             except InterpreteurException as e:
235                 raise InterpreteurException (e.__str__())
236             if not oper :
237                 # on recherche une expression entre parentheses...
238                 try:
239                     oper,reste = self.cherche_expression_entre_parentheses(texte)
240                 except InterpreteurException as e:
241                     raise InterpreteurException(e.__str__())
242                 if not oper :
243                     # on recherche le debut d'un operateur unaire en debut de texte
244                     try:
245                         oper,reste = self.cherche_operateur_unaire(texte)
246                     except InterpreteurException as e:
247                         raise InterpreteurException(e.__str__())
248                     if not oper :
249                         type_objet,nom_objet = self.get_type(texte)
250                         if type_objet == 'constante':
251                             raise InterpreteurException( "Constante %s inconnue" %nom_objet)
252                         elif type_objet == 'fonction':
253                             raise InterpreteurException( "Fonction %s inconnue dans %s" %(nom_objet,texte))
254                         else:
255                             raise InterpreteurException( "Impossible d'interpreter : %s" %texte)
256         # on a trouve un operateur (nombre, constante ou unaire)
257         # il faut encore verifier que l'on est en fin de texte ou qu'il est bien suivi
258         # d'un operateur binaire
259         l_operateurs.append(oper)
260         if reste :
261             texte = reste.strip()
262             oper,reste = self.cherche_operateur_binaire(texte)
263             if not oper :
264                 # on a un reste et pas d'operateur binaire --> erreur
265                 raise InterpreteurException("L'operateur %s doit etre suivi d'un operateur binaire" %l_operateurs[-1])
266             else:
267                 # on a bien trouve un operateur binaire:
268                 l_operateurs.append(oper)
269                 # il faut recommencer l'analyse du reste par split_operateurs ...
270                 try:
271                     l_op = self.split_operateurs(reste)
272                 except InterpreteurException as e:
273                     raise InterpreteurException(e.__str__())
274                 l_operateurs.extend(l_op)
275                 return l_operateurs
276         else:
277             # on a fini d'analyser texte
278             return l_operateurs
279
280     def cherche_nombre(self,texte):
281         """
282         Cherche un nombre en debut de texte
283         Retourne ce nombre et le reste ou None et le texte initial
284         Peut lever une InterpreteurException dans le cas ou le nombre n'est pas valide
285         """
286         texte = texte.strip()
287         m = pat_number_complet.match(texte)
288         if m:
289             # on a trouve un nombre avec exposant
290             l_groups = m.groups()
291             sgn = l_groups[0]
292             nb = l_groups[1]
293             if l_groups[2]:
294                 nb = nb+l_groups[2]
295             if l_groups[3]:
296                 nb = nb+l_groups[3]
297             nombre = sgn+nb
298             return nombre,l_groups[4]
299         else:
300             m = pat_number.match(texte)
301             if m :
302                 # on a trouve un nombre sans exposant
303                 l_groups = m.groups()
304                 sgn = l_groups[0]
305                 nb = l_groups[1]
306                 if l_groups[2]:
307                     nb = nb+l_groups[2]
308                 nombre = sgn+nb
309                 # il faut verifier si ce nombre n'est pas suivi d'un exposant incomplet ...
310                 reste = l_groups[3].strip()
311                 if reste == '':
312                     return nombre,l_groups[3]
313                 if reste[0] in ('e','E','d','D') :
314                     raise InterpreteurException("La syntaxe de l'exposant de %s est erronee " %nb)
315                 else:
316                     return nombre,l_groups[3]
317             else:
318                 # on n'a pas trouve de nombre
319                 return None,texte
320         
321     def cherche_constante_old(self,texte):
322         """
323         Recherche une constante en debut de texte parmi la liste des constantes.
324         Retourne le texte representant la constante et le reste du texte ou
325         Retourne None,texte si aucune constante trouvee
326         """
327         txt = None
328         texte = texte.strip()
329         for cte in self.l_constantes:
330             index = texte.find(cte)
331             #if index == 0 : print 'on a trouve %s dans %s en %d' %(cte,texte,index)
332             if index == 0 :
333                 txt = cte
334                 zz,reste = texte.split(cte,1)
335                 break
336         if txt :
337             return txt,reste
338         else:
339             # aucune constante trouvee
340             return None,texte
341
342     def cherche_constante(self,texte):
343         """
344         Recherche une constante en debut de texte parmi la liste des constantes.
345         Retourne le texte representant la constante et le reste du texte ou
346         Retourne None,texte si aucune constante trouvee
347         """
348         txt = None
349         texte = texte.strip()
350         m = pat_constante.match(texte)
351         if m :
352             # on a trouve un identificateur en debut de texte
353             l_groups = m.groups()
354             sgn = l_groups[0]
355             identificateur = l_groups[1].strip()
356             reste = l_groups[2]
357             # il faut verifier qu'il ne s'agit pas d'un appel a une fonction
358             if reste :
359                 if reste[0] == '(' :
360                     # --> appel de fonction
361                     return None,texte
362             # il faut encore verifier qu'elle est bien dans la liste des constantes...
363             if identificateur not in self.l_constantes :
364                 raise InterpreteurException("La constante %s est inconnue dans %s" %(identificateur,texte))
365             else:
366                 return sgn+identificateur,reste
367         else:
368             # aucune constante trouvee
369             return None,texte
370         
371     def cherche_args(self,texte):
372         """
373         Cherche au debut de texte une liste d'arguments entre parentheses
374         """
375         if texte[0]!='(':
376             return None,texte
377         else:
378             n=0
379             cpt=1
380             while cpt != 0:
381                 n=n+1
382                 if n>= len(texte):
383                     # on a atteint la fin de texte sans avoir trouve la parenthese fermante --> erreur
384                     raise InterpreteurException("Manque parenthese fermante dans %s" %texte)
385                 if texte[n] == '(':
386                     cpt=cpt+1
387                 elif texte[n]==')':
388                     cpt=cpt-1
389             if (n+1 < len(texte)):
390                 return texte[0:n+1],texte[n+1:]
391             else:
392                 # on a fini d'analyser le texte : reste = None
393                 return texte,None
394                     
395     def cherche_operateur_unaire_old(self,texte):
396         """
397         Cherche dans texte un operateur unaire
398         """
399         txt = None
400         texte = texte.strip()
401         for oper in self.l_fonctions_unaires:
402             index = texte.find(oper)
403             if index == 0 :
404                 txt = oper
405                 zz,reste = texte.split(oper,1)
406                 break
407         if txt :
408             #print 'on a trouve :',txt
409             operateur = txt
410             texte = reste
411             try:
412                 args,reste = self.cherche_args(texte)
413             except InterpreteurException as e:
414                 raise InterpreteurException(e.__str__())
415             if not args :
416                 # operateur unaire sans arguments
417                 raise InterpreteurException('operateur unaire  %s sans arguments' %operateur)
418             else:
419                 #operateur = operateur+args
420                 args = self.split_args(txt,args,self.d_fonctions_unaires[operateur])
421                 formule_operateur = (txt,'',self.t_formule[2],args)
422                 operateur = Interpreteur_Formule(formule = formule_operateur,
423                                                  constantes = self.new_constantes,
424                                                  fonctions_unaires = self.new_fonctions_unaires,
425                                                  parent = self)
426                 operateur.interprete_formule()
427                 texte = reste
428                 return operateur,reste
429         else:
430             # aucun operateur unaire trouve
431             return None,texte
432
433     def cherche_operateur_unaire(self,texte):
434         """
435         Cherche dans texte un operateur unaire
436         """
437         txt = None
438         texte = texte.strip()
439         m = pat_constante.match(texte)
440         if m :
441             # on a trouve un identificateur en debut de texte
442             # il faut encore verifier que l'on a bien a faire a un appel de fonction ...
443             l_groups = m.groups()
444             sgn = l_groups[0]
445             identificateur = l_groups[1].strip()
446             reste = l_groups[2]
447             try:
448                 args,reste = self.cherche_args(reste)
449             except InterpreteurException as e:
450                 raise InterpreteurException (e.__str__())
451             if not args :
452                 # operateur unaire sans arguments
453                 # en principe on ne doit jamais etre dans ce cas car il est deja trappe par cherche_constante ...
454                 raise InterpreteurException ('Fonction %s sans arguments !' %identificateur)
455             else:
456                 # il faut encore verifier que l'on a bien a faire a une fonction connue
457                 if identificateur not in self.l_fonctions_unaires:
458                     raise InterpreteurException ('Fonction %s inconnue dans %s !' %(identificateur,texte))
459                 args = self.split_args(identificateur,args,self.d_fonctions_unaires[identificateur])
460                 formule_operateur = (sgn+identificateur,'',self.t_formule[2],args)
461                 operateur = Interpreteur_Formule(formule = formule_operateur,
462                                                  constantes = self.new_constantes,
463                                                  fonctions = self.new_fonctions_unaires,
464                                                  parent = self)
465                 operateur.interprete_formule()
466                 texte = reste
467                 return operateur,reste
468         elif texte[0] == '-':
469             # Il faut pouvoir trapper les expressions du type exp(-(x+1)) ...
470             try :
471                args,reste = self.cherche_args(texte[1:])
472             except InterpreteurException as e:
473                 raise InterpreteurException (e.__str__())
474             if not args :
475                # Il ne s'agit pas de '-' comme operateur unaire --> on retourne None
476                return None,texte
477             else:
478                identificateur = '-'
479                args = self.split_args(identificateur,args,self.d_fonctions_unaires[identificateur])
480                formule_operateur = (identificateur,'',self.t_formule[2],args)
481                operateur = Interpreteur_Formule(formule = formule_operateur,
482                                                  constantes = self.new_constantes,
483                                                  fonctions = self.new_fonctions_unaires,
484                                                  parent = self)
485                operateur.interprete_formule()
486                texte = reste
487                return operateur,reste
488         else:
489             return None,texte
490             
491     def cherche_operateur_binaire(self,texte):
492         """
493         Cherche dans texte un operateur unaire
494         """
495         txt = None
496         texte = texte.strip()
497         for oper in self.l_fonctions_binaires:
498             index = texte.find(oper)
499             #if index != -1 : print 'on a trouve %s dans %s en %d' %(oper,texte,index)
500             if index == 0 :
501                 txt = oper
502                 zz,reste = texte.split(oper,1)
503                 break
504         if txt :
505             return txt,reste
506         else:
507             # aucun operateur unaire trouve
508             return None,texte
509
510     def cherche_expression_entre_parentheses(self,texte):
511         """
512         Cherche en debut de texte une expression entre parentheses
513         """
514         args,reste = self.cherche_args(texte.strip())
515         if not args :
516             return None,texte
517         else:
518             # on a trouve une expression entre parentheses en debut de texte
519             # --> on retourne un objet Interpreteur_Formule
520             formule_operateur = ('','',self.t_formule[2],args[1:-1])
521             operateur = Interpreteur_Formule(formule = formule_operateur,
522                                              constantes = self.new_constantes,
523                                              fonctions = self.new_fonctions_unaires,
524                                              parent = self)
525             operateur.interprete_formule()
526             texte = reste
527             return operateur,reste
528             
529     def split_args(self,nom_fonction,args,nb_args):
530         """
531         Tente de partager args en nb_args elements
532         Retourne une liste de chaines de caracteres (liste de longueur nb_args)
533         """
534         args = args[1:-1] # on enleve les parentheses ouvrante et fermante
535         if nb_args == 1 : return args
536         l_args = args.split(',')
537         if len(l_args) != nb_args:
538             raise InterpreteurException  ("La fonction %s requiert %d arguments : %d fourni(s)" %(nom_fonction,nb_args,len(l_args)))
539         else:
540             return l_args
541
542     def get_type(self,texte):
543         """
544         Retourne le type de l'objet defini dans texte, a savoir:
545         - constante
546         - fonction
547         - unknown
548         et son nom
549         """
550         texte = texte.strip()
551         if '(' not in texte:
552             return 'constante',texte
553         if texte[-1] != ')':
554             return 'unknown',''
555         nom_oper,args = texte.split('(',1)
556         return 'fonction',nom_oper
557
558     def get_nb_args(self,formule):
559         """
560         Retourne le nombre d'arguments dans la definition de formule (sous forme de tuple)
561         """
562         args = formule[2][1:-1] # on enleve les parentheses ouvrante et fermante
563         l_args = args.split(',')
564         return len(l_args)
565
566 if __name__ == '__main__':
567     constantes = ['FREQ3','AMOR1']
568     fonctions_unaires=[('ACC','REEL','(REEL:x)','''bidon'''),]
569     f1 = ('f1','REEL','(REEL:x)','''SIN(x)+3*x''')
570     f2 = ('f2','REEL','(REEL:x)','''ATAN(x+3)+3*x''')
571     f3 = ('f3','REEL','(REEL:INST)','''ACC(INST,FREQ3,AMOR1)''')
572     f4 = ('f4','REEL','(REEL:INST)','''ACC(INST,FREQ2,AMOR1)''')
573     f5 = ('f5','REEL','(REEL:INST,REEL:Y)','''ACC(INST,FREQ3,AMOR1)+Y*INST''')
574     f6 = ('f6','REEL','(REEL:x)','''(x+ 3)/ 35.698''')
575     f7 = ('f7','REEL','(REEL:x)','''(x+ 3)/ 35.698E-10''')
576     f8 = ('f8','REEL','(REEL:x)','''(x+ 3)/ 35.698E''')
577     f9 = ('f9','REEL','(REEL:INSTA,REEl:INSTB)','''2.*SIN((PI/4)+((INSTA-INSTB)/2.))* COS((PI/4)-((INSTA+INSTB)/2.))''')
578     f10 = ('f10','REEL','(REEL:X)','''EXP(-(X+1))''')
579     for formule in (f1,f2,f3,f4,f5,f6,f7,f8,f9,f10):
580         i = Interpreteur_Formule(formule = formule,
581                                  constantes = constantes,
582                                  fonctions = fonctions_unaires)
583         txt = i.str()
584         print(('\nformule %s = %s' %(str(formule),txt)))
585         #if i.isvalid() :
586         #    print "\n\tPas d'erreur !"
587         #else:
588         #    print i.report()