executable-engineering 0.1.42__tar.gz → 0.1.44__tar.gz

{executable_engineering-0.1.42 → executable_engineering-0.1.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: executable_engineering
-Version: 0.1.42
+Version: 0.1.44
 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.42 → executable_engineering-0.1.44}/executable_engineering/__init__.py

@@ -1,19 +1,31 @@
-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
+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",
   "plot_polynomial_roots_companion",
+  "plot_secant",
+  "plot_newton_raphson",
+  "plot_basins_of_attraction",
+  "newton_raphson",
   "plot_and_find_roots",
   "complex_plot_with_shadow",
   "weierstrass",

{executable_engineering-0.1.42 → executable_engineering-0.1.44}/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.44/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.44/executable_engineering/functions_module.py

@@ -0,0 +1,292 @@
+import numpy as np
+
+def weierstrass(x, a=0.5, b=13, iterations=100):
+    """
+    Computes the Weierstrass function.
+    
+    Parameters:
+    x (array-like): The points at which to evaluate the function.
+    a (float): Parameter 0 < a < 1.
+    b (float): Parameter such that ab > 1 + 3pi/2.
+    iterations (int): Number of terms in the sum.
+    
+    Returns:
+    y (ndarray): The function values.
+    """
+    x = np.asarray(x)
+    y = np.zeros_like(x, dtype=float)
+    for n in range(iterations):
+        y += (a**n) * np.cos((b**n) * np.pi * x)
+    return y
+
+import plotly.graph_objects as go
+from scipy.optimize import root
+
+def plot_and_find_roots(func):
+    x = np.linspace(-10, 10, 400)
+    y = func(x)
+
+    # Find roots
+    x0s = np.arange(-10, 10, 1)
+    roots = []
+    for x0 in x0s:
+        r = root(func, x0=x0)
+        if r.success:
+            roots.append((r.x[0], r.fun[0]))
+
+    # Remove duplicate roots (within tolerance)
+    unique_roots = []
+    tol = 1e-6
+    for rx, ry in roots:
+        if not any(abs(rx - ux) < tol for ux, _ in unique_roots):
+            unique_roots.append((rx, ry))
+
+    # Plot with Plotly
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=x, y=y, mode='lines', name='f(x)'))
+    fig.add_hline(y=0, line_dash='dash', line_color='black', annotation_text='x-axis')
+    if unique_roots:
+        rx_vals = [rx for rx, _ in unique_roots]
+        fig.add_trace(go.Scatter(x=rx_vals, y=[0]*len(unique_roots), mode='markers', marker=dict(color='red', size=10), name='Roots'))
+    fig.update_layout(title='Plot of f(x) and its Roots', xaxis_title='x', yaxis_title='f(x)', xaxis_range=[-10, 10], yaxis_range=[-10, 10])
+    fig.show()
+
+def complex_plot_with_shadow(func, title='Complex Plot of f(z)', roots=None, plot_range=(-3, 3)):
+    real_range = np.linspace(plot_range[0], plot_range[1], 100)
+    imag_range = np.linspace(plot_range[0], plot_range[1], 100)
+    abs_val = np.empty((len(real_range), len(imag_range)))
+
+    for i, real in enumerate(real_range):
+        for j, imag in enumerate(imag_range):
+            z = complex(real, imag)
+            result = func(z)
+            abs_val[i, j] = abs(result)
+
+    surface = go.Surface(
+        z=abs_val.T, 
+        x=real_range, 
+        y=imag_range, 
+        colorscale='Viridis',
+        contours=dict(z=dict(show=True, usecolormap=True, highlightcolor="limegreen", project_z=True))
+    )
+    
+    data = [surface]
+    
+    if roots is not None:
+        root_x = [r.real for r in roots]
+        root_y = [r.imag for r in roots]
+        # Calculate z for roots (which is abs(func(r)) = 0)
+        root_z = [0 for r in roots]
+        
+        data.append(go.Scatter3d(
+            x=root_x, y=root_y, z=root_z, 
+            mode='markers', 
+            marker=dict(color='red', size=5, symbol='circle'),
+            name='Roots'
+        ))
+
+    fig = go.Figure(data=data)
+    fig.update_layout(
+        title=title, 
+        scene=dict(xaxis_title='Real', yaxis_title='Imaginary', zaxis_title='|f(z)|')
+    )
+    fig.show()
+
+
+from scipy.linalg import companion
+
+def plot_polynomial_roots_companion(n):
+    """
+    Creates a random polynomial of order n, solves for its roots 
+    using the companion matrix method, and plots the polynomial 
+    along with the roots as a complex surface with a shadow.
+    """
+    # Create random coefficients from -10 to 10
+    # A polynomial of order n has n+1 coefficients. Let's make the leading coefficient non-zero.
+    coeffs = np.random.uniform(-10, 10, n + 1)
+    
+    # Make sure leading coefficient is not too small
+    if abs(coeffs[0]) < 1:
+        coeffs[0] = 1.0 * np.sign(coeffs[0]) if coeffs[0] != 0 else 1.0
+        
+    poly_func = np.poly1d(coeffs)
+    
+    print("Polynomial:")
+    print(poly_func)
+    
+    # Solve for roots using companion matrix
+    comp_matrix = companion(coeffs)
+    
+    print("\nCompanion Matrix:")
+    print(np.round(comp_matrix, 2))
+    
+    roots = np.linalg.eigvals(comp_matrix)
+    
+    print("\nRoots from eigenvalues of companion matrix:")
+    print(np.round(roots, 2))
+    
+    # Determine plot range based on roots
+    max_abs_root = max(abs(roots)) if len(roots) > 0 else 1.0
+    plot_limit = max_abs_root * 1.5
+    
+    # --- Real-space plot ---
+    x_real = np.linspace(-plot_limit, plot_limit, 400)
+    y_real = poly_func(x_real)
+    
+    fig_real = go.Figure()
+    fig_real.add_trace(go.Scatter(x=x_real, y=y_real, mode='lines', name='f(x)'))
+    fig_real.add_hline(y=0, line_dash='dash', line_color='black', annotation_text='x-axis')
+    
+    # Find real roots (imaginary part near 0)
+    real_roots = [r.real for r in roots if abs(r.imag) < 1e-6]
+    if real_roots:
+        fig_real.add_trace(go.Scatter(x=real_roots, y=[0]*len(real_roots), mode='markers', marker=dict(color='red', size=10), name='Real Roots'))
+        
+    fig_real.update_layout(title=f"Real Space Plot: Roots of Order {n} Polynomial", xaxis_title='x', yaxis_title='f(x)')
+    fig_real.show()
+    
+    # Plot using complex_plot_with_shadow
+    title = f"Complex Space Plot: Roots of Order {n} Polynomial"
+    complex_plot_with_shadow(poly_func, title=title, roots=roots, plot_range=(-plot_limit, plot_limit))
+
+
+def plot_secant(f, x0, x1, tolerance=1e-6, max_iterations=100, title='Secant Method'):
+    import plotly.graph_objects as go
+    import plotly.express as px
+    import numpy as np
+
+    x_values = [x0, x1]
+    for i in range(max_iterations):
+        denom = f(x1) - f(x0)
+        if denom == 0:
+            break
+        x_new = x1 - f(x1) * (x1 - x0) / denom
+        x_values.append(x_new)
+        if abs(f(x_new)) < tolerance:
+            break
+        x0 = x1
+        x1 = x_new
+    
+    root = x_values[-1] if abs(f(x_values[-1])) < tolerance else None
+
+    # Determine plot bounds
+    min_x = min(x_values)
+    max_x = max(x_values)
+    padding = (max_x - min_x) * 0.2 if max_x > min_x else 0.5
+    x = np.linspace(min_x - padding, max_x + padding, 100)
+    
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines', name='f(x)'))
+    fig.add_trace(go.Scatter(x=[x_values[0], x_values[1]], y=[f(x_values[0]), f(x_values[1])], mode='markers', name='Initial guesses'))
+    
+    colors = px.colors.qualitative.Plotly
+    
+    for i in range(1, len(x_values) - 1):
+        # Secant line intersecting x-axis
+        fig.add_trace(go.Scatter(x=[x_values[i-1], x_values[i], x_values[i+1]], y=[f(x_values[i-1]), f(x_values[i]), 0], mode='lines', line=dict(dash='dash', color='gray'), showlegend=False))
+        # Vertical dotted line to the curve
+        fig.add_trace(go.Scatter(x=[x_values[i+1], x_values[i+1]], y=[0, f(x_values[i+1])], mode='lines', line=dict(dash='dot', color='gray'), showlegend=False))
+        
+        color = colors[(i-1) % len(colors)]
+        fig.add_trace(go.Scatter(x=[x_values[i+1]], y=[0], mode='markers', marker=dict(size=10, color=color), name=f'x_{i+1}'))
+    
+    if root:
+        fig.add_trace(go.Scatter(x=[root], y=[0], mode='markers', marker=dict(color='green', size=10), name='Approximate root'))
+    
+    fig.update_layout(title=title, xaxis_title='x', yaxis_title='f(x)')
+    fig.show()
+    return root, x_values
+
+def plot_newton_raphson(f, df, x0, tolerance=1e-6, max_iterations=100, title='Newton-Raphson Method', xrange=None, yrange=None):
+    import plotly.graph_objects as go
+    import plotly.express as px
+    import numpy as np
+    
+    x_values = [x0]
+    for i in range(max_iterations):
+        d = df(x0)
+        if d == 0:
+            break
+        x_new = x0 - f(x0) / d
+        x_values.append(x_new)
+        if abs(f(x_new)) < tolerance or abs(x_new - x0) < tolerance:
+            break
+        x0 = x_new
+
+    root = x_values[-1] if abs(f(x_values[-1])) < tolerance or abs(x_values[-1] - x_values[-2]) < tolerance else None
+
+    # Determine plot bounds
+    if xrange is None:
+        min_x = min(x_values)
+        max_x = max(x_values)
+        padding = (max_x - min_x) * 0.2 if max_x > min_x else 0.5
+        x = np.linspace(min_x - padding, max_x + padding, 100)
+    else:
+        x = np.linspace(xrange[0], xrange[1], 100)
+        
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines', name='f(x)'))
+    fig.add_trace(go.Scatter(x=[x_values[0]], y=[f(x_values[0])], mode='markers', name='Initial guess'))
+    
+    colors = px.colors.qualitative.Plotly
+    
+    for i in range(len(x_values) - 1):
+        # Tangent line intersecting x-axis
+        fig.add_trace(go.Scatter(x=[x_values[i], x_values[i+1]], y=[f(x_values[i]), 0], mode='lines', line=dict(dash='dash', color='gray'), showlegend=False))
+        # Vertical dotted line to the curve
+        fig.add_trace(go.Scatter(x=[x_values[i+1], x_values[i+1]], y=[0, f(x_values[i+1])], mode='lines', line=dict(dash='dot', color='gray'), showlegend=False))
+        
+        color = colors[i % len(colors)]
+        fig.add_trace(go.Scatter(x=[x_values[i+1]], y=[0], mode='markers', marker=dict(size=10, color=color), name=f'x_{i+1}'))
+    
+    if root:
+        fig.add_trace(go.Scatter(x=[root], y=[0], mode='markers', marker=dict(color='green', size=10), name='Approximate root'))
+    
+    fig.update_layout(title=title, xaxis_title='x', yaxis_title='f(x)')
+    if xrange:
+        fig.update_layout(xaxis_range=xrange)
+    if yrange:
+        fig.update_layout(yaxis_range=yrange)
+        
+    fig.show()
+    return root, x_values
+
+def plot_basins_of_attraction(f, df, known_roots, title, real_range=(-2, 2), imag_range=(-2, 2), grid_size=500, th=1e-3):
+    import numpy as np
+    import plotly.graph_objects as go
+    from scipy.optimize import newton
+
+    real_values = np.linspace(real_range[0], real_range[1], grid_size)
+    imag_values = np.linspace(imag_range[0], imag_range[1], grid_size)
+    z_grid = np.array([[complex(r, i) for r in real_values] for i in imag_values])
+
+    roots = newton(f, z_grid, fprime=df)
+
+    colors = np.zeros((grid_size, grid_size))
+    for i in range(grid_size):
+        for j in range(grid_size):
+            if roots[i, j] is None:
+                colors[i, j] = 0
+            else:
+                for idx, r in enumerate(known_roots):
+                    if abs(roots[i, j] - r) < th:
+                        colors[i, j] = idx + 1
+                        break
+                        
+    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.42 → executable_engineering-0.1.44}/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
@@ -139,32 +144,40 @@ def backward_pass(zs, activations, y_true, lr=0.01):
     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,52 @@ 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=0.005, max_steps=10000, tol=1e-5, patience=200):
+    """Trains the neural network iteratively until a 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 = 50
+    step_count = 0
+    best_loss = float('inf')
+    stagnant_count = 0
+    stop_reason = ""
+    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)
+            losses.append(current_loss)
+        step_count += batch_size
+
+        if current_loss <= target_loss:
+            stop_reason = f"Target loss met ({current_loss:.4e} <= {target_loss}) in {step_count} steps. Total: {len(losses)}"
+            break
+
+        if abs(best_loss - current_loss) < tol:
+            stagnant_count += batch_size
+            if stagnant_count >= patience:
+                stop_reason = f"Converged (loss change < {tol:.0e} over {patience} steps) at loss {current_loss:.4e} in {step_count} steps. Total: {len(losses)}"
+                break
+        else:
+            stagnant_count = 0
+            if current_loss < best_loss:
+                best_loss = current_loss
+
+    if not stop_reason:
+        stop_reason = f"Reached maximum of {max_steps} steps. Current loss: {current_loss:.4e}. Total: {len(losses)}"
+
+    status_label.value = stop_reason
+    update_plots(output_plot, metrics_plot, network_plot)
 
+
+def draw_network(activations):
     G = nx.DiGraph()
     labels = {}
     pos = {}
@@ -242,44 +297,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 target loss (<=0.005) or plateau 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.42 → executable_engineering-0.1.44}/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.42 → executable_engineering-0.1.44}/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.42 → executable_engineering-0.1.44}/executable_engineering.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: executable_engineering
-Version: 0.1.42
+Version: 0.1.44
 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.42 → executable_engineering-0.1.44}/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.42 → executable_engineering-0.1.44}/setup.py

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

executable_engineering-0.1.42/executable_engineering/functions_module.py

@@ -1,151 +0,0 @@
-import numpy as np
-
-def weierstrass(x, a=0.5, b=13, iterations=100):
-    """
-    Computes the Weierstrass function.
-    
-    Parameters:
-    x (array-like): The points at which to evaluate the function.
-    a (float): Parameter 0 < a < 1.
-    b (float): Parameter such that ab > 1 + 3pi/2.
-    iterations (int): Number of terms in the sum.
-    
-    Returns:
-    y (ndarray): The function values.
-    """
-    x = np.asarray(x)
-    y = np.zeros_like(x, dtype=float)
-    for n in range(iterations):
-        y += (a**n) * np.cos((b**n) * np.pi * x)
-    return y
-
-import plotly.graph_objects as go
-from scipy.optimize import root
-
-def plot_and_find_roots(func):
-    x = np.linspace(-10, 10, 400)
-    y = func(x)
-
-    # Find roots
-    x0s = np.arange(-10, 10, 1)
-    roots = []
-    for x0 in x0s:
-        r = root(func, x0=x0)
-        if r.success:
-            roots.append((r.x[0], r.fun[0]))
-
-    # Remove duplicate roots (within tolerance)
-    unique_roots = []
-    tol = 1e-6
-    for rx, ry in roots:
-        if not any(abs(rx - ux) < tol for ux, _ in unique_roots):
-            unique_roots.append((rx, ry))
-
-    # Plot with Plotly
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(x=x, y=y, mode='lines', name='f(x)'))
-    fig.add_hline(y=0, line_dash='dash', line_color='black', annotation_text='x-axis')
-    if unique_roots:
-        rx_vals = [rx for rx, _ in unique_roots]
-        fig.add_trace(go.Scatter(x=rx_vals, y=[0]*len(unique_roots), mode='markers', marker=dict(color='red', size=10), name='Roots'))
-    fig.update_layout(title='Plot of f(x) and its Roots', xaxis_title='x', yaxis_title='f(x)', xaxis_range=[-10, 10], yaxis_range=[-10, 10])
-    fig.show()
-
-def complex_plot_with_shadow(func, title='Complex Plot of f(z)', roots=None, plot_range=(-3, 3)):
-    real_range = np.linspace(plot_range[0], plot_range[1], 100)
-    imag_range = np.linspace(plot_range[0], plot_range[1], 100)
-    abs_val = np.empty((len(real_range), len(imag_range)))
-
-    for i, real in enumerate(real_range):
-        for j, imag in enumerate(imag_range):
-            z = complex(real, imag)
-            result = func(z)
-            abs_val[i, j] = abs(result)
-
-    surface = go.Surface(
-        z=abs_val.T, 
-        x=real_range, 
-        y=imag_range, 
-        colorscale='Viridis',
-        contours=dict(z=dict(show=True, usecolormap=True, highlightcolor="limegreen", project_z=True))
-    )
-    
-    data = [surface]
-    
-    if roots is not None:
-        root_x = [r.real for r in roots]
-        root_y = [r.imag for r in roots]
-        # Calculate z for roots (which is abs(func(r)) = 0)
-        root_z = [0 for r in roots]
-        
-        data.append(go.Scatter3d(
-            x=root_x, y=root_y, z=root_z, 
-            mode='markers', 
-            marker=dict(color='red', size=5, symbol='circle'),
-            name='Roots'
-        ))
-
-    fig = go.Figure(data=data)
-    fig.update_layout(
-        title=title, 
-        scene=dict(xaxis_title='Real', yaxis_title='Imaginary', zaxis_title='|f(z)|')
-    )
-    fig.show()
-
-
-from scipy.linalg import companion
-
-def plot_polynomial_roots_companion(n):
-    """
-    Creates a random polynomial of order n, solves for its roots 
-    using the companion matrix method, and plots the polynomial 
-    along with the roots as a complex surface with a shadow.
-    """
-    # Create random coefficients from -10 to 10
-    # A polynomial of order n has n+1 coefficients. Let's make the leading coefficient non-zero.
-    coeffs = np.random.uniform(-10, 10, n + 1)
-    
-    # Make sure leading coefficient is not too small
-    if abs(coeffs[0]) < 1:
-        coeffs[0] = 1.0 * np.sign(coeffs[0]) if coeffs[0] != 0 else 1.0
-        
-    poly_func = np.poly1d(coeffs)
-    
-    print("Polynomial:")
-    print(poly_func)
-    
-    # Solve for roots using companion matrix
-    comp_matrix = companion(coeffs)
-    
-    print("\nCompanion Matrix:")
-    print(np.round(comp_matrix, 2))
-    
-    roots = np.linalg.eigvals(comp_matrix)
-    
-    print("\nRoots from eigenvalues of companion matrix:")
-    print(np.round(roots, 2))
-    
-    # Determine plot range based on roots
-    max_abs_root = max(abs(roots)) if len(roots) > 0 else 1.0
-    plot_limit = max_abs_root * 1.5
-    
-    # --- Real-space plot ---
-    x_real = np.linspace(-plot_limit, plot_limit, 400)
-    y_real = poly_func(x_real)
-    
-    fig_real = go.Figure()
-    fig_real.add_trace(go.Scatter(x=x_real, y=y_real, mode='lines', name='f(x)'))
-    fig_real.add_hline(y=0, line_dash='dash', line_color='black', annotation_text='x-axis')
-    
-    # Find real roots (imaginary part near 0)
-    real_roots = [r.real for r in roots if abs(r.imag) < 1e-6]
-    if real_roots:
-        fig_real.add_trace(go.Scatter(x=real_roots, y=[0]*len(real_roots), mode='markers', marker=dict(color='red', size=10), name='Real Roots'))
-        
-    fig_real.update_layout(title=f"Real Space Plot: Roots of Order {n} Polynomial", xaxis_title='x', yaxis_title='f(x)')
-    fig_real.show()
-    
-    # Plot using complex_plot_with_shadow
-    title = f"Complex Space Plot: Roots of Order {n} Polynomial"
-    complex_plot_with_shadow(poly_func, title=title, roots=roots, plot_range=(-plot_limit, plot_limit))
-