PureBasic

pour le fun , je me suis mis a essayer un evaluateur d'expression mathematique simple

c'est a dire que l'expression ne dois pas avoir de parenthese (pour le moment)
et je me contente des 4 opérations ....

voici le code :
j'utilise une ruse de sioux pour mettre a jour l'expression au fur et a mesure des calcul
(Tracez le code pour vous amuser a comprendre l'astuce )

c'est chaud quand meme a faire, au dernier moment j'ai été confronté aux priorité de calcul
je me suis servi de l'exemple donné sur ce site pour tester
http://www.lelivrescolaire.fr/#!manuel/ ... rite/lecon

ce code devrai pouvoir s'en sortir sur des calculs simple genre
5*8/2+8 =28

j'essaierai d'ajouter les parentheses plus tard... mais il faut que j'y reflechisse d'abords

Code : Tout sélectionner

;***********************************************
;Titre  :*evaluateur_expression
;Auteur  : Zorro
;Date  :16/02/2017
;Heure  :00:35:06
;Version Purebasic :  PureBasic 5.50 (Windows - x86)
;Version de l'editeur :EPB V2.64
; Libairies necessaire : Aucune 
;***********************************************

Enumeration
		#file
EndEnumeration
Declare.f recherche_arriere(pos)
Declare.f recherche_avant(pos)

Global expression.s="20-2*3+12/6" ; ok pour ce type de calcul
For i=1 To len(expression.s)
		extrait.s=mid(expression.s,i,1)
		Pos=i
		Select extrait.s
		Case "*"
				gauche.f=recherche_arriere(pos)
				droite.f=recherche_avant(pos)
				sortie.f=gauche.f*droite.f
				expression.s=replacestring(expression.s,"z*z",strf(sortie.f))
				expression.s=removestring(expression.s,"z")
		EndSelect
Next i
For i=1 To len(expression.s)
		extrait.s=mid(expression.s,i,1)
		Pos=i
		Select extrait.s
		Case "/"
				gauche.f=recherche_arriere(pos)
				droite.f=recherche_avant(pos)
				sortie.f=gauche.f/droite.f
				expression.s=replacestring(expression.s,"z/z",strf(sortie.f))
				expression.s=removestring(expression.s,"z")
		EndSelect
Next i
For i=1 To len(expression.s)
		extrait.s=mid(expression.s,i,1)
		Pos=i
		Select extrait.s
		Case "-"
				gauche.f=recherche_arriere(pos)
				droite.f=recherche_avant(pos)
				sortie.f=gauche.f-droite.f
				expression.s=replacestring(expression.s,"z-z",strf(sortie.f))
				expression.s=removestring(expression.s,"z")
		EndSelect
Next i
For i=1 To len(expression.s)
		extrait.s=mid(expression.s,i,1)
		Pos=i
		Select extrait.s
		Case "+"
				gauche.f=recherche_arriere(pos)
				droite.f=recherche_avant(pos)
				sortie.f=gauche.f+droite.f
				expression.s=replacestring(expression.s,"z+z",strf(sortie.f))
				expression.s=removestring(expression.s,"z")
		EndSelect
Next i


Debug "le resultat est :"+strf(sortie.f)



Procedure.f recherche_arriere(pos)
		;By Dobro
		For i=pos-1 To 1 Step-1
				Extrait.s=mid(expression.s,i,1)
				If asc(Extrait.s)=46 Or (asc(Extrait.s)>=48 And asc(Extrait.s)<=57 )  ; c'est un chiffre
						; if  asc(Extrait.s)=46
						; pos=pos-1
						; Endif
						mot.s=mot.s+Extrait.s ; on recupere
						expression.s=replacestring(expression.s,Extrait.s,"z",#PB_String_NoCase,i,1)
				Else ; c'est pas un chiffre , on arrete
						mot.s=ReverseString(mot.s)
						ProcedureReturn valf(mot.s)
				Endif
		Next i
		mot.s=ReverseString(mot.s)
		ProcedureReturn valf(mot.s)
EndProcedure
Procedure.f recherche_avant(pos)
		;By Dobro
		For i=pos+1 to len(expression.s)
				Extrait.s=mid(expression.s,i,1)
				if  asc(Extrait.s)=46 or (asc(Extrait.s)>=48 and asc(Extrait.s)<=57)  ; c'est un chiffre
						; if  asc(Extrait.s)=46
						; pos=pos+1
						; Endif
						mot.s=mot.s+Extrait.s ; on recupere
						expression.s=replacestring(expression.s,Extrait.s,"z",#PB_String_NoCase,i,1)
				Else ; c'est pas un chiffre , on arrete
						ProcedureReturn valf(mot.s)
				Endif
		Next i
		ProcedureReturn valf(mot.s)
EndProcedure

Merveilleux, merci pour le partage

Courageux de se lancer sur un tel sujet, qui peut effectivement rapidement s'avérer très complexe ! Par contre, c'est un bon très bon challenge à relever pour n'importe quel développeur, où chacun peut apporter sa touche de personnalité et de talent

Tu te lance dans quelque chose de ardu là Zorro

Mais tu as les connaissance pour donc tu va y arriver.
Bon courage et merci.

voici la version avec parenthese de premier niveau

donc capable de calculer les 4 operations avec parenthèses simple (non imbriquée )

exemple : "(20-2)*3+(12/6)+(3*2)+5" = 67

je vais me lancer dans l'etude des parentheses imbriquée .....

en fait le principe reste le meme , il me faut juste reperer la parentheses fermante qui va avec la parenthese ouvrante ...
mais c'est deja pas simple

sur un calcul du type : 45+((5*9)+3)
lorsque je rencontre la premiere parenthese, il me faut trouver la position de la derniere parenthese, et non pas la premiere fermante qui suit (celle apres le 9)
bref, je vais encore me triturer le neurone qui me reste en etat

mais je suis deja bien content de mon resultat actuel

Code : Tout sélectionner

;***********************************************
;Titre  :*evaluateur_expression
;Auteur  : Zorro
;Date  :16/02/2017
;Heure  :00:35:06
;Version Purebasic :  PureBasic 5.50 (Windows - x86)
;Version de l'editeur :EPB V2.64
; Libairies necessaire : Aucune 
;***********************************************
; ************** Init ********************************
Enumeration
		#file
EndEnumeration
Declare.f calcul()
Declare recherche_parenthese()
Declare.f recherche_arriere(pos)
Declare.f recherche_avant(pos)
Structure position
		pos1.l ; position de la parenthese ouverte
		pos2.l ;position de la parenthese fermée
EndStructure
Global position.position
;*************************************************

Global expression.s="(20.4-2)*3+(12/6)+(3.2*2)+5" ; ok pour ce type de calcul

calldebugger
; **************************************************************************
debut:
retour=recherche_parenthese()
select retour
Case -1
		MessageRequester("erreur","il y a une erreur de parentheses dans votre expression" )
		End
Case 0 ; pas de parentheses
		position\pos1.l=1
		position\pos2.l=Len(expression.s)
		sortie.f=calcul()
		Debug "le resultat est :"+StrF(sortie.f)
		end
Case 1 ; parentheses
		calcul()
		goto debut ; tant qu'il reste des parentheses on recommence
Endselect
; ******************************************************************************

;- Zone Procedures
Procedure.f calcul()
		For i=position\pos1.l To position\pos2.l
				extrait.s=Mid(expression.s,i,1)
				Pos=i
				Select extrait.s
				Case "*"
						gauche.f=recherche_arriere(pos)
						droite.f=recherche_avant(pos)
						sortie.f=gauche.f*droite.f
						expression.s=ReplaceString(expression.s,"z*z",StrF(sortie.f))
						expression.s=RemoveString(expression.s,"z")	
						i=position\pos1.l
				Case ")"
						break
				EndSelect;|
				Next i		;|
				For i=position\pos1.l To position\pos2.l ;|
						extrait.s=Mid(expression.s,i,1)
						Pos=i
						Select extrait.s
						Case "/"
								gauche.f=recherche_arriere(pos)
								droite.f=recherche_avant(pos)
								sortie.f=gauche.f/droite.f
								expression.s=ReplaceString(expression.s,"z/z",StrF(sortie.f))
								expression.s=RemoveString(expression.s,"z")
								i=position\pos1.l
						Case ")"
								break
						EndSelect
				Next i
				For i=position\pos1.l To position\pos2.l
						extrait.s=Mid(expression.s,i,1)
						Pos=i
						Select extrait.s
						Case "-"
								gauche.f=recherche_arriere(pos)
								droite.f=recherche_avant(pos)
								sortie.f=gauche.f-droite.f
								expression.s=ReplaceString(expression.s,"z-z",StrF(sortie.f))
								expression.s=RemoveString(expression.s,"z")
								i=position\pos1.l
						Case ")"
								break
						EndSelect
				Next i
				For i=position\pos1.l To position\pos2.l
						extrait.s=Mid(expression.s,i,1)
						Pos=i
						Select extrait.s
						Case "+"
								gauche.f=recherche_arriere(pos)
								droite.f=recherche_avant(pos)
								sortie.f=gauche.f+droite.f
								expression.s=ReplaceString(expression.s,"z+z",StrF(sortie.f))
								expression.s=RemoveString(expression.s,"z")
								i=position\pos1.l
						Case ")"
								break
						EndSelect
				Next i			
				expression.s=RemoveString(expression.s,"(",#PB_String_NoCase,position\pos1,1)
				expression.s=RemoveString(expression.s,")",#PB_String_NoCase,i-1,1)
				sortie=valf(expression.s)
				ProcedureReturn sortie
		EndProcedure
		
		Procedure recherche_parenthese()
				; By Dobro
				pos1=FindString( expression.s,"(")
				pos2=FindString( expression.s,")",pos1)
				If pos1=0 and pos2=0
						ProcedureReturn 0 ; pas de parentheses
				EndIf
				If (pos2=1 and pos1=0) or (pos2=0 and pos1=1) 
						ProcedureReturn -1   ;erreur manque une parenthese 
				EndIf							;|
						If pos1>0 And pos2>0  ; on a trouvé un couple de parentheses
								position\pos1=pos1 ; on recupere les positions des parenthese
								position\pos2=pos2 ; plus qu'a calculer ce qui se trouve dedans
								ProcedureReturn 1 		
						EndIf
				EndProcedure
		Procedure.f recherche_arriere(pos);|
				;By Dobro
				For i=pos-1 To 1 Step-1
						Extrait.s=Mid(expression.s,i,1)
						If Asc(Extrait.s)=46 Or (Asc(Extrait.s)>=48 And Asc(Extrait.s)<=57 )  ; c'est un chiffre
								mot.s=mot.s+Extrait.s															 ; on recupere
								expression.s=ReplaceString(expression.s,Extrait.s,"z",#PB_String_NoCase,i,1)
						Else ; c'est pas un chiffre , on arrete
								mot.s=ReverseString(mot.s)
								ProcedureReturn ValF(mot.s)
						EndIf
				Next i
				mot.s=ReverseString(mot.s)
				ProcedureReturn ValF(mot.s)
		EndProcedure
		Procedure.f recherche_avant(pos)
				;By Dobro
				For i=pos+1 To Len(expression.s)
						Extrait.s=Mid(expression.s,i,1)
						If  Asc(Extrait.s)=46 Or (Asc(Extrait.s)>=48 And Asc(Extrait.s)<=57)  ; c'est un chiffre
								mot.s=mot.s+Extrait.s															 ; on recupere
								expression.s=ReplaceString(expression.s,Extrait.s,"z",#PB_String_NoCase,i,1)
						Else ; c'est pas un chiffre , on arrete
								ProcedureReturn ValF(mot.s)
						EndIf
				Next i
				ProcedureReturn ValF(mot.s)
		EndProcedure

Si cela peut te rendre service (pour ça ou autre chose) voici un moyen pour découper rapidement une expression.
Oui, oui, avec une expression régulière

Je n'ai traité que les éléments que tu utilises pour l'instant (pas les décimaux par exemple)

Code : Tout sélectionner

Global expression.s="(20-2)*3+(12/6)+(3*2)+5"

If Not CreateRegularExpression(0, "\d+|\+|\-|\*|\/|\(|\)")
     Debug ":-( RegEx Fausse" : End
EndIf

If ExamineRegularExpression(0, expression)
     While NextRegularExpressionMatch(0)
          Debug RegularExpressionMatchString(0) 
          ; Mettre les valeur en tableau ou effectuer l'opération correspondant à la chaine
     Wend
EndIf

Version prenant les nombres décimaux (séparateur '.')

Code : Tout sélectionner

CreateRegularExpression(0, "\d+\.\d+|\d+|\+|\-|\*|\/|\(|\)")

Extensible à tout ce que tu veux:

Code : Tout sélectionner

CreateRegularExpression(0, "\d+\.\d+|\d+|\+|\-|\*|\/|\(|\)|SIN|COS|TAN")

Enjoy

Marc56 a écrit : Je n'ai traité que les éléments que tu utilises pour l'instant (pas les décimaux par exemple)

si ! si ! j'avais juste oublié de typer la procedure calcul()

c'est corrigé

maintenant un calcul type : (20.4-2)*3+(12/6)+(3.2*2)+5

sera pris en compte

ps ; oui je connais les expressions reguliere, je vais peut etre voir avec ça...
mais j'aime bien maitriser l'ensemble des manipulation de chaines... j'aime bien

Dans mon interpréteur Brainfuck, si je me rapelle bien, les imbrications de boucles ( donc de "[" ... "]" ) fonctionnaient trés bien... Ca peut fournir un point de départ sur l'utilisation de parenthéses imbriquées

oui.... je vais regarder ça de plus pret

Ah merde , je viens de me rendre compte que le principe n'est pas le même... En fait j'enregistre la position de la premiére [ puis je continue jusqu'à la premiére ] rencontrée pour revenir a la [ précédente... Cen'est pas trés adapté au cas présent... Désolé

Y'a aussi ça (à condition de compiler avec le debuggeur):

Code : Tout sélectionner

ClearClipboard()

Debug (20.4-2)*3+(12/6)+(3.2*2)+5

CopyDebugOutput()

Delay(100)

MessageRequester("Résultat", GetClipboardText())

(il faut un petit délai au clipboard pour reçevoir)

@JohnJohnsonSHERMAN

oui mais le principe de base reste quand meme le meme
c'est d'ailleurs a ça que je pensais ....
compter les parentheses que je rencontre da gauche a droite de l'expression

puis en fonction du "level" faire effectuer le calcul (et supression des parentheses concernées... ce que je fait deja actuellement )

pour le moment, je ne suis pas sur ce code, mais j'y reviendrai bientot (j'aime bien laisser faisander un code

)
mon code en l'etat est deja multi-parentheses friendly

@Marc
le principe d'un evaluateur d'expression , c'est de ne pas avoir a utiliser le compilo ...

fait une calculatrice par exemple , le compilo , ne pourra pas analyser une chaine d'expression ...

fait un langage (interpreteur) , sans evaluateur d'expression , c'est pas possible de faire effectuer un calcul par ton langage ....

ps : le coup d'exploiter le compilo , j'ai donné le truc dans le topic a Shadow

toutefois l'utilisation du debugger est une idée marrante
mais que ce passe t'il dans un code compilé ??

Zorro a écrit :toutefois l'utilisation du debugger est une idée marrante
mais que ce passe t'il dans un code compilé ??

Tu as raison, ça ne marche pas puisque tout ce qui suit une instruction Debug est ignoré lors de la compilation.
J'suis con...

voici une version "multi-parentheses"
probablement perfectible, mais je dois dire que ça marche pas mal
j'ai aussi integré le fait qu'il puisse y avoir des nombres négatif....

Code : Tout sélectionner

;***********************************************
;Titre  :*evaluateur_expression
;Auteur  : Zorro
;Date  :16/02/2017
;Heure  :00:35:06
;Version Purebasic :  PureBasic 5.50 (Windows - x86)
;Version de l'editeur :EPB V2.64
; Libairies necessaire : Aucune 
;***********************************************
; ************** Init ********************************
Enumeration
		#file
EndEnumeration

Declare.s lanceur_calcul( expression.s)
Declare.s calcul()
Declare reset_parenthese()
Declare recherche_parenthese()
Declare.f recherche_arriere(pos);|
Declare.f recherche_avant(pos)

Structure parenthese
		pos1.l ; position de la parenthese ouverte
		pos2.l ;position de la parenthese fermée
		level.l ; niveau de la parenthese
EndStructure
Global newlist parenthese.parenthese() 

Global compteur :Global priorite:Global u:Global Level.i=0
;*************************************************

;Global expression.s="(20.4-2)*3+(12/6)+(3.2*2)+5" ; ok pour ce type de calcul
;Global expression.s="(20.4-2)*3+(12/6+(3.2*2))+5" ; = 68.59  (68.6)

;debut:


global expression.s=InputRequester("calculateur" ,"entrez une expression valide ", "3*5+((12*8)/2)+5") ; par defaut =68
If expression.s=""
		End
		Else		
		sortie.s= lanceur_calcul( expression.s)
			MessageRequester("Resultat","le resultat est :"+sortie.s)
Endif



; ***********************ON CALCUL !************************

Procedure.s lanceur_calcul( expression.s)
		retour=recherche_parenthese()
		
		select retour
		Case -1
				MessageRequester("erreur","il y a une erreur de parentheses dans votre expression" )
				End
		Case 1 ; calcul avec parentheses
				
				; recherche les parentheses les plus forte level
				SortStructuredList(parenthese(), #PB_Sort_Descending, OffsetOf(parenthese\level),TypeOf(parenthese\Level.l)) ; on trie la list pour faire apparaitre en premier les parentheses les plus prioritaires
				ResetList(parenthese())
				for t= 0 to ListSize(parenthese())
						SelectElement(parenthese(), t)
						calcul( )	
						if ListSize(parenthese()) >0
								ResetList(parenthese())
								t=-1
						Endif
				next t
				
				AddElement(parenthese() )	 ; on rempli bidon pour faire croire qu'il reste une parenthese au debut et a la fin de l'expression
				parenthese()\pos1.l =1
				parenthese()\pos2.l=len(expression.s) 
				
				sortie.s=calcul( ) ; sans parenthese			
				ProcedureReturn 	sortie.s
				
				
		Case 0 ; sans parentheses
				AddElement(parenthese() )	 ; on rempli bidon pour faire croire qu'il reste une parenthese au debut et a la fin de l'expression
				parenthese()\pos1.l =1
				parenthese()\pos2.l=len(expression.s) 
				
				sortie.s=calcul( ) ; sans parenthese		
				ProcedureReturn 	sortie.s			
				;	goto debut
		Endselect
		; ******************************************************************************
EndProcedure

;- Zone Procedures
Procedure.s calcul()
		
		For i=parenthese()\pos1.l To parenthese()\pos2.l
				extrait.s=Mid(expression.s,i,1)
				Pos=i
				Select extrait.s
				Case "*"
						
						gauche.f=recherche_arriere(pos)
						droite.f=recherche_avant(pos)
						sortie.f=gauche.f*droite.f
						
						expression.s=ReplaceString(expression.s,"z*z",StrF(sortie.f))
						expression.s=RemoveString(expression.s,"z")	
						
						i=parenthese()\pos1.l
						
				Case ")"
						break
				EndSelect;|
				Next i		;|
				For i=parenthese()\pos1.l To parenthese()\pos2.l ;|
						extrait.s=Mid(expression.s,i,1)
						Pos=i
						Select extrait.s
						Case "/"
								gauche.f=recherche_arriere(pos)
								droite.f=recherche_avant(pos)
								sortie.f=gauche.f/droite.f
								expression.s=ReplaceString(expression.s,"z/z",StrF(sortie.f))
								expression.s=RemoveString(expression.s,"z")
								
								i=parenthese()\pos1.l
								
						Case ")"
								break
						EndSelect
				Next i
				For i=parenthese()\pos1.l To parenthese()\pos2.l
						extrait.s=Mid(expression.s,i,1)
						Pos=i
						Select extrait.s
						Case "-"
								gauche.f=recherche_arriere(pos)
								if gauche.f<>0.0 ; cas des nombres negatif
										droite.f=recherche_avant(pos)
										sortie.f=gauche.f-droite.f
										expression.s=ReplaceString(expression.s,"z-z",StrF(sortie.f))
										expression.s=RemoveString(expression.s,"z")
										
										i=parenthese()\pos1.l
								endif
						Case ")"
								break
						EndSelect
				Next i
				For i=parenthese()\pos1.l To parenthese()\pos2.l
						extrait.s=Mid(expression.s,i,1)
						Pos=i
						Select extrait.s
						Case "+"
								gauche.f=recherche_arriere(pos)
								droite.f=recherche_avant(pos)
								sortie.f=gauche.f+droite.f
								expression.s=ReplaceString(expression.s,"z+z",StrF(sortie.f))
								expression.s=RemoveString(expression.s,"z")
								
								i=parenthese()\pos1.l
								;;	reset_parenthese()
						Case ")"
								break
						EndSelect
				Next i			
				expression.s=RemoveString(expression.s,"(",#PB_String_NoCase,parenthese()\pos1,1)
				expression.s=RemoveString(expression.s,")",#PB_String_NoCase,i-1,1)
				sortie.f=valf(expression.s)
				
				reset_parenthese()
				
				ProcedureReturn expression.s
		EndProcedure
		procedure reset_parenthese()
				ClearList(parenthese()) 				
				recherche_parenthese()
				SortStructuredList(parenthese(), #PB_Sort_Descending, OffsetOf(parenthese\level),TypeOf(parenthese\Level.l)) ; on trie la list pour faire apparaitre en premier les parentheses les plus prioritaires
		Endprocedure
		
		Procedure recherche_parenthese()
				;By Dobro
				ouv=countstring(expression.s,"(")
				ferm=countstring(expression.s,")")
				If ouv<>ferm 
						ProcedureReturn -1 ; erreur de parenthese
				Endif
				
				For i=1 To Len(expression.s)
						Extrait.s=Mid(expression.s,i,1)
						If  Extrait.s="("
								
								LastElement(parenthese())								
								AddElement(parenthese() )								
								parenthese()\pos1.l=i
								parenthese()\level.l=Level.i	
								Level.i=Level.i+1
						Endif
						if Extrait.s=")"								
								
								parenthese()\pos2.l=i																	
								;	parenthese()\level.l=Level.i
								Level.i=Level.i-1
								PreviousElement(parenthese()) 								
						Endif
				Next i
				If ouv>0 and ferm >0
						ProcedureReturn 1 ; parentheses
				Endif
				If ouv=0 and ferm=0
						ProcedureReturn 0; pas de parenthese
				Endif
				
				
		Endprocedure
		
		
Procedure.f recherche_arriere(pos);|
		;By Dobro
		
		For i=pos-1 To 1 Step-1
				Extrait.s=Mid(expression.s,i,1)
				If Asc(Extrait.s)=46 Or  Asc(Extrait.s)=45 or (Asc(Extrait.s)>=48 And Asc(Extrait.s)<=57 )  ; c'est un chiffre
						mot.s=mot.s+Extrait.s															 ; on recupere
						expression.s=ReplaceString(expression.s,Extrait.s,"z",#PB_String_NoCase,i,1)
				Else ; c'est pas un chiffre , on arrete
						mot.s=ReverseString(mot.s)
						ProcedureReturn ValF(mot.s)
				EndIf
		Next i
		mot.s=ReverseString(mot.s)
		ProcedureReturn ValF(mot.s)
EndProcedure
Procedure.f recherche_avant(pos)
		;By Dobro
		For i=pos+1 To Len(expression.s)
				Extrait.s=Mid(expression.s,i,1)
				If  Asc(Extrait.s)=46 Or Asc(Extrait.s)=45 or (Asc(Extrait.s)>=48 And Asc(Extrait.s)<=57)  ; c'est un chiffre
						mot.s=mot.s+Extrait.s															 ; on recupere
						expression.s=ReplaceString(expression.s,Extrait.s,"z",#PB_String_NoCase,i,1)
				Else ; c'est pas un chiffre , on arrete
						ProcedureReturn ValF(mot.s)
				EndIf
		Next i
		ProcedureReturn ValF(mot.s)
EndProcedure

J'ai une IMA à la ligne 35, mais merci pour le partage tout de même

PureBasic

evaluateur d'expression calcul simple

evaluateur d'expression calcul simple

Re: evaluateur d'expression calcul simple

Re: evaluateur d'expression calcul simple

Re: evaluateur d'expression calcul simple

Re: evaluateur d'expression calcul simple

Re: evaluateur d'expression calcul simple

Re: evaluateur d'expression calcul simple

Re: evaluateur d'expression calcul simple

Re: evaluateur d'expression calcul simple

Re: evaluateur d'expression calcul simple

Re: evaluateur d'expression calcul simple

Re: evaluateur d'expression calcul simple

Re: evaluateur d'expression calcul simple

Re: evaluateur d'expression calcul simple

Re: evaluateur d'expression calcul simple