Update app.py

app.py

@@ -1,340 +1,3 @@
-import gradio as gr
-import numpy as np
-import re
-import math
-import pandas as pd
-from typing import List, Dict, Any, Tuple
-
-EPS = 1e-9
-BIG_M = 1e6
-
-# ---------------- Parsing utilities ----------------
-
-def parse_coeffs(text: str) -> List[float]:
-    if not text or not text.strip():
-        return []
-    s = text.replace(',', ' ')
-    parts = [p for p in s.split() if p.strip()]
-    coeffs = []
-    for p in parts:
-        try:
-            coeffs.append(float(eval(p)))
-        except Exception:
-            raise ValueError(f"Coeficiente inválido: '{p}'")
-    return coeffs
-
-def parse_constraints(text: str, nvars: int) -> List[Dict[str,Any]]:
-    lines = [ln.strip() for ln in text.strip().splitlines() if ln.strip()]
-    cons = []
-    pattern = r'([+-]?[0-9./]*)x([0-9]+)'
-
-    for ln in lines:
-        s = ln.replace(' ', '')
-        if '<=' in s or '=< ' in s:
-            s = s.replace('=<', '<=')
-            left, right = s.split('<=')
-            sense = '<='
-        elif '>=' in s or '=>' in s:
-            s = s.replace('=>', '>=')
-            left, right = s.split('>=')
-            sense = '>='
-        elif '=' in s:
-            left, right = s.split('=')
-            sense = '='
-        else:
-            raise ValueError(f"Restrição inválida, faltando <=, >= ou = : '{ln}'")
-        try:
-            rhs = float(eval(right))
-        except Exception:
-            raise ValueError(f"RHS inválido na restrição: '{right}' na linha '{ln}'")
-
-        terms = re.findall(pattern, left)
-        coeffs = [0.0] * nvars
-        for coef_str, var_str in terms:
-            idx = int(var_str) - 1
-            if idx < 0 or idx >= nvars:
-                raise ValueError(f"Variável fora do intervalo: x{idx+1} na linha '{ln}'")
-            if coef_str in ['', '+']:
-                v = 1.0
-            elif coef_str == '-':
-                v = -1.0
-            else:
-                try:
-                    v = float(eval(coef_str))
-                except Exception:
-                    raise ValueError(f"Coeficiente inválido: '{coef_str}' na linha '{ln}'")
-            coeffs[idx] += v
-        cons.append({'coeffs': coeffs, 'sense': sense, 'rhs': rhs})
-    return cons
-
-# ---------------- Tableau builder (Big-M) ----------------
-
-def build_tableau_bigM(c: List[float], constraints: List[Dict[str,Any]], sense: str = 'max') -> Tuple[np.ndarray, List[int], Tuple[int,int,int]]:
-    obj_mult = 1.0
-    if sense == 'min':
-        obj_mult = -1.0
-    c_adj = [ci * obj_mult for ci in c]
-
-    n = len(c_adj)
-    m = len(constraints)
-
-    slacks = 0
-    artificials = 0
-    for row in constraints:
-        if row['sense'] == '<=':
-            slacks += 1
-        elif row['sense'] == '>=':
-            slacks += 1
-            artificials += 1
-        else:
-            artificials += 1
-
-    total_cols = n + slacks + artificials + 1
-    T = np.zeros((m + 1, total_cols))
-
-    slack_idx = n
-    artificial_idx = n + slacks
-
-    basis = []
-    art_positions = []
-
-    s_counter = 0
-    a_counter = 0
-
-    for i, row in enumerate(constraints):
-        coeffs = row['coeffs']
-        T[i, :n] = coeffs
-        if row['sense'] == '<=':
-            T[i, slack_idx + s_counter] = 1.0
-            basis.append(slack_idx + s_counter)
-            s_counter += 1
-        elif row['sense'] == '>=':
-            T[i, slack_idx + s_counter] = -1.0
-            T[i, artificial_idx + a_counter] = 1.0
-            basis.append(artificial_idx + a_counter)
-            art_positions.append(artificial_idx + a_counter)
-            s_counter += 1
-            a_counter += 1
-        else:  # equality
-            T[i, artificial_idx + a_counter] = 1.0
-            basis.append(artificial_idx + a_counter)
-            art_positions.append(artificial_idx + a_counter)
-            a_counter += 1
-        T[i, -1] = row['rhs']
-
-    T[-1, :n] = -np.array(c_adj)
-
-    for a_pos in art_positions:
-        T[-1, a_pos] = T[-1, a_pos] - BIG_M
-
-    return T, basis, (n, slacks, artificials)
-
-# ---------------- Simplex tableau operations ----------------
-
-def snapshot_html(tableau: np.ndarray, basis: List[int]) -> str:
-    cols = tableau.shape[1]
-    html = '<table border="1" style="border-collapse:collapse;font-family:Arial; font-size:12px;">'
-    for i in range(tableau.shape[0]):
-        html += '<tr>'
-        for j in range(cols):
-            val = tableau[i, j]
-            html += f'<td style="padding:4px;">{val:.6g}</td>'
-        html += '</tr>'
-    html += '</table>'
-    return html
-
-def primal_simplex_tableau(T: np.ndarray, basis: List[int], max_iters=500) -> Tuple[np.ndarray, List[int], List[Dict[str,Any]]]:
-    m = T.shape[0] - 1
-    path = []
-    path.append({'tableau': T.copy(), 'basis': basis.copy(), 'html': snapshot_html(T, basis)})
-    it = 0
-    while it < max_iters:
-        it += 1
-        obj_row = T[-1, :-1]
-        entering_candidates = np.where(obj_row < -EPS)[0]
-        if entering_candidates.size == 0:
-            break
-        entering = int(entering_candidates[0])
-        ratios = np.full(m, np.inf)
-        for i in range(m):
-            a = T[i, entering]
-            if a > EPS:
-                ratios[i] = T[i, -1] / a
-        if np.all(np.isinf(ratios)):
-            raise ValueError('Unbounded LP')
-        leaving = int(np.argmin(ratios))
-        piv = T[leaving, entering]
-        T[leaving, :] = T[leaving, :] / piv
-        for i in range(m+1):
-            if i == leaving: continue
-            T[i, :] = T[i, :] - T[i, entering] * T[leaving, :]
-        basis[leaving] = entering
-        path.append({'tableau': T.copy(), 'basis': basis.copy(), 'html': snapshot_html(T, basis)})
-    return T, basis, path
-
-def dual_simplex_tableau(T: np.ndarray, basis: List[int], max_iters=500) -> Tuple[np.ndarray, List[int], List[Dict[str,Any]]]:
-    m = T.shape[0] - 1
-    ncols = T.shape[1]
-    path = []
-    path.append({'tableau': T.copy(), 'basis': basis.copy(), 'html': snapshot_html(T, basis)})
-    it = 0
-    while it < max_iters:
-        it += 1
-        rhs = T[:-1, -1]
-        leaving_candidates = np.where(rhs < -EPS)[0]
-        if leaving_candidates.size == 0:
-            break
-        leaving = int(leaving_candidates[0])
-        entering = -1
-        best = math.inf
-        for j in range(ncols-1):
-            a = T[leaving, j]
-            cj = T[-1, j]
-            if a < -EPS:
-                val = cj / a
-                if val < best:
-                    best = val
-                    entering = j
-        if entering == -1:
-            raise ValueError('Dual infeasible')
-        piv = T[leaving, entering]
-        T[leaving, :] = T[leaving, :] / piv
-        for i in range(m+1):
-            if i == leaving: continue
-            T[i, :] = T[i, :] - T[i, entering] * T[leaving, :]
-        basis[leaving] = entering
-        path.append({'tableau': T.copy(), 'basis': basis.copy(), 'html': snapshot_html(T, basis)})
-    return T, basis, path
-
-# ---------------- Extraction & reporting ----------------
-
-def extract_solution_from_bigM_tableau(T: np.ndarray, basis: List[int], n_orig: int) -> Tuple[List[float], float]:
-    m = T.shape[0] - 1
-    x = [0.0] * n_orig
-    for i, bi in enumerate(basis):
-        if bi < n_orig:
-            x[bi] = float(T[i, -1])
-    z = float(T[-1, -1])
-    return x, z
-
-def clean_vector(vec):
-    try:
-        return [float(v) for v in vec]
-    except:
-        return vec
-
-# ---------------- Gradio handler ----------------
-
-def run_algorithms(nvars_str, objective_str, cons_str, sense, mode):
-    try:
-        nvars = int(nvars_str)
-        if nvars <= 0:
-            return 'Erro: nvars deve ser inteiro positivo', '', '', '', ''
-        c = parse_coeffs(objective_str)
-        if len(c) != nvars:
-            return 'Erro: coeficientes do objetivo não correspondem a nvars', '', '', '', ''
-        constraints = parse_constraints(cons_str, nvars)
-    except Exception as e:
-        return f'Erro ao ler entrada: {e}', '', '', '', ''
-
-    try:
-        T0, basis0, (n_orig, n_slack, n_art) = build_tableau_bigM(c, constraints, sense)
-    except Exception as e:
-        return f'Erro ao construir tableau: {e}', '', '', '', ''
-
-    # run primal simplex
-    try:
-        T_primal, basis_primal, path_primal = primal_simplex_tableau(T0.copy(), basis0.copy())
-    except Exception as e:
-        return f'Erro durante Simplex primal: {e}', '', '', '', ''
-
-    # run dual simplex starting from same initial tableau (demonstration)
-    try:
-        T_dual, basis_dual, path_dual = dual_simplex_tableau(T0.copy(), basis0.copy())
-    except Exception as e:
-        # dual pode falhar, mas não quebra a app — colocamos mensagem
-        T_dual, basis_dual, path_dual = None, None, []
-        dual_error = str(e)
-
-    x_primal, z_primal = extract_solution_from_bigM_tableau(T_primal, basis_primal, n_orig)
-
-    # final HTML steps (primal)
-    steps_html_primal = ''
-    for idx, step in enumerate(path_primal):
-        steps_html_primal += f"<h4>Primal — Passo {idx+1} — Base: {step['basis']}</h4>"
-        steps_html_primal += step['html'] + '<br/>'
-
-    # final HTML steps (dual)
-    steps_html_dual = ''
-    if path_dual:
-        for idx, step in enumerate(path_dual):
-            steps_html_dual += f"<h4>Dual — Passo {idx+1} — Base: {step['basis']}</h4>"
-            steps_html_dual += step['html'] + '<br/>'
-    else:
-        steps_html_dual = f"<p>Dual não executado: {locals().get('dual_error','(sem erro especificado)')}</p>"
-
-    # solution table (primal)
-    df = pd.DataFrame({'Variável': [f'x{i+1}' for i in range(len(x_primal))], 'Valor': x_primal})
-    solution_html = df.to_html(index=False)
-    solution_html += f"<p><b>Valor ótimo (estimado) = {z_primal:.6g}</b></p>"
-
-    # reduced costs and shadow prices
-    reduced = []
-    for j in range(n_orig):
-        z_j = -T_primal[-1, j]
-        reduced.append(round(c[j] - z_j, 8))
-    shadow = []
-    for i in range(len(constraints)):
-        idx = n_orig + i
-        if idx < T_primal.shape[1]-1:
-            shadow.append(round(-T_primal[-1, idx], 8))
-        else:
-            shadow.append(0.0)
-
-    # clean numeric types
-    x_primal = clean_vector(x_primal)
-    reduced = clean_vector(reduced)
-    shadow = clean_vector(shadow)
-    z_primal = float(z_primal)
-
-    model_txt = f"Objective ({'min' if sense=='min' else 'max'}): {c} \n Constraints: \n"
-    for r in constraints:
-        model_txt += f"  {r['coeffs']} {r['sense']} {r['rhs']} \n"
-
-    summary = ''
-    summary += f"Solução primal x* = {x_primal} \n"
-    summary += f"Z_primal (estimado) = {z_primal:.6g} \n"
-    summary += f"Preços-sombra (dual estimado) = {shadow} \n"
-    summary += f"Custos reduzidos (orig vars) = {reduced} \n"
-
-    # outputs: model, solution_html, steps_primal_html, steps_dual_html, summary
-    return model_txt, solution_html, steps_html_primal, steps_html_dual, summary
-
-# ---------------- Gradio UI ----------------
-
-with gr.Blocks() as demo:
-    gr.Markdown("# Simplex (Big-M) — Primal & Dual (educational)")
-    with gr.Row():
-        with gr.Column(scale=1):
-            nvars = gr.Textbox(label='Número de variáveis (n)', value='2')
-            objective = gr.Textbox(label='Coeficientes da função objetivo (ex: \"60 30\" ou \"60,30\")', value='60 30')
-            cons = gr.Textbox(label='Restrições (uma por linha). Ex.: 2x1+3x2<=300', lines=6,
-                              value='6x1 + 8x2 <= 48 \n1x1 <= 5 \n1x2 <= 4')
-            sense = gr.Radio(['max','min'], value='max', label='Tipo de objetivo')
-            run = gr.Button('Executar Simplex (Big-M)')
-        with gr.Column(scale=2):
-            model_out = gr.Textbox(label='Função objetivo e restrições (modelo)', lines=6)
-            solution_out = gr.HTML(label='Solução ótima (tabela)')
-            steps_primal_out = gr.HTML(label='Passos do Simplex (primal tableaus)')
-            steps_dual_out = gr.HTML(label='Passos do Simplex (dual tableaus)')
-            summary_out = gr.Textbox(label='Resumo', lines=8)
-
-    run.click(run_algorithms, inputs=[nvars, objective, cons, sense, gr.State(value='primal_and_dual')], outputs=[model_out, solution_out, steps_primal_out, steps_dual_out, summary_out])
-
-    gr.Examples(examples=[["2","60 30","6x1 + 8x2 <= 48 \n 1x1 <= 5 \n 1x2 <= 4","max"]], inputs=[nvars, objective, cons, sense])
-
-if __name__ == '__main__':
-    demo.launch()
 
 """
 # app.py — Simplex Duas Fases + Simplex Dual + PDF + Gradio (corrigido)
@@ -1033,7 +696,7 @@ if __name__ == '__main__':
 
 
 
-"""import gradio as gr
+import gradio as gr
 from typing import List, Tuple, Dict, Any
 import math
 import re
@@ -1248,6 +911,6 @@ with gr.Blocks() as demo:
               inputs=[nvars, objective, cons, sense],
               outputs=[model_out, primal_out, dual_out])
 if __name__ == "__main__":
-    demo.launch()"""
+    demo.launch()