executable-engineering 0.1.39__py3-none-any.whl → 0.1.41__py3-none-any.whl

executable_engineering/__init__.py

@@ -6,8 +6,13 @@ from .openoptimization_module import OptimizerOpen
 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
 
 __all__ = [
+  "plot_polynomial_roots_companion",
+  "plot_and_find_roots",
+  "complex_plot_with_shadow",
+  "weierstrass",
   "discretise_poisson",
   "spai",
   "visual_solve_2d",

executable_engineering/closedrootfinder_module.py

@@ -134,22 +134,30 @@ class RootFinderClosed:
         )
         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)
+            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
+    
+            # Create Output widgets to capture rich HTML and script execution
+            bisect_out = widgets.Output()
+            falsepos_out = widgets.Output()
+    
+            with bisect_out:
+                display(bisect_anim_html)
+    
+            with falsepos_out:
+                display(falsepos_anim_html)
+    
+            # Assign Output widgets as the tab children
+            tab_container = widgets.Tab()
+            tab_container.children = [bisect_out, falsepos_out]
+    
+            tab_container.set_title(0, 'Bisection')
+            tab_container.set_title(1, 'False Position')
+    
+            display(tab_container)

executable_engineering/functions_module.py

@@ -0,0 +1,151 @@
+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))
+

{executable_engineering-0.1.39.dist-info → executable_engineering-0.1.41.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: executable_engineering
-Version: 0.1.39
+Version: 0.1.41
 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.39.dist-info → executable_engineering-0.1.41.dist-info}/RECORD

@@ -1,14 +1,15 @@
-executable_engineering/__init__.py,sha256=TbE18BDMSDAqyHnJI0XQXMIcM6bXQv8ebV3rWijyVP0,1656
+executable_engineering/__init__.py,sha256=-Pcd1x1O6zkA2ro9iz6RLgeq68yNQyV4aPBhNjQSKx4,1887
 executable_engineering/closedoptimization_module.py,sha256=i9KkdulyCZmriYKlx0CuUetjoMmxJm9ADWgStU3w85w,9273
-executable_engineering/closedrootfinder_module.py,sha256=ozccVABOrTiqcdkkqwAWRNo04MsDC0Z_f_tfukl3q20,5706
+executable_engineering/closedrootfinder_module.py,sha256=hQ6iWNi16RkZTaE_WPUEwkohmrYrAyU8WWSXO2EPLJY,6000
+executable_engineering/functions_module.py,sha256=NsPFoVwd3h7zsyW3QFTGZxciKyLQP1vepvmwXP2GQ20,5164
 executable_engineering/gradientoptimization_module.py,sha256=-2fErE9cemSEPeV9PlWOf4cF7Tr6DjilEw_NxvE-JYw,6601
 executable_engineering/linearsystems_module.py,sha256=w6UkwZu80gUz5bAIWY47xJbwaEVzR9tCcIBkMsKjIRk,18356
 executable_engineering/neuralnet_module.py,sha256=Hu9QFoMyODg4RCEpHmT9zTwzjcVFYM8ZLYtbB3CbrsA,10102
 executable_engineering/numerical_error_module.py,sha256=wxfYP8u29c19I2D6MxpQV3zDMV0DpS1QUqFpp3f6eGE,1204
 executable_engineering/openoptimization_module.py,sha256=OCPyrynkTo1It50RoT7irnL72aQn6FexE_R1SfFYxlg,8590
 executable_engineering/openrootfinder_module.py,sha256=R_lPtCQsIGLXV-j_uDpQepImOOgtgA7I6qnhUPwWLLc,5944
-executable_engineering-0.1.39.dist-info/licenses/LICENSE,sha256=Tg4nrt8rFhgpkPbIA8SWoCR3MlGLw0NufB8AE6-TH_o,1074
-executable_engineering-0.1.39.dist-info/METADATA,sha256=D3CtWo1BiOOo9yR8WeFNw-LBi94rd9flj-M2BxTqKC0,1648
-executable_engineering-0.1.39.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-executable_engineering-0.1.39.dist-info/top_level.txt,sha256=0U5ATV5WGTLvN9rRSjQ54TyL-ztTyXaN3FzZ_QMq4HM,23
-executable_engineering-0.1.39.dist-info/RECORD,,
+executable_engineering-0.1.41.dist-info/licenses/LICENSE,sha256=Tg4nrt8rFhgpkPbIA8SWoCR3MlGLw0NufB8AE6-TH_o,1074
+executable_engineering-0.1.41.dist-info/METADATA,sha256=ayq_EWUXT-C5IuQrx1ys-RVtBFoOk6oN5WpCdazWAwE,1648
+executable_engineering-0.1.41.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+executable_engineering-0.1.41.dist-info/top_level.txt,sha256=0U5ATV5WGTLvN9rRSjQ54TyL-ztTyXaN3FzZ_QMq4HM,23
+executable_engineering-0.1.41.dist-info/RECORD,,