executable-engineering 0.1.43__tar.gz → 0.1.46__tar.gz

{executable_engineering-0.1.43 → executable_engineering-0.1.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: executable_engineering
-Version: 0.1.43
+Version: 0.1.46
 Summary: Demonstrative tools for the Executable Engineering textbook
 Home-page: https://github.com/themintlab/ExecutableEngineering/tree/main/executable_engineering
 Author: Michael Welland

{executable_engineering-0.1.43 → executable_engineering-0.1.46}/executable_engineering/__init__.py

@@ -1,15 +1,23 @@
-from .neuralnet_module import init_weights, tanh, tanh_derivative, forward, compute_loss, backward, plot_nn_diagram, init_model, forward_pass, backward_pass, step, reset_model, save_function, change_depth, change_width, draw_network, update_plots
+from .neuralnet_module import init_weights, tanh, tanh_derivative, forward, compute_loss, backward, plot_nn_diagram, init_model, forward_pass, backward_pass, step, reset_model, save_function, change_depth, change_width, draw_network, update_plots, interactive_neural_network, train_until_convergence
 from .openrootfinder_module import RootFinderOpen
 from .closedrootfinder_module import RootFinderClosed
-from .closedoptimization_module import OptimizerClosed
-from .openoptimization_module import OptimizerOpen
+from .closedoptimization_module import OptimizerClosed, ScalarTracker, plot_bracketed_progression
+from .openoptimization_module import OptimizerOpen, plot_optimization_path_2d, plot_optimization_path_3d
 from .gradientoptimization_module import OptimizerGrad
 from .numerical_error_module import python_internal_binary, decimal_to_binary
 from .linearsystems_module import visual_solve_2d, visualize_conditioning, visualize_matrix_norms, jacobi_step, gauss_seidel_step, sor_step, visualize_convergence_2d, create_diagonally_dominant_matrix, iter_solve, steepest_descent, conjugate_gradient, IterationTracker, discretise_poisson, spai
-from .functions_module import weierstrass, plot_and_find_roots, complex_plot_with_shadow, plot_polynomial_roots_companion, plot_secant, plot_newton_raphson, plot_basins_of_attraction
+from .functions_module import weierstrass, plot_and_find_roots, complex_plot_with_shadow, plot_polynomial_roots_companion, plot_secant, plot_newton_raphson, plot_basins_of_attraction, newton_raphson
 from .optimization_module import visual_golden_section, visual_powell_2d, newton_method
+from .constrainedoptimization_module import plot_constrained_optimum_3d
 
 __all__ = [
+  "interactive_neural_network",
+  "train_until_convergence",
+  "plot_constrained_optimum_3d",
+  "plot_optimization_path_3d",
+  "plot_optimization_path_2d",
+  "ScalarTracker",
+  "plot_bracketed_progression",
   "newton_method",
   "visual_powell_2d",
   "visual_golden_section",
@@ -17,6 +25,7 @@ __all__ = [
   "plot_secant",
   "plot_newton_raphson",
   "plot_basins_of_attraction",
+  "newton_raphson",
   "plot_and_find_roots",
   "complex_plot_with_shadow",
   "weierstrass",

{executable_engineering-0.1.43 → executable_engineering-0.1.46}/executable_engineering/closedoptimization_module.py

@@ -280,3 +280,139 @@ class OptimizerClosed:
         tab_container.set_title(1, "Brent's Method")
 
         display(tab_container)
+
+
+class ScalarTracker:
+    """Wraps a 1D objective function to record scalar evaluations during optimization."""
+    def __init__(self, f):
+        self.f = f
+        self.x_history = []
+        self.f_history = []
+
+    def __call__(self, x):
+        val = self.f(x)
+        if np.ndim(x) == 0 or (isinstance(x, np.ndarray) and x.size == 1):
+            x_scalar = float(np.squeeze(x))
+            f_scalar = float(np.squeeze(val))
+            self.x_history.append(x_scalar)
+            self.f_history.append(f_scalar)
+        return val
+
+
+def plot_bracketed_progression(f, tracker, result=None, x_range=(-5, 5), x_true=None, title=None):
+    """Plots a 2-panel Plotly figure showing function evaluations and convergence progression."""
+    import plotly.graph_objects as go
+    from plotly.subplots import make_subplots
+
+    x_vals = np.linspace(x_range[0], x_range[1], 400)
+    y_vals = f(x_vals)
+
+    xs = np.array(tracker.x_history, dtype=float)
+    ys = np.array(tracker.f_history, dtype=float)
+    steps = np.arange(1, len(xs) + 1)
+
+    if result is not None:
+        x_min, y_min = float(result.x), float(result.fun)
+    elif len(xs) > 0:
+        idx = int(np.argmin(ys))
+        x_min, y_min = xs[idx], ys[idx]
+    else:
+        x_min, y_min = 0.0, float(f(0.0))
+
+    x_ref = float(x_true) if x_true is not None else x_min
+
+    fig = make_subplots(
+        rows=1, cols=2,
+        subplot_titles=("Objective Function & Evaluations", "Solver Progression (|xₖ - x*| & xₖ)"),
+        horizontal_spacing=0.12,
+        specs=[[{"secondary_y": False}, {"secondary_y": True}]]
+    )
+
+    # Left panel: f(x) curve
+    fig.add_trace(
+        go.Scatter(x=x_vals, y=y_vals, mode='lines', name='f(x)', line=dict(color='royalblue', width=2)),
+        row=1, col=1
+    )
+
+    # Left panel: evaluated points colored by iteration
+    if len(xs) > 0:
+        hover_texts = [f"Eval {k}<br>x = {xk:.6g}<br>f(x) = {yk:.6g}" for k, xk, yk in zip(steps, xs, ys)]
+        fig.add_trace(
+            go.Scatter(
+                x=xs, y=ys,
+                mode='markers+lines',
+                name='Evaluations',
+                line=dict(color='rgba(150, 150, 150, 0.35)', dash='dot', width=1),
+                marker=dict(
+                    size=8,
+                    color=steps,
+                    colorscale='Viridis',
+                    showscale=True,
+                    colorbar=dict(title="Eval #", len=0.85, x=-0.12),
+                    line=dict(width=1, color='black')
+                ),
+                text=hover_texts,
+                hoverinfo='text'
+            ),
+            row=1, col=1
+        )
+
+    # Left panel: Final minimum star
+    fig.add_trace(
+        go.Scatter(
+            x=[x_min], y=[y_min],
+            mode='markers',
+            name=f'Minimum (x*={x_min:.4g})',
+            marker=dict(color='crimson', size=13, symbol='star', line=dict(width=1, color='black'))
+        ),
+        row=1, col=1
+    )
+
+    # Right panel: x_k progression (primary y-axis) and |x_k - x*| (secondary log y-axis)
+    if len(xs) > 0:
+        fig.add_trace(
+            go.Scatter(
+                x=steps, y=xs,
+                mode='lines+markers',
+                name='Guess xₖ',
+                line=dict(color='teal', width=2),
+                marker=dict(size=6)
+            ),
+            row=1, col=2, secondary_y=False
+        )
+        fig.add_hline(y=x_ref, line_dash='dash', line_color='crimson', opacity=0.6, row=1, col=2, secondary_y=False)
+
+        raw_err = np.abs(xs - x_ref)
+        if x_true is None and np.any(raw_err == 0):
+            nonzero = raw_err[raw_err > 0]
+            floor_val = 0.5 * np.min(nonzero) if len(nonzero) > 0 else 1e-12
+            err = np.where(raw_err == 0, floor_val, raw_err)
+        else:
+            err = np.maximum(raw_err, 1e-16)
+
+        fig.add_trace(
+            go.Scatter(
+                x=steps, y=err,
+                mode='lines+markers',
+                name='|xₖ - x*| (log)',
+                line=dict(color='darkorange', width=2, dash='dot'),
+                marker=dict(size=6, symbol='diamond')
+            ),
+            row=1, col=2, secondary_y=True
+        )
+
+    fig.update_xaxes(title_text="x", row=1, col=1)
+    fig.update_yaxes(title_text="f(x)", row=1, col=1)
+    fig.update_xaxes(title_text="Evaluation Number (k)", row=1, col=2)
+    fig.update_yaxes(title_text="Guess xₖ", row=1, col=2, secondary_y=False)
+    fig.update_yaxes(title_text="Error |xₖ - x*|", type="log", row=1, col=2, secondary_y=True)
+
+    fig.update_layout(
+        title=title or f"Solver Progression ({len(xs)} Function Evaluations)",
+        width=950,
+        height=430,
+        margin=dict(l=90, r=60, t=60, b=50),
+        legend=dict(orientation="h", yanchor="bottom", y=-0.28, xanchor="center", x=0.5)
+    )
+    fig.show()
+

executable_engineering-0.1.46/executable_engineering/constrainedoptimization_module.py

@@ -0,0 +1,160 @@
+import numpy as np
+import plotly.graph_objects as go
+
+
+def plot_constrained_optimum_3d(
+    func,
+    optimum,
+    constraint_curve=None,
+    x_range=(-1.5, 1.5),
+    y_range=(-1.5, 1.5),
+    x0=None,
+    path=None,
+    displacement_factor=0.8,
+    title="Constrained Optimization Surface",
+):
+    """
+    Plots an interactive 3D objective surface, constraint boundary, iterates, and the constrained optimum.
+
+    Args:
+        func: Callable taking a 2-element sequence [x, y] and returning a scalar f(x, y).
+        optimum: Sequence [x*, y*] representing the constrained optimum.
+        constraint_curve: Optional array-like of shape (M, 2) defining (x, y) coordinates of the constraint boundary.
+        x_range: Tuple of (x_min, x_max).
+        y_range: Tuple of (y_min, y_max).
+        x0: Optional sequence [x0, y0] representing the initial starting guess.
+        path: Optional array-like of shape (N, 2) representing intermediate iterates.
+        displacement_factor: Fraction of z-span to displace the floor plane below the surface minimum.
+        title: Plot title.
+    """
+    x_vals = np.linspace(x_range[0], x_range[1], 100)
+    y_vals = np.linspace(y_range[0], y_range[1], 100)
+    X, Y = np.meshgrid(x_vals, y_vals)
+
+    Z = np.zeros_like(X)
+    for i in range(X.shape[0]):
+        for j in range(X.shape[1]):
+            Z[i, j] = func([X[i, j], Y[i, j]])
+
+    z_min_surf = float(np.min(Z))
+    z_max_surf = float(np.max(Z))
+    z_span = z_max_surf - z_min_surf if z_max_surf > z_min_surf else 1.0
+    z_floor = z_min_surf - displacement_factor * z_span
+
+    fig = go.Figure()
+
+    # 3D surface with bottom-projected contours (shadow)
+    fig.add_trace(
+        go.Surface(
+            x=x_vals,
+            y=y_vals,
+            z=Z,
+            colorscale="Viridis",
+            opacity=0.8,
+            contours=dict(
+                z=dict(
+                    show=True,
+                    usecolormap=True,
+                    highlightcolor="limegreen",
+                    project_z=True,
+                )
+            ),
+            colorbar=dict(title="f(x, y)", len=0.75, x=1.05),
+            name="Surface",
+        )
+    )
+
+    # Constraint curve (both along surface and on floor plane)
+    if constraint_curve is not None:
+        c_pts = np.asarray(constraint_curve, dtype=float)
+        cz_surf = np.array([float(func(pt)) for pt in c_pts])
+
+        # Constraint along surface
+        fig.add_trace(
+            go.Scatter3d(
+                x=c_pts[:, 0],
+                y=c_pts[:, 1],
+                z=cz_surf,
+                mode="lines",
+                line=dict(color="orange", width=6),
+                name="Constraint on Surface",
+            )
+        )
+
+        # Constraint projected on floor
+        fig.add_trace(
+            go.Scatter3d(
+                x=c_pts[:, 0],
+                y=c_pts[:, 1],
+                z=[z_floor] * len(c_pts),
+                mode="lines",
+                line=dict(color="rgba(255, 140, 0, 0.7)", width=4, dash="dash"),
+                name="Constraint on Floor",
+            )
+        )
+
+    # Optional optimization path
+    if path is not None:
+        pts = np.asarray(path, dtype=float)
+        if pts.ndim == 2 and len(pts) > 0:
+            pz = np.array([float(func(pt)) for pt in pts])
+            fig.add_trace(
+                go.Scatter3d(
+                    x=pts[:, 0],
+                    y=pts[:, 1],
+                    z=pz,
+                    mode="lines+markers",
+                    line=dict(color="red", width=4),
+                    marker=dict(size=4, color="crimson"),
+                    name="Solver Path",
+                )
+            )
+
+    # Initial guess
+    if x0 is not None:
+        pt0 = np.asarray(x0, dtype=float)
+        z0 = float(func(pt0))
+        fig.add_trace(
+            go.Scatter3d(
+                x=[pt0[0]],
+                y=[pt0[1]],
+                z=[z0],
+                mode="markers",
+                marker=dict(size=8, color="cyan", symbol="circle"),
+                name=f"Initial Guess ({pt0[0]:.2f}, {pt0[1]:.2f})",
+            )
+        )
+
+    # Optimum point
+    opt = np.asarray(optimum, dtype=float)
+    z_opt = float(func(opt))
+    fig.add_trace(
+        go.Scatter3d(
+            x=[opt[0]],
+            y=[opt[1]],
+            z=[z_opt],
+            mode="markers",
+            marker=dict(size=10, color="crimson", symbol="diamond"),
+            name=f"Optimum ({opt[0]:.3f}, {opt[1]:.3f})",
+        )
+    )
+
+    fig.update_layout(
+        title=title,
+        scene=dict(
+            xaxis_title="x",
+            yaxis_title="y",
+            zaxis_title="f(x, y)",
+            zaxis=dict(range=[z_floor, z_max_surf + 0.05 * z_span]),
+            aspectmode="manual",
+            aspectratio=dict(x=1, y=1, z=0.9),
+            camera=dict(eye=dict(x=1.6, y=1.6, z=1.3)),
+        ),
+        width=750,
+        height=550,
+        margin=dict(l=20, r=20, t=50, b=20),
+        legend=dict(
+            orientation="h", yanchor="bottom", y=-0.15, xanchor="center", x=0.5
+        ),
+    )
+    fig.show()

{executable_engineering-0.1.43 → executable_engineering-0.1.46}/executable_engineering/functions_module.py

@@ -276,3 +276,17 @@ def plot_basins_of_attraction(f, df, known_roots, title, real_range=(-2, 2), ima
     fig = go.Figure(data=go.Heatmap(z=colors, x=real_values, y=imag_values, colorscale='Viridis', showscale=False))
     fig.update_layout(title=title, xaxis_title='Real', yaxis_title='Imaginary', width=600, height=600)
     fig.show()
+
+def newton_raphson(f, df, x0, max_iter=8, tolerance=1e-6):
+  x = x0
+  guesses = [x]
+  for i in range(max_iter):
+    d = df(x)
+    if d == 0:
+        break
+    x_new = x - f(x) / d
+    guesses.append(x_new)
+    if abs(x_new - x) < tolerance:
+      return x_new, guesses
+    x = x_new
+  return None, guesses

{executable_engineering-0.1.43 → executable_engineering-0.1.46}/executable_engineering/neuralnet_module.py

@@ -1,9 +1,14 @@
 # Neural network model UI and plotting
 import ipywidgets as widgets
 import matplotlib.pyplot as plt
+import matplotlib.cm as cm
+import matplotlib.colors as mcolors
 import networkx as nx
 import numpy as np
 import plotly.graph_objs as go
+from IPython.display import display
+
+plt.ioff()
 
 def init_weights():
     global W1, b1, W2, b2
@@ -133,38 +138,46 @@ def forward_pass(x):
     activations.append(z)  # no activation on final output
     return zs, activations
 
-def backward_pass(zs, activations, y_true, lr=0.01):
+def backward_pass(zs, activations, y_true, lr=0.02):
     global weights, biases, weight_history, bias_history
     grads_w = [None] * len(weights)
     grads_b = [None] * len(biases)
 
     delta = (activations[-1] - y_true)
-    grads_w[-1] = activations[-2].T @ delta / len(X)
+    inv_m = 1.0 / len(y_true)
+    grads_w[-1] = (activations[-2].T @ delta) * inv_m
     grads_b[-1] = np.mean(delta, axis=0, keepdims=True)
 
     for l in range(2, len(weights)+1):
         z = zs[-l]
         sp = activation_derivative(z)
         delta = (delta @ weights[-l+1].T) * sp
-        grads_w[-l] = activations[-l-1].T @ delta / len(X)
+        grads_w[-l] = (activations[-l-1].T @ delta) * inv_m
         grads_b[-l] = np.mean(delta, axis=0, keepdims=True)
 
     for i in range(len(weights)):
         weights[i] -= lr * grads_w[i]
         biases[i] -= lr * grads_b[i]
-        weight_history[i].append(weights[i].copy())
-        bias_history[i].append(biases[i].copy())
+        # Efficient scalar tracking to eliminate memory overhead
+        weight_history[i].append(float(weights[i].ravel()[0]))
+        bias_history[i].append(float(biases[i].ravel()[0]))
 
-    return np.mean((activations[-1] - y_true)**2)
+    return float(np.mean((activations[-1] - y_true)**2))
 
-def step(n,output_plot, metrics_plot, network_plot):
+def step(n, output_plot, metrics_plot, network_plot, status_label=None):
     global losses
-    if true_function is None: return
+    if true_function is None:
+        if status_label:
+            status_label.value = "Please save a function first."
+        return
     y_true = true_function(X)
+    last_loss = 0.0
     for _ in range(n):
         zs, activations = forward_pass(X)
-        loss = backward_pass(zs, activations, y_true)
-        losses.append(loss)
+        last_loss = backward_pass(zs, activations, y_true)
+        losses.append(last_loss)
+    if status_label:
+        status_label.value = f"Trained {n} steps. Total steps: {len(losses)} | Loss: {last_loss:.4e}"
     update_plots(output_plot, metrics_plot, network_plot)
 
 def reset_model(output_plot, metrics_plot, network_plot, status_label):
@@ -195,10 +208,48 @@ def change_width(d, output_plot, metrics_plot, network_plot, status_label):
     reset_model(output_plot, metrics_plot, network_plot, status_label)
 
 
-def draw_network(activations):
-    import matplotlib.cm as cm
-    import matplotlib.colors as mcolors
+def train_until_convergence(output_plot, metrics_plot, network_plot, status_label, target_loss=1e-4, max_steps=50000, window=5000, min_rel_improvement=0.005):
+    """Trains the neural network iteratively until a high-precision target loss or convergence plateau is reached."""
+    global losses
+    if true_function is None:
+        status_label.value = "Please save a function first."
+        return
+
+    y_true = true_function(X)
+    status_label.value = "Training to convergence..."
+
+    batch_size = 500
+    step_count = 0
+    stop_reason = ""
+    window_start_loss = float('inf')
+    current_loss = float('inf')
+
+    while step_count < max_steps:
+        for _ in range(batch_size):
+            zs, activations = forward_pass(X)
+            current_loss = backward_pass(zs, activations, y_true, lr=0.02)
+            losses.append(current_loss)
+        step_count += batch_size
+
+        if current_loss <= target_loss:
+            stop_reason = f"Target loss reached ({current_loss:.4e} <= {target_loss}) in {step_count} steps. Total: {len(losses)}"
+            break
+
+        if step_count % window == 0:
+            rel_improvement = (window_start_loss - current_loss) / max(window_start_loss, 1e-8)
+            if step_count > window and rel_improvement < min_rel_improvement:
+                stop_reason = f"Converged to plateau (rel. change < {min_rel_improvement:.1%} over {window} steps) at loss {current_loss:.4e}. Total steps: {len(losses)}"
+                break
+            window_start_loss = current_loss
+
+    if not stop_reason:
+        stop_reason = f"Completed {step_count} steps. Total steps: {len(losses)} | Loss: {current_loss:.4e} (Click again to train further)"
+
+    status_label.value = stop_reason
+    update_plots(output_plot, metrics_plot, network_plot)
 
+
+def draw_network(activations):
     G = nx.DiGraph()
     labels = {}
     pos = {}
@@ -242,44 +293,112 @@ def draw_network(activations):
 
 
 def update_plots(output_plot, metrics_plot, network_plot):
-    output_plot.clear_output(wait=True)
-    metrics_plot.clear_output(wait=True)
-    network_plot.clear_output(wait=True)
+    plt.ioff()
     with output_plot:
+        output_plot.clear_output(wait=True)
         if true_function:
-            plt.figure(figsize=(6, 3))
+            fig_out = plt.figure(figsize=(6, 3))
             y_true = true_function(X)
             _, activations = forward_pass(X2)
             y_pred = activations[-1]
-            plt.plot(X, y_true, label='True')
-            plt.scatter(X2, y_pred, label='NN')
+            plt.plot(X, y_true, label='True', color='black', linewidth=1.5)
+            plt.scatter(X2, y_pred, label='NN Output', color='tab:blue', s=20, alpha=0.8, zorder=3)
             plt.legend()
             plt.title("Function vs NN Output")
-            plt.grid(True)
-            plt.show()
+            plt.grid(True, linestyle='--', alpha=0.6)
+            plt.tight_layout()
+            display(fig_out)
+            plt.close(fig_out)
 
     with metrics_plot:
         if losses:
-            plt.figure(figsize=(6, 3))
-            plt.plot(losses, label="Loss", color='red')
+            metrics_plot.clear_output(wait=True)
+            fig_met = plt.figure(figsize=(6, 3))
+            stride = max(1, len(losses) // 500)
+            indices = list(range(0, len(losses), stride))
+            loss_sub = [losses[idx] for idx in indices]
+            plt.plot(indices, loss_sub, label="Loss", color='red', linewidth=1.5, zorder=4)
             for i, history in enumerate(weight_history):
-                flat_vals = [w.flatten()[0] for w in history]
-                plt.plot(flat_vals, label=f"W{i}_0", alpha=0.5)
+                sub_w = [history[idx] for idx in indices]
+                plt.plot(indices, sub_w, label=f"W{i}_0", alpha=0.5)
             for i, history in enumerate(bias_history):
-                flat_vals = [b.flatten()[0] for b in history]
-                plt.plot(flat_vals, label=f"b{i}_0", linestyle='dotted', alpha=0.5)
+                sub_b = [history[idx] for idx in indices]
+                plt.plot(indices, sub_b, label=f"b{i}_0", linestyle='dotted', alpha=0.5)
             plt.title("Loss and Parameter Changes")
+            plt.grid(True, linestyle='--', alpha=0.6)
+            plt.legend(loc='upper right', fontsize=8)
+            plt.tight_layout()
+            display(fig_met)
+            plt.close(fig_met)
+        else:
+            metrics_plot.clear_output(wait=False)
 
-            plt.grid(True)
-            plt.legend()
-            plt.show()
     with network_plot:
+        network_plot.clear_output(wait=True)
         if true_function:
             _, activations = forward_pass(X)
+            fig_net = plt.figure(figsize=(7, 3.5))
             G, pos, labels, edge_labels, edge_colors = draw_network(activations)
             edge_color_vals = [edge_colors.get(edge, '#888888') for edge in G.edges()]
             nx.draw(G, pos, labels=labels, node_color='lightblue', node_size=600,
-                    edge_color=edge_color_vals, edge_cmap=plt.cm.bwr, arrows=True)
+                    edge_color=edge_color_vals, arrows=True, font_size=9)
             nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=8)
             plt.title("Neural Network Diagram")
-            plt.show()
+            display(fig_net)
+            plt.close(fig_net)
+
+
+def interactive_neural_network():
+    """Constructs and displays the interactive neural network training widget."""
+    import ipywidgets as widgets
+    from ipywidgets import VBox, HBox, Button, Text, Label, Output
+
+    plt.ioff()
+    output_plot = Output()
+    network_plot = Output(layout={"height": "500px", "overflow": "auto"})
+    metrics_plot = Output()
+    status_label = Label(value="Press 'Step' to begin training.")
+
+    function_input = Text(value='exp(-x/2)*sin(2*pi*x)', description='f(x):')
+    save_button = Button(description='Save Function', button_style='success')
+    reset_button = Button(description='Reset Model', button_style='warning')
+
+    step_label = Label(value="Step:")
+    step_1 = Button(description='1')
+    step_10 = Button(description='10')
+    step_100 = Button(description='100')
+    step_1000 = Button(description='1000')
+    step_10000 = Button(description='10000')
+    train_converge_btn = Button(description='Train to Convergence', button_style='primary', tooltip='Trains iteratively until a plateau or high-precision convergence (<1e-4) is reached')
+
+    depth_label = Label(value="Change Depth (layers):")
+    depth_add = Button(description='+1')
+    depth_sub = Button(description='-1')
+    width_label = Label(value="Change Width (neurons):")
+    width_add = Button(description='+1')
+    width_sub = Button(description='-1')
+
+    save_button.on_click(lambda b: save_function(function_input, output_plot, metrics_plot, network_plot, status_label))
+    reset_button.on_click(lambda b: reset_model(output_plot, metrics_plot, network_plot, status_label))
+    step_1.on_click(lambda b: step(1, output_plot, metrics_plot, network_plot, status_label))
+    step_10.on_click(lambda b: step(10, output_plot, metrics_plot, network_plot, status_label))
+    step_100.on_click(lambda b: step(100, output_plot, metrics_plot, network_plot, status_label))
+    step_1000.on_click(lambda b: step(1000, output_plot, metrics_plot, network_plot, status_label))
+    step_10000.on_click(lambda b: step(10000, output_plot, metrics_plot, network_plot, status_label))
+    train_converge_btn.on_click(lambda b: train_until_convergence(output_plot, metrics_plot, network_plot, status_label))
+    depth_add.on_click(lambda b: change_depth(1, output_plot, metrics_plot, network_plot, status_label))
+    depth_sub.on_click(lambda b: change_depth(-1, output_plot, metrics_plot, network_plot, status_label))
+    width_add.on_click(lambda b: change_width(1, output_plot, metrics_plot, network_plot, status_label))
+    width_sub.on_click(lambda b: change_width(-1, output_plot, metrics_plot, network_plot, status_label))
+
+    top_controls = HBox([function_input, save_button, reset_button])
+    step_controls = HBox([step_label, step_1, step_10, step_100, step_1000, step_10000, train_converge_btn])
+    depth_controls = HBox([depth_label, depth_sub, depth_add])
+    width_controls = HBox([width_label, width_sub, width_add])
+    graph_row = HBox([output_plot, metrics_plot])
+    full_ui = VBox([top_controls, status_label, step_controls, depth_controls, width_controls, network_plot, graph_row])
+    display(full_ui)
+
+    init_model()
+    save_function(function_input, output_plot, metrics_plot, network_plot, status_label)
+

{executable_engineering-0.1.43 → executable_engineering-0.1.46}/executable_engineering/openoptimization_module.py

@@ -229,3 +229,138 @@ class OptimizerOpen:
         tab.set_title(0, "Powell's Method")
         tab.set_title(1, "Nelder–Mead Method")
         display(tab)
+
+
+def plot_optimization_path_3d(func, path, x_range=None, y_range=None, displacement_factor=0.8, title="3D Optimization Surface & Path"):
+    """
+    Plots an interactive 3D surface with floor contour shadow and the optimization path.
+    
+    Args:
+        func: Callable taking a 2-element sequence [x1, x2] and returning a scalar.
+        path: Array-like of shape (N, 2) containing the sequence of iterate points.
+        x_range: Tuple of (x_min, x_max). If None, inferred with margin from path.
+        y_range: Tuple of (y_min, y_max). If None, inferred with margin from path.
+        displacement_factor: Fraction of z-span to displace the floor below the surface minimum.
+        title: Plot title.
+    """
+    import numpy as np
+    import plotly.graph_objects as go
+
+    pts = np.asarray(path, dtype=float)
+    if pts.ndim != 2 or pts.shape[1] != 2:
+        raise ValueError("path must be of shape (N, 2)")
+
+    if x_range is None:
+        dx = max(np.ptp(pts[:, 0]) * 0.35, 1.0)
+        x_range = (np.min(pts[:, 0]) - dx, np.max(pts[:, 0]) + dx)
+    if y_range is None:
+        dy = max(np.ptp(pts[:, 1]) * 0.35, 1.0)
+        y_range = (np.min(pts[:, 1]) - dy, np.max(pts[:, 1]) + dy)
+
+    x_vals = np.linspace(x_range[0], x_range[1], 100)
+    y_vals = np.linspace(y_range[0], y_range[1], 100)
+    X, Y = np.meshgrid(x_vals, y_vals)
+
+    Z = np.zeros_like(X)
+    for i in range(X.shape[0]):
+        for j in range(X.shape[1]):
+            Z[i, j] = func([X[i, j], Y[i, j]])
+
+    z_pts = np.array([float(func(pt)) for pt in pts])
+    z_min_surf = float(np.min(Z))
+    z_max_surf = float(np.max(Z))
+    z_span = z_max_surf - z_min_surf if z_max_surf > z_min_surf else 1.0
+    z_gap = displacement_factor * z_span
+    z_floor = z_min_surf - z_gap
+    steps = np.arange(len(pts))
+
+    fig = go.Figure()
+
+    # 3D surface with bottom-projected contours (shadow)
+    fig.add_trace(go.Surface(
+        x=x_vals, y=y_vals, z=Z,
+        colorscale="Viridis",
+        opacity=0.85,
+        contours=dict(
+            z=dict(show=True, usecolormap=True, highlightcolor="limegreen", project_z=True)
+        ),
+        colorbar=dict(title="f(x1, x2)", len=0.75, x=1.05),
+        name="Surface"
+    ))
+
+    # 3D path line along the surface
+    fig.add_trace(go.Scatter3d(
+        x=pts[:, 0], y=pts[:, 1], z=z_pts,
+        mode="lines",
+        line=dict(color="red", width=5),
+        name="Path (3D)"
+    ))
+
+    # 3D iterate markers colored by step number
+    hover_texts = [
+        f"Step {k}<br>x1 = {pt[0]:.4f}<br>x2 = {pt[1]:.4f}<br>f = {zk:.4e}"
+        for k, (pt, zk) in enumerate(zip(pts, z_pts))
+    ]
+
+    fig.add_trace(go.Scatter3d(
+        x=pts[:, 0], y=pts[:, 1], z=z_pts,
+        mode="markers",
+        marker=dict(
+            size=5,
+            color=steps,
+            colorscale="Plasma",
+            showscale=True,
+            colorbar=dict(title="Iteration", len=0.75, x=-0.08)
+        ),
+        name="Iterates",
+        text=hover_texts,
+        hoverinfo="text"
+    ))
+
+    # Projected 2D shadow path on the floor plane z = z_floor
+    fig.add_trace(go.Scatter3d(
+        x=pts[:, 0], y=pts[:, 1], z=[z_floor] * len(pts),
+        mode="lines+markers",
+        line=dict(color="rgba(40, 40, 40, 0.6)", width=3, dash="dot"),
+        marker=dict(size=3, color="black"),
+        name="Floor Projection"
+    ))
+
+    # Start and End points
+    fig.add_trace(go.Scatter3d(
+        x=[pts[0, 0]], y=[pts[0, 1]], z=[z_pts[0]],
+        mode="markers",
+        marker=dict(size=8, color="cyan", symbol="circle"),
+        name=f"Start ({pts[0, 0]:.2f}, {pts[0, 1]:.2f})"
+    ))
+
+    fig.add_trace(go.Scatter3d(
+        x=[pts[-1, 0]], y=[pts[-1, 1]], z=[z_pts[-1]],
+        mode="markers",
+        marker=dict(size=10, color="crimson", symbol="diamond"),
+        name=f"End ({pts[-1, 0]:.4f}, {pts[-1, 1]:.4f})"
+    ))
+
+    fig.update_layout(
+        title=title,
+        scene=dict(
+            xaxis_title="x1",
+            yaxis_title="x2",
+            zaxis_title="f(x1, x2)",
+            zaxis=dict(range=[z_floor, z_max_surf + 0.05 * z_span]),
+            aspectmode="manual",
+            aspectratio=dict(x=1, y=1, z=0.9),
+            camera=dict(eye=dict(x=1.6, y=1.6, z=1.3))
+        ),
+        width=800,
+        height=600,
+        margin=dict(l=20, r=20, t=50, b=20),
+        legend=dict(orientation="h", yanchor="bottom", y=-0.15, xanchor="center", x=0.5)
+    )
+    fig.show()
+
+
+# Backward-compatible alias
+plot_optimization_path_2d = plot_optimization_path_3d
+
+

{executable_engineering-0.1.43 → executable_engineering-0.1.46}/executable_engineering/optimization_module.py

@@ -290,8 +290,8 @@ def visual_golden_section(f, x1, x3, tol=1e-5, max_iter=None):
         ),
         xaxis_title="x",
         yaxis_title="f(x)",
-        width=800,
-        height=620,
+        width=700,
+        height=540,
         margin=dict(
             l=25,
             r=25,
@@ -479,23 +479,13 @@ def visual_powell_2d(
         )
     )
 
-    if converged:
-        title = (
-            f"Powell's Method: Converged "
-            f"({iteration + 1} iterations)"
-        )
-    else:
-        title = (
-            f"Powell's Method: Maximum Iterations Reached "
-            f"({max_iter} iterations)"
-        )
-
+    title = (f"Powell's Method")
     fig.update_layout(
         title=title,
         xaxis_title="x",
         yaxis_title="y",
-        width=800,
-        height=600,
+        width=700,
+        height=525,
         margin=dict(
             l=25,
             r=25,
@@ -550,6 +540,7 @@ def newton_method(f, grad_f, hessian_f, x0, tol=1e-6, max_iter=100):
 
   fig.update_layout(
       title='Newton\'s Method Optimization',
+      height = 600,
       scene=dict(
           xaxis_title='x',
           yaxis_title='y',

{executable_engineering-0.1.43 → executable_engineering-0.1.46}/executable_engineering.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: executable_engineering
-Version: 0.1.43
+Version: 0.1.46
 Summary: Demonstrative tools for the Executable Engineering textbook
 Home-page: https://github.com/themintlab/ExecutableEngineering/tree/main/executable_engineering
 Author: Michael Welland

{executable_engineering-0.1.43 → executable_engineering-0.1.46}/executable_engineering.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ setup.py
 executable_engineering/__init__.py
 executable_engineering/closedoptimization_module.py
 executable_engineering/closedrootfinder_module.py
+executable_engineering/constrainedoptimization_module.py
 executable_engineering/functions_module.py
 executable_engineering/gradientoptimization_module.py
 executable_engineering/linearsystems_module.py

{executable_engineering-0.1.43 → executable_engineering-0.1.46}/setup.py

@@ -6,7 +6,7 @@ long_description = (this_directory / "README.md").read_text(encoding="utf-8")
 
 setup(
     name="executable_engineering",
-    version="0.1.43",
+    version="0.1.46",
     description="Demonstrative tools for the Executable Engineering textbook",
     long_description=long_description,
     long_description_content_type="text/markdown",