executable-engineering 0.1.29__py3-none-any.whl

executable_engineering/__init__.py

@@ -0,0 +1,32 @@
+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 .openrootfinder_module import RootFinderOpen
+from .closedrootfinder_module import RootFinderClosed
+from .closedoptimization_module import OptimizerClosed
+from .openoptimization_module import OptimizerOpen
+from .gradientoptimization_module import OptimizerGrad
+
+
+__all__ = [
+  "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",
+  "RootFinderOpen",
+  "RootFinderClosed",
+  "OptimizerClosed",
+  "OptimizerOpen",
+  "OptimizerGrad",
+]

executable_engineering/closedoptimization_module.py

@@ -0,0 +1,282 @@
+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 OptimizerClosed:
+    def __init__(self, f, a=None, b=None, tol=1e-6, max_iter=30):
+        self.f = f
+        self.a = a
+        self.b = b
+        self.tol = tol
+        self.max_iter = max_iter
+        self.gold_steps = self._run_golden_section()
+        self.brent_steps = self._run_brent()
+
+    def _run_golden_section(self):
+        if self.a is None or self.b is None:
+            return []
+
+        a, b = self.a, self.b
+        gr = (np.sqrt(5) - 1) / 2
+        c = b - gr * (b - a)
+        d = a + gr * (b - a)
+        steps = []
+
+        for _ in range(self.max_iter):
+            steps.append((a, b, c, d))
+
+            if abs(b - a) < self.tol:
+                break
+
+            if self.f(c) < self.f(d):
+                b = d
+                d = c
+                c = b - gr * (b - a)
+            else:
+                a = c
+                c = d
+                d = a + gr * (b - a)
+        return steps
+
+
+    def _run_brent(self):
+
+        if self.a is None or self.b is None:
+            return []
+
+        a, b = self.a, self.b
+        C = (3.0 - np.sqrt(5.0)) / 2.0
+
+        x = w = v = a + C * (b - a)
+        fx = fw = fv = self.f(x)
+
+        d = e = b - a
+        steps = []
+
+        for iteration in range(self.max_iter):
+            m = 0.5 * (a + b)
+            tol1 = self.tol * abs(x) + 1e-12
+            tol2 = 2.0 * tol1
+
+            if abs(x - m) <= tol2 - 0.5 * (b - a):
+                break
+
+            parabolic_accepted = False
+            method = "golden"
+            g = e
+
+            if abs(g) > tol1:
+                r = (x - w) * (fx - fv)
+                q = (x - v) * (fx - fw)
+                p = (x - v) * q - (x - w) * r
+                q = 2.0 * (q - r)
+
+                if q != 0:
+                    if q > 0:
+                        p = -p
+                    q = abs(q)
+
+                    p_over_q = p / q
+                    u_candidate = x + p_over_q
+
+                    cond1 = (a + tol2) <= u_candidate <= (b - tol2)
+                    cond2 = abs(p_over_q) < abs(0.5 * g)
+
+                    if cond1 and cond2:
+                        u = u_candidate
+                        method = "parabolic"
+                        parabolic_accepted = True
+
+            if not parabolic_accepted:
+                if x < m:
+                    e = b - x
+                else:
+                    e = a - x
+                d = C * e
+                u = x + d
+                method = "golden"
+
+            if abs(u - x) < tol1:
+                u = x + np.sign(u - x) * tol1
+
+            fu = self.f(u)
+
+            steps.append((a, b, x, w, v, u, method))
+
+            if fu <= fx:
+                if u >= x:
+                    a = x
+                else:
+                    b = x
+                v, fv = w, fw
+                w, fw = x, fx
+                x, fx = u, fu
+            else:
+                if u < x:
+                    a = u
+                else:
+                    b = u
+                if (fu <= fw) or (w == x):
+                    v, fv = w, fw
+                    w, fw = u, fu
+                elif (fu <= fv) or (v == x) or (v == w):
+                    v, fv = u, fu
+
+            e = d if parabolic_accepted else e
+
+        return steps
+
+
+    def _animate_golden(self, interval_ms=1000):
+        steps = self.gold_steps
+        if not steps:
+            return None
+
+        x_vals = np.linspace(self.a, self.b, 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.set_title("Golden Section Search", fontsize=14)
+        ax.set_xlabel("x")
+        ax.set_ylabel("f(x)")
+        ax.grid(True, linestyle=':')
+        ax.legend()
+
+        a_line = ax.axvline(0, color='red', linestyle=':', lw=1.5, label='x1')
+        b_line = ax.axvline(0, color='green', linestyle=':', lw=1.5, label='x2')
+
+        a_point, = ax.plot([], [], 'o', color='gold')
+        b_point, = ax.plot([], [], 'o', color='gold')
+        c_point, = ax.plot([], [], 'o', color='gold', label='x3')
+        d_point, = ax.plot([], [], 'o', color='orange', label='x4')
+        conn, = ax.plot([], [], '--', color='purple', alpha=0.5)
+
+        ax.legend()
+
+        def update(i):
+            a, b, c, d = steps[i]
+            y_a, y_b, y_c, y_d = self.f(a), self.f(b), self.f(c), self.f(d)
+
+            a_line.set_xdata([a])
+            b_line.set_xdata([b])
+
+            a_point.set_data([a], [y_a])
+            b_point.set_data([b], [y_b])
+            c_point.set_data([c], [y_c])
+            d_point.set_data([d], [y_d])
+            conn.set_data([a, c, d, b], [y_a, y_c, y_d, y_b])
+
+            ax.set_title(f"Golden Section Search - Step {i+1}\n"
+                         f"Interval: [{a:.4f}, {b:.4f}]")
+            return a_line, b_line, a_point, b_point, c_point, d_point, conn
+
+        anim = FuncAnimation(fig, update, frames=len(steps),
+                             interval=interval_ms, blit=True, repeat=False)
+        plt.close(fig)
+        return HTML(anim.to_jshtml())
+
+
+    def _animate_brent(self, interval_ms=1200):
+        steps = self.brent_steps
+        if not steps:
+            return None
+
+        x_vals = np.linspace(self.a, self.b, 800)
+        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.set_title("Brent's Method (parabolic interpolation + golden fallback)", fontsize=13)
+        ax.set_xlabel("x")
+        ax.set_ylabel("f(x)")
+        ax.grid(True, linestyle=':')
+
+        a_line = ax.axvline(0, color='red', linestyle=':', lw=1.5, label='a')
+        b_line = ax.axvline(0, color='green', linestyle=':', lw=1.5, label='b')
+        x_dot, = ax.plot([], [], 'ro', label='x (best)')
+        w_dot, = ax.plot([], [], 'go', label='w')
+        v_dot, = ax.plot([], [], 'bo', label='v')
+        u_dot, = ax.plot([], [], marker='*', markersize=10, color='gold', label='u (candidate)')
+        parabola_line, = ax.plot([], [], '--', color='purple', alpha=0.8, label='parabola (if stable)')
+
+        annotation_texts = []
+        ax.legend()
+
+        def good_for_parabola(xs):
+            xs = np.asarray(xs, dtype=float)
+            min_spacing = np.min(np.abs(np.diff(np.sort(xs))))
+            domain_width = abs(self.b - self.a) if self.b != self.a else 1.0
+            return (min_spacing > 1e-10 * domain_width)
+
+        def update(i):
+            for t in annotation_texts:
+                t.remove()
+            annotation_texts.clear()
+
+            a, b, x, w, v, u, method = steps[i]
+            fa, fb, fx, fw, fv, fu = self.f(a), self.f(b), self.f(x), self.f(w), self.f(v), self.f(u)
+
+            a_line.set_xdata([a])
+            b_line.set_xdata([b])
+
+            x_dot.set_data([x], [fx])
+            w_dot.set_data([w], [fw])
+            v_dot.set_data([v], [fv])
+            u_dot.set_data([u], [fu])
+
+            xs_to_fit = np.array([x, w, v])
+            min_spacing = np.min(np.abs(np.diff(np.sort(xs_to_fit))))
+            domain_width = abs(self.b - self.a) if self.b != self.a else 1.0
+
+            xs_parabola = np.linspace(min(x, w, v) - 0.05*domain_width, max(x, w, v) + 0.05*domain_width, 300)
+            draw_parabola = False
+            if min_spacing > 1e-10 * domain_width:
+                try:
+                    coeffs = np.polyfit([x, w, v], [fx, fw, fv], 2)
+                    parabola = np.polyval(coeffs, xs_parabola)
+                    if np.all(np.isfinite(parabola)):
+                        parabola_line.set_data(xs_parabola, parabola)
+                        draw_parabola = True
+                except Exception:
+                    draw_parabola = False
+
+            if not draw_parabola:
+                parabola_line.set_data([], [])
+
+            labels = [
+                (a, fa, 'a'),
+                (b, fb, 'b'),
+                (x, fx, 'x'),
+                (w, fw, 'w'),
+                (v, fv, 'v'),
+                (u, fu, f'u ({method[:3]})')
+            ]
+
+            ax.set_title(f"Brent's Method - Step {i+1}  (method: {method})\nInterval: [{a:.6f}, {b:.6f}]")
+            return (a_line, b_line, x_dot, w_dot, v_dot, u_dot, parabola_line, *annotation_texts)
+
+        anim = FuncAnimation(fig, update, frames=len(steps),
+                             interval=interval_ms, blit=False, repeat=False)
+        plt.close(fig)
+        return HTML(anim.to_jshtml())
+
+    def show_toggle_closed(self, interval_ms=1000):
+        gold_anim_html = self._animate_golden(interval_ms)
+        brent_anim_html = self._animate_brent(interval_ms)
+
+        if gold_anim_html is None or brent_anim_html is None:
+            print("Cannot create animations. Check initial interval [a, b].")
+            return
+
+        gold_content = widgets.HTML(value=gold_anim_html.data)
+        brent_content = widgets.HTML(value=brent_anim_html.data)
+
+        tab_container = widgets.Tab()
+        tab_container.children = [gold_content, brent_content]
+        tab_container.set_title(0, 'Golden Section Search')
+        tab_container.set_title(1, "Brent's Method")
+
+        display(tab_container)

executable_engineering/closedrootfinder_module.py

@@ -0,0 +1,155 @@
+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 RootFinderClosed:
+    def __init__(self, f, a=None, b=None, tol=1e-6, max_iter=20):
+        self.f = f
+        self.a = a
+        self.b = b
+        self.tol = tol
+        self.max_iter = max_iter
+        self.bisect_intervals, self.bisect_guesses = self._run_bisection()
+        self.falsepos_intervals, self.falsepos_guesses = self._run_false_position()
+
+    def _run_bisection(self):
+        if self.a is None or self.b is None:
+            return [], []
+        a, b = self.a, self.b
+        if self.f(a) * self.f(b) > 0:
+            return [], []
+
+        intervals = []
+        guesses = []
+        for _ in range(self.max_iter):
+            c = (a + b) / 2.0
+            intervals.append((a, b, c))
+            guesses.append(c)
+            if abs(self.f(c)) < self.tol or abs(b - a) < self.tol:
+                break
+            if self.f(a) * self.f(c) < 0:
+                b = c
+            else:
+                a = c
+        return intervals, guesses
+
+    def _run_false_position(self):
+        if self.a is None or self.b is None:
+            return [], []
+        a, b = self.a, self.b
+        if self.f(a) * self.f(b) > 0:
+            return [], []
+
+        intervals = []
+        guesses = []
+        for _ in range(self.max_iter):
+            fa, fb = self.f(a), self.f(b)
+            if abs(fb - fa) < 1e-12:
+                break
+            c = b - fb * (b - a) / (fb - fa)
+            intervals.append((a, b, c))
+            guesses.append(c)
+            if abs(self.f(c)) < self.tol:
+                break
+            if fa * self.f(c) < 0:
+                b = c
+                fb = self.f(b)
+            else:
+                a = c
+                fa = self.f(a)
+        return intervals, guesses
+
+    def _make_animation_closed(self, method='Bisection', interval_ms=750):
+        if method == 'Bisection':
+            intervals, guesses = self.bisect_intervals, self.bisect_guesses
+            title_method = "Bisection Method"
+            guess_label = "Midpoint"
+        else:
+            intervals, guesses = self.falsepos_intervals, self.falsepos_guesses
+            title_method = "False Position Method"
+            guess_label = "Point c"
+
+        if not guesses:
+            return None
+
+        total_steps = len(guesses)
+        all_points = [g for g in guesses] + [p for ab in intervals for p in ab[:2]]
+        min_g, max_g = min(all_points), max(all_points)
+
+        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=6, alpha=0.6, label='Previous guesses')
+        a_line = ax.axvline(0, color='red', linestyle=':', lw=1.5, alpha=0.9, label='a (left endpoint)')
+        b_line = ax.axvline(0, color='green', linestyle=':', lw=1.5, alpha=0.9, label='b (right endpoint)')
+        current_point, = ax.plot([], [], marker='o', color='gold', markersize=10, markeredgecolor='black', label=guess_label)
+        vertical_line, = ax.plot([], [], color='purple', linestyle=':', linewidth=2, label='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 + [0]), max(f_g + [0])
+        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_closed(frame):
+            step = frame
+            shown_intervals = intervals[:step+1]
+            shown_guesses = guesses[:step+1]
+            f_guesses = [self.f(g) for g in shown_guesses]
+
+            a, b, c = shown_intervals[-1]
+            a_line.set_xdata([a])
+            b_line.set_xdata([b])
+
+            line.set_data(shown_guesses[:-1], f_guesses[:-1])
+            current_point.set_data([c], [self.f(c)]) 
+            vertical_line.set_data([c, c], [0, self.f(c)])
+
+            ax.set_title(f"{title_method} - Step {step}/{total_steps-1}", fontsize=14)
+            return line, current_point, vertical_line, a_line, b_line
+
+        anim = FuncAnimation(
+            fig, update_closed,
+            frames=total_steps,
+            interval=interval_ms,
+            blit=True,
+            repeat=False
+        )
+        plt.close(fig)
+        return HTML(anim.to_jshtml())
+
+    def show_toggle_closed(self, interval_ms=750):
+        bisect_anim_html = self._make_animation_closed('Bisection', interval_ms)
+        falsepos_anim_html = self._make_animation_closed('False Position', interval_ms)
+
+        if bisect_anim_html is None or falsepos_anim_html is None:
+            print("Cannot create animations. Check initial interval [a, b].")
+            return
+
+        bisect_content = widgets.HTML(value=bisect_anim_html.data)
+        falsepos_content = widgets.HTML(value=falsepos_anim_html.data)
+
+        tab_container = widgets.Tab()
+        tab_container.children = [bisect_content, falsepos_content]
+
+        tab_container.set_title(0, 'Bisection')
+        tab_container.set_title(1, 'False Position')
+
+        display(tab_container)

executable_engineering/gradientoptimization_module.py

@@ -0,0 +1,169 @@
+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 OptimizerGrad:
+
+    def __init__(self, f, grad, hess, x0, lr=0.1, tol=1e-4, max_iter=200):
+        self.f = f
+        self.grad = grad
+        self.hess = hess
+        self.x0 = np.asarray(x0, dtype=float)
+        self.lr = lr
+        self.tol = tol
+        self.max_iter = max_iter
+
+        self.newton_steps = self._run_newton()
+        self.gd_steps = self._run_gradient_descent()
+
+        self._define_plot_domain()
+
+
+    def _run_gradient_descent(self):
+        x = self.x0.copy()
+        steps = [x.copy()]
+        for _ in range(self.max_iter):
+            g = self.grad(x)
+            x_new = x - self.lr * g
+            steps.append(x_new.copy())
+            if np.linalg.norm(g) < self.tol:
+                break
+            x = x_new
+        return [tuple(s) for s in steps]
+
+    def _run_newton(self):
+        x = self.x0.copy()
+        steps = [x.copy()]
+        for _ in range(self.max_iter):
+            g = self.grad(x)
+            H = self.hess(x)
+            try:
+                p = np.linalg.solve(H, g)
+            except np.linalg.LinAlgError:
+                break
+            x_new = x - p
+            steps.append(x_new.copy())
+            if np.linalg.norm(g) < self.tol:
+                break
+            x = x_new
+        return [tuple(s) for s in steps]
+
+
+    def _define_plot_domain(self):
+        all_points = np.array(self.newton_steps + self.gd_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 _animate_optimization(self, steps, method_name, interval_ms=500, show_vectors=False):
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))
+        fig.subplots_adjust(wspace=0.3)
+
+        contour = ax1.contourf(self.X, self.Y, self.Z, levels=50, cmap='viridis')
+        ax1.contour(self.X, self.Y, self.Z, levels=15, colors='k', alpha=0.3, linewidths=0.5)
+        ax1.plot(self.x0[0], self.x0[1], 'r*', markersize=10, label='Initial Guess')
+        path_line, = ax1.plot([], [], 'r-', lw=1.5, alpha=0.7)
+        current_dot, = ax1.plot([], [], 'ro', markersize=6, label='Current Point')
+        ax1.legend(loc='lower left')
+        cbar = fig.colorbar(contour, ax=ax1)
+        cbar.set_label("f(x, y)", rotation=270, labelpad=15)
+
+        title_text = ax1.text(0.5, 1.03, '', transform=ax1.transAxes,
+                              ha='center', fontsize=12)
+
+        indicator_box = ax1.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")
+        )
+
+        quivers = []
+
+        grad_vals = np.array([[self.grad([xi, yi]) for xi in self.x] for yi in self.y])
+        Gx, Gy = grad_vals[:, :, 0], grad_vals[:, :, 1]
+        grad_mag = np.sqrt(Gx**2 + Gy**2)
+
+        if "Gradient" in method_name:
+            Gx_u = np.divide(Gx, grad_mag, out=np.zeros_like(Gx), where=grad_mag != 0)
+            Gy_u = np.divide(Gy, grad_mag, out=np.zeros_like(Gy), where=grad_mag != 0)
+
+            skip = (slice(None, None, 6), slice(None, None, 6))
+            Q = ax2.quiver(
+                self.X[skip], self.Y[skip],
+                Gx_u[skip], Gy_u[skip],
+                grad_mag[skip], cmap='plasma',
+                angles='xy', scale_units='xy', scale=15, width=0.005
+            )
+            ax2.set_title("Gradient Vector Field ∇f(x, y)")
+            fig.colorbar(Q, ax=ax2, label="‖∇f(x, y)‖")
+        else:
+            grad_contour = ax2.contourf(self.X, self.Y, grad_mag, levels=40, cmap='plasma')
+            fig.colorbar(grad_contour, ax=ax2, label="‖∇f(x, y)‖")
+            ax2.set_title("Gradient Magnitude Field ‖∇f(x, y)‖")
+
+        ax2.set_xlabel("x")
+        ax2.set_ylabel("y")
+
+        def update(i):
+            current_path_x = [step[0] for step in steps[:i+1]]
+            current_path_y = [step[1] for step in steps[:i+1]]
+            path_line.set_data(current_path_x, current_path_y)
+
+            current_x, current_y = steps[i]
+            current_dot.set_data([current_x], [current_y])
+            f_val = self.f([current_x, current_y])
+
+            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
+                q1 = ax1.quiver(x_prev, y_prev, dx, dy, angles='xy', scale_units='xy',
+                                scale=1, color='red', width=0.005)
+                q2 = ax2.quiver(x_prev, y_prev, dx, dy, angles='xy', scale_units='xy',
+                                scale=1, color='black', width=0.005)
+                quivers.extend([q1, q2])
+
+            title_text.set_text(
+                f"{method_name} Step {i+1}/{len(steps)}\n"
+                f"({current_x:.4f}, {current_y:.4f})  f={f_val:.4f}"
+            )
+
+            grad_norm = np.linalg.norm(self.grad([current_x, current_y]))
+            indicator_box.set_text(f"‖∇f‖ = {grad_norm:.4e}")
+
+            return path_line, current_dot, title_text, indicator_box, *quivers
+
+        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):
+        gd_anim = self._animate_optimization(self.gd_steps, "Gradient Descent",
+                                             interval_ms, show_vectors=True)
+        newton_anim = self._animate_optimization(self.newton_steps, "Newton's Method",
+                                                 interval_ms, show_vectors=True)
+
+        gd_tab = widgets.HTML(value=gd_anim.data)
+        newton_tab = widgets.HTML(value=newton_anim.data)
+        tab = widgets.Tab()
+        tab.children = [gd_tab, newton_tab]
+        tab.set_title(0, "Gradient Descent")
+        tab.set_title(1, "Newton's Method")
+        display(tab)