executable-engineering 0.1.29__py3-none-any.whl

executable_engineering/neuralnet_module.py

@@ -0,0 +1,285 @@
+# Neural network model UI and plotting
+import ipywidgets as widgets
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+import plotly.graph_objs as go
+
+def init_weights():
+    global W1, b1, W2, b2
+    W1 = np.random.randn(4,1) * 0.5
+    b1 = np.random.randn(4,1) * 0.5
+    W2 = np.random.randn(1,4) * 0.5
+    b2 = np.random.randn(1,1) * 0.5
+
+def tanh(x): return np.tanh(x)
+def tanh_derivative(x): return 1 - np.tanh(x)**2
+
+np.random.seed(42)
+
+init_weights()
+loss_history = []
+
+depth = 1
+width = 3
+activation = np.tanh
+activation_derivative = lambda x: 1 - np.tanh(x) ** 2
+
+X = np.linspace(0, 3, 50).reshape(-1, 1)
+X2 = np.linspace(0, 3.5, 50).reshape(-1, 1)
+true_function = None
+losses = []
+weights, biases = [], []
+weight_history, bias_history = [], []
+
+def forward(X):
+    Z1 = W1 @ X + b1
+    A1 = tanh(Z1)
+    Z2 = W2 @ A1 + b2
+    A2 = Z2
+    return Z1, A1, Z2, A2
+
+def compute_loss(A2, y): return np.mean((A2 - y)**2)
+
+def backward(X, y, Z1, A1, A2, lr=0.1):
+    global W1, b1, W2, b2
+    m = X.shape[1]
+    dZ2 = (A2 - y) / m
+    dW2 = dZ2 @ A1.T
+    db2 = np.sum(dZ2, axis=1, keepdims=True)
+    dA1 = W2.T @ dZ2
+    dZ1 = dA1 * tanh_derivative(Z1)
+    dW1 = dZ1 @ X.T
+    db1 = np.sum(dZ1, axis=1, keepdims=True)
+    W2 -= lr * dW2
+    b2 -= lr * db2
+    W1 -= lr * dW1
+    b1 -= lr * db1
+
+
+def plot_nn_diagram():
+    layer_x = [0, 2, 4]
+    y_positions = [[0], [-3, -1, 1, 3], [0]]
+    annotations = []
+    shapes = []
+    layer_titles = ['x', 'Hidden Layer', 'f(x)']
+
+    for l, ys in enumerate(y_positions):
+        for i, y in enumerate(ys):
+            shapes.append(dict(type="circle", xref="x", yref="y",
+                x0=layer_x[l]-0.2, x1=layer_x[l]+0.2,
+                y0=y-0.2, y1=y+0.2, line_color="black"))
+            label = 'x' if l==0 else ('y' if l==2 else f'h{i+1}')
+            annotations.append(dict(x=layer_x[l], y=y, text=label,
+                showarrow=False, font=dict(size=12)))
+            if l == 1:
+                bias = b1[i, 0]
+                annotations.append(dict(x=layer_x[l]+0.3, y=y, text=f"b={bias:.2f}",
+                    showarrow=False, font=dict(size=10, color='gray')))
+            elif l == 2:
+                annotations.append(dict(x=layer_x[l]+0.3, y=y, text=f"b={b2[0,0]:.2f}",
+                    showarrow=False, font=dict(size=10, color='gray')))
+
+    for i, y_in in enumerate(y_positions[0]):
+        for j, y_hid in enumerate(y_positions[1]):
+            weight = W1[j, i]
+            shapes.append(dict(type='line', xref='x', yref='y',
+                x0=layer_x[0]+0.2, y0=y_in, x1=layer_x[1]-0.2, y1=y_hid,
+                line=dict(color='blue')))
+            annotations.append(dict(x=1, y=(y_in + y_hid)/2, text=f"{weight:.2f}",
+                showarrow=False, font=dict(size=9, color='blue')))
+
+    for j, y_hid in enumerate(y_positions[1]):
+        for k, y_out in enumerate(y_positions[2]):
+            weight = W2[k, j]
+            shapes.append(dict(type='line', xref='x', yref='y',
+                x0=layer_x[1]+0.2, y0=y_hid, x1=layer_x[2]-0.2, y1=y_out,
+                line=dict(color='red')))
+            annotations.append(dict(x=3, y=(y_hid + y_out)/2, text=f"{weight:.2f}",
+                showarrow=False, font=dict(size=9, color='red')))
+
+    for i, x in enumerate(layer_x):
+        annotations.append(dict(x=x, y=max(y_positions[1])+1.5,
+            text=layer_titles[i], showarrow=False, font=dict(size=14)))
+
+    fig = go.Figure()
+    fig.update_layout(shapes=shapes, annotations=annotations,
+                      xaxis=dict(visible=False), yaxis=dict(visible=False),
+                      title='Neural Network Structure', height=500, width=700,
+                      margin=dict(l=20, r=20, t=40, b=20))
+    fig.show()
+
+
+
+def init_model():
+    global weights, biases, weight_history, bias_history
+    layers = [1] + [width]*depth + [1]
+    weights = [np.random.randn(layers[i], layers[i+1]) * np.sqrt(2 / layers[i]) for i in range(len(layers)-1)]
+    biases = [np.zeros((1, layers[i+1])) for i in range(len(layers)-1)]
+    weight_history = [[] for _ in weights]
+    bias_history = [[] for _ in biases]
+
+def forward_pass(x):
+    activations = [x]
+    zs = []
+    a = x
+    for w, b in zip(weights[:-1], biases[:-1]):
+        z = a @ w + b
+        zs.append(z)
+        a = activation(z)
+        activations.append(a)
+    z = a @ weights[-1] + biases[-1]
+    zs.append(z)
+    activations.append(z)  # no activation on final output
+    return zs, activations
+
+def backward_pass(zs, activations, y_true, lr=0.01):
+    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)
+    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_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())
+
+    return np.mean((activations[-1] - y_true)**2)
+
+def step(n,output_plot, metrics_plot, network_plot):
+    global losses
+    if true_function is None: return
+    y_true = true_function(X)
+    for _ in range(n):
+        zs, activations = forward_pass(X)
+        loss = backward_pass(zs, activations, y_true)
+        losses.append(loss)
+    update_plots(output_plot, metrics_plot, network_plot)
+
+def reset_model(output_plot, metrics_plot, network_plot, status_label):
+    init_model()
+    losses.clear()
+    status_label.value = "Model reset."
+    update_plots(output_plot, metrics_plot, network_plot)
+
+def save_function(function_input, output_plot, metrics_plot, network_plot, status_label):
+    global true_function, losses
+    try:
+        code = function_input.value
+        true_function = lambda x: eval(code, {"x": x, "np": np, "sin": np.sin, "cos": np.cos, "exp": np.exp, "pi": np.pi})
+        losses.clear()
+        status_label.value = "Function saved."
+        update_plots(output_plot, metrics_plot, network_plot)
+    except Exception as e:
+        status_label.value = f"Error: {e}"
+
+def change_depth(d, output_plot, metrics_plot, network_plot, status_label):
+    global depth
+    depth = max(0, depth + d)
+    reset_model(output_plot, metrics_plot, network_plot, status_label)
+
+def change_width(d, output_plot, metrics_plot, network_plot, status_label):
+    global width
+    width = max(1, width + d)
+    reset_model(output_plot, metrics_plot, network_plot, status_label)
+
+
+def draw_network(activations):
+    import matplotlib.cm as cm
+    import matplotlib.colors as mcolors
+
+    G = nx.DiGraph()
+    labels = {}
+    pos = {}
+    edge_labels = {}
+    edge_colors = {}
+    layer_sizes = [1] + [width] * depth + [1]
+
+    max_layer_size = max(layer_sizes)
+
+    for l, size in enumerate(layer_sizes):
+        layer_offset = (max_layer_size - size) / 2
+        for n in range(size):
+            node = f"L{l}N{n}"
+            pos[node] = (l, -(n + layer_offset))
+            G.add_node(node)
+
+            # Label nodes
+            if l == 0:
+                labels[node] = "x"
+            elif l == len(layer_sizes) - 1:
+                labels[node] = "f(x)"
+            else:
+                try:
+                    act_val = activations[l][0, n]
+                    bias_val = biases[l - 1][0, n]
+                    labels[node] = f"{act_val:.2f}\nb={bias_val:.2f}"
+                except Exception:
+                    labels[node] = f"H{l-1}N{n}"
+
+            # Add edges
+            if l > 0:
+                for p in range(layer_sizes[l - 1]):
+                    prev_node = f"L{l-1}N{p}"
+                    G.add_edge(prev_node, node)
+                    w_val = weights[l - 1][p, n]
+                    edge_labels[(prev_node, node)] = f"{w_val:.2f}"
+                    norm_val = np.tanh(w_val)  # normalized for color
+                    edge_colors[(prev_node, node)] = plt.cm.bwr((norm_val + 1) / 2)
+
+    return G, pos, labels, edge_labels, edge_colors
+
+
+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)
+    with output_plot:
+        if true_function:
+            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.legend()
+            plt.title("Function vs NN Output")
+            plt.grid(True)
+            plt.show()
+
+    with metrics_plot:
+        if losses:
+            plt.figure(figsize=(6, 3))
+            plt.plot(losses, label="Loss", color='red')
+            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)
+            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)
+            plt.title("Loss and Parameter Changes")
+
+            plt.grid(True)
+            plt.legend()
+            plt.show()
+    with network_plot:
+        if true_function:
+            _, activations = forward_pass(X)
+            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)
+            nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=8)
+            plt.title("Neural Network Diagram")
+            plt.show()

executable_engineering/openoptimization_module.py

@@ -0,0 +1,231 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+from IPython.display import HTML, display
+import ipywidgets as widgets
+from scipy.optimize import minimize
+
+class OptimizerOpen:
+
+    def __init__(self, f, x0, tol=1e-6, max_iter=300):
+        self.f = f
+        self.x0 = np.asarray(x0, dtype=float)
+        self.tol = tol
+        self.max_iter = max_iter
+
+
+        self.powell_steps = self._run_optimization('Powell')
+        self.nm_data = self._run_nelder_mead()
+        (self.nelder_mead_steps,
+         self.nelder_mead_labels,
+         self.nelder_mead_simplices,
+         self.rejected_points) = self.nm_data
+
+        self._define_plot_domain()
+
+    def _run_optimization(self, method):
+        steps = []
+        def callback(xk):
+            steps.append(xk.copy())
+        res = minimize(self.f, self.x0, method=method, callback=callback,
+                       options={'maxiter': self.max_iter})
+        if not steps or not np.allclose(steps[0], self.x0):
+            steps.insert(0, self.x0.copy())
+        return [tuple(s) for s in steps]
+
+    def _run_nelder_mead(self):
+        α, γ, ρ, σ = 1.0, 2.0, 0.5, 0.5
+        x0 = self.x0
+        n = len(x0)
+        simplex = [x0]
+        for i in range(n):
+            e = np.zeros(n)
+            e[i] = 0.05 if x0[i] == 0 else 0.05 * x0[i]
+            simplex.append(x0 + e)
+        simplex = np.array(simplex)
+        fvals = np.array([self.f(v) for v in simplex])
+
+        steps = [x0.copy()]
+        labels = ["Initial simplex"]
+        simplices = [simplex.copy()]
+        rejected_points = [None]
+
+        for _ in range(self.max_iter):
+            order = np.argsort(fvals)
+            simplex, fvals = simplex[order], fvals[order]
+            centroid = np.mean(simplex[:-1], axis=0)
+
+            xr = centroid + α * (centroid - simplex[-1])
+            fr = self.f(xr)
+
+            label = None
+            rejected_point = None
+
+            if fvals[0] <= fr < fvals[-2]:
+                simplex[-1], fvals[-1] = xr, fr
+                label = "Reflection accepted"
+            elif fr < fvals[0]:
+                xe = centroid + γ * (xr - centroid)
+                fe = self.f(xe)
+                if fe < fr:
+                    simplex[-1], fvals[-1] = xe, fe
+                    label = "Reflection accepted → Expansion accepted"
+                    rejected_point = xr
+                else:
+                    simplex[-1], fvals[-1] = xr, fr
+                    label = "Expansion rejected → Reflection accepted"
+                    rejected_point = xe
+            else:
+                xc = centroid + ρ * (simplex[-1] - centroid)
+                fc = self.f(xc)
+                if fc < fvals[-1]:
+                    simplex[-1], fvals[-1] = xc, fc
+                    label = "Reflection rejected → Contraction accepted"
+                    rejected_point = xr
+                else:
+                    rejected_point = xc
+                    best = simplex[0]
+                    for j in range(1, len(simplex)):
+                        simplex[j] = best + σ * (simplex[j] - best)
+                        fvals[j] = self.f(simplex[j])
+                    label = "Contraction rejected → Shrinkage accepted"
+
+            steps.append(centroid.copy())
+            labels.append(label)
+            simplices.append(simplex.copy())
+            rejected_points.append(rejected_point.copy() if rejected_point is not None else None)
+
+            if np.std(fvals) < self.tol:
+                break
+
+        return (
+            [tuple(s) for s in steps],
+            labels,
+            simplices,
+            rejected_points
+        )
+
+    def _define_plot_domain(self):
+        all_points = np.array(self.powell_steps + self.nelder_mead_steps)
+        x_min, y_min = np.min(all_points, axis=0)
+        x_max, y_max = np.max(all_points, axis=0)
+        dx, dy = (x_max - x_min) * 0.3, (y_max - y_min) * 0.3
+        x_min, x_max = x_min - dx, x_max + dx
+        y_min, y_max = y_min - dy, y_max + dy
+        self.x = np.linspace(x_min, x_max, 150)
+        self.y = np.linspace(y_min, y_max, 150)
+        self.X, self.Y = np.meshgrid(self.x, self.y)
+        self.Z = np.array([[self.f([xi, yi]) for xi in self.x] for yi in self.y])
+
+    def _get_color_for_rejection(self, label):
+        if "Reflection rejected" in label:
+            return "blue"
+        elif "Expansion rejected" in label:
+            return "green"
+        elif "Contraction rejected" in label:
+            return "orange"
+        elif "Shrinkage accepted" in label:
+            return "purple"
+        return None
+
+    def _animate_optimization(self, steps, method_name, interval_ms=500,
+                             labels=None, simplices=None, rejected_points=None, show_vectors=False):
+        if not steps:
+            return None
+        fig, ax = plt.subplots(figsize=(8,8))
+        contour = ax.contourf(self.X, self.Y, self.Z, levels=50, cmap='viridis')
+        ax.contour(self.X, self.Y, self.Z, levels=15, colors='k', alpha=0.3, linewidths=0.5)
+        cbar = fig.colorbar(contour, ax=ax)
+        cbar.set_label("f(x, y)", rotation=270, labelpad=15)
+
+        ax.plot(self.x0[0], self.x0[1], 'r*', markersize=10, label='Initial Guess')
+
+
+        path_line, = ax.plot([], [], 'r-', lw=1.5, alpha=0.7)
+        current_dot, = ax.plot([], [], 'ro', markersize=6, label='Current Point')
+
+        ax.set_xlim(self.x[0], self.x[-1])
+        ax.set_ylim(self.y[0], self.y[-1])
+
+        title_text = ax.text(0.5, 1.03, '', transform=ax.transAxes,
+
+                             ha='center', fontsize=12)
+
+        indicator_box = ax.annotate(
+            '',
+            xy=(0.02, 0.98),
+            xycoords='axes fraction',
+            textcoords='axes fraction',
+            ha='left',
+            va='top',
+            fontsize=10,
+            bbox=dict(boxstyle="round,pad=0.5", fc="white", alpha=0.8, ec="black")
+        )
+
+        ax.legend(loc='lower left')
+        simplex_lines, rejected_markers = [], []
+        quivers = []
+
+        def update(i):
+            for ln in simplex_lines:
+                ln.remove()
+            for m in rejected_markers:
+                m.remove()
+            simplex_lines.clear()
+            rejected_markers.clear()
+
+            px, py = [s[0] for s in steps[:i+1]], [s[1] for s in steps[:i+1]]
+            path_line.set_data(px, py)
+            cx, cy = steps[i]
+            current_dot.set_data([cx], [cy])
+
+            if simplices is not None and i < len(simplices):
+                tri = simplices[i]
+                tri_closed = np.vstack([tri, tri[0]])
+                ln, = ax.plot(tri_closed[:,0], tri_closed[:,1], 'w-', lw=2, alpha=0.9)
+                simplex_lines.append(ln)
+
+
+            for q in quivers:
+                q.remove()
+            quivers.clear()
+
+            if show_vectors and i > 0:
+                x_prev, y_prev = steps[i-1]
+                dx, dy = current_x - x_prev, current_y - y_prev
+                q = ax.quiver(x_prev, y_prev, dx, dy, angles='xy', scale_units='xy',
+                              scale=1, color='red', width=0.005)
+                quivers.append(q)
+
+            label_text = labels[i] if labels and i < len(labels) else ""
+            title_text.set_text(
+                f"{method_name} Step {i+1}/{len(steps)}\n"
+                f"({cx:.4f}, {cy:.4f})  f={self.f([cx, cy]):.4f}"
+            )
+            if method_name == "Nelder–Mead":
+                indicator_box.set_text(
+                    f"Action: {label_text}\n"
+                )
+
+            return path_line, current_dot, title_text, indicator_box, *simplex_lines, *rejected_markers
+
+        anim = FuncAnimation(fig, update, frames=len(steps),
+                             interval=interval_ms, blit=True, repeat=False)
+        plt.close(fig)
+        return HTML(anim.to_jshtml())
+
+    def show_toggle_open(self, interval_ms=500):
+        powell_anim = self._animate_optimization(
+            self.powell_steps, "Powell's Method", interval_ms, show_vectors=True)
+        nm_anim = self._animate_optimization(
+            self.nelder_mead_steps, "Nelder–Mead", interval_ms,
+            labels=self.nelder_mead_labels,
+            simplices=self.nelder_mead_simplices,
+            rejected_points=self.rejected_points)
+        powell_tab = widgets.HTML(value=powell_anim.data)
+        nm_tab = widgets.HTML(value=nm_anim.data)
+        tab = widgets.Tab()
+        tab.children = [powell_tab, nm_tab]
+        tab.set_title(0, "Powell's Method")
+        tab.set_title(1, "Nelder–Mead Method")
+        display(tab)

executable_engineering/openrootfinder_module.py

@@ -0,0 +1,157 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+from IPython.display import HTML, display
+import ipywidgets as widgets
+
+class RootFinderOpen:
+    def __init__(self, f, fprime=None, x0=None, x1=None, tol=1e-6, max_iter=20):
+        self.f = f
+        self.fprime = fprime
+        self.x0 = x0
+        self.x1 = x1
+        self.tol = tol
+        self.max_iter = max_iter
+        self.newton_guesses = self._run_newton()
+        self.secant_guesses = self._run_secant()
+
+    def _run_newton(self):
+        if self.fprime is None or self.x0 is None:
+            return []
+        x = self.x0
+        guesses = [x]
+        for _ in range(self.max_iter):
+            fx, fpx = self.f(x), self.fprime(x)
+            if abs(fpx) < 1e-10:
+                break
+            x_new = x - fx / fpx
+            guesses.append(x_new)
+            if abs(x_new - x) < self.tol:
+                break
+            x = x_new
+        return guesses
+
+    def _run_secant(self):
+        if self.x0 is None or self.x1 is None:
+            return []
+        x0, x1 = self.x0, self.x1
+        guesses = [x0, x1]
+        for _ in range(self.max_iter):
+            f0, f1 = self.f(x0), self.f(x1)
+            if abs(f1 - f0) < 1e-10:
+                break
+            x2 = x1 - f1 * (x1 - x0) / (f1 - f0)
+            guesses.append(x2)
+            if abs(x2 - x1) < self.tol:
+                break
+            x0, x1 = x1, x2
+        return guesses
+
+    def _make_animation_open(self, method='Newton', interval_ms=750):
+        if method == 'Newton':
+            guesses = self.newton_guesses
+            title_method = "Newton's Method"
+            line_label = "Tangent Line"
+        else:
+            guesses = self.secant_guesses
+            title_method = "Secant Method"
+            line_label = "Secant Line"
+
+        if not guesses or len(guesses) < 2:
+            return None
+
+        total_steps = len(guesses)
+        min_g, max_g = min(guesses), max(guesses)
+
+        x_span = max_g - min_g if max_g > min_g else 1.0
+        x_pad = max(0.2 * x_span, 1.0)
+        x_min, x_max = min_g - x_pad, max_g + x_pad
+
+        x_vals = np.linspace(x_min, x_max, 400)
+        y_vals = self.f(x_vals)
+
+        fig, ax = plt.subplots(figsize=(10, 6))
+        ax.plot(x_vals, y_vals, label='f(x)', color='blue')
+        ax.axhline(0, color='gray', linestyle='--', alpha=0.7)
+
+        line, = ax.plot([], [], marker='o', linestyle='-', color='red', markersize=8, label='Iterations')
+        aux_line, = ax.plot([], [], color='green', linestyle='--', label=line_label)
+        current_point, = ax.plot([], [], marker='o', color='gold', markersize=10, markeredgecolor='red', label='Current $x_k$')
+        vertical_line, = ax.plot([], [], color='purple', linestyle=':', linewidth=2, label='Next guess connector')
+
+        ax.set_title(f"{title_method} Animation", fontsize=14)
+        ax.set_xlabel("x", fontsize=12)
+        ax.set_ylabel("f(x)", fontsize=12)
+        ax.grid(True, linestyle=':', alpha=0.6)
+        ax.legend()
+        ax.set_xlim(x_min, x_max)
+
+        f_g = [self.f(g) for g in guesses]
+        y_min, y_max = min(f_g), max(f_g)
+
+        y_span = y_max - y_min if y_max > y_min else 1.0
+        y_pad = max(0.2 * y_span, 1.0)
+        ax.set_ylim(y_min - y_pad, y_max + y_pad)
+
+        def update_open(frame):
+            step = frame
+            shown_guesses = guesses[:step+1]
+            f_guesses = [self.f(g) for g in shown_guesses]
+
+            line.set_data(shown_guesses, f_guesses)
+            current_point.set_data([shown_guesses[-1]], [f_guesses[-1]])
+            aux_line.set_data([], [])
+            vertical_line.set_data([], [])
+            ax.set_title(f"{title_method} - Step {step}/{total_steps-1}", fontsize=14)
+
+            if step > 0:
+                x_k_prev = shown_guesses[step - 1]
+                f_k_prev = self.f(x_k_prev)
+
+                if method == 'Newton':
+                    m = self.fprime(x_k_prev)
+                elif method == 'Secant' and step > 1:
+                    x_k_minus_2 = shown_guesses[step - 2]
+                    f_k_minus_2 = self.f(x_k_minus_2)
+                    m = (f_k_prev - f_k_minus_2) / (x_k_prev - x_k_minus_2) if abs(x_k_prev - x_k_minus_2) > 1e-10 else None
+                else:
+                    m = None
+
+                if m is not None:
+                    x_line = np.linspace(x_min, x_max, 400)
+                    y_line = f_k_prev + m * (x_line - x_k_prev)
+                    aux_line.set_data(x_line, y_line)
+                    if abs(m) > 1e-12:
+                        x_intersect = x_k_prev - f_k_prev / m
+                        vertical_line.set_data([x_intersect, x_intersect], [0, self.f(shown_guesses[step])])
+
+            return line, current_point, aux_line, vertical_line
+
+        anim = FuncAnimation(
+            fig, update_open,
+            frames=total_steps,
+            interval=interval_ms,
+            blit=True,
+            repeat=False
+        )
+        plt.close(fig)
+        return HTML(anim.to_jshtml())
+
+    def show_toggle_open(self, interval_ms=750):
+        newton_anim_html = self._make_animation_open('Newton', interval_ms)
+        secant_anim_html = self._make_animation_open('Secant', interval_ms)
+
+        if newton_anim_html is None or secant_anim_html is None:
+            print("Cannot create animations. Check function definition or initial points (x0, x1).")
+            return
+
+        newton_content = widgets.HTML(value=newton_anim_html.data)
+        secant_content = widgets.HTML(value=secant_anim_html.data)
+
+        tab_container = widgets.Tab()
+        tab_container.children = [newton_content, secant_content]
+
+        tab_container.set_title(0, 'Newton')
+        tab_container.set_title(1, 'Secant')
+
+        display(tab_container)