IBB-Helper 0.3.2__tar.gz

ibb_helper-0.3.2/IBB_Helper/__init__.py

@@ -0,0 +1,12 @@
+__version__ = "0.3.2"
+from .display_matrix   import display_matrix
+from .display          import display
+from .display_eigen    import display_eigen
+from .plot_2d          import plot_2d
+from .plot_3d          import plot_3d
+from .extend_plot      import extend_plot
+from .combine_plots    import combine_plots
+from .symbolic_BSpline import symbolic_BSpline
+from .minimize         import minimize
+from .num_int          import num_int
+from .plot_param_grid  import plot_param_grid

ibb_helper-0.3.2/IBB_Helper/combine_plots.py

@@ -0,0 +1,239 @@
+import matplotlib.pyplot as plt
+import plotly.graph_objects as go
+import copy
+from   sympy import latex
+
+def combine_plots(plot_list, labels=None, line_styles=None, colors=None,
+                 swap_axes=False, show=True, grid=False,
+                 xlim=None, ylim=None, title=None, xlabel=None, ylabel=None):
+    """
+    Combines multiple individual matplotlib Axes or plotly Figures into a single figure.
+        
+        This function intelligently detects the type of plot object (Matplotlib or Plotly)
+        and merges all data onto a new, single canvas. It preserves the original styling
+        of each plot by default, but allows for explicit overrides for the final output.
+
+        Parameters
+        ----------
+        plot_list : list
+            The list of plot objects to be combined. All plots must be of the same type.
+            - Syntax: `[ax1, ax2]` or `[fig1, fig2]`
+        
+        labels : list[str], optional
+            A list of new labels to override the existing ones for the legend.
+            - Syntax: `['Plot A', 'Plot B']`
+
+        line_styles : list[str], optional
+            A list of new line styles to override the existing ones. Can also be used
+            to force a marker style (e.g., 'o', 'x').
+            - Syntax: `['solid', 'dashed', 'o', 'x']`
+
+        colors : list[str], optional
+            A list of new colors to override the existing ones.
+            - Syntax: `['red', 'blue', '#FF5733']`
+
+        swap_axes : bool, optional
+            If True, the x and y data for all plots will be swapped.
+            - Syntax: `True` or `False`
+
+        show : bool, optional
+            If True, displays the combined plot immediately. If False, the plot object
+            is returned without being shown.
+            - Syntax: `True` or `False`
+
+        grid : bool, optional
+            If True, displays a grid on the final combined plot.
+            - Syntax: `True` or `False`
+
+        xlim : tuple[float, float], optional
+            Sets the x-axis limits for the combined plot.
+            - Syntax: `(0, 10)`
+
+        ylim : tuple[float, float], optional
+            Sets the y-axis limits for the combined plot.
+            - Syntax: `(-5, 5)`
+
+        title : str, optional
+            The main title for the combined plot.
+            - Syntax: `"My Combined Plot"`
+
+        xlabel : str, optional
+            The x-axis label for the combined plot.
+            - Syntax: `"Time (s)"`
+
+        ylabel : str, optional
+            The y-axis label for the combined plot.
+            - Syntax: `"Value"`
+
+        Returns
+        -------
+        matplotlib.axes.Axes or plotly.graph_objects.Figure
+            The final combined plot object, either a Matplotlib Axes or a Plotly Figure,
+            depending on the input.
+    """
+
+    # === SMART LABEL HELPER ===
+    def smart_label(lbl):
+        """Converts label or SymPy expression into LaTeX-compatible string."""
+        if lbl is None:
+            return None
+        if isinstance(lbl, str):
+            if any(c in lbl for c in ['_', '^', '\\']):
+                return f"${lbl}$"
+            else:
+                return lbl
+        else:
+            return f"${latex(lbl)}$"
+        
+    if not plot_list:
+        raise ValueError("plot_list cannot be empty")
+
+    first_plot = plot_list[0]
+    
+    # Define marker symbols for internal check (same list used in plot_2d)
+    marker_symbols = ['o', 's', '^', 'x', '*', 'D', 'p', '+', 'v', '<', '>', '1', '2', '3', '4']
+
+    # === MATPLOTLIB AXES HANDLING ===
+    if hasattr(first_plot, 'lines'):
+        fig, ax = plt.subplots()
+        
+        for i, plot_ax in enumerate(plot_list):
+            first_line = True
+            
+            for line in plot_ax.lines:
+                x, y = line.get_data()
+
+                # --- 1. Retrieve Existing Properties (Default Transfer) ---
+                current_color = line.get_color()
+                current_marker = line.get_marker()
+                current_linestyle = line.get_linestyle()
+                current_markersize = line.get_markersize()
+                current_linewidth = line.get_linewidth()
+                
+                # Normalize marker: Convert 'None' string to None
+                if current_marker in ['None', '']:
+                    current_marker = None
+                    
+                # Normalize linestyle: Matplotlib stores '' for marker-only plots
+                if current_linestyle in ['None', '']: 
+                    current_linestyle = 'None' 
+
+                # --- 2. Apply Overrides from append_plots Arguments (Only for First Line) ---
+                if first_line:
+                    # Override Line Style / Marker
+                    if line_styles and i < len(line_styles):
+                        new_style = line_styles[i]
+                        
+                        if new_style in marker_symbols:
+                            # Case A: User forces a marker (e.g., 'o', 'x')
+                            current_marker = new_style
+                            current_linestyle = 'None' # Ensure linestyle is off
+                        else:
+                            # Case B: User forces a line style (e.g., '--', 'solid')
+                            current_linestyle = new_style
+                            current_marker = None # Clear the marker
+
+                    # Override Color
+                    if colors and i < len(colors):
+                        current_color = colors[i]
+                
+                # Apply label only to the first line of the current plot_ax
+                label_to_use = smart_label(labels[i]) if first_line and labels and i < len(labels) else None
+
+                # --- 3. Plot on the New Axes ---
+                if swap_axes:
+                    ax.plot(y, x, 
+                            color=current_color, 
+                            linestyle=current_linestyle if current_linestyle != 'None' else '', 
+                            marker=current_marker if current_marker else '',
+                            markersize=current_markersize,
+                            linewidth=current_linewidth,
+                            label=label_to_use)
+                else:
+                    ax.plot(x, y, 
+                            color=current_color, 
+                            linestyle=current_linestyle if current_linestyle != 'None' else '', 
+                            marker=current_marker if current_marker else '',
+                            markersize=current_markersize,
+                            linewidth=current_linewidth,
+                            label=label_to_use)
+
+                first_line = False
+
+        # --- 4. Final Axis/Figure Configuration (Matplotlib) ---
+        if xlim:
+            ax.set_xlim(xlim)
+        if ylim:
+            ax.set_ylim(ylim)
+        if title:
+            ax.set_title(smart_label(title))
+        if xlabel:
+            ax.set_xlabel(smart_label(xlabel))
+        if ylabel:
+            ax.set_ylabel(smart_label(ylabel))
+        if grid:
+            ax.grid()
+        if labels:
+            ax.legend()
+        if show:
+            plt.show()
+        else:
+            plt.close(fig)
+
+        return ax
+
+    # === PLOTLY FIGURE HANDLING ===
+    elif hasattr(first_plot, 'data'):
+        combined_fig = go.Figure()
+        
+        for i, fig in enumerate(plot_list):
+            for trace in fig.data:
+                # Use deepcopy for safe cloning of the trace
+                new_trace = copy.deepcopy(trace)
+
+                # Apply colors if provided and trace supports it
+                if colors and i < len(colors):
+                    if hasattr(new_trace, 'line'):
+                        new_trace.line.color = colors[i]
+                    if hasattr(new_trace, 'marker'):
+                        new_trace.marker.color = colors[i]
+
+                # Apply line styles (dash) if provided
+                if line_styles and i < len(line_styles):
+                    if isinstance(new_trace, go.Scatter) and hasattr(new_trace, 'line'):
+                        new_trace.line.dash = line_styles[i]
+
+                # Apply labels/name
+                if labels and i < len(labels):
+                    new_trace.name = labels[i]
+                
+                # Handle Axis Swap (if requested)
+                if swap_axes and hasattr(new_trace, 'x') and hasattr(new_trace, 'y'):
+                     new_trace.x, new_trace.y = new_trace.y, new_trace.x
+
+                combined_fig.add_trace(new_trace)
+
+        # Final Layout Configuration (Plotly)
+        if title:
+            combined_fig.update_layout(title=smart_label(title))
+        
+        final_xlabel = smart_label(ylabel) if swap_axes and ylabel else smart_label(xlabel) if xlabel else None
+        final_ylabel = smart_label(xlabel) if swap_axes and xlabel else smart_label(ylabel) if ylabel else None
+
+        if final_xlabel or final_ylabel:
+            combined_fig.update_layout(xaxis_title=final_xlabel,
+                                       yaxis_title=final_ylabel)
+        if xlim:
+            combined_fig.update_xaxes(range=xlim if not swap_axes else ylim)
+        if ylim:
+            combined_fig.update_yaxes(range=ylim if not swap_axes else xlim)
+        if grid:
+            combined_fig.update_layout(xaxis_showgrid=True, yaxis_showgrid=True)
+
+        if show:
+            combined_fig.show()
+
+        return combined_fig
+
+    else:
+        raise TypeError("Unknown plot object type passed to combine_plots.")

ibb_helper-0.3.2/IBB_Helper/display.py

@@ -0,0 +1,42 @@
+import numpy                as     np
+import sympy                as     sp
+from   sympy                import latex
+import IPython.display      as     ipy
+
+def display(obj, name="obj", evalf=False, prec=5):
+    """
+    Converts vectors/numbers/matrices to LaTeX with optional simplification.
+
+    Parameters:
+        obj     : Input (SymPy or NumPy object)
+        name    : Name used for display
+        evalf   : If T, evaluates to decimal form before display (default: F)
+        prec    : Evaluate the given formula to an accuracy of prec digits (default: 5)
+    """
+
+    def safe_eval_entry(x):
+        try:
+            return sp.sympify(x).evalf(prec)
+        except (TypeError, ValueError):
+            return x
+
+    if evalf:
+        if isinstance(obj, np.ndarray):
+            obj = sp.Matrix(obj).applyfunc(safe_eval_entry)
+        elif isinstance(obj, (sp.Matrix, list)):
+            obj = sp.Matrix(obj).applyfunc(safe_eval_entry)
+        elif isinstance(obj, sp.NDimArray):
+            obj = obj.applyfunc(safe_eval_entry)
+        else:
+            obj = safe_eval_entry(obj)
+    else:
+        if isinstance(obj, np.ndarray):
+            obj = sp.Matrix(obj)
+        elif isinstance(obj, (sp.Matrix, list)):
+            obj = sp.Matrix(obj)
+        elif isinstance(obj, sp.NDimArray):
+            obj = obj
+        else:
+            obj = sp.sympify(obj)
+
+    ipy.display(ipy.Math(f"{name} = {latex(obj)}"))

ibb_helper-0.3.2/IBB_Helper/display_eigen.py

@@ -0,0 +1,133 @@
+import numpy                as     np
+import sympy                as     sp
+from   sympy                import latex
+import IPython.display      as     ipy
+
+def display_eigen(A, name="Matrix", evalf=False, prec=5, return_data=False, show="both", output="default"):
+    """
+    Computes and displays the eigenvalues and eigenvectors of a matrix A with enhanced display options.
+
+    Parameters:
+        A          : Square matrix (SymPy Matrix or NumPy ndarray)
+        name       : Label used for the matrix (default="Matrix")
+        evalf      : If True, show decimal values (default=False)
+        prec       : Evaluate the given formula to an accuracy of prec digits (default: 5)
+        show       : What to display ("both", "eigvals", "eigvecs", or "none") (default="both")
+        output     : How to display ("default", "compact", "Maple") (default="default")
+        return_data: If True, also returns eigenvalues and eigenvectors (default=False)
+
+    Returns (if return_data=True):
+        - eigvals: List of eigenvalues
+        - eigvecs: List of corresponding eigenvectors (each as a SymPy Matrix)
+    """
+
+    threshold = 10**(-10)
+
+    # Track original input type
+    is_numpy_input = isinstance(A, np.ndarray)
+
+    def safe_eval(x):
+        try:
+            val = x.evalf(prec)
+            if abs(val) < threshold:
+                return sp.Integer(0)
+            return round(float(val), prec)
+        except (TypeError, ValueError):
+            return x
+
+    # Convert NumPy array to SymPy Matrix if needed
+    if isinstance(A, np.ndarray):
+        A = sp.Matrix(A)
+
+    # Compute eigenvalues and eigenvectors
+    eigen_data = A.eigenvects()
+
+    # To store raw data
+    eigvals = []
+    eigvecs = []
+
+    # Validate show parameter
+    show = show.lower()
+    valid_options = ["both", "eigvals", "eigvecs", "none"]
+    if show not in valid_options:
+        raise ValueError(f"show must be one of {valid_options}")
+
+    # Validate output parameter
+    output = output.lower()
+    valid_options_output = ["default", "compact", "maple"]
+    if output not in valid_options_output:
+        raise ValueError(f"output must be one of {valid_options_output}")
+
+
+    # Prepare data
+    counter = 1
+    for eigval, mult, vects in eigen_data:
+        for i in range(mult):
+            val_disp = safe_eval(eigval) if evalf else eigval
+            v_disp = vects[i].applyfunc(safe_eval) if evalf else vects[i]
+            eigvals.append(val_disp)
+            eigvecs.append(v_disp)
+            counter += 1
+
+    # Sort eigenvalues and eigenvectors
+    def sort_key(pair):
+        val = pair[0]
+        try:
+            # Try to get numerical value
+            if hasattr(val, 'evalf'):
+                num_val = complex(val.evalf())
+            else:
+                num_val = complex(val)
+            
+            # For numpy inputs: simple ascending sort
+            if is_numpy_input:
+                return (num_val.real, num_val.imag)
+            
+            # For sympy inputs: zeros first, then ascending
+            is_zero = abs(num_val) < threshold
+            return (not is_zero, num_val.real, num_val.imag)
+            
+        except (TypeError, ValueError, AttributeError):
+            # Fallback for symbolic values
+            return (0, 0, 0)
+    
+    paired = list(zip(eigvals, eigvecs))
+    paired.sort(key=sort_key)
+    eigvals, eigvecs = zip(*paired) if paired else ([], [])
+    eigvals = list(eigvals)
+    eigvecs = list(eigvecs)
+
+    # Build LaTeX string based on options
+    if show == "both":
+        latex_str = f"\\text{{Eigenvalues and Eigenvectors of }} {name}:"
+        ipy.display(ipy.Math(latex_str))
+        if output == "default":
+            latex_str = f""
+            for i, (val, vec) in enumerate(zip(eigvals, eigvecs)):
+                latex_str += f"\\lambda_{{{i+1}}} = {latex(val)}, v_{{{i+1}}} = {latex(vec)} \\qquad"
+            ipy.display(ipy.Math(latex_str))
+        elif output == "compact":
+            for i, (val, vec) in enumerate(zip(eigvals, eigvecs)):
+                latex_str = f"\\lambda_{{{i+1}}} = {latex(val)}, \\quad v_{{{i+1}}} = {latex(vec.T)}"
+                ipy.display(ipy.Math(latex_str))
+        elif output == "maple":
+            latex_str = f"\\lambda = {latex(sp.Matrix(eigvals))}"
+            ipy.display(ipy.Math(latex_str))
+            V = sp.Matrix.hstack(*[vec for vec in eigvecs])
+            latex_str = f"v = {latex(V)}"
+            ipy.display(ipy.Math(latex_str))
+
+    elif show == "eigvals":
+        # Default vector display for eigenvalues only
+        latex_str = f"\\text{{Eigenvalues of }} {name}: \\quad \\lambda = {latex(sp.Matrix(eigvals))}"
+        ipy.display(ipy.Math(latex_str))
+
+    elif show == "eigvecs":
+        # Default matrix display for eigenvectors only
+        V = sp.Matrix.hstack(*[vec for vec in eigvecs])
+        latex_str = f"\\text{{Eigenvectors of }} {name}: \\quad v = {latex(V)}"
+        ipy.display(ipy.Math(latex_str))
+
+    if return_data:
+        return eigvals, eigvecs
+    return None

ibb_helper-0.3.2/IBB_Helper/display_matrix.py

@@ -0,0 +1,39 @@
+import numpy                as     np
+import sympy                as     sp
+from   sympy                import latex
+import IPython.display      as     ipy
+
+def display_matrix(matrix, name="Matrix", r=8, c=8, evalf=False, prec=5):
+    """
+    Displays a truncated matrix with optional numerical evaluation and rational simplification.
+    
+    Parameters:
+        matrix  : Input matrix (NumPy array, SymPy Matrix, or list)
+        name    : Display name (default: "Matrix")
+        r       : Max rows to display (default: 8)
+        c       : Max columns to display (default: 8)
+        evalf   : If T, apply numerical evaluation (default: F)
+        prec    : Evaluate the given formula to an accuracy of prec digits
+    """
+    
+    # Convert to SymPy Matrix if needed
+    if isinstance(matrix, (np.ndarray, list)):
+        matrix = sp.Matrix(matrix)
+
+    # Truncate to r rows and c columns
+    submatrix = matrix[:min(r, matrix.rows), :min(c, matrix.cols)]
+
+    # Apply evaluation if needed
+    if evalf:
+        processed = submatrix.applyfunc(lambda x: x.evalf(prec))
+    else:
+        processed = submatrix
+
+    # Display matrix
+    ipy.display(ipy.Math(f"{name} = {latex(processed)}"))
+
+    m = matrix.rows
+    n = matrix.cols
+    # Show truncation message if applicable
+    if matrix.rows > r or matrix.cols > c:
+        ipy.display(ipy.Math(rf"\text{{... Truncated to first {r}x{c} out of {m}x{n} matrix}}"))