display mode bar for 2D plot

dist/assets/{pyodide.worker-CGobkf40.js → pyodide.worker-CMc9uFEp.js}

@@ -354,6 +354,209 @@ class OptimizationManager:
                 )
             else:
                 raise ValueError("Unsupported algorithm for bivariate mode")
+
+        def handle_compute_trajectory(self, settings: dict) -> dict[str, dict]:
+            """
+            Compute function values and a full trajectory for the given settings
+            without modifying the manager's current state.
+            """
+            try:
+                mode = settings.get("mode", "").lower().strip()
+                function = settings.get("functionExpr", "").strip()
+                xlim = settings.get("xlim", [])
+                ylim = settings.get("ylim", [])
+
+                if not self._is_valid_function(function, mode, xlim, ylim):
+                    return {
+                        "trajectoryValues": {"x": [], "y": []},
+                        "functionValues": {"x": [], "y": []},
+                    }
+
+                # compute function values (local)
+                if mode == "univariate":
+                    x = np.linspace(xlim[0], xlim[1], 101)
+                    f = lambdify('x', self._parse_function(function), modules=['numpy'])
+                    y = f(x)
+                    if not isinstance(y, np.ndarray):
+                        y = np.full_like(x, y)
+                    function_values = {"x": x.tolist(), "y": y.tolist()}
+
+                elif mode == "bivariate":
+                    x = np.linspace(xlim[0], xlim[1], 101)
+                    y = np.linspace(ylim[0], ylim[1], 101)
+                    X, Y = np.meshgrid(x, y)
+                    expr = self._parse_function(function)
+                    f = lambdify(('x', 'y'), expr, modules=['numpy'])
+                    gradient_x = lambdify(('x', 'y'), expr.diff('x'), modules=['numpy'])
+                    gradient_y = lambdify(('x', 'y'), expr.diff('y'), modules=['numpy'])
+                    Z = f(X, Y)
+                    gradient_x_values = gradient_x(X, Y)
+                    gradient_y_values = gradient_y(X, Y)
+                    if not isinstance(Z, np.ndarray):
+                        Z = np.full_like(X, Z)
+                    if not isinstance(gradient_x_values, np.ndarray):
+                        gradient_x_values = np.full_like(X, gradient_x_values)
+                    if not isinstance(gradient_y_values, np.ndarray):
+                        gradient_y_values = np.full_like(Y, gradient_y_values)
+                    function_values = {
+                        "x": x.tolist(),
+                        "y": y.tolist(),
+                        "z": Z.tolist(),
+                        "gradientX": gradient_x_values.tolist(),
+                        "gradientY": gradient_y_values.tolist(),
+                    }
+                else:
+                    raise ValueError("Unsupported mode")
+
+                # compute trajectory values using existing helper logic
+                # choose a reasonably large number of steps for comparison
+                steps = 100
+                # reuse _compute_trajectory_values logic by calling the same functions
+                # but capture result into a local variable
+                mode_key = mode
+                algorithm = settings.get("algorithm", "").lower().strip().replace(" ", "_")
+
+                if mode_key == "univariate":
+                    if algorithm == "gradient_descent":
+                        traj = gd_univariate(
+                            self._parse_function(function),
+                            float(settings["x0"]),
+                            float(settings.get("learningRate", 0.1)),
+                            float(settings.get("momentum", 0.0)),
+                            steps,
+                        )
+                    elif algorithm == "nesterov":
+                        traj = nesterov_univariate(
+                            self._parse_function(function),
+                            float(settings["x0"]),
+                            float(settings.get("learningRate", 0.1)),
+                            float(settings.get("momentum", 0.0)),
+                            steps,
+                        )
+                    elif algorithm == "adam":
+                        traj = adam_univariate(
+                            self._parse_function(function),
+                            float(settings["x0"]),
+                            float(settings.get("learningRate", 0.1)),
+                            float(settings.get("beta1", 0.9)),
+                            float(settings.get("beta2", 0.999)),
+                            float(settings.get("epsilon", 1e-8)),
+                            steps,
+                        )
+                    elif algorithm == "adagrad":
+                        traj = adagrad_univariate(
+                            self._parse_function(function),
+                            float(settings["x0"]),
+                            float(settings.get("learningRate", 0.1)),
+                            float(settings.get("epsilon", 1e-8)),
+                            steps,
+                        )
+                    elif algorithm == "rmsprop":
+                        traj = rmsprop_univariate(
+                            self._parse_function(function),
+                            float(settings["x0"]),
+                            float(settings.get("learningRate", 0.1)),
+                            float(settings.get("beta", 0.9)),
+                            float(settings.get("epsilon", 1e-8)),
+                            steps,
+                        )
+                    elif algorithm == "adadelta":
+                        traj = adadelta_univariate(
+                            self._parse_function(function),
+                            float(settings["x0"]),
+                            float(settings.get("beta", 0.9)),
+                            float(settings.get("epsilon", 1e-3)),
+                            steps,
+                        )
+                    elif algorithm == "newton":
+                        traj = newton_univariate(
+                            self._parse_function(function),
+                            float(settings["x0"]),
+                            steps,
+                        )
+                    else:
+                        raise ValueError("Unsupported algorithm for univariate mode")
+
+                elif mode_key == "bivariate":
+                    if algorithm == "gradient_descent":
+                        traj = gd_bivariate(
+                            self._parse_function(function),
+                            float(settings["x0"]),
+                            float(settings["y0"]),
+                            float(settings.get("learningRate", 0.1)),
+                            float(settings.get("momentum", 0.0)),
+                            steps,
+                        )
+                    elif algorithm == "nesterov":
+                        traj = nesterov_bivariate(
+                            self._parse_function(function),
+                            float(settings["x0"]),
+                            float(settings["y0"]),
+                            float(settings.get("learningRate", 0.1)),
+                            float(settings.get("momentum", 0.0)),
+                            steps,
+                        )
+                    elif algorithm == "adam":
+                        traj = adam_bivariate(
+                            self._parse_function(function),
+                            float(settings["x0"]),
+                            float(settings["y0"]),
+                            float(settings.get("learningRate", 0.1)),
+                            float(settings.get("beta1", 0.9)),
+                            float(settings.get("beta2", 0.999)),
+                            float(settings.get("epsilon", 1e-8)),
+                            steps,
+                        )
+                    elif algorithm == "adagrad":
+                        traj = adagrad_bivariate(
+                            self._parse_function(function),
+                            float(settings["x0"]),
+                            float(settings["y0"]),
+                            float(settings.get("learningRate", 0.1)),
+                            float(settings.get("epsilon", 1e-8)),
+                            steps,
+                        )
+                    elif algorithm == "rmsprop":
+                        traj = rmsprop_bivariate(
+                            self._parse_function(function),
+                            float(settings["x0"]),
+                            float(settings["y0"]),
+                            float(settings.get("learningRate", 0.1)),
+                            float(settings.get("beta", 0.9)),
+                            float(settings.get("epsilon", 1e-8)),
+                            steps,
+                        )
+                    elif algorithm == "adadelta":
+                        traj = adadelta_bivariate(
+                            self._parse_function(function),
+                            float(settings["x0"]),
+                            float(settings["y0"]),
+                            float(settings.get("beta", 0.9)),
+                            float(settings.get("epsilon", 1e-3)),
+                            steps,
+                        )
+                    elif algorithm == "newton":
+                        traj = newton_bivariate(
+                            self._parse_function(function),
+                            float(settings["x0"]),
+                            float(settings["y0"]),
+                            steps,
+                        )
+                    else:
+                        raise ValueError("Unsupported algorithm for bivariate mode")
+
+                else:
+                    raise ValueError("Unsupported mode")
+
+                return {
+                    "functionValues": function_values,
+                    "trajectoryValues": traj,
+                }
+            except Exception as e:
+                return {
+                    "trajectoryValues": {"x": [], "y": []},
+                    "functionValues": {"x": [], "y": []},
+                }
 `,l=`import numpy as np
 from sympy import lambdify, Expr
 
@@ -1017,4 +1220,4 @@ def adam_bivariate(
         "gradient": gradient_values,
         "hessian": hessian_values,
     }
-`;const f="https://cdn.jsdelivr.net/pyodide/v0.26.1/full/pyodide.mjs";let e=null,a=null;async function r(){const{loadPyodide:n}=await import(f);e=await n({indexURL:"https://cdn.jsdelivr.net/pyodide/v0.26.1/full/"}),await e.loadPackage(["numpy","sympy"]),e.FS.writeFile("optimization_logic.py",l),e.FS.writeFile("optimization_manager.py",s),e.runPython("from optimization_manager import OptimizationManager; manager = OptimizationManager();"),a=e.globals.get("manager"),a||console.error("Failed to initialize optimization manager"),self.postMessage({type:"READY"})}function i(n){if(!n)return null;try{const t=n.toJs({dict_converter:Object.fromEntries});n.destroy&&n.destroy(),self.postMessage({type:"RESULT",data:t})}catch(t){console.error("Error handling Python result:",t)}}self.onmessage=async n=>{const t=n.data;if(!a){console.warn("Pyodide is not ready yet");return}switch(t.type){case"INIT":const o=e.toPy(t.settings);i(a.handle_update_settings(o));break;case"NEXT_STEP":i(a.handle_next_step());break;case"PREV_STEP":i(a.handle_prev_step());break;case"RESET":i(a.handle_reset());break;default:console.error("Unknown message type:",t);break}},r()})();
+`;const f="https://cdn.jsdelivr.net/pyodide/v0.26.1/full/pyodide.mjs";let e=null,t=null;async function r(){const{loadPyodide:n}=await import(f);e=await n({indexURL:"https://cdn.jsdelivr.net/pyodide/v0.26.1/full/"}),await e.loadPackage(["numpy","sympy"]),e.FS.writeFile("optimization_logic.py",l),e.FS.writeFile("optimization_manager.py",s),e.runPython("from optimization_manager import OptimizationManager; manager = OptimizationManager();"),t=e.globals.get("manager"),t||console.error("Failed to initialize optimization manager"),self.postMessage({type:"READY"})}function i(n){if(!n)return null;try{const a=n.toJs({dict_converter:Object.fromEntries});n.destroy&&n.destroy(),self.postMessage({type:"RESULT",data:a})}catch(a){console.error("Error handling Python result:",a)}}self.onmessage=async n=>{const a=n.data;if(!t){console.warn("Pyodide is not ready yet");return}switch(a.type){case"INIT":const o=e.toPy(a.settings);i(t.handle_update_settings(o));break;case"NEXT_STEP":i(t.handle_next_step());break;case"PREV_STEP":i(t.handle_prev_step());break;case"RESET":i(t.handle_reset());break;default:console.error("Unknown message type:",a);break}},r()})();

dist/index.html

@@ -5,7 +5,7 @@
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Optimization</title>
-    <script type="module" crossorigin src="/assets/index-Mctteb_d.js"></script>
+    <script type="module" crossorigin src="/assets/index-DxXDp_Rq.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Bs9s2ktO.css">
   </head>
   <body>

frontends/react/src/OptimizationPlot.tsx

@@ -297,7 +297,7 @@ export default function OptimizationPlot({ data, isLoading, xlim, ylim, setAxisL
           style={{ width: '100%', height: '100%' }}
           config={{ 
             responsive: true,
-            displayModeBar: false,
+            displayModeBar: true,
             scrollZoom: true,
           }}
         />