Change to static sdk

Dockerfile

@@ -1,20 +0,0 @@
-# Step 1: Build your app
-FROM node:20 AS builder
-WORKDIR /app
-COPY frontends/react/package*.json ./frontends/react/
-RUN cd frontends/react && npm install
-COPY . .
-RUN cd frontends/react && npm run build
-
-# Step 2: Serve it with npx
-FROM node:20-slim
-WORKDIR /app
-# Only copy the built files from the builder
-COPY --from=builder /app/frontends/react/dist ./dist
-
-# Install the server tool
-RUN npm install -g serve
-
-# Serve the 'dist' folder on the correct Hugging Face port
-# -s flag handles Single Page App routing (important for React)
-CMD ["serve", "-s", "dist", "-l", "7860"]

README.md

@@ -3,7 +3,8 @@ title: Optimization
 emoji: 🚀
 colorFrom: purple
 colorTo: indigo
-sdk: docker
+sdk: static
+app_file: dist/index.html
 pinned: false
 ---
 

dist/assets/index-BE9C_h4C.css

@@ -0,0 +1 @@
+@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-space-y-reverse:0;--tw-border-style:solid;--tw-font-weight:initial;--tw-tracking:initial}}}@layer theme{:root,:host{--font-sans:ui-sans-serif,system-ui,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";--font-mono:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace;--color-orange-200:oklch(90.1% .076 70.697);--color-orange-300:oklch(83.7% .128 66.29);--color-orange-500:oklch(70.5% .213 47.604);--color-blue-600:oklch(54.6% .245 262.881);--color-slate-50:oklch(98.4% .003 247.858);--color-slate-200:oklch(92.9% .013 255.508);--color-slate-800:oklch(27.9% .041 260.031);--color-gray-100:oklch(96.7% .003 264.542);--color-gray-200:oklch(92.8% .006 264.531);--color-gray-300:oklch(87.2% .01 258.338);--color-gray-700:oklch(37.3% .034 259.733);--color-gray-950:oklch(13% .028 261.692);--color-white:#fff;--spacing:.25rem;--text-sm:.875rem;--text-sm--line-height:calc(1.25/.875);--text-xl:1.25rem;--text-xl--line-height:calc(1.75/1.25);--font-weight-semibold:600;--tracking-tight:-.025em;--animate-spin:spin 1s linear infinite;--default-font-family:var(--font-sans);--default-mono-font-family:var(--font-mono)}}@layer base{*,:after,:before,::backdrop{box-sizing:border-box;border:0 solid;margin:0;padding:0}::file-selector-button{box-sizing:border-box;border:0 solid;margin:0;padding:0}html,:host{-webkit-text-size-adjust:100%;tab-size:4;line-height:1.5;font-family:var(--default-font-family,ui-sans-serif,system-ui,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji");font-feature-settings:var(--default-font-feature-settings,normal);font-variation-settings:var(--default-font-variation-settings,normal);-webkit-tap-highlight-color:transparent}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--default-mono-font-family,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace);font-feature-settings:var(--default-mono-font-feature-settings,normal);font-variation-settings:var(--default-mono-font-variation-settings,normal);font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}:-moz-focusring{outline:auto}progress{vertical-align:baseline}summary{display:list-item}ol,ul,menu{list-style:none}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}button,input,select,optgroup,textarea{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}::file-selector-button{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}:where(select:is([multiple],[size])) optgroup{font-weight:bolder}:where(select:is([multiple],[size])) optgroup option{padding-inline-start:20px}::file-selector-button{margin-inline-end:4px}::placeholder{opacity:1}@supports (not ((-webkit-appearance:-apple-pay-button))) or (contain-intrinsic-size:1px){::placeholder{color:currentColor}@supports (color:color-mix(in lab,red,red)){::placeholder{color:color-mix(in oklab,currentcolor 50%,transparent)}}}textarea{resize:vertical}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-date-and-time-value{min-height:1lh;text-align:inherit}::-webkit-datetime-edit{display:inline-flex}::-webkit-datetime-edit-fields-wrapper{padding:0}::-webkit-datetime-edit{padding-block:0}::-webkit-datetime-edit-year-field{padding-block:0}::-webkit-datetime-edit-month-field{padding-block:0}::-webkit-datetime-edit-day-field{padding-block:0}::-webkit-datetime-edit-hour-field{padding-block:0}::-webkit-datetime-edit-minute-field{padding-block:0}::-webkit-datetime-edit-second-field{padding-block:0}::-webkit-datetime-edit-millisecond-field{padding-block:0}::-webkit-datetime-edit-meridiem-field{padding-block:0}::-webkit-calendar-picker-indicator{line-height:1}:-moz-ui-invalid{box-shadow:none}button,input:where([type=button],[type=reset],[type=submit]){appearance:button}::file-selector-button{appearance:button}::-webkit-inner-spin-button{height:auto}::-webkit-outer-spin-button{height:auto}[hidden]:where(:not([hidden=until-found])){display:none!important}}@layer components;@layer utilities{.fixed{position:fixed}.relative{position:relative}.inset-0{inset:calc(var(--spacing)*0)}.z-50{z-index:50}.mb-4{margin-bottom:calc(var(--spacing)*4)}.flex{display:flex}.grid{display:grid}.h-16{height:calc(var(--spacing)*16)}.h-dvh{height:100dvh}.h-full{height:100%}.w-16{width:calc(var(--spacing)*16)}.w-full{width:100%}.animate-spin{animation:var(--animate-spin)}.cursor-pointer{cursor:pointer}.grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.grid-cols-\[2fr_1fr\]{grid-template-columns:2fr 1fr}.flex-col{flex-direction:column}.items-center{align-items:center}.justify-center{justify-content:center}.gap-1{gap:calc(var(--spacing)*1)}.gap-2{gap:calc(var(--spacing)*2)}.gap-4{gap:calc(var(--spacing)*4)}:where(.space-y-6>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*6)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*6)*calc(1 - var(--tw-space-y-reverse)))}.rounded{border-radius:.25rem}.rounded-full{border-radius:3.40282e38px}.border{border-style:var(--tw-border-style);border-width:1px}.border-4{border-style:var(--tw-border-style);border-width:4px}.border-b-2{border-bottom-style:var(--tw-border-style);border-bottom-width:2px}.border-gray-300{border-color:var(--color-gray-300)}.border-orange-500{border-color:var(--color-orange-500)}.border-slate-200{border-color:var(--color-slate-200)}.border-t-blue-600{border-top-color:var(--color-blue-600)}.bg-gray-100{background-color:var(--color-gray-100)}.bg-orange-200{background-color:var(--color-orange-200)}.bg-slate-50{background-color:var(--color-slate-50)}.bg-white{background-color:var(--color-white)}.p-2{padding:calc(var(--spacing)*2)}.p-4{padding:calc(var(--spacing)*4)}.px-5{padding-inline:calc(var(--spacing)*5)}.py-2{padding-block:calc(var(--spacing)*2)}.text-center{text-align:center}.text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.text-xl{font-size:var(--text-xl);line-height:var(--tw-leading,var(--text-xl--line-height))}.font-semibold{--tw-font-weight:var(--font-weight-semibold);font-weight:var(--font-weight-semibold)}.tracking-tight{--tw-tracking:var(--tracking-tight);letter-spacing:var(--tracking-tight)}.text-gray-700{color:var(--color-gray-700)}.text-gray-950{color:var(--color-gray-950)}.text-orange-500{color:var(--color-orange-500)}.text-slate-800{color:var(--color-slate-800)}@media(hover:hover){.hover\:bg-gray-200:hover{background-color:var(--color-gray-200)}.hover\:bg-orange-300:hover{background-color:var(--color-orange-300)}}}@property --tw-space-y-reverse{syntax:"*";inherits:false;initial-value:0}@property --tw-border-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-font-weight{syntax:"*";inherits:false}@property --tw-tracking{syntax:"*";inherits:false}@keyframes spin{to{transform:rotate(360deg)}}

dist/assets/pyodide.worker-BeUH2O5o.js

@@ -0,0 +1,828 @@
+(function(){"use strict";var i=`import numpy as np
+from sympy import sympify, lambdify
+
+from optimization_logic import *
+
+
+class OptimizationManager:
+    def __init__(self):
+        self.function_values = {"x": [], "y": []}
+        self.trajectory_values = {"x": [], "y": []}
+        self.settings = {}
+
+    def handle_update_settings(self, new_settings) -> dict[str, dict] | None:
+        if new_settings == self.settings:
+            return None
+
+        self.settings = new_settings
+
+        function = new_settings.get("functionExpr", "").strip()
+        mode = new_settings.get("mode", "").lower().strip()
+        xlim = new_settings.get("xlim", [])
+        ylim = new_settings.get("ylim", [])
+
+        if not self._is_valid_function(function, mode, xlim, ylim):
+            return {
+                "trajectoryValues": {"x": [], "y": []},
+                "functionValues": {"x": [], "y": []},
+            }
+
+        self._reset_trajectory()  # Must reset trajectory on any settings change that is valid
+
+        if not self._function_changed(function, mode):
+            return {
+                "trajectoryValues": self.trajectory_values,
+            }
+
+        try:
+            self._compute_function_values(function, mode, xlim, ylim)
+        except Exception as e:
+            self.function_values = {"x": [], "y": []}
+            self.trajectory_values = {"x": [], "y": []}
+
+        return {
+            "functionValues": self.function_values,
+            "trajectoryValues": self.trajectory_values,
+        }
+
+    def handle_reset(self) -> dict[str, list]:
+        self._reset_trajectory()
+        return {
+            "trajectoryValues": self.trajectory_values,
+        }
+
+    def handle_next_step(self) -> dict[str, list]:
+        current_steps = len(self.trajectory_values["x"])
+        self._compute_trajectory_values(self.settings, current_steps + 1)
+        return {
+            "trajectoryValues": self.trajectory_values,
+        }
+
+    def handle_prev_step(self) -> dict[str, list]:
+        current_steps = len(self.trajectory_values["x"])
+        if current_steps > 1:
+            self._compute_trajectory_values(self.settings, current_steps - 1)
+        return {
+            "trajectoryValues": self.trajectory_values,
+        }
+
+    def handle_play(self) -> dict[str, list]:
+        pass
+
+    def handle_pause(self) -> dict[str, list]:
+        pass
+
+    def _is_valid_function(
+        self, function: str, mode: str, xlim: list, ylim: list
+    ) -> bool:
+        # axis limit checks
+        if len(xlim) != 2 or len(ylim) != 2:
+            return False
+        if xlim[0] >= xlim[1] or ylim[0] >= ylim[1]:
+            return False
+
+        # function expression check
+        try:
+            expr = sympify(function)
+            symbols = {s.name for s in expr.free_symbols}
+            if mode == "univariate":
+                return symbols in {frozenset({'x'}), frozenset(set())}
+            elif mode == "bivariate":
+                return symbols in {
+                    frozenset({'x', 'y'}), 
+                    frozenset({'x'}), 
+                    frozenset({'y'}), 
+                    frozenset(set()),
+                }
+            else:
+                return False
+
+        except Exception as e:
+            pass
+
+        return False
+        
+    def _function_changed(self, function: str, mode: str) -> bool:
+        function = function.strip()
+        previous_function = self.settings.get("function", "").strip()
+        previous_mode = self.settings.get("mode", "")
+        return function != previous_function or mode != previous_mode
+
+    def _reset_trajectory(self) -> None:
+        try:
+            self._compute_trajectory_values(self.settings, steps=1)
+        except Exception as e:
+            self.trajectory_values = {"x": [], "y": []}
+
+    def _compute_function_values(self, function: str, mode: str, xlim: list, ylim: list) -> None:
+        expr = sympify(function)
+        if mode == "univariate":
+            x = np.linspace(xlim[0], xlim[1], 100)
+            f = lambdify('x', expr, modules=['numpy'])
+            y = f(x)
+
+            if not isinstance(y, np.ndarray):
+                y = np.full_like(x, y)
+
+            self.function_values = {
+                "x": x.tolist(),
+                "y": y.tolist(),
+            }
+
+        elif mode == "bivariate":
+            x = np.linspace(xlim[0], xlim[1], 100)
+            y = np.linspace(ylim[0], ylim[1], 100)
+            X, Y = np.meshgrid(x, y)
+            f = lambdify(('x', 'y'), expr, modules=['numpy'])
+            Z = f(X, Y)
+
+            if not isinstance(Z, np.ndarray):
+                Z = np.full_like(X, Z)
+
+            self.function_values = {
+                "x": x.tolist(),
+                "y": y.tolist(),
+                "z": Z.tolist(),
+            }
+
+        else:
+            raise ValueError("Unsupported mode")
+
+    def _compute_trajectory_values(self, settings: dict, steps: int) -> None:
+        mode = settings.get("mode", "").lower().strip()
+        algorithm = settings.get("algorithm", "").lower().strip().replace(" ", "_")
+        function = sympify(settings.get("functionExpr", "").strip())
+
+        if mode == "univariate":
+            if algorithm == "gradient_descent":
+                self.trajectory_values = gd_univariate(
+                    function,
+                    float(settings["x0"]),
+                    float(settings["learningRate"]),
+                    float(settings["momentum"]),
+                    steps,
+                )
+            elif algorithm == "nesterov":
+                self.trajectory_values = nesterov_univariate(
+                    function,
+                    float(settings["x0"]),
+                    float(settings["learningRate"]),
+                    float(settings["momentum"]),
+                    steps,
+                )
+            elif algorithm == "adam":
+                self.trajectory_values = adam_univariate(
+                    function,
+                    float(settings["x0"]),
+                    float(settings["learningRate"]),
+                    float(settings["beta1"]),
+                    float(settings["beta2"]),
+                    float(settings["epsilon"]),
+                    steps,
+                )
+            elif algorithm == "adagrad":
+                self.trajectory_values = adagrad_univariate(
+                    function,
+                    float(settings["x0"]),
+                    float(settings["learningRate"]),
+                    float(settings["epsilon"]),
+                    steps,
+                )
+            elif algorithm == "rmsprop":
+                self.trajectory_values = rmsprop_univariate(
+                    function,
+                    float(settings["x0"]),
+                    float(settings["learningRate"]),
+                    float(settings["beta"]),
+                    float(settings["epsilon"]),
+                    steps,
+                )
+            elif algorithm == "adadelta":
+                self.trajectory_values = adadelta_univariate(
+                    function,
+                    float(settings["x0"]),
+                    float(settings["beta"]),
+                    float(settings["epsilon"]),
+                    steps,
+                )
+            elif algorithm == "newton":
+                self.trajectory_values = newton_univariate(
+                    function,
+                    float(settings["x0"]),
+                    steps,
+                )
+            else:
+                raise ValueError("Unsupported algorithm for univariate mode")
+
+        elif mode == "bivariate":
+            if algorithm == "gradient_descent":
+                self.trajectory_values = gd_bivariate(
+                    function,
+                    float(settings["x0"]),
+                    float(settings["y0"]),
+                    float(settings["learningRate"]),
+                    float(settings["momentum"]),
+                    steps,
+                )
+            elif algorithm == "nesterov":
+                self.trajectory_values = nesterov_bivariate(
+                    function,
+                    float(settings["x0"]),
+                    float(settings["y0"]),
+                    float(settings["learningRate"]),
+                    float(settings["momentum"]),
+                    steps,
+                )
+            elif algorithm == "adam":
+                self.trajectory_values = adam_bivariate(
+                    function,
+                    float(settings["x0"]),
+                    float(settings["y0"]),
+                    float(settings["learningRate"]),
+                    float(settings["beta1"]),
+                    float(settings["beta2"]),
+                    float(settings["epsilon"]),
+                    steps,
+                )
+            elif algorithm == "adagrad":
+                self.trajectory_values = adagrad_bivariate(
+                    function,
+                    float(settings["x0"]),
+                    float(settings["y0"]),
+                    float(settings["learningRate"]),
+                    float(settings["epsilon"]),
+                    steps,
+                )
+            elif algorithm == "rmsprop":
+                self.trajectory_values = rmsprop_bivariate(
+                    function,
+                    float(settings["x0"]),
+                    float(settings["y0"]),
+                    float(settings["learningRate"]),
+                    float(settings["beta"]),
+                    float(settings["epsilon"]),
+                    steps,
+                )
+            elif algorithm == "adadelta":
+                self.trajectory_values = adadelta_bivariate(
+                    function,
+                    float(settings["x0"]),
+                    float(settings["y0"]),
+                    float(settings["beta"]),
+                    float(settings["epsilon"]),
+                    steps,
+                )
+            elif algorithm == "newton":
+                self.trajectory_values = newton_bivariate(
+                    function,
+                    float(settings["x0"]),
+                    float(settings["y0"]),
+                    steps,
+                )
+            else:
+                raise ValueError("Unsupported algorithm for bivariate mode")
+
+`,l=`import numpy as np
+from sympy import lambdify, Expr
+
+
+def gd_univariate(
+    function: Expr, 
+    x0: float,
+    learning_rate: float,
+    momentum: float,
+    steps: int,
+) -> dict:
+    """
+    Perform gradient descent on a univariate function.
+
+    Assumes function is valid and in terms of x
+    """
+    f = lambdify('x', function, modules=['numpy'])
+    f_prime = lambdify('x', function.diff('x'), modules=['numpy'])
+
+    x_values = [x0]
+    y_values = [f(x0)]
+
+    x = x0
+    for i in range(steps - 1):
+        if i == 0:
+            m = 0
+        else:
+            m = momentum * (x_values[-1] - x_values[-2])
+        
+        x = x - learning_rate * f_prime(x) + m
+        x_values.append(x)
+        y_values.append(f(x))
+
+    return {
+        "x": x_values,
+        "y": y_values,
+    }
+
+
+def gd_bivariate(
+    function: Expr,
+    x0: float,
+    y0: float,
+    learning_rate: float,
+    momentum: float,
+    steps: int,
+) -> dict:
+    f = lambdify(('x', 'y'), function, modules=['numpy'])
+    fx = lambdify(('x', 'y'), function.diff('x'), modules=['numpy'])
+    fy = lambdify(('x', 'y'), function.diff('y'), modules=['numpy'])
+
+    x_values = [x0]
+    y_values = [y0]
+    z_values = [f(x0, y0)]
+
+    x = x0
+    y = y0
+    for i in range(steps -1):
+        if i == 0:
+            mx = 0
+            my = 0
+        else:
+            mx = momentum * (x_values[-1] - x_values[-2])
+            my = momentum * (y_values[-1] - y_values[-2])
+        
+        x = x - learning_rate * fx(x, y) + mx
+        y = y - learning_rate * fy(x, y) + my
+        x_values.append(x)
+        y_values.append(y)
+        z_values.append(f(x, y))
+
+    return {
+        "x": x_values,
+        "y": y_values,
+        "z": z_values,
+    }
+
+
+def nesterov_univariate(
+    function: Expr,
+    x0: float,
+    learning_rate: float,
+    momentum: float,
+    steps: int,
+) -> dict:
+    f = lambdify('x', function, modules=['numpy'])
+    f_prime = lambdify('x', function.diff('x'), modules=['numpy'])
+
+    x_values = [x0]
+    y_values = [f(x0)]
+
+    x = x0
+    for i in range(steps - 1):
+        if i == 0:
+            m = 0
+        else:
+            m = momentum * (x_values[-1] - x_values[-2])
+        
+        x_lookahead = x - m
+        x = x_lookahead - learning_rate * f_prime(x_lookahead)
+
+        x_values.append(x)
+        y_values.append(f(x))
+
+    return {
+        "x": x_values,
+        "y": y_values,
+    }
+
+
+def nesterov_bivariate(
+    function: Expr,
+    x0: float,
+    y0: float,
+    learning_rate: float,
+    momentum: float,
+    steps: int,
+) -> dict:
+    f = lambdify(('x', 'y'), function, modules=['numpy'])
+    fx = lambdify(('x', 'y'), function.diff('x'), modules=['numpy'])
+    fy = lambdify(('x', 'y'), function.diff('y'), modules=['numpy'])
+
+    x_values = [x0]
+    y_values = [y0]
+    z_values = [f(x0, y0)]
+
+    x = x0
+    y = y0
+    for i in range(steps - 1):
+        if i == 0:
+            mx = 0
+            my = 0
+        else:
+            mx = momentum * (x_values[-1] - x_values[-2])
+            my = momentum * (y_values[-1] - y_values[-2])
+        
+        x_lookahead = x - mx
+        y_lookahead = y - my
+
+        x = x_lookahead - learning_rate * fx(x_lookahead, y_lookahead)
+        y = y_lookahead - learning_rate * fy(x_lookahead, y_lookahead)
+
+        x_values.append(x)
+        y_values.append(y)
+        z_values.append(f(x, y))
+
+    return {
+        "x": x_values,
+        "y": y_values,
+        "z": z_values,
+    }
+
+
+def newton_univariate(
+    function: Expr,
+    x0: float,
+    steps: int,
+) -> dict:
+    f = lambdify('x', function, modules=['numpy'])
+    f_prime = lambdify('x', function.diff('x'), modules=['numpy'])
+    f_prime_prime = lambdify('x', function.diff('x', 2), modules=['numpy'])
+
+    x_values = [x0]
+    y_values = [f(x0)]
+
+    x = x0
+    for i in range(steps - 1):
+        x = x - f_prime(x) / f_prime_prime(x)
+        x_values.append(x)
+        y_values.append(f(x))
+
+    return {
+        "x": x_values,
+        "y": y_values,
+    }
+
+
+def newton_bivariate(
+    function: Expr,
+    x0: float,
+    y0: float,
+    steps: int,
+) -> dict:
+    f = lambdify(('x', 'y'), function, modules=['numpy'])
+    fx = lambdify(('x', 'y'), function.diff('x'), modules=['numpy'])
+    fy = lambdify(('x', 'y'), function.diff('y'), modules=['numpy'])
+    fxx = lambdify(('x', 'y'), function.diff('x', 2), modules=['numpy'])
+    fyy = lambdify(('x', 'y'), function.diff('y', 2), modules=['numpy'])
+    fxy = lambdify(('x', 'y'), function.diff('x', 'y'), modules=['numpy'])
+
+    x_values = [x0]
+    y_values = [y0]
+    z_values = [f(x0, y0)]
+
+    x = x0
+    y = y0
+    for i in range(steps - 1):
+        hessian = np.array(
+            [
+                [fxx(x, y), fxy(x, y)],
+                [fxy(x, y), fyy(x, y)],
+            ],
+        )
+        grad = np.array([fx(x, y), fy(x, y)])
+
+        try:
+            # delta = hessian^-1 * grad
+            delta = np.linalg.solve(hessian, grad)
+        except np.linalg.LinAlgError:
+            # singular hessian - cannot proceed
+            break
+
+        x = x - delta[0]
+        y = y - delta[1]
+
+        x_values.append(x)
+        y_values.append(y)
+        z_values.append(f(x, y))
+
+    return {
+        "x": x_values,
+        "y": y_values,
+        "z": z_values,
+    }
+
+
+def adagrad_univariate(
+    function: Expr,
+    x0: float,
+    learning_rate: float,
+    epsilon: float,
+    steps: int,
+) -> dict:
+    f = lambdify('x', function, modules=['numpy'])
+    f_prime = lambdify('x', function.diff('x'), modules=['numpy'])
+
+    x_values = [x0]
+    y_values = [f(x0)]
+
+    x = x0
+    v = 0  # accumulated squared gradients
+    for i in range(steps - 1):
+        g = f_prime(x)
+        v += g ** 2
+        x = x - (learning_rate / (np.sqrt(v) + epsilon)) * g
+
+        x_values.append(x)
+        y_values.append(f(x))
+
+    return {
+        "x": x_values,
+        "y": y_values,
+    }
+
+
+def adagrad_bivariate(
+    function: Expr,
+    x0: float,
+    y0: float,
+    learning_rate: float,
+    epsilon: float,
+    steps: int,
+) -> dict:
+    f = lambdify(('x', 'y'), function, modules=['numpy'])
+    fx = lambdify(('x', 'y'), function.diff('x'), modules=['numpy'])
+    fy = lambdify(('x', 'y'), function.diff('y'), modules=['numpy'])
+
+    x_values = [x0]
+    y_values = [y0]
+    z_values = [f(x0, y0)]
+
+    x = x0
+    y = y0
+    # accumulated squared gradients
+    vx = 0
+    vy = 0
+    for i in range(steps - 1):
+        gx = fx(x, y)
+        gy = fy(x, y)
+        vx += gx ** 2
+        vy += gy ** 2
+
+        x = x - (learning_rate / (np.sqrt(vx) + epsilon)) * gx
+        y = y - (learning_rate / (np.sqrt(vy) + epsilon)) * gy
+
+        x_values.append(x)
+        y_values.append(y)
+        z_values.append(f(x, y))
+
+    return {
+        "x": x_values,
+        "y": y_values,
+        "z": z_values,
+    }
+
+
+def rmsprop_univariate(
+    function: Expr,
+    x0: float,
+    learning_rate: float,
+    beta: float,
+    epsilon: float,
+    steps: int,
+) -> dict:
+    f = lambdify('x', function, modules=['numpy'])
+    f_prime = lambdify('x', function.diff('x'), modules=['numpy'])
+
+    x_values = [x0]
+    y_values = [f(x0)]
+
+    x = x0
+    v = 0  # exponentially weighted average of squared gradients
+    for i in range(steps - 1):
+        g = f_prime(x)
+        v = beta * v + (1 - beta) * g ** 2
+        x = x - (learning_rate / (np.sqrt(v) + epsilon)) * g
+
+        x_values.append(x)
+        y_values.append(f(x))
+
+    return {
+        "x": x_values,
+        "y": y_values,
+    }
+    
+
+def rmsprop_bivariate(
+    function: Expr,
+    x0: float,
+    y0: float,
+    learning_rate: float,
+    beta: float,
+    epsilon: float,
+    steps: int,
+) -> dict:
+    f = lambdify(('x', 'y'), function, modules=['numpy'])
+    fx = lambdify(('x', 'y'), function.diff('x'), modules=['numpy'])
+    fy = lambdify(('x', 'y'), function.diff('y'), modules=['numpy'])
+
+    x_values = [x0]
+    y_values = [y0]
+    z_values = [f(x0, y0)]
+
+    x = x0
+    y = y0
+    # exponentially weighted average of squared gradients
+    vx = 0
+    vy = 0
+    for i in range(steps - 1):
+        gx = fx(x, y)
+        gy = fy(x, y)
+        vx = beta * vx + (1 - beta) * gx ** 2
+        vy = beta * vy + (1 - beta) * gy ** 2
+
+        x = x - (learning_rate / (np.sqrt(vx) + epsilon)) * gx
+        y = y - (learning_rate / (np.sqrt(vy) + epsilon)) * gy
+
+        x_values.append(x)
+        y_values.append(y)
+        z_values.append(f(x, y))
+
+    return {
+        "x": x_values,
+        "y": y_values,
+        "z": z_values,
+    }
+
+
+def adadelta_univariate(
+    function: Expr,
+    x0: float,
+    learning_rate: float,
+    beta: float,
+    epsilon: float,
+    steps: int,
+) -> dict:
+    f = lambdify('x', function, modules=['numpy'])
+    f_prime = lambdify('x', function.diff('x'), modules=['numpy'])
+
+    x_values = [x0]
+    y_values = [f(x0)]
+
+    x = x0
+    v = 0  # exponentially weighted average of squared gradients
+    s = 0  # exponentially weighted average of squared updates
+    for i in range(steps - 1):
+        g = f_prime(x)
+        v = beta * v + (1 - beta) * g ** 2
+        delta_x = - (np.sqrt(s + epsilon) / np.sqrt(v + epsilon)) * g
+        x = x + delta_x
+
+        s = beta * s + (1 - beta) * delta_x ** 2
+
+        x_values.append(x)
+        y_values.append(f(x))
+
+    return {
+        "x": x_values,
+        "y": y_values,
+    }
+
+
+def adadelta_bivariate(
+    function: Expr,
+    x0: float,
+    y0: float,
+    learning_rate: float,
+    beta: float,
+    epsilon: float,
+    steps: int,
+) -> dict:
+    f = lambdify(('x', 'y'), function, modules=['numpy'])
+    fx = lambdify(('x', 'y'), function.diff('x'), modules=['numpy'])
+    fy = lambdify(('x', 'y'), function.diff('y'), modules=['numpy'])
+
+    x_values = [x0]
+    y_values = [y0]
+    z_values = [f(x0, y0)]
+
+    x = x0
+    y = y0
+    # exponentially weighted average of squared gradients
+    vx = 0
+    vy = 0
+    # exponentially weighted average of squared updates
+    sx = 0
+    sy = 0
+    for i in range(steps - 1):
+        gx = fx(x, y)
+        gy = fy(x, y)
+        vx = beta * vx + (1 - beta) * gx ** 2
+        vy = beta * vy + (1 - beta) * gy ** 2
+
+        delta_x = - (np.sqrt(sx + epsilon) / np.sqrt(vx + epsilon)) * gx
+        delta_y = - (np.sqrt(sy + epsilon) / np.sqrt(vy + epsilon)) * gy
+
+        x = x + delta_x
+        y = y + delta_y
+
+        sx = beta * sx + (1 - beta) * delta_x ** 2
+        sy = beta * sy + (1 - beta) * delta_y ** 2
+
+        x_values.append(x)
+        y_values.append(y)
+        z_values.append(f(x, y))
+
+    return {
+        "x": x_values,
+        "y": y_values,
+        "z": z_values,
+    }
+
+
+def adam_univariate(
+    function: Expr,
+    x0: float,
+    learning_rate: float,
+    beta1: float,
+    beta2: float,
+    epsilon: float,
+    steps: int,
+) -> dict:
+    f = lambdify('x', function, modules=['numpy'])
+    f_prime = lambdify('x', function.diff('x'), modules=['numpy'])
+
+    x_values = [x0]
+    y_values = [f(x0)]
+
+    x = x0
+    m = 0  # first moment
+    v = 0  # second moment
+    for i in range(steps - 1):
+        g = f_prime(x)
+        m = beta1 * m + (1 - beta1) * g
+        v = beta2 * v + (1 - beta2) * g ** 2
+
+        m_hat = m / (1 - beta1 ** (i + 1))
+        v_hat = v / (1 - beta2 ** (i + 1))
+
+        x = x - (learning_rate / (np.sqrt(v_hat) + epsilon)) * m_hat
+
+        x_values.append(x)
+        y_values.append(f(x))
+
+    return {
+        "x": x_values,
+        "y": y_values,
+    }
+
+
+def adam_bivariate(
+    function: Expr,
+    x0: float,
+    y0: float,
+    learning_rate: float,
+    beta1: float,
+    beta2: float,
+    epsilon: float,
+    steps: int,
+) -> dict:
+    f = lambdify(('x', 'y'), function, modules=['numpy'])
+    fx = lambdify(('x', 'y'), function.diff('x'), modules=['numpy'])
+    fy = lambdify(('x', 'y'), function.diff('y'), modules=['numpy'])
+
+    x_values = [x0]
+    y_values = [y0]
+    z_values = [f(x0, y0)]
+
+    x = x0
+    y = y0
+    # first moments
+    mx = 0
+    my = 0
+    # second moments
+    vx = 0
+    vy = 0
+    for i in range(steps - 1):
+        gx = fx(x, y)
+        gy = fy(x, y)
+
+        mx = beta1 * mx + (1 - beta1) * gx
+        my = beta1 * my + (1 - beta1) * gy
+
+        vx = beta2 * vx + (1 - beta2) * gx ** 2
+        vy = beta2 * vy + (1 - beta2) * gy ** 2
+
+        mx_hat = mx / (1 - beta1 ** (i + 1))
+        my_hat = my / (1 - beta1 ** (i + 1))
+
+        vx_hat = vx / (1 - beta2 ** (i + 1))
+        vy_hat = vy / (1 - beta2 ** (i + 1))
+
+        x = x - (learning_rate / (np.sqrt(vx_hat) + epsilon)) * mx_hat
+        y = y - (learning_rate / (np.sqrt(vy_hat) + epsilon)) * my_hat
+
+        x_values.append(x)
+        y_values.append(y)
+        z_values.append(f(x, y))
+
+    return {
+        "x": x_values,
+        "y": y_values,
+        "z": z_values,
+    }`;const o="https://cdn.jsdelivr.net/pyodide/v0.26.1/full/pyodide.mjs";let e=null,t=null;async function f(){const{loadPyodide:n}=await import(o);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",i),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 s(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 r=e.toPy(a.settings);s(t.handle_update_settings(r));break;case"NEXT_STEP":s(t.handle_next_step());break;case"PREV_STEP":s(t.handle_prev_step());break;case"RESET":s(t.handle_reset());break;default:console.error("Unknown message type:",a);break}},f()})();

dist/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <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-BSZlS5Yr.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BE9C_h4C.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

frontends/react/vite.config.ts

@@ -4,16 +4,12 @@ import tailwindcss from '@tailwindcss/vite'
 
 // https://vite.dev/config/
 export default defineConfig({
-  base: './',
   plugins: [
     react(),
     tailwindcss(),
   ],
-  assetsInclude: ['**/*.py'],
-  server: {
-    fs: {
-      // allow importing from ../../
-      allow: ['..'],
-    }
+  build: {
+    outDir: "../../dist",
+    emptyOutDir: true,
   }
 })