executable-engineering 0.1.31__py3-none-any.whl → 0.1.33__py3-none-any.whl

executable_engineering/__init__.py

@@ -5,9 +5,11 @@ from .closedoptimization_module import OptimizerClosed
 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
 
 __all__ = [
+  "visual_solve_2d",
+  "visualize_conditioning",
   "init_weights",
   "tanh",
   "tanh_derivative",

executable_engineering/linearsystems_module.py

@@ -0,0 +1,169 @@
+import numpy as np
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import plotly.colors as pcolors
+
+def visual_solve_2d(A, b, method='exact'):
+    """
+    Solves and visualizes a 2D linear system Ax = b.
+    Plots the lines represented by the rows of A and b, and the solution point.
+    
+    Args:
+        A: (N, 2) array-like of coefficients.
+        b: (N,) array-like of constants.
+        method: 'exact' (uses np.linalg.solve) or 'pseudo' (uses np.linalg.pinv).
+    """
+    A = np.array(A, dtype=float)
+    b = np.array(b, dtype=float).flatten()
+    
+    if A.shape[1] != 2:
+        raise ValueError("visual_solve_2d only supports 2D systems (A must have 2 columns).")
+    
+    # 1. Solve the system based on chosen method
+    sol = None
+    plot_star = False
+    
+    if method == 'exact':
+        try:
+            if A.shape[0] == A.shape[1]:
+                sol = np.linalg.solve(A, b)
+                if np.allclose(A @ sol, b):
+                    plot_star = True
+                    sol_label = "Exact Solution"
+        except np.linalg.LinAlgError:
+            pass # No exact unique solution
+            
+    elif method == 'pseudo':
+        sol = np.linalg.pinv(A) @ b
+        plot_star = True
+        
+        if np.allclose(A @ sol, b):
+            sol_label = "Exact Solution (via Pseudoinverse)"
+        else:
+            sol_label = "Best Fit Solution"
+    else:
+        raise ValueError("method must be 'exact' or 'pseudo'")
+        
+    # 2. Determine plotting range
+    if sol is not None:
+        center_x = sol[0]
+        center_y = sol[1]
+    else:
+        # Fallback if no solution is found
+        center_x = 10
+        center_y = 10
+        
+    x_margin = 10
+    x_range = (center_x - x_margin, center_x + x_margin)
+    x_vals = np.linspace(x_range[0], x_range[1], 100)
+    
+    fig = go.Figure()
+    colors = pcolors.qualitative.Plotly
+    
+    # 3. Plot each line
+    for i in range(A.shape[0]):
+        a1, a2 = A[i]
+        bi = b[i]
+        line_name = f"Row {i+1}"
+        
+        if np.abs(a2) > 1e-10:
+            y_vals = (bi - a1 * x_vals) / a2
+            fig.add_trace(go.Scatter(x=x_vals, y=y_vals, mode='lines', name=line_name, line=dict(color=colors[i % len(colors)])))
+        else:
+            if np.abs(a1) > 1e-10:
+                x_val = bi / a1
+                fig.add_trace(go.Scatter(x=[x_val, x_val], y=[center_y - 100, center_y + 100], mode='lines', name=line_name, line=dict(color=colors[i % len(colors)])))
+                
+    # 4. Plot solution point if required
+    if plot_star and sol is not None:
+        hover_text = f"x={sol[0]:.4g}, y={sol[1]:.4g}"
+        fig.add_trace(go.Scatter(
+            x=[sol[0]], 
+            y=[sol[1]], 
+            mode='markers', 
+            marker=dict(color='black', size=12, symbol='star'),
+            name=sol_label,
+            hoverinfo='text',
+            hovertext=hover_text
+        ))
+    
+    # 5. Auto-adjust y-range nicely around the center
+    y_margin = (x_range[1] - x_range[0]) / 2.0
+    yaxis_dict = dict(range=[center_y - y_margin, center_y + y_margin], scaleanchor="x", scaleratio=1)
+        
+    fig.update_layout(
+        xaxis=dict(range=[x_range[0], x_range[1]]),
+        yaxis=yaxis_dict,
+        width=700,
+        height=500,
+        margin=dict(l=20, r=20, t=50, b=20)
+    )
+    
+    return fig
+
+
+def visualize_conditioning(A):
+    """
+    Visualizes the effect of the condition number by applying the matrix transformation
+    and its inverse to the unit circle.
+    
+    Args:
+        A: (2, 2) array-like matrix
+    """
+    A = np.array(A, dtype=float)
+    if A.shape != (2, 2):
+        raise ValueError("visualize_conditioning requires a 2x2 matrix.")
+        
+    # Create the unit circle
+    theta = np.linspace(0, 2*np.pi, 200)
+    circle = np.array([np.cos(theta), np.sin(theta)])
+    
+    # Apply transformation A to the unit circle
+    transformed_A = A @ circle
+    
+    # Check if invertible, if so, apply A^-1 to the unit circle
+    try:
+        A_inv = np.linalg.inv(A)
+        transformed_Ainv = A_inv @ circle
+        cond = np.linalg.cond(A)
+        subtitle = f"Condition Number: {cond:.2f}"
+    except np.linalg.LinAlgError:
+        transformed_Ainv = np.zeros_like(circle)
+        subtitle = "Matrix is singular (Condition Number: ∞)"
+        
+    fig = make_subplots(
+        rows=1, cols=2, 
+        subplot_titles=(f"Forward Transformation (A*x)", f"Inverse Transformation (A⁻¹*b)"),
+        horizontal_spacing=0.1
+    )
+    
+    # Subplot 1: Forward transformation
+    fig.add_trace(go.Scatter(x=circle[0], y=circle[1], mode='lines', name='Unit Circle', line=dict(color='gray', dash='dash')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=transformed_A[0], y=transformed_A[1], mode='lines', name='A * Circle', line=dict(color='blue')), row=1, col=1)
+    
+    # Subplot 2: Inverse transformation
+    fig.add_trace(go.Scatter(x=circle[0], y=circle[1], mode='lines', name='Unit Circle', line=dict(color='gray', dash='dash'), showlegend=False), row=1, col=2)
+    fig.add_trace(go.Scatter(x=transformed_Ainv[0], y=transformed_Ainv[1], mode='lines', name='A⁻¹ * Circle', line=dict(color='red')), row=1, col=2)
+    
+    # Update axes to be equal aspect ratio
+    max_A = np.max(np.abs(transformed_A)) * 1.1 if np.max(np.abs(transformed_A)) > 0 else 1
+    max_Ainv = np.max(np.abs(transformed_Ainv)) * 1.1 if np.max(np.abs(transformed_Ainv)) > 0 else 1
+    
+    # Ensure they are at least 1.1 so the unit circle is visible
+    max_A = max(max_A, 1.1)
+    max_Ainv = max(max_Ainv, 1.1)
+    
+    fig.update_xaxes(range=[-max_A, max_A], row=1, col=1)
+    fig.update_yaxes(range=[-max_A, max_A], scaleanchor="x", scaleratio=1, row=1, col=1)
+    
+    fig.update_xaxes(range=[-max_Ainv, max_Ainv], row=1, col=2)
+    fig.update_yaxes(range=[-max_Ainv, max_Ainv], scaleanchor="x2", scaleratio=1, row=1, col=2)
+    
+    fig.update_layout(
+        title=f"Visualizing Matrix Distortion ({subtitle})",
+        width=900,
+        height=500,
+        margin=dict(l=20, r=20, t=60, b=20)
+    )
+    
+    return fig

{executable_engineering-0.1.31.dist-info → executable_engineering-0.1.33.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: executable_engineering
-Version: 0.1.31
-Summary: Tools for ENGPHYS 3NM4
+Version: 0.1.33
+Summary: Demonstrative tools for the Executable Engineering textbook
 Home-page: https://github.com/themintlab/ExecutableEngineering/tree/main/executable_engineering
 Author: Michael Welland
 License: MIT

{executable_engineering-0.1.31.dist-info → executable_engineering-0.1.33.dist-info}/RECORD

@@ -1,13 +1,14 @@
-executable_engineering/__init__.py,sha256=sKydh1swA1LaNjxLVe9N7NG-uGNYhXHiHzcnf5uw5E8,1044
+executable_engineering/__init__.py,sha256=jrrsfub0C6cM1R9r7Gw97tW5CxX5kNEoYkvxlHzSJjU,1166
 executable_engineering/closedoptimization_module.py,sha256=i9KkdulyCZmriYKlx0CuUetjoMmxJm9ADWgStU3w85w,9273
 executable_engineering/closedrootfinder_module.py,sha256=ozccVABOrTiqcdkkqwAWRNo04MsDC0Z_f_tfukl3q20,5706
 executable_engineering/gradientoptimization_module.py,sha256=-2fErE9cemSEPeV9PlWOf4cF7Tr6DjilEw_NxvE-JYw,6601
+executable_engineering/linearsystems_module.py,sha256=JNKcHPUxOBJ4xoFYZyUFwbEOGGD_gi6zRQfcJKYBb5E,6080
 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=rmXDi0XdrDYdLZdPFgYCihMg_4NF1D71i6kh8Kx-V2w,5802
-executable_engineering-0.1.31.dist-info/licenses/LICENSE,sha256=Tg4nrt8rFhgpkPbIA8SWoCR3MlGLw0NufB8AE6-TH_o,1074
-executable_engineering-0.1.31.dist-info/METADATA,sha256=8_qdrwmMDcHZIxc2hdKXPMJv5Q8fAx32hcDi-Zr-NZU,1611
-executable_engineering-0.1.31.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-executable_engineering-0.1.31.dist-info/top_level.txt,sha256=0U5ATV5WGTLvN9rRSjQ54TyL-ztTyXaN3FzZ_QMq4HM,23
-executable_engineering-0.1.31.dist-info/RECORD,,
+executable_engineering-0.1.33.dist-info/licenses/LICENSE,sha256=Tg4nrt8rFhgpkPbIA8SWoCR3MlGLw0NufB8AE6-TH_o,1074
+executable_engineering-0.1.33.dist-info/METADATA,sha256=bZoPtBOuuAakueT9uX15GfwOIJeQaEw3YDkewAiKjaM,1648
+executable_engineering-0.1.33.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+executable_engineering-0.1.33.dist-info/top_level.txt,sha256=0U5ATV5WGTLvN9rRSjQ54TyL-ztTyXaN3FzZ_QMq4HM,23
+executable_engineering-0.1.33.dist-info/RECORD,,