15/12/2023 19:05 application qui permet de visionner la résolution d'un programme linéaire, en utilisant la méthode du simplexe

In [20]:
import tkinter as tk
from tkinter import messagebox
import numpy as np
from scipy.optimize import linprog

def create_entries():
try:
num_vars = int(num_vars_entry.get())
num_constraints = int(num_constraints_entry.get())

global A_entries, b_entries, c_entries, inequalities_var, positive_vars_var

A_frame = tk.Frame(root)
A_frame.pack()

A_entries = []
for i in range(num_constraints):
row_entries = []
for j in range(num_vars):
entry = tk.Entry(A_frame)
entry.grid(row=i, column=j)
row_entries.append(entry)
A_entries.append(row_entries)

b_frame = tk.Frame(root)
b_frame.pack()

b_entries = []
for i in range(num_constraints):
entry = tk.Entry(b_frame)
entry.grid(row=i, column=0)
b_entries.append(entry)

c_frame = tk.Frame(root)
c_frame.pack()

c_entries = []
for j in range(num_vars):
entry = tk.Entry(c_frame)
entry.grid(row=0, column=j)
c_entries.append(entry)

inequalities_frame = tk.Frame(root)
inequalities_frame.pack()

inequalities_var = []
inequalities_options = ['≤', '≥', '=']
for i in range(num_constraints):
var = tk.StringVar()
var.set('≤') # Initialiser à ≤
option_menu = tk.OptionMenu(inequalities_frame, var, *inequalities_optio
option_menu.grid(row=i, column=0)
inequalities_var.append(var)

positive_vars_frame = tk.Frame(root)
positive_vars_frame.pack()

positive_vars_var = []
positive_vars_options = ['Positif', 'Non-positif']
for j in range(num_vars):
var = tk.StringVar()
var.set('Positif') # Initialiser à Positif

localhost:8888/nbconvert/html/application qui permet de visionner la résolution d'un programme linéaire%2C en utilisant la méthode du simplexe.… 1/3
15/12/2023 19:05 application qui permet de visionner la résolution d'un programme linéaire, en utilisant la méthode du simplexe
option_menu = tk.OptionMenu(positive_vars_frame, var, *positive_vars_opt
option_menu.grid(row=0, column=j)
positive_vars_var.append(var)

solve_button = tk.Button(root, text="Résoudre", command=solve_linear_program

solve_button.pack()

except ValueError:
messagebox.showerror("Erreur", "Veuillez entrer des valeurs numériques valid

def solve_linear_program():
try:
num_vars = int(num_vars_entry.get())
num_constraints = int(num_constraints_entry.get())

A_values = []
for i in range(num_constraints):
row = []
for j in range(num_vars):
val = float(A_entries[i][j].get())
row.append(val)
A_values.append(row)

A = np.array(A_values)

b_values = []
for i in range(num_constraints):
val = float(b_entries[i].get())
b_values.append(val)
b = np.array(b_values)

c_values = []
for j in range(num_vars):
val = float(c_entries[j].get())
c_values.append(val)
c = np.array(c_values)

inequalities = [inequalities_var[i].get() for i in range(num_constraints)]

positive_vars = [positive_vars_var[j].get() for j in range(num_vars)]

result = solve_lp_with_simplex(A, b, c, inequalities, positive_vars)

display_solution(result)

except ValueError:
messagebox.showerror("Erreur", "Veuillez entrer des valeurs numériques valid

def solve_lp_with_simplex(A, b, c, inequalities, positive_vars):

sign_mapping = {'≤': '<=', '≥': '>=', '=': '=='}
inequalities = [sign_mapping[s] for s in inequalities]
bounds = [(0, None) if var == 'Positif' else (None, None) for var in positive_va

res = linprog(c, A_ub=A, b_ub=b, method='highs', bounds=bounds, options={"presol

if res.success:
return res
else:
return "Le problème n'a pas pu être résolu."

def display_solution(result):
messagebox.showinfo("Solution", f"Résultat de la résolution :\n\n{result}")

root = tk.Tk()
root.title("Résolveur de Programme Linéaire")

localhost:8888/nbconvert/html/application qui permet de visionner la résolution d'un programme linéaire%2C en utilisant la méthode du simplexe.… 2/3
15/12/2023 19:05 application qui permet de visionner la résolution d'un programme linéaire, en utilisant la méthode du simplexe
num_vars_label = tk.Label(root, text="Nombre de variables :")
num_vars_label.pack()

num_vars_entry = tk.Entry(root)
num_vars_entry.pack()

num_constraints_label = tk.Label(root, text="Nombre de contraintes :")

num_constraints_label.pack()

num_constraints_entry = tk.Entry(root)
num_constraints_entry.pack()

create_entries_button = tk.Button(root, text="Créer les champs d'entrée", command=cr

create_entries_button.pack()

A_entries = []
b_entries = []
c_entries = []
inequalities_var = []
positive_vars_var = []

root.mainloop()

localhost:8888/nbconvert/html/application qui permet de visionner la résolution d'un programme linéaire%2C en utilisant la méthode du simplexe.… 3/3