Update app_1.py

app_1.py

@@ -1600,4 +1600,222 @@ with gr.Blocks() as demo:
 if __name__ == "__main__":
     demo.launch()
 
- """
+
+ """
+
+"""import gradio as gr
+from typing import List, Tuple, Dict, Any
+import math
+import re
+EPS = 1e-9
+# --------------------------- Linear Algebra Helpers ---------------------------
+def zeros(rows, cols):
+    return [[0.0] * cols for _ in range(rows)]
+# --------------------------- Parser Utilities ---------------------------
+def parse_coeffs(text: str) -> List[float]:
+    # Parseia coeficientes da função objetivo.
+    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 = []
+    for ln in lines:
+        s = ln.replace(" ", "")
+        # operador lógico
+        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}'")
+        # RHS
+        try:
+            rhs = float(eval(right))
+        except:
+            raise ValueError(f"RHS inválido: '{right}'")
+        # capturar termos tipo +2x1, -3x2, 6/5x1
+        pattern = r'([+-]?[0-9./]*)(x[0-9]+)'
+        terms = re.findall(pattern, left)
+        coeffs = [0.0] * nvars
+        for coef_str, var_str in terms:
+            idx = int(var_str[1:]) - 1
+            if idx < 0 or idx >= nvars:
+                raise ValueError(f"Variável fora do intervalo: {var_str}")
+            if coef_str in ["", "+"]:
+                v = 1.0
+            elif coef_str == "-":
+                v = -1.0
+            else:
+                v = float(eval(coef_str))
+            coeffs[idx] += v
+        cons.append({
+            "coeffs": coeffs,
+            "sense": sense,
+            "rhs": rhs
+        })
+    return cons
+# --------------------------- Simplex Implementation ---------------------------
+def build_canonical_tableau(objective: List[float], constraints: List[Dict[str,Any]], sense: str = 'max'):
+    c = objective[:]
+    obj_mult = 1.0
+    if sense == 'min':
+        obj_mult = -1.0
+    c_adj = [ci * obj_mult for ci in c]
+    norm = []
+    for row in constraints:
+        coeffs = row['coeffs'][:]
+        rhs = row['rhs']
+        s = row['sense']
+        if s == '>=':
+            coeffs = [-a for a in coeffs]
+            rhs = -rhs
+            s = '<='
+        norm.append({"coeffs": coeffs, "rhs": rhs, "sense": s})
+    m = len(norm)
+    n = len(c_adj)
+    T = zeros(m + 1, n + m + 1)
+    for i in range(m):
+        for j in range(n):
+            T[i][j] = norm[i]['coeffs'][j]
+        T[i][n + i] = 1.0
+        T[i][n + m] = norm[i]['rhs']
+    for j in range(n):
+        T[m][j] = -c_adj[j]
+    return T, n, m, c, obj_mult, norm
+def extract_solution_from_tableau(T, basis, n, m, original_c):
+    x = [0.0] * n
+    for i in range(m):
+        if basis[i] < n:
+            x[basis[i]] = T[i][n + m]
+    obj = sum(original_c[j] * x[j] for j in range(n))
+    return x, obj
+def snapshot(T, basis, n, m):
+    x = [0.0] * n
+    for i in range(m):
+        if basis[i] < n:
+            x[basis[i]] = T[i][n + m]
+    return {
+        "basis": basis[:],
+        "x": [float(f"{v:.6f}") for v in x],
+        "tableau": [row[:] for row in T]
+    }
+def pivot(T, row, col):
+    piv = T[row][col]
+    if abs(piv) < EPS:
+        raise ZeroDivisionError("Pivot quase zero")
+    cols = len(T[0])
+    rows = len(T)
+    for j in range(cols):
+        T[row][j] /= piv
+    for i in range(rows):
+        if i == row:
+            continue
+        factor = T[i][col]
+        for j in range(cols):
+            T[i][j] -= factor * T[row][j]
+def primal_simplex(objective, constraints, sense):
+    T, n, m, original_c, obj_mult, norm = build_canonical_tableau(objective, constraints, sense)
+    basis = [n + i for i in range(m)]
+    path = [snapshot(T, basis, n, m)]
+    for _ in range(500):
+        entering = next((j for j in range(n + m) if T[m][j] < -EPS), None)
+        if entering is None:
+            break
+        best = math.inf
+        leaving = None
+        for i in range(m):
+            a = T[i][entering]
+            if a > EPS:
+                r = T[i][n + m] / a
+                if r < best:
+                    best = r
+                    leaving = i
+        if leaving is None:
+            return {"status": "unbounded", "path": path}
+        pivot(T, leaving, entering)
+        basis[leaving] = entering
+        path.append(snapshot(T, basis, n, m))
+    x, obj = extract_solution_from_tableau(T, basis, n, m, original_c)
+    reduced = [float(f"{(original_c[j] + T[m][j]):.6f}") for j in range(n)]
+    shadow = [float(f"{(-T[m][n + i]):.6f}") for i in range(m)]
+    return {
+        "status": "optimal",
+        "x": x,
+        "obj": obj,
+        "path": path,
+        "reduced_costs": reduced,
+        "shadow_prices": shadow
+    }
+def dual_simplex(objective, constraints, sense):
+    # usa mesma implementação — ok
+    return primal_simplex(objective, constraints, sense)
+# --------------------------- Gradio App UI ---------------------------
+def run_algorithms(nvars_str, objective_str, cons_str, sense):
+    try:
+        nvars = int(nvars_str)
+        objective = parse_coeffs(objective_str)
+        constraints = parse_constraints(cons_str, nvars)
+        if len(objective) != nvars:
+            return "Erro: objetivo não bate com nvars", "", ""
+    except Exception as e:
+        return f"Erro ao ler entrada: {e}", "", ""
+    primal = primal_simplex(objective, constraints, sense)
+    dual = dual_simplex(objective, constraints, sense)
+    def format_res(res):
+        if res["status"] != "optimal":
+            return f"Status: {res['status']}"
+        out = []
+        out.append(f"Solução x* = {res['x']}")
+        out.append(f"Valor objetivo = {res['obj']}")
+        out.append(f"Preços-sombra = {res['shadow_prices']}")
+        out.append(f"Custos reduzidos = {res['reduced_costs']}")
+        out.append(f"\n--- Path ({len(res['path'])}) ---")
+        for k, step in enumerate(res["path"]):
+            out.append(f"\n### Passo {k+1}")
+            out.append(f"Base = {step['basis']}")
+            out.append(f"x = {step['x']}")
+            out.append("Tableau:")
+            for row in step["tableau"]:
+                out.append("  " + "  ".join(f"{v:8.3f}" for v in row))
+        return "\n".join(out)
+    model_txt = "Modelo:\nObjetivo: " + str(objective) + "\nRestrições:\n"
+    for c in constraints:
+        model_txt += f"{c['coeffs']} {c['sense']} {c['rhs']}\n"
+    return model_txt, format_res(primal), format_res(dual)
+def demo_input():
+    return "2", "60,30", "2x1+3x2<=300\n6/5x1+3/2x2=200\n-x1+4x2>=0", "max"
+with gr.Blocks() as demo:
+    gr.Markdown("# Simplex Primal & Dual — Educational App")
+    with gr.Row():
+        with gr.Column(scale=1):
+            nvars = gr.Textbox(label="Número de variáveis", value="2")
+            objective = gr.Textbox(label="Função objetivo", value="60,30")
+            cons = gr.Textbox(label="Restrições", lines=6,
+                              value="2x1+3x2<=300\n6/5x1+3/2x2=200\n-x1+4x2>=0")
+            sense = gr.Radio(["max","min"], value="max", label="Objetivo")
+            run = gr.Button("Executar")
+        with gr.Column(scale=1):
+            model_out = gr.Textbox(label="Modelo", lines=8)
+            primal_out = gr.Textbox(label="Primal", lines=20)
+            dual_out = gr.Textbox(label="Dual", lines=20)
+    run.click(run_algorithms,
+              inputs=[nvars, objective, cons, sense],
+              outputs=[model_out, primal_out, dual_out])
+if __name__ == "__main__":
+    demo.launch()"""