Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import sympy as sp | |
| def default_symbols(): | |
| names = ["x","y","z","t","theta","a","b","c","n","m"] | |
| d = {name: sp.symbols(name, real=True) for name in names} | |
| d["pi"] = sp.pi | |
| d["e"] = sp.E | |
| d["sqrt"] = sp.sqrt | |
| return d | |
| def parse_constraints(parts, syms): | |
| cons = [] | |
| for p in parts: | |
| s = p.strip() | |
| if not s: | |
| continue | |
| try: | |
| rel = sp.sympify(s, locals=syms) | |
| cons.append(rel) | |
| except Exception: | |
| pass | |
| return cons | |
| def solve_line(txt): | |
| syms = default_symbols() | |
| # constraints after comma: "eq, 0 <= theta < 2*pi" | |
| if "," in txt: | |
| main = txt.split(",", 1)[0].strip() | |
| cons = parse_constraints(txt.split(",")[1:].copy(), syms) | |
| else: | |
| main = txt.strip() | |
| cons = [] | |
| if not main: | |
| return "Empty input." | |
| if "=" in main: | |
| left, right = main.split("=", 1) | |
| try: | |
| eq = sp.Eq(sp.sympify(left, locals=syms), sp.sympify(right, locals=syms)) | |
| except Exception as e: | |
| return f"Parse equation failed: {e}" | |
| vars_set = set(eq.free_symbols) | |
| if not vars_set: | |
| vars_set = {sp.symbols("x", real=True)} | |
| vars_list = list(vars_set) | |
| # try solveset on first var with simple real-domain extraction | |
| if cons: | |
| v = vars_list[0] | |
| domain = sp.S.Reals | |
| try: | |
| # If constraints form an And of relationals, keep as boolean condition. | |
| cond = cons[0] | |
| for c in cons[1:]: | |
| cond = sp.And(cond, c) | |
| # best-effort: do not over-process; pass domain=Reals | |
| sol = sp.solveset(eq, v, domain=domain) | |
| return f"solveset({v} in Reals): {sp.simplify(sol)}" | |
| except Exception: | |
| pass | |
| try: | |
| sols = sp.solve([eq], vars_list, dict=True) | |
| if not sols: | |
| return "No solution or need more conditions." | |
| lines = [] | |
| for i, s in enumerate(sols, 1): | |
| parts = [] | |
| for k, v in s.items(): | |
| parts.append(f"{k} = {sp.simplify(v)}") | |
| lines.append("Solution " + str(i) + ": " + ", ".join(parts)) | |
| return "\n".join(lines) | |
| except Exception as e: | |
| return f"Solve failed: {e}" | |
| # pure expression branch | |
| try: | |
| expr = sp.sympify(main, locals=syms) | |
| except Exception as e: | |
| return f"Parse failed: {e}" | |
| out = [] | |
| try: | |
| out.append("Simplify: " + str(sp.simplify(expr))) | |
| except Exception: | |
| pass | |
| try: | |
| fact = sp.factor(expr) | |
| if fact != expr: | |
| out.append("Factor: " + str(fact)) | |
| except Exception: | |
| pass | |
| try: | |
| v = list(expr.free_symbols)[0] if expr.free_symbols else sp.symbols("x", real=True) | |
| out.append("d/d" + str(v) + ": " + str(sp.diff(expr, v))) | |
| out.append("Integral d" + str(v) + ": " + str(sp.integrate(expr, v))) | |
| except Exception: | |
| pass | |
| if out: | |
| return "\n".join(out) | |
| return "Result: " + str(expr) | |
| def solve_math(q): | |
| q = (q or "").strip() | |
| if not q: | |
| return "Enter expression(s) or equation(s). Use semicolons or newlines to separate.\nExamples:\n 2*x + 5 = 11\n sin(theta) = sqrt(3)/2, 0 <= theta < 2*pi\n factor(x**4 - 1)" | |
| segs = [] | |
| for line in q.splitlines(): | |
| segs.extend([p for p in line.split(";")]) | |
| segs = [s.strip() for s in segs if s.strip()] | |
| outputs = [] | |
| for s in segs: | |
| outputs.append(">>> " + s + "\n" + solve_line(s)) | |
| return "\n\n".join(outputs) | |
| with gr.Blocks(title="LanguageBridge — Math Fast Agent (SymPy)") as demo: | |
| gr.Markdown("# LanguageBridge — Math Fast Agent (SymPy)") | |
| gr.Markdown("Paste expressions or equations. Add constraints after a comma. Examples:\n- 2*x + 5 = 11\n- sin(theta) = sqrt(3)/2, 0 <= theta < 2*pi\n- factor(x**4 - 1)") | |
| q = gr.Textbox(lines=6, label="Problem / Expression (semicolon or newline for systems)") | |
| out = gr.Textbox(lines=12, label="Output") | |
| btn = gr.Button("Solve") | |
| btn.click(fn=solve_math, inputs=q, outputs=out) | |
| if __name__ == "__main__": | |
| demo.launch(share=True) | |