barraux.a
/
calculatrice_Barraux
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

fonction cos, sin ln

master
BARRAUX Arthur 2 years ago
parent
6dd9959ef2
commit
45d34ccee0
1 changed files with 245 additions and 119 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 328
      main.py

328
main.py
View File

@ -1,10 +1,11 @@
from data_structure import *
import customtkinter as ctk
import math import math
import customtkinter as ctk
from data_structure import Pile_chaine
class Expression: class Expression:
"""manipule les expression sous forme d'arbre""" """manipule les expression sous forme d'arbre"""
def __init__(self, val, fils_gauche, fils_droit) -> None: def __init__(self, val, fils_gauche=None, fils_droit=None) -> None:
self.val = val self.val = val
self.fils_gauche = fils_gauche self.fils_gauche = fils_gauche
self.fils_droit = fils_droit self.fils_droit = fils_droit
@ -15,51 +16,97 @@ class Expression:
return str(self.val) return str(self.val)
return '('+self.fils_gauche.__str__()+str(self.val)+self.fils_droit.__str__()+')' return '('+self.fils_gauche.__str__()+str(self.val)+self.fils_droit.__str__()+')'
def print_tree(self, level=0):
""" Affiche le noeud joliment"""
if self.fils_gauche is not None:
self.fils_gauche.print_tree(level + 1)
print(' ' * 4 * level + '-> ' + str(self.val))
if self.fils_droit is not None:
self.fils_droit.print_tree(level + 1)
def est_feuille(self) -> bool: def est_feuille(self) -> bool:
"""renvoie true si le noeud est une feuille""" """ Renvoie true si le noeud est une feuille"""
if self.fils_droit is None and self.fils_gauche is None: if self.fils_droit is None and self.fils_gauche is None:
return True return True
return False return False
def evalue(self, x=0) -> float: def evalue(self, x=0) -> float:
"""renvoie le résultat de l'expression""" """ Renvoie le résultat de l'expression"""
try:
if self.est_feuille(): if self.est_feuille():
if self.val == 'x': if self.val == 'x':
return x return x
return float(self.val) return float(self.val)
if self.val == '+': elif self.val == '+':
return self.fils_gauche.evalue(x) + self.fils_droit.evalue(x) return self.fils_gauche.evalue(x) + self.fils_droit.evalue(x)
if self.val == '*': elif self.val == '*':
return self.fils_gauche.evalue(x) * self.fils_droit.evalue(x) return self.fils_gauche.evalue(x) * self.fils_droit.evalue(x)
if self.val == '/': elif self.val == '/':
return self.fils_gauche.evalue(x) / self.fils_droit.evalue(x) return self.fils_gauche.evalue(x) / self.fils_droit.evalue(x)
if self.val == '^': elif self.val == '^':
return self.fils_gauche.evalue(x) ** self.fils_droit.evalue(x) return self.fils_gauche.evalue(x) ** self.fils_droit.evalue(x)
if self.val == '-': elif self.val == '-':
return self.fils_gauche.evalue(x) - self.fils_droit.evalue(x) return self.fils_gauche.evalue(x) - self.fils_droit.evalue(x)
elif self.val == 'ln':
def valeurs_de_fonction(self): return math.log(self.fils_gauche.evalue(x))
"""calcul les 100 premieres valeurs""" elif self.val == '√':
return math.sqrt(self.fils_gauche.evalue(x))
elif self.val == "cos":
return math.cos(self.fils_gauche.evalue(x))
elif self.val == "sin":
return math.sin(self.fils_gauche.evalue(x))
elif self.val == "tan":
return math.tan(self.fils_gauche.evalue(x))
except ZeroDivisionError:
raise ZeroDivisionError
def valeurs_de_fonction(self, start, end):
""" Calcul les valeurs entre start et end"""
result = [] result = []
for i in range(-100, 100): for i in range(start, end+1):
try:
result.append((i, self.evalue(i))) result.append((i, self.evalue(i)))
except:
pass
return result return result
def change_appearance_mode_event(new_appearance_mode: str) -> None:
"""Change le thème de sombre à Claire"""
ctk.set_appearance_mode(new_appearance_mode)
class App(ctk.CTk): class App(ctk.CTk):
"""Classe pour l'interface graphique"""
def __init__(self) -> None: def __init__(self) -> None:
super().__init__() super().__init__()
self.grid_columnconfigure(0, weight=0)
self.numbers = [] change_appearance_mode_event('dark')
for i, val in enumerate(["(", ")", "/", "^", 7,8,9,"*", 4, 5, 6, "-", 1, 2, 3, "+", "clear", 0, '.', "exe"]): # add numbers button
self.numbers.append(ctk.CTkButton(self, text=val)) self.fonction_screen_height = None
if val == "clear": self.fonction_screen_width = None
self.numbers[i]._command = self.clear_screen self.grid_columnconfigure(0, weight=0)
self.grid_columnconfigure((1,2,3,4,5), weight=1)
self.grid_rowconfigure(0, weight=0)
self.grid_rowconfigure((1,2,3,4,5), weight=1)
# touches de la calculette
self.keys = []
for i, val in enumerate(["←", "cos", "sin", "tan", "→", "x", "e", "√", "^", "𝜋", 7, 8, 9, "(", ")", 4, 5, 6, "*", "/", 1, 2, 3, "+", "-",
"clear", 0, ".", "ln", "exe"]): # add numbers button
if type(val) == int:
self.keys.append(ctk.CTkButton(self, text=val, command=lambda x=val: self.add_value(x), fg_color=("gray50","gray20"), text_color="gray90", hover_color=("gray40", "gray30")))
elif val == "clear":
self.keys.append(ctk.CTkButton(self, text=val, command=self.clear_screen))
elif val == "←":
self.keys.append(ctk.CTkButton(self, text=val, command=self.move_cursor_left))
elif val == "→":
self.keys.append(ctk.CTkButton(self, text=val, command=self.move_cursor_right))
else: else:
self.numbers[i]._command = lambda x=val: self.add_value(x) self.keys.append(ctk.CTkButton(self, text=val, command=lambda x=val: self.add_value(x)))
self.numbers[i].grid(row=5+i//4, column=i%4+1, sticky="NSEW", padx=5, pady=5) self.keys[i].grid(row=i//5+1, column=i % 5+1, sticky="NSEW", padx=5, pady=5)
# Calcul Frame # Calcul Frame
@ -75,40 +122,42 @@ class App(ctk.CTk):
self.fonction_frame = ctk.CTkFrame(self, fg_color="transparent") self.fonction_frame = ctk.CTkFrame(self, fg_color="transparent")
self.fonction_screen = ctk.CTkCanvas(self.fonction_frame) self.fonction_screen = ctk.CTkCanvas(self.fonction_frame)
self.fonction_screen.pack(fill="both", expand=True) self.fonction_screen.grid(sticky="nsew", column=1, row=0)
self.fonction_entry = ctk.CTkEntry(self.fonction_frame) self.fonction_entry = ctk.CTkEntry(self.fonction_frame)
self.fonction_entry.pack(fill="both", expand=True) self.fonction_entry.grid(sticky='ew', column=1, row=1)
# navigation menu # navigation menu
self.navigation_frame = ctk.CTkFrame(self, corner_radius=0) self.navigation_frame = ctk.CTkFrame(self, corner_radius=0)
self.navigation_frame.grid_rowconfigure(4, weight=1) self.navigation_frame.grid_rowconfigure(4, weight=1)
self.navigation_frame.grid(row=0, rowspan=10, column=0, sticky="nsew") self.navigation_frame.grid(row=0, rowspan=10, column=0, sticky="nsew")
self.titre = ctk.CTkLabel(self.navigation_frame, text="Wx Calculator", self.titre = ctk.CTkLabel(self.navigation_frame, text="Wx Calculator", compound="left"
compound="left", font=ctk.CTkFont(size=15, weight="bold")) , font=ctk.CTkFont(size=15, weight="bold"))
self.titre.grid(row=0, column=0, padx=20, pady=20) self.titre.grid(row=0, column=0, padx=20, pady=20)
self.home_button = ctk.CTkButton(self.navigation_frame, corner_radius=0, height=40, border_spacing=10, text="Calcul", self.home_button = ctk.CTkButton(self.navigation_frame, corner_radius=0, height=40, border_spacing=10
fg_color="transparent", text_color=("gray10", "gray90"), hover_color=("gray70", "gray30"), , text="Calcul", fg_color="transparent", text_color=("gray10", "gray90")
anchor="w", command=lambda: self.select_frame_by_name("Calcul")) , hover_color=("gray70", "gray30"), anchor="w"
, command=lambda: self.select_frame_by_name("Calcul"))
self.home_button.grid(row=1, column=0, sticky="ew") self.home_button.grid(row=1, column=0, sticky="ew")
self.function_button = ctk.CTkButton(self.navigation_frame, corner_radius=0, height=40, border_spacing=10, text="Fonction", self.function_button = ctk.CTkButton(self.navigation_frame, corner_radius=0, height=40, border_spacing=10
fg_color="transparent", text_color=("gray10", "gray90"), hover_color=("gray70", "gray30"), , text="Fonction", fg_color="transparent", text_color=("gray10", "gray90")
anchor="w", command=lambda: self.select_frame_by_name("Fonction")) , hover_color=("gray70", "gray30"), anchor="w"
, command=lambda: self.select_frame_by_name("Fonction"))
self.function_button.grid(row=2, column=0, sticky="ew") self.function_button.grid(row=2, column=0, sticky="ew")
self.appearance_mode_menu = ctk.CTkOptionMenu(self.navigation_frame, values=["Light", "Dark", "System"], self.appearance_mode_menu = ctk.CTkOptionMenu(self.navigation_frame, values=["Light", "Dark", "System"]
command=self.change_appearance_mode_event) , command=change_appearance_mode_event)
self.appearance_mode_menu.grid(row=4, column=0, padx=20, pady=20, sticky="s") self.appearance_mode_menu.grid(row=4, column=0, padx=20, pady=20, sticky="s")
self.mode = 'Calcul' self.mode = 'Calcul'
# select default frame # select default frame
self.select_frame_by_name("Calcul") self.select_frame_by_name("Calcul")
def select_frame_by_name(self, name): def select_frame_by_name(self, name):
"""Change de mode : passe de calcul à fonction"""
# set button color for selected button # set button color for selected button
self.home_button.configure(fg_color=("gray75", "gray25") if name == "Calcul" else "transparent") self.home_button.configure(fg_color=("gray75", "gray25") if name == "Calcul" else "transparent")
self.function_button.configure(fg_color=("gray75", "gray25") if name == "Fonction" else "transparent") self.function_button.configure(fg_color=("gray75", "gray25") if name == "Fonction" else "transparent")
@ -116,128 +165,211 @@ class App(ctk.CTk):
# show selected frame # show selected frame
if name == "Calcul": if name == "Calcul":
self.mode = "Calcul" self.mode = "Calcul"
self.calcul_frame.grid(padx=20, pady=20,columnspan=4, column=1, rowspan=5, row=0, sticky="nsew") self.calcul_frame.grid(padx=20, pady=20, columnspan=5, column=1, row=0, sticky="nsew")
self.numbers[-1]._command = self.calculate self.keys[-1]._command = self.calculate
else: else:
self.calcul_frame.grid_forget() self.calcul_frame.grid_forget()
if name == "Fonction": if name == "Fonction":
self.mode = "Fonction" self.mode = "Fonction"
self.fonction_frame.grid(columnspan=4, column=1, row=0, padx=20, pady=20, sticky="nsew") self.fonction_frame.grid(columnspan=5, column=1, row=0, padx=20, pady=20, sticky="ns")
self.fonction_frame.update() self.fonction_frame.update()
self.fonction_screen_width = self.fonction_screen.winfo_width() self.fonction_screen_width = self.fonction_screen.winfo_width()
self.numbers[-1]._command = self.draw_graph self.keys[-1]._command = self.draw_graph
self.fonction_screen_height = self.fonction_screen.winfo_height() self.fonction_screen_height = self.fonction_screen.winfo_height()
print(self.fonction_screen_height)
else: else:
self.fonction_frame.grid_forget() self.fonction_frame.grid_forget()
def change_appearance_mode_event(self, new_appearance_mode):
ctk.set_appearance_mode(new_appearance_mode)
def add_value(self, value) -> None: def add_value(self, value) -> None:
"""Ajoute le charactère à la suite de l'expression"""
parenthesis = False
if value == "e":
value += "^"
if value == "(":
value += ")"
parenthesis = True
elif value in ["ln", "cos", "sin", "tan", "√"]:
value += "()"
parenthesis = True
if self.mode == 'Fonction': if self.mode == 'Fonction':
self.fonction_entry.insert("end", value) self.fonction_entry.insert(ctk.INSERT, value)
else: else:
self.calcul_entry.insert("end", value) self.calcul_entry.insert(ctk.INSERT, value)
if parenthesis:
self.move_cursor_left()
def clear_screen(self) -> None: def clear_screen(self) -> None:
"""Enlève l'affichage actuel"""
if self.mode == "Calcul": if self.mode == "Calcul":
self.calcul_screen.configure(text="") self.calcul_screen.configure(text="")
self.calcul_entry.delete('0', 'end')
else: else:
self.fonction_screen.delete('all') self.fonction_screen.delete('all')
self.fonction_entry.delete(0, 'end')
def move_cursor_left(self):
"""Déplace le curseur à gauche"""
if self.mode == "Calcul":
pos = self.calcul_entry.index(ctk.INSERT)
if pos > 0:
self.calcul_entry.icursor(pos -1)
else:
pos = self.fonction_entry.index(ctk.INSERT)
if pos > 0:
self.fonction_entry.icursor(pos-1)
def move_cursor_right(self):
"""Déplace le curseur à droite"""
if self.mode == "Calcul":
pos = self.calcul_entry.index(ctk.INSERT)
if pos < len(self.calcul_entry.get()):
self.calcul_entry.icursor(pos + 1)
else:
pos = self.fonction_entry.index(ctk.INSERT)
if pos < len(self.fonction_entry.get()):
self.fonction_entry.icursor(pos + 1)
def draw_framing(self, min_x, max_x, min_y, max_y): def draw_framing(self, min_x, max_x, min_y, max_y):
"""Dessine le cadrillage du graphique"""
ratio = self.fonction_screen_height / self.fonction_screen_width # longueur par largeur du canvas ratio = self.fonction_screen_height / self.fonction_screen_width # longueur par largeur du canvas
# position du max dans l'interval # position du max dans l'interval
abscisse = max_y / (abs(min_y)+abs(max_y)) abscisse = max_y / (abs(min_y)+abs(max_y))
ordonnee = max_x / (abs(min_x)+abs(max_x)) ordonnee = max_x / (abs(min_x)+abs(max_x))
for i in range(20): # dessin des lignes verticales for i in range(20): # dessin des lignes verticales
if i == int(20*ordonnee): if i == int(20*ordonnee):
self.fonction_screen.create_line(0 + i * self.fonction_screen_width/20, 0, 0 + i * self.fonction_screen_width/20, self.fonction_screen_height, fill='red', width=4) self.fonction_screen.create_line(0 + i * self.fonction_screen_width/20, 0
, 0 + i * self.fonction_screen_width/20, self.fonction_screen_height
, fill='red', width=4)
text = self.fonction_screen.create_text(0 + i * self.fonction_screen_width/20, 10, text=max_y) text = self.fonction_screen.create_text(0 + i * self.fonction_screen_width/20, 10, text=max_y)
rect = self.fonction_screen.create_rectangle(self.fonction_screen.bbox(text), fill="white") rect = self.fonction_screen.create_rectangle(self.fonction_screen.bbox(text), fill="white")
self.fonction_screen.tag_lower(rect, text) self.fonction_screen.tag_lower(rect, text)
text = self.fonction_screen.create_text(0 + i * self.fonction_screen_width/20, self.fonction_screen_height - 10, text=min_y) text = self.fonction_screen.create_text(0 + i * self.fonction_screen_width/20,
self.fonction_screen_height - 10, text=min_y)
rect = self.fonction_screen.create_rectangle(self.fonction_screen.bbox(text), fill="white") rect = self.fonction_screen.create_rectangle(self.fonction_screen.bbox(text), fill="white")
self.fonction_screen.tag_lower(rect, text) self.fonction_screen.tag_lower(rect, text)
else: else:
self.fonction_screen.create_line(0 + i * self.fonction_screen_width/20, 0, 0 + i * self.fonction_screen_width/20, self.fonction_screen_height, fill='red') self.fonction_screen.create_line(0 + i * self.fonction_screen_width/20, 0
coo_abscisse = self.fonction_screen_height * ordonnee % 20 -6 # décalage modulo 20 par rapport à l'origine , 0 + i * self.fonction_screen_width/20, self.fonction_screen_height
nb_abscisse_lines = math.ceil(20*ratio)+1 # nombres de lignes horizontales à tracer , fill='red')
for i in range(nb_abscisse_lines): # dessin des lignes verticales nb_abscisse_lines = int(20*ratio) # nombre de lignes horizontales à tracer
for i in range(nb_abscisse_lines): # dessin des lignes horizontales
if i == int(nb_abscisse_lines * abscisse): # tracer de l'axe des abscisses if i == int(nb_abscisse_lines * abscisse): # tracer de l'axe des abscisses
self.fonction_screen.create_line(0, 0 + i * self.fonction_screen_width/20 - coo_abscisse, self.fonction_screen_width, 0 + i * self.fonction_screen_width/20 - coo_abscisse, fill='red', width=4) self.fonction_screen.create_line(0, 0 + i * self.fonction_screen_width/20
text = self.fonction_screen.create_text(15, 0 + i * self.fonction_screen_width/20 - coo_abscisse, text=min_x) , self.fonction_screen_width
rect = self.fonction_screen.create_rectangle(self.fonction_screen.bbox(text),fill="white") , 0 + i * self.fonction_screen_width/20, fill='red'
, width=4)
text = self.fonction_screen.create_text(15, 0 + i * self.fonction_screen_width/20
, text=min_x)
rect = self.fonction_screen.create_rectangle(self.fonction_screen.bbox(text)
, fill="white")
self.fonction_screen.tag_lower(rect, text) self.fonction_screen.tag_lower(rect, text)
text = self.fonction_screen.create_text(self.fonction_screen_width - 15, 0 + i * self.fonction_screen_width/20 - coo_abscisse, text=max_x) text = self.fonction_screen.create_text(self.fonction_screen_width - 15
, 0 + i * self.fonction_screen_width/20
, text=max_x)
rect = self.fonction_screen.create_rectangle(self.fonction_screen.bbox(text), fill="white") rect = self.fonction_screen.create_rectangle(self.fonction_screen.bbox(text), fill="white")
self.fonction_screen.tag_lower(rect, text) self.fonction_screen.tag_lower(rect, text)
else: else:
self.fonction_screen.create_line(0, 0 + i * self.fonction_screen_width/20 - coo_abscisse, self.fonction_screen_width, 0 + i * self.fonction_screen_width/20 - coo_abscisse, fill='red') self.fonction_screen.create_line(0, 0 + i * self.fonction_screen_width/20
, self.fonction_screen_width
, 0 + i * self.fonction_screen_width/20, fill='red')
def calculate(self) -> None: def calculate(self) -> None:
exp = list(self.calcul_entry.get()) """Calcule dans la partie graphique"""
exp = inf2npi(exp) exp = parse_string_to_list(self.calcul_entry.get())
result = npi2tree(exp).evalue() exp = npi2tree(inf2npi(exp))
exp.print_tree()
try:
result = exp.evalue()
except ZeroDivisionError:
result = "ERREUR"
self.calcul_screen.configure(text=result) self.calcul_screen.configure(text=result)
def draw_graph(self): def draw_graph(self):
"""Dessine les points du graphique"""
self.fonction_screen.delete('all') self.fonction_screen.delete('all')
self.fonction_points = npi2tree(inf2npi(parse_string_to_list(self.fonction_entry.get()))).valeurs_de_fonction() fonction_points = npi2tree(inf2npi(parse_string_to_list(self.fonction_entry.get()))).valeurs_de_fonction(-100, 100)
max_y = max(self.fonction_points,key=lambda item:item[1])[1] max_y = max(fonction_points, key=lambda item: item[1])[1]
min_y = min(self.fonction_points,key=lambda item:item[1])[1] min_y = min(fonction_points, key=lambda item: item[1])[1]
self.draw_framing(-100, 100, min_y, max_y) self.draw_framing(-1000, 1000, min_y, max_y)
for x, y in self.fonction_points: for x, y in fonction_points:
image_x = self.fonction_screen_width / 2 + x * (self.fonction_screen_width/len(self.fonction_points)) image_x = self.fonction_screen_width / 2 + x * (self.fonction_screen_width/len(fonction_points))
image_y = self.fonction_screen_height - (y - min_y) * self.fonction_screen_height / (abs(max_y)+abs(min_y)) - 3 image_y = self.fonction_screen_height - (y - min_y) * self.fonction_screen_height / (abs(max_y)+abs(min_y))
self.fonction_screen.create_rectangle(image_x, image_y, image_x, image_y) self.fonction_screen.create_rectangle(image_x, image_y, image_x, image_y)
def parse_string_to_list(text: str) -> list: def parse_string_to_list(text: str) -> list:
""" Transforme le text en liste d'éléments intelligible par le programme """
text = list(text) text = list(text)
result = [] result = []
elem = "" buffer_function = ""
buffer_number = ""
number_first = False # Savoir dans quel ordre sont les chiffres et les lettres
for char in text: for char in text:
if char.isdigit(): if char == 'e':
elem += char result.append(math.e)
elif char == 'x': elif char == '𝜋':
result.append(char) result.append(math.pi)
elif char.isdigit() or char == ".":
buffer_number += char
if len(buffer_function) == 0:
number_first = True
elif char.isalpha():
print(char)
buffer_function += char
else: else:
if len(elem) != 0: if number_first:
result.append(elem) print("number", char)
elem = "" result.append(float(buffer_number))
result.append(char) buffer_number = ""
if len(elem) != 0: number_first = False
result.append(elem) if len(buffer_function) != 0:
elem = "" result.append('*')
result.append(buffer_function)
buffer_function = ""
elif char == '(':
print("()")
result.append('*')
else:
if len(buffer_function) != 0:
result.append(buffer_function)
buffer_function = ""
if len(buffer_number) != 0:
result.append(float(buffer_number))
buffer_number = ""
number_first = False
result.append(char)
if len(buffer_number) != 0:
result.append(float(buffer_number))
if len(buffer_function) != 0:
result.append('*')
result.append(buffer_function)
elif len(buffer_function) != 0:
result.append(buffer_function)
print(result)
return result return result
def npi2tree(expr: list) -> Expression: def npi2tree(expr: list) -> Expression:
"""renvoie l'arbre formé a partir de l'expression donnée""" """ Renvoie l'arbre formé à partir de l'expression donnée"""
pile = Pile_chaine() pile = Pile_chaine()
for val in expr: for val in expr:
if not val.isdigit() and val != "x": if not type(val) is float and val != "x":
# on inverse pour avoir les nombres dans le bon ordre # on inverse pour avoir les nombres dans le bon ordre
nombre2, nombre1 = pile.depiler(), pile.depiler() nombre2 = pile.depiler()
pile.empiler(Expression(val, nombre1, nombre2)) if not pile.est_vide():
pile.empiler(Expression(val, pile.depiler(), nombre2))
else:
pile.empiler(Expression(val, nombre2))
else: else:
pile.empiler(Expression(val, None, None)) pile.empiler(Expression(val))
return pile.sommet() return pile.sommet()
def inf2npi(expr: list) -> list: def inf2npi(expr: list) -> list:
"""Transforme une expression infixé en notation polonaise inversée""" """Transforme une expression infixé en notation polonaise inversée"""
operator_stack = Pile_chaine() operator_stack = Pile_chaine()
@ -245,14 +377,14 @@ def inf2npi(expr: list) -> list:
'+': 1, '+': 1,
'-': 1, '-': 1,
'*': 2, '*': 2,
'^': 2, '^': 3,
'/': 2, '/': 2,
'(': 0, '(': 0,
')': 0 ')': 0
} }
output = [] output = []
for val in expr: for val in expr:
if val.isdigit() or val == 'x': if type(val) is float or val == 'x':
output.append(val) output.append(val)
else: else:
if operator_stack.est_vide() or ( val == '(' or operator_priority[val] > operator_priority[operator_stack.sommet()]): if operator_stack.est_vide() or ( val == '(' or operator_priority[val] > operator_priority[operator_stack.sommet()]):
@ -261,22 +393,16 @@ def inf2npi(expr: list) -> list:
while not operator_stack.est_vide(): while not operator_stack.est_vide():
if operator_stack.sommet() == '(': if operator_stack.sommet() == '(':
operator_stack.depiler() operator_stack.depiler()
if operator_stack.est_vide(): # test si il y a un astérix avant la parenthèse
output.append('*')
elif operator_stack.sommet() != '*':
output.append('*')
else:
output.append(operator_stack.depiler())
else: else:
output.append(operator_stack.depiler()) output.append(operator_stack.depiler())
if val != ')': if val != ')':
operator_stack.empiler(val) operator_stack.empiler(val)
while not operator_stack.est_vide(): while not operator_stack.est_vide():
output.append(operator_stack.depiler()) output.append(operator_stack.depiler())
print(output)
return output return output
# [3, '-', 6, '*', 4, '+', 3] # [3, '-', 6, '*', 4, '+', 3]
print(parse_string_to_list('x'))
print(inf2npi(parse_string_to_list('x')))
gui = App() gui = App()
gui.mainloop() gui.mainloop()
Write Preview
Loading…
Cancel
Save