Add current point info monitoring

backend/src/optimization_logic.py

@@ -2,8 +2,19 @@ import numpy as np
 from sympy import lambdify, Expr
 
 
+def _gradient_values(fx, fy, x: float, y: float) -> list:
+    return [float(fx(x, y)), float(fy(x, y))]
+
+
+def _hessian_values(fxx, fxy, fyy, x: float, y: float) -> list:
+    return [
+        [float(fxx(x, y)), float(fxy(x, y))],
+        [float(fxy(x, y)), float(fyy(x, y))],
+    ]
+
+
 def gd_univariate(
-    function: Expr, 
+    function: Expr,
     x0: float,
     learning_rate: float,
     momentum: float,
@@ -16,9 +27,12 @@ def gd_univariate(
     """
     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)]
+    derivative_values = [f_prime(x0)]
+    second_derivative_values = [f_prime_prime(x0)]
 
     x = x0
     for i in range(steps - 1):
@@ -26,14 +40,18 @@ def gd_univariate(
             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))
+        derivative_values.append(f_prime(x))
+        second_derivative_values.append(f_prime_prime(x))
 
     return {
         "x": x_values,
         "y": y_values,
+        "derivative": derivative_values,
+        "secondDerivative": second_derivative_values,
     }
 
 
@@ -48,31 +66,40 @@ def gd_bivariate(
     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)]
+    gradient_values = [_gradient_values(fx, fy, x0, y0)]
+    hessian_values = [_hessian_values(fxx, fxy, fyy, x0, y0)]
 
     x = x0
     y = y0
-    for i in range(steps -1):
+    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))
+        gradient_values.append(_gradient_values(fx, fy, x, y))
+        hessian_values.append(_hessian_values(fxx, fxy, fyy, x, y))
 
     return {
         "x": x_values,
         "y": y_values,
         "z": z_values,
+        "gradient": gradient_values,
+        "hessian": hessian_values,
     }
 
 
@@ -85,9 +112,12 @@ def nesterov_univariate(
 ) -> 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)]
+    derivative_values = [f_prime(x0)]
+    second_derivative_values = [f_prime_prime(x0)]
 
     x = x0
     for i in range(steps - 1):
@@ -95,16 +125,20 @@ def nesterov_univariate(
             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))
+        derivative_values.append(f_prime(x))
+        second_derivative_values.append(f_prime_prime(x))
 
     return {
         "x": x_values,
         "y": y_values,
+        "derivative": derivative_values,
+        "secondDerivative": second_derivative_values,
     }
 
 
@@ -119,10 +153,15 @@ def nesterov_bivariate(
     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)]
+    gradient_values = [_gradient_values(fx, fy, x0, y0)]
+    hessian_values = [_hessian_values(fxx, fxy, fyy, x0, y0)]
 
     x = x0
     y = y0
@@ -133,7 +172,7 @@ def nesterov_bivariate(
         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
 
@@ -143,11 +182,15 @@ def nesterov_bivariate(
         x_values.append(x)
         y_values.append(y)
         z_values.append(f(x, y))
+        gradient_values.append(_gradient_values(fx, fy, x, y))
+        hessian_values.append(_hessian_values(fxx, fxy, fyy, x, y))
 
     return {
         "x": x_values,
         "y": y_values,
         "z": z_values,
+        "gradient": gradient_values,
+        "hessian": hessian_values,
     }
 
 
@@ -162,16 +205,22 @@ def newton_univariate(
 
     x_values = [x0]
     y_values = [f(x0)]
+    derivative_values = [f_prime(x0)]
+    second_derivative_values = [f_prime_prime(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))
+        derivative_values.append(f_prime(x))
+        second_derivative_values.append(f_prime_prime(x))
 
     return {
         "x": x_values,
         "y": y_values,
+        "derivative": derivative_values,
+        "secondDerivative": second_derivative_values,
     }
 
 
@@ -191,6 +240,8 @@ def newton_bivariate(
     x_values = [x0]
     y_values = [y0]
     z_values = [f(x0, y0)]
+    gradient_values = [_gradient_values(fx, fy, x0, y0)]
+    hessian_values = [_hessian_values(fxx, fxy, fyy, x0, y0)]
 
     x = x0
     y = y0
@@ -216,11 +267,15 @@ def newton_bivariate(
         x_values.append(x)
         y_values.append(y)
         z_values.append(f(x, y))
+        gradient_values.append(_gradient_values(fx, fy, x, y))
+        hessian_values.append(_hessian_values(fxx, fxy, fyy, x, y))
 
     return {
         "x": x_values,
         "y": y_values,
         "z": z_values,
+        "gradient": gradient_values,
+        "hessian": hessian_values,
     }
 
 
@@ -233,9 +288,12 @@ def adagrad_univariate(
 ) -> 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)]
+    derivative_values = [f_prime(x0)]
+    second_derivative_values = [f_prime_prime(x0)]
 
     x = x0
     v = 0  # accumulated squared gradients
@@ -246,10 +304,14 @@ def adagrad_univariate(
 
         x_values.append(x)
         y_values.append(f(x))
+        derivative_values.append(f_prime(x))
+        second_derivative_values.append(f_prime_prime(x))
 
     return {
         "x": x_values,
         "y": y_values,
+        "derivative": derivative_values,
+        "secondDerivative": second_derivative_values,
     }
 
 
@@ -264,10 +326,15 @@ def adagrad_bivariate(
     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)]
+    gradient_values = [_gradient_values(fx, fy, x0, y0)]
+    hessian_values = [_hessian_values(fxx, fxy, fyy, x0, y0)]
 
     x = x0
     y = y0
@@ -286,11 +353,15 @@ def adagrad_bivariate(
         x_values.append(x)
         y_values.append(y)
         z_values.append(f(x, y))
+        gradient_values.append(_gradient_values(fx, fy, x, y))
+        hessian_values.append(_hessian_values(fxx, fxy, fyy, x, y))
 
     return {
         "x": x_values,
         "y": y_values,
         "z": z_values,
+        "gradient": gradient_values,
+        "hessian": hessian_values,
     }
 
 
@@ -304,9 +375,12 @@ def rmsprop_univariate(
 ) -> 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)]
+    derivative_values = [f_prime(x0)]
+    second_derivative_values = [f_prime_prime(x0)]
 
     x = x0
     v = 0  # exponentially weighted average of squared gradients
@@ -317,12 +391,16 @@ def rmsprop_univariate(
 
         x_values.append(x)
         y_values.append(f(x))
+        derivative_values.append(f_prime(x))
+        second_derivative_values.append(f_prime_prime(x))
 
     return {
         "x": x_values,
         "y": y_values,
+        "derivative": derivative_values,
+        "secondDerivative": second_derivative_values,
     }
-    
+
 
 def rmsprop_bivariate(
     function: Expr,
@@ -336,10 +414,15 @@ def rmsprop_bivariate(
     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)]
+    gradient_values = [_gradient_values(fx, fy, x0, y0)]
+    hessian_values = [_hessian_values(fxx, fxy, fyy, x0, y0)]
 
     x = x0
     y = y0
@@ -358,11 +441,15 @@ def rmsprop_bivariate(
         x_values.append(x)
         y_values.append(y)
         z_values.append(f(x, y))
+        gradient_values.append(_gradient_values(fx, fy, x, y))
+        hessian_values.append(_hessian_values(fxx, fxy, fyy, x, y))
 
     return {
         "x": x_values,
         "y": y_values,
         "z": z_values,
+        "gradient": gradient_values,
+        "hessian": hessian_values,
     }
 
 
@@ -376,9 +463,12 @@ def adadelta_univariate(
 ) -> 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)]
+    derivative_values = [f_prime(x0)]
+    second_derivative_values = [f_prime_prime(x0)]
 
     x = x0
     v = 0  # exponentially weighted average of squared gradients
@@ -393,10 +483,14 @@ def adadelta_univariate(
 
         x_values.append(x)
         y_values.append(f(x))
+        derivative_values.append(f_prime(x))
+        second_derivative_values.append(f_prime_prime(x))
 
     return {
         "x": x_values,
         "y": y_values,
+        "derivative": derivative_values,
+        "secondDerivative": second_derivative_values,
     }
 
 
@@ -412,10 +506,15 @@ def adadelta_bivariate(
     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)]
+    gradient_values = [_gradient_values(fx, fy, x0, y0)]
+    hessian_values = [_hessian_values(fxx, fxy, fyy, x0, y0)]
 
     x = x0
     y = y0
@@ -443,11 +542,15 @@ def adadelta_bivariate(
         x_values.append(x)
         y_values.append(y)
         z_values.append(f(x, y))
+        gradient_values.append(_gradient_values(fx, fy, x, y))
+        hessian_values.append(_hessian_values(fxx, fxy, fyy, x, y))
 
     return {
         "x": x_values,
         "y": y_values,
         "z": z_values,
+        "gradient": gradient_values,
+        "hessian": hessian_values,
     }
 
 
@@ -462,9 +565,12 @@ def adam_univariate(
 ) -> 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)]
+    derivative_values = [f_prime(x0)]
+    second_derivative_values = [f_prime_prime(x0)]
 
     x = x0
     m = 0  # first moment
@@ -481,10 +587,14 @@ def adam_univariate(
 
         x_values.append(x)
         y_values.append(f(x))
+        derivative_values.append(f_prime(x))
+        second_derivative_values.append(f_prime_prime(x))
 
     return {
         "x": x_values,
         "y": y_values,
+        "derivative": derivative_values,
+        "secondDerivative": second_derivative_values,
     }
 
 
@@ -501,10 +611,15 @@ def adam_bivariate(
     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)]
+    gradient_values = [_gradient_values(fx, fy, x0, y0)]
+    hessian_values = [_hessian_values(fxx, fxy, fyy, x0, y0)]
 
     x = x0
     y = y0
@@ -536,9 +651,13 @@ def adam_bivariate(
         x_values.append(x)
         y_values.append(y)
         z_values.append(f(x, y))
+        gradient_values.append(_gradient_values(fx, fy, x, y))
+        hessian_values.append(_hessian_values(fxx, fxy, fyy, x, y))
 
     return {
         "x": x_values,
         "y": y_values,
         "z": z_values,
-    }
+        "gradient": gradient_values,
+        "hessian": hessian_values,
+    }

backend/src/optimization_manager.py

@@ -337,4 +337,3 @@ class OptimizationManager:
                 )
             else:
                 raise ValueError("Unsupported algorithm for bivariate mode")
-

dist/assets/{pyodide.worker-Dr32d4MW.js → pyodide.worker-CqQKSeoe.js}

@@ -1,4 +1,4 @@
-(function(){"use strict";var i=`import numpy as np
+(function(){"use strict";var s=`import numpy as np
 from sympy import (
     lambdify, 
     symbols, 
@@ -337,13 +337,23 @@ class OptimizationManager:
                 )
             else:
                 raise ValueError("Unsupported algorithm for bivariate mode")
-
 `,l=`import numpy as np
 from sympy import lambdify, Expr
 
 
+def _gradient_values(fx, fy, x: float, y: float) -> list:
+    return [float(fx(x, y)), float(fy(x, y))]
+
+
+def _hessian_values(fxx, fxy, fyy, x: float, y: float) -> list:
+    return [
+        [float(fxx(x, y)), float(fxy(x, y))],
+        [float(fxy(x, y)), float(fyy(x, y))],
+    ]
+
+
 def gd_univariate(
-    function: Expr, 
+    function: Expr,
     x0: float,
     learning_rate: float,
     momentum: float,
@@ -356,9 +366,12 @@ def gd_univariate(
     """
     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)]
+    derivative_values = [f_prime(x0)]
+    second_derivative_values = [f_prime_prime(x0)]
 
     x = x0
     for i in range(steps - 1):
@@ -366,14 +379,18 @@ def gd_univariate(
             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))
+        derivative_values.append(f_prime(x))
+        second_derivative_values.append(f_prime_prime(x))
 
     return {
         "x": x_values,
         "y": y_values,
+        "derivative": derivative_values,
+        "secondDerivative": second_derivative_values,
     }
 
 
@@ -388,31 +405,40 @@ def gd_bivariate(
     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)]
+    gradient_values = [_gradient_values(fx, fy, x0, y0)]
+    hessian_values = [_hessian_values(fxx, fxy, fyy, x0, y0)]
 
     x = x0
     y = y0
-    for i in range(steps -1):
+    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))
+        gradient_values.append(_gradient_values(fx, fy, x, y))
+        hessian_values.append(_hessian_values(fxx, fxy, fyy, x, y))
 
     return {
         "x": x_values,
         "y": y_values,
         "z": z_values,
+        "gradient": gradient_values,
+        "hessian": hessian_values,
     }
 
 
@@ -425,9 +451,12 @@ def nesterov_univariate(
 ) -> 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)]
+    derivative_values = [f_prime(x0)]
+    second_derivative_values = [f_prime_prime(x0)]
 
     x = x0
     for i in range(steps - 1):
@@ -435,16 +464,20 @@ def nesterov_univariate(
             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))
+        derivative_values.append(f_prime(x))
+        second_derivative_values.append(f_prime_prime(x))
 
     return {
         "x": x_values,
         "y": y_values,
+        "derivative": derivative_values,
+        "secondDerivative": second_derivative_values,
     }
 
 
@@ -459,10 +492,15 @@ def nesterov_bivariate(
     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)]
+    gradient_values = [_gradient_values(fx, fy, x0, y0)]
+    hessian_values = [_hessian_values(fxx, fxy, fyy, x0, y0)]
 
     x = x0
     y = y0
@@ -473,7 +511,7 @@ def nesterov_bivariate(
         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
 
@@ -483,11 +521,15 @@ def nesterov_bivariate(
         x_values.append(x)
         y_values.append(y)
         z_values.append(f(x, y))
+        gradient_values.append(_gradient_values(fx, fy, x, y))
+        hessian_values.append(_hessian_values(fxx, fxy, fyy, x, y))
 
     return {
         "x": x_values,
         "y": y_values,
         "z": z_values,
+        "gradient": gradient_values,
+        "hessian": hessian_values,
     }
 
 
@@ -502,16 +544,22 @@ def newton_univariate(
 
     x_values = [x0]
     y_values = [f(x0)]
+    derivative_values = [f_prime(x0)]
+    second_derivative_values = [f_prime_prime(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))
+        derivative_values.append(f_prime(x))
+        second_derivative_values.append(f_prime_prime(x))
 
     return {
         "x": x_values,
         "y": y_values,
+        "derivative": derivative_values,
+        "secondDerivative": second_derivative_values,
     }
 
 
@@ -531,6 +579,8 @@ def newton_bivariate(
     x_values = [x0]
     y_values = [y0]
     z_values = [f(x0, y0)]
+    gradient_values = [_gradient_values(fx, fy, x0, y0)]
+    hessian_values = [_hessian_values(fxx, fxy, fyy, x0, y0)]
 
     x = x0
     y = y0
@@ -556,11 +606,15 @@ def newton_bivariate(
         x_values.append(x)
         y_values.append(y)
         z_values.append(f(x, y))
+        gradient_values.append(_gradient_values(fx, fy, x, y))
+        hessian_values.append(_hessian_values(fxx, fxy, fyy, x, y))
 
     return {
         "x": x_values,
         "y": y_values,
         "z": z_values,
+        "gradient": gradient_values,
+        "hessian": hessian_values,
     }
 
 
@@ -573,9 +627,12 @@ def adagrad_univariate(
 ) -> 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)]
+    derivative_values = [f_prime(x0)]
+    second_derivative_values = [f_prime_prime(x0)]
 
     x = x0
     v = 0  # accumulated squared gradients
@@ -586,10 +643,14 @@ def adagrad_univariate(
 
         x_values.append(x)
         y_values.append(f(x))
+        derivative_values.append(f_prime(x))
+        second_derivative_values.append(f_prime_prime(x))
 
     return {
         "x": x_values,
         "y": y_values,
+        "derivative": derivative_values,
+        "secondDerivative": second_derivative_values,
     }
 
 
@@ -604,10 +665,15 @@ def adagrad_bivariate(
     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)]
+    gradient_values = [_gradient_values(fx, fy, x0, y0)]
+    hessian_values = [_hessian_values(fxx, fxy, fyy, x0, y0)]
 
     x = x0
     y = y0
@@ -626,11 +692,15 @@ def adagrad_bivariate(
         x_values.append(x)
         y_values.append(y)
         z_values.append(f(x, y))
+        gradient_values.append(_gradient_values(fx, fy, x, y))
+        hessian_values.append(_hessian_values(fxx, fxy, fyy, x, y))
 
     return {
         "x": x_values,
         "y": y_values,
         "z": z_values,
+        "gradient": gradient_values,
+        "hessian": hessian_values,
     }
 
 
@@ -644,9 +714,12 @@ def rmsprop_univariate(
 ) -> 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)]
+    derivative_values = [f_prime(x0)]
+    second_derivative_values = [f_prime_prime(x0)]
 
     x = x0
     v = 0  # exponentially weighted average of squared gradients
@@ -657,12 +730,16 @@ def rmsprop_univariate(
 
         x_values.append(x)
         y_values.append(f(x))
+        derivative_values.append(f_prime(x))
+        second_derivative_values.append(f_prime_prime(x))
 
     return {
         "x": x_values,
         "y": y_values,
+        "derivative": derivative_values,
+        "secondDerivative": second_derivative_values,
     }
-    
+
 
 def rmsprop_bivariate(
     function: Expr,
@@ -676,10 +753,15 @@ def rmsprop_bivariate(
     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)]
+    gradient_values = [_gradient_values(fx, fy, x0, y0)]
+    hessian_values = [_hessian_values(fxx, fxy, fyy, x0, y0)]
 
     x = x0
     y = y0
@@ -698,11 +780,15 @@ def rmsprop_bivariate(
         x_values.append(x)
         y_values.append(y)
         z_values.append(f(x, y))
+        gradient_values.append(_gradient_values(fx, fy, x, y))
+        hessian_values.append(_hessian_values(fxx, fxy, fyy, x, y))
 
     return {
         "x": x_values,
         "y": y_values,
         "z": z_values,
+        "gradient": gradient_values,
+        "hessian": hessian_values,
     }
 
 
@@ -716,9 +802,12 @@ def adadelta_univariate(
 ) -> 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)]
+    derivative_values = [f_prime(x0)]
+    second_derivative_values = [f_prime_prime(x0)]
 
     x = x0
     v = 0  # exponentially weighted average of squared gradients
@@ -733,10 +822,14 @@ def adadelta_univariate(
 
         x_values.append(x)
         y_values.append(f(x))
+        derivative_values.append(f_prime(x))
+        second_derivative_values.append(f_prime_prime(x))
 
     return {
         "x": x_values,
         "y": y_values,
+        "derivative": derivative_values,
+        "secondDerivative": second_derivative_values,
     }
 
 
@@ -752,10 +845,15 @@ def adadelta_bivariate(
     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)]
+    gradient_values = [_gradient_values(fx, fy, x0, y0)]
+    hessian_values = [_hessian_values(fxx, fxy, fyy, x0, y0)]
 
     x = x0
     y = y0
@@ -783,11 +881,15 @@ def adadelta_bivariate(
         x_values.append(x)
         y_values.append(y)
         z_values.append(f(x, y))
+        gradient_values.append(_gradient_values(fx, fy, x, y))
+        hessian_values.append(_hessian_values(fxx, fxy, fyy, x, y))
 
     return {
         "x": x_values,
         "y": y_values,
         "z": z_values,
+        "gradient": gradient_values,
+        "hessian": hessian_values,
     }
 
 
@@ -802,9 +904,12 @@ def adam_univariate(
 ) -> 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)]
+    derivative_values = [f_prime(x0)]
+    second_derivative_values = [f_prime_prime(x0)]
 
     x = x0
     m = 0  # first moment
@@ -821,10 +926,14 @@ def adam_univariate(
 
         x_values.append(x)
         y_values.append(f(x))
+        derivative_values.append(f_prime(x))
+        second_derivative_values.append(f_prime_prime(x))
 
     return {
         "x": x_values,
         "y": y_values,
+        "derivative": derivative_values,
+        "secondDerivative": second_derivative_values,
     }
 
 
@@ -841,10 +950,15 @@ def adam_bivariate(
     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)]
+    gradient_values = [_gradient_values(fx, fy, x0, y0)]
+    hessian_values = [_hessian_values(fxx, fxy, fyy, x0, y0)]
 
     x = x0
     y = y0
@@ -876,9 +990,14 @@ def adam_bivariate(
         x_values.append(x)
         y_values.append(y)
         z_values.append(f(x, y))
+        gradient_values.append(_gradient_values(fx, fy, x, y))
+        hessian_values.append(_hessian_values(fxx, fxy, fyy, 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 r(){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 f=e.toPy(a.settings);s(t.handle_update_settings(f));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}},r()})();
+        "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()})();

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-xwMlQNfu.js"></script>
+    <script type="module" crossorigin src="/assets/index-DOAl0ZPy.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DiNT9sUn.css">
   </head>
   <body>

frontends/react/src/App.tsx

@@ -63,6 +63,7 @@ export default function App() {
           settings={settingsUi} 
           setSettings={handleSettingsUiChange} 
           onRandomInitialPoint={handleRandomInitialPoint}
+          trajectoryValues={api.plotData.trajectoryValues}
 
           onReset={() => api.sendReset()}
           onNextStep={() => api.sendNextStep()}

frontends/react/src/OptimizationPlot.tsx

@@ -16,10 +16,11 @@ export default function OptimizationPlot({ data, xlim, ylim, setAxisLimits }: Op
   let x: number[] = data.functionValues ? data.functionValues.x : [];
   let y: number[] = data.functionValues ? data.functionValues.y : [];
   let z: number[][] = data.functionValues && data.functionValues.z ? data.functionValues.z : [];
+
   let trajX: number[] = data.trajectoryValues ? data.trajectoryValues.x : [];
   let trajY: number[] = data.trajectoryValues ? data.trajectoryValues.y : [];
-  let trajZ: number[][] = data.trajectoryValues && data.trajectoryValues.z ? data.trajectoryValues.z : [];
-
+  let trajZ: number[] = data.trajectoryValues && data.trajectoryValues.z ? data.trajectoryValues.z : [];
+  
   const [colorScaleRange, setColorScaleRange] = useState<[number, number] | null>(null);
   const nextColorScaleRangeRef = useRef<[number, number] | null>(null);
 

frontends/react/src/Sidebar.tsx

@@ -4,7 +4,7 @@ import Tabs from "./ui/Tabs.tsx";
 import Dropdown from "./ui/Dropdown.tsx";
 import Button from "./ui/Button.tsx";
 import Radio from "./ui/Radio.tsx";
-import { SUPPORTED_MODES, SUPPORTED_ALGORITHMS, type SettingsUi } from "./types.ts";
+import { SUPPORTED_MODES, SUPPORTED_ALGORITHMS, type SettingsUi, type TrajectoryValues } from "./types.ts";
 
 
 const DEFAULT_HYPERPARAMETERS = {
@@ -40,6 +40,7 @@ interface SidebarProps {
   settings: SettingsUi,
   setSettings: (settings: SettingsUi) => void,
   onRandomInitialPoint: () => void,
+  trajectoryValues?: TrajectoryValues | null,
 
   onReset?: () => void,
   onNextStep?: () => void,
@@ -52,6 +53,7 @@ export default function Sidebar({
   settings, 
   setSettings,
   onRandomInitialPoint,
+  trajectoryValues,
   onReset,
   onNextStep,
   onPrevStep,
@@ -91,7 +93,21 @@ export default function Sidebar({
     setFunctionOption(newFunctionOption);
   }
 
+  function getLastValue<T>(values?: T[] | null): T | null {
+    return values && values.length > 0 ? values[values.length - 1] : null;
+  }
+
+  const currentX = getLastValue(trajectoryValues?.x);
+  const currentY = getLastValue(trajectoryValues?.y);
+
+  // univariate only
+  const currentDerivative = getLastValue(trajectoryValues?.derivative);
+  const currentSecondDerivative = getLastValue(trajectoryValues?.secondDerivative);
 
+  // bivariate only
+  const currentZ = getLastValue(trajectoryValues?.z);
+  const currentGradient = getLastValue(trajectoryValues?.gradient);
+  const currentHessian = getLastValue(trajectoryValues?.hessian);
 
   return (
     <div className="bg-gray-100 flex flex-col h-full p-4 gap-2">
@@ -209,6 +225,59 @@ export default function Sidebar({
 
       {activeTab === "Optimize" && (
         <>
+          { settings.mode === "Univariate" && (
+            <>
+              <InputField
+                label="Current X"
+                value={currentX !== null ? currentX.toFixed(4) : ""}
+                readonly
+              />
+              <InputField
+                label="Current Y"
+                value={currentY !== null ? currentY.toFixed(4) : ""}
+                readonly
+              />
+              <InputField
+                label="Current Derivative"
+                value={currentDerivative !== null ? currentDerivative.toFixed(4) : ""}
+                readonly
+              />
+              <InputField
+                label="Current Second Derivative"
+                value={currentSecondDerivative !== null ? currentSecondDerivative.toFixed(4) : ""}
+                readonly
+              />
+            </>
+          )}
+          { settings.mode === "Bivariate" && (
+            <>
+              <InputField
+                label="Current X"
+                value={currentX !== null ? currentX.toFixed(4) : ""}
+                readonly
+              />
+              <InputField
+                label="Current Y"
+                value={currentY !== null ? currentY.toFixed(4) : ""}
+                readonly
+              />
+              <InputField
+                label="Current Z"
+                value={currentZ !== null ? currentZ.toFixed(4) : ""}
+                readonly
+              />
+              <InputField
+                label="Current Gradient"
+                value={currentGradient !== null ? `[${currentGradient.map(v => v.toFixed(4)).join(", ")}]` : ""}
+                readonly
+              />
+              <InputField
+                label="Current Hessian"
+                value={currentHessian !== null ? `[${currentHessian.map(row => `[${row.map(v => v.toFixed(4)).join(", ")}]`).join(", ")}]` : ""}
+                readonly
+              />
+            </>
+          )}
           <div className="grid grid-cols-2 gap-2">
             <Button label="Next Step" onClick={onNextStep}/ >
             <Button label="Previous Step" onClick={onPrevStep} />

frontends/react/src/types.ts

@@ -31,9 +31,23 @@ export type PlotValues = {
   z?: number[][];
 }
 
+export type TrajectoryValues = {
+  x: number[];
+  y: number[];
+
+  // univariate only
+  derivative?: number[];
+  secondDerivative?: number[];
+
+  // bivariate only
+  z?: number[];
+  gradient?: number[][];
+  hessian?: number[][][];
+}
+
 export type PlotData = {
   functionValues?: PlotValues;
-  trajectoryValues?: PlotValues;
+  trajectoryValues?: TrajectoryValues;
 }
 
 export const SUPPORTED_MODES = ["Univariate", "Bivariate"] as const;