IBB-Helper 0.4.8.dev29__tar.gz → 0.4.8.dev30__tar.gz

{ibb_helper-0.4.8.dev29/src/IBB_Helper.egg-info → ibb_helper-0.4.8.dev30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IBB_Helper
-Version: 0.4.8.dev29
+Version: 0.4.8.dev30
 Summary: Helper functions for symbolic math, matrix visualization, and plotting
 Author-email: "University of Stuttgart, Institute for Structural Mechanics (IBB)" <mvs@ibb.uni-stuttgart.de>
 License-Expression: BSD-3-Clause

{ibb_helper-0.4.8.dev29 → ibb_helper-0.4.8.dev30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "IBB_Helper"
-version = "0.4.8.dev29"
+version = "0.4.8.dev30"
 description = "Helper functions for symbolic math, matrix visualization, and plotting"
 readme = "README.md"
 license = "BSD-3-Clause"

ibb_helper-0.4.8.dev30/src/IBB_Helper/animate.py

@@ -0,0 +1,249 @@
+import numpy as np
+import sympy as sp
+import matplotlib.pyplot as plt
+import matplotlib.animation
+from sympy import latex, Matrix
+
+def animate(exprs, var, 
+            # --- Labels & Text ---
+            labels=None, title="Animation", xlabel="x", ylabel="y",
+            # --- Styling ---
+            line_styles=None, colors=None, linewidth=2, 
+            # --- Limits ---
+            xlim=None, ylim=None, 
+            # --- Animation Config ---
+            animation_time=5000, frames=100, resolution=400, show=True):
+
+    """
+    Animates 2D curves from symbolic expressions or numeric datasets using Matplotlib.
+
+    Parameters:
+        exprs          : Expression, tuple, or list of expressions (symbolic, parametric, or numeric data)
+        var            : Symbol or tuple defining variable/range, or array mode ('array', x_values)
+        
+        # --- Labels ---
+        labels         : Curve labels (strings or SymPy expressions, LaTeX supported) (default=None)
+        title          : Plot title (default="Animation")
+        xlabel         : X-axis label (default="x")
+        ylabel         : Y-axis label (default="y")
+        
+        # --- Styling ---
+        line_styles    : Line styles for each curve (default=None -> solid)
+        colors         : Colors for each curve (default=None -> Matplotlib cycle)
+        linewidth      : Line width(s) as int or list (default=2)
+        
+        # --- Limits ---
+        xlim           : X-axis limits as (min, max) (default=None -> auto)
+        ylim           : Y-axis limits as (min, max) (default=None -> auto)
+        
+        # --- Animation Config ---
+        animation_time : Total animation duration in milliseconds (default=5000)
+        frames         : Number of animation frames (default=100)
+        resolution     : Number of evaluation points for symbolic expressions (default=400)
+        show           : Whether to display the animation (default=True)
+
+    Returns:
+        matplotlib.animation.FuncAnimation
+            The animation object
+    """
+
+    # Configuration
+    plt.rcParams["animation.html"] = "jshtml"
+    plt.rcParams['figure.dpi'] = 150
+    plt.ioff()
+
+    # Label Formatting
+    def _smart_label(lbl):
+        """Converts strings or SymPy objects to LaTeX formatted strings."""
+        if lbl is None:
+            return None
+        if isinstance(lbl, str):
+            # Check for LaTeX characters
+            if any(c in lbl for c in ['_', '^', '\\', '$']):
+                return f"${lbl}$" if '$' not in lbl else lbl
+            return lbl
+        # Convert SymPy expression to LaTeX
+        return f"${latex(lbl)}$"
+
+    # Data Preparation
+    def _prepare_data(raw_exprs, variable_def):
+        """
+        Parses inputs (Symbolic/Numeric) and generates consistent (x, y) arrays.
+        """
+        # Normalize inputs to lists
+        if not isinstance(raw_exprs, list):
+            expr_list = [raw_exprs]
+        else:
+            expr_list = raw_exprs
+
+        # Determine symbol and range
+        is_sympy_mode = True
+        
+        if isinstance(variable_def, tuple):
+            if variable_def[0] == 'array':
+                is_sympy_mode = False
+                x_vals_sample = variable_def[1]
+                # If array mode, frames usually equals array length
+                nonlocal frames 
+                frames = len(x_vals_sample) 
+                x_sym = None
+            else:
+                x_sym = variable_def[0]
+                x_range = variable_def[1]
+                x_vals_sample = np.linspace(float(x_range[0]), float(x_range[1]), frames)
+        else:
+            x_sym = variable_def
+            x_range = (-1, 1)
+            x_vals_sample = np.linspace(float(x_range[0]), float(x_range[1]), frames)
+
+        prepared_data = []
+
+        for expr in expr_list:
+            # Handle SymPy Matrices
+            if isinstance(expr, Matrix):
+                expr = np.array(expr).astype(np.float64).flatten()
+            
+            # Handle Parametric or Data Tuples (x, y)
+            if isinstance(expr, (tuple, list)) and len(expr) == 2:
+                x_comp, y_comp = expr
+                
+                # Symbolic Parametric
+                if isinstance(x_comp, sp.Basic) or isinstance(y_comp, sp.Basic):
+                    if is_sympy_mode:
+                        f_x = sp.lambdify(x_sym, x_comp, modules='numpy')
+                        f_y = sp.lambdify(x_sym, y_comp, modules='numpy')
+                        x_data = f_x(x_vals_sample)
+                        y_data = f_y(x_vals_sample)
+                    else:
+                         # Fallback if mixed types (shouldn't happen often)
+                        x_data, y_data = x_comp, y_comp
+                else:
+                    # Numeric Data or Constants
+                    x_data, y_data = x_comp, y_comp
+                    
+                    # specific check for constant arrays
+                    is_x_array = hasattr(x_data, '__len__')
+                    is_y_array = hasattr(y_data, '__len__')
+
+                    if is_x_array and not is_y_array:
+                        y_data = np.full_like(x_data, y_data)
+                    elif not is_x_array and is_y_array:
+                        x_data = np.full_like(y_data, x_data)
+
+                prepared_data.append((np.array(x_data), np.array(y_data)))
+
+            # Handle Single Expressions (y = f(x))
+            else:
+                expr = sp.sympify(expr)
+                
+                # Constant function check
+                if is_sympy_mode and not expr.has(x_sym):
+                    y_vals = np.full_like(x_vals_sample, float(expr))
+                else:
+                    if is_sympy_mode:
+                        f = sp.lambdify(x_sym, expr, modules='numpy')
+                        try:
+                            y_vals = f(x_vals_sample)
+                            # Handle case where lambdify returns a scalar for vector input
+                            if np.isscalar(y_vals): 
+                                y_vals = np.full_like(x_vals_sample, y_vals)
+                        except Exception:
+                            # Fallback for complex constant expressions
+                            y_vals = np.full_like(x_vals_sample, float(expr))
+                    else:
+                        y_vals = np.array(expr).flatten()
+                
+                y_vals = np.array(y_vals).flatten()
+                prepared_data.append((x_vals_sample, y_vals))
+                
+        return prepared_data
+
+    # Animation Logic
+    def _create_animation_object(plot_data):
+        """Sets up the figure, axes, and FuncAnimation object."""
+        
+        # 1. Normalize Styling
+        n_plots = len(plot_data)
+        
+        # Thickness
+        if isinstance(linewidth, (int, float)):
+            lw_list = [linewidth] * n_plots
+        else:
+            lw_list = linewidth
+            
+        # Limits Calculation (if None)
+        nonlocal xlim, ylim
+        if xlim is None:
+            all_x = np.concatenate([d[0] for d in plot_data])
+            x_min, x_max = np.min(all_x), np.max(all_x)
+            dx = x_max - x_min if x_max != x_min else 1.0
+            xlim = (x_min - 0.05 * dx, x_max + 0.05 * dx)
+            
+        if ylim is None:
+            all_y = np.concatenate([d[1] for d in plot_data])
+            y_min, y_max = np.min(all_y), np.max(all_y)
+            dy = y_max - y_min if y_max != y_min else 1.0
+            ylim = (y_min - 0.1 * dy, y_max + 0.1 * dy)
+
+        # 2. Setup Figure
+        fig, ax = plt.subplots(figsize=(10, 6))
+
+        # 3. Update Function
+        def _update_frame(frame):
+            ax.clear()
+            
+            # Use 'frame + 1' to ensure we plot at least one point
+            idx = int(frame + 1)
+            
+            for i, (x_data, y_data) in enumerate(plot_data):
+                # Safe Styling Retrieval
+                style = line_styles[i] if line_styles and i < len(line_styles) else 'solid'
+                color = colors[i] if colors and i < len(colors) else None
+                
+                # Label Handling
+                raw_lbl = labels[i] if labels and i < len(labels) else None
+                lbl = _smart_label(raw_lbl)
+
+                # Slice data for animation effect
+                # Ensure we don't index out of bounds if frames > data length
+                curr_x = x_data[:min(idx, len(x_data))]
+                curr_y = y_data[:min(idx, len(y_data))]
+
+                ax.plot(curr_x, curr_y,
+                       label=lbl,
+                       linestyle=style,
+                       color=color,
+                       linewidth=lw_list[i] if i < len(lw_list) else 2)
+
+            # Apply Layout Settings
+            ax.set_xlim(xlim)
+            ax.set_ylim(ylim)
+            ax.set_title(_smart_label(title))
+            ax.set_xlabel(_smart_label(xlabel))
+            ax.set_ylabel(_smart_label(ylabel))
+            
+            if labels:
+                ax.legend()
+            ax.grid(True, alpha=0.3)
+
+        # 4. Create Animation
+        interval = animation_time / frames
+        anim = matplotlib.animation.FuncAnimation(
+            fig, _update_frame, frames=frames, interval=interval, repeat=True
+        )
+        
+        return anim
+
+    # Main Execution
+    
+    # 1. Prepare Data
+    data = _prepare_data(exprs, var)
+    
+    # 2. Create Animation
+    anim_obj = _create_animation_object(data)
+    
+    # 3. Display
+    if not show:
+        plt.close()
+        
+    return anim_obj

{ibb_helper-0.4.8.dev29 → ibb_helper-0.4.8.dev30/src/IBB_Helper.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IBB_Helper
-Version: 0.4.8.dev29
+Version: 0.4.8.dev30
 Summary: Helper functions for symbolic math, matrix visualization, and plotting
 Author-email: "University of Stuttgart, Institute for Structural Mechanics (IBB)" <mvs@ibb.uni-stuttgart.de>
 License-Expression: BSD-3-Clause

ibb_helper-0.4.8.dev29/src/IBB_Helper/animate.py

@@ -1,206 +0,0 @@
-import numpy as np
-import sympy as sp
-import matplotlib.pyplot as plt
-import matplotlib.animation
-from sympy import latex, Matrix
-from IPython.display import display, HTML
-
-def animate(exprs, var, 
-            # --- Plot Labels ---
-            title="Animation", xlabel="x", ylabel="y", labels=None,
-            # --- Styling ---
-            colors=None, line_styles=None, linewidth=2, scaling=None,
-            # --- Limits ---
-            xlim=None, ylim=None,
-            # --- Animation Settings ---
-            animation_time=5000, frames=100, resolution=200, show=True,
-            # --- Figure Size ---
-            width=800, height=600):
-
-    """
-    Animates 2D curves from symbolic expressions or numeric datasets using Matplotlib.
-
-    Parameters:
-        exprs          : Expression, tuple, or list of expressions to animate (symbolic, parametric, or numeric data)
-        var            : Symbol or tuple defining the variable and range, or array mode ('array', x_values)
-        title          : Plot title (string or SymPy expression, LaTeX supported) (default="Animation")
-        xlabel         : X-axis label (string or SymPy expression, LaTeX supported) (default="x")
-        ylabel         : Y-axis label (string or SymPy expression, LaTeX supported) (default="y")
-        labels         : Curve labels (strings or SymPy expressions, LaTeX supported) (default=None)
-        colors         : Colors for each curve (default=None → Matplotlib cycle)
-        line_styles    : Line styles for each curve (default=None → solid)
-        linewidth      : Line width(s) as int or list (default=2)
-        scaling        : Plot scaling behavior (e.g., 'constrained' for equal aspect ratio)
-        xlim           : X-axis limits as (min, max) (default=None → auto)
-        ylim           : Y-axis limits as (min, max) (default=None → auto)
-        animation_time : Total animation duration in milliseconds (default=5000)
-        frames         : Number of animation frames (default=100)
-        resolution     : Number of evaluation points for symbolic spatial meshes (default=200)
-        show           : Whether to display the animation (default=True)
-        width          : Plot width in pixels (default=800)
-        height         : Plot height in pixels (default=600)
-
-    Returns:
-        matplotlib.animation.FuncAnimation
-            The animation object
-    """
-
-    # Jupyter Configuration
-    plt.rcParams["animation.html"] = "jshtml"
-    plt.rcParams['figure.dpi'] = 100
-    plt.ioff()
-
-    # Default Handling for Mutable Arguments
-    if colors is None:
-        colors = ['black', 'blue', 'red', 'green']
-    if line_styles is None:
-        line_styles = ['solid'] * 10
-    if labels is None:
-        labels = []
-
-    # Helper: Range Unpacker
-    def _unpack_range(r_tuple):
-        if len(r_tuple) == 3: return r_tuple[0], float(r_tuple[1]), float(r_tuple[2])
-        elif len(r_tuple) == 2: return r_tuple[0], float(r_tuple[1][0]), float(r_tuple[1][1])
-        raise ValueError(f"Invalid range format: {r_tuple}")
-
-    # Parse Main Animation Variable
-    t_sym, t_start, t_end = _unpack_range(var)
-    t_vals = np.linspace(t_start, t_end, frames)
-
-    # Process Expressions & Generate Frame Data
-    all_curves_data = [] 
-
-    if not isinstance(exprs, list): exprs = [exprs]
-
-    for i, expr in enumerate(exprs):
-        
-        # Check for Deformation Mode: (x, y, (z, 0, h))
-        if isinstance(expr, (tuple, list)) and len(expr) == 3 and isinstance(expr[2], (tuple, list)):
-            x_e, y_e, spatial_info = expr
-            z_sym, z_min, z_max = _unpack_range(spatial_info)
-            
-            # Create Spatial Mesh using resolution parameter
-            z_vals = np.linspace(z_min, z_max, resolution) 
-            
-            # Lambdify f(z, t)
-            fx = sp.lambdify((z_sym, t_sym), x_e, modules='numpy')
-            fy = sp.lambdify((z_sym, t_sym), y_e, modules='numpy')
-            
-            frame_x_list = []
-            frame_y_list = []
-            
-            for t in t_vals:
-                x_res = fx(z_vals, t)
-                y_res = fy(z_vals, t)
-                
-                if not hasattr(x_res, '__len__'): x_res = np.full_like(z_vals, x_res)
-                if not hasattr(y_res, '__len__'): y_res = np.full_like(z_vals, y_res)
-                
-                frame_x_list.append(x_res)
-                frame_y_list.append(y_res)
-                
-            all_curves_data.append({
-                'type': 'deformation',
-                'x': frame_x_list, 
-                'y': frame_y_list
-            })
-
-        # Standard Trace Mode
-        else:
-            if isinstance(expr, (tuple, list)) and len(expr) == 2:
-                x_e, y_e = expr
-            else:
-                x_e, y_e = t_sym, expr
-            
-            fx = sp.lambdify(t_sym, x_e, modules='numpy')
-            fy = sp.lambdify(t_sym, y_e, modules='numpy')
-            
-            full_x = fx(t_vals)
-            full_y = fy(t_vals)
-            
-            if not hasattr(full_x, '__len__'): full_x = np.full_like(t_vals, full_x)
-            if not hasattr(full_y, '__len__'): full_y = np.full_like(t_vals, full_y)
-            
-            all_curves_data.append({
-                'type': 'trace',
-                'x': full_x, 
-                'y': full_y
-            })
-
-    # Auto-Scaling
-    if xlim is None or ylim is None:
-        flat_x, flat_y = [], []
-        for c in all_curves_data:
-            if c['type'] == 'deformation':
-                flat_x.append(np.concatenate(c['x']))
-                flat_y.append(np.concatenate(c['y']))
-            else:
-                flat_x.append(c['x'])
-                flat_y.append(c['y'])
-        
-        flat_x = np.concatenate(flat_x)
-        flat_y = np.concatenate(flat_y)
-        
-        if xlim is None:
-            xmin, xmax = np.min(flat_x), np.max(flat_x)
-            pad = (xmax - xmin) * 0.1 if xmax != xmin else 1.0
-            xlim = (xmin - pad, xmax + pad)
-            
-        if ylim is None:
-            ymin, ymax = np.min(flat_y), np.max(flat_y)
-            pad = (ymax - ymin) * 0.1 if ymax != ymin else 1.0
-            ylim = (ymin - pad, ymax + pad)
-
-    # Plotting Setup
-    fig, ax = plt.subplots(figsize=(width/100, height/100))
-    
-    if scaling == 'constrained' or (isinstance(scaling, list) and 'constrained' in scaling):
-        ax.set_aspect('equal')
-        
-    ax.set_xlim(xlim)
-    ax.set_ylim(ylim)
-    ax.grid(True, alpha=0.3)
-    
-    def fmt_latex(l): 
-        return f"${latex(l)}$" if hasattr(l, 'free_symbols') or (isinstance(l, str) and '\\' in l) else str(l)
-    
-    ax.set_title(fmt_latex(title))
-    ax.set_xlabel(fmt_latex(xlabel))
-    ax.set_ylabel(fmt_latex(ylabel))
-
-    # Initialize Lines
-    lines = []
-    for i in range(len(all_curves_data)):
-        col = colors[i % len(colors)]
-        sty = line_styles[i % len(line_styles)]
-        lbl = labels[i] if i < len(labels) else None
-        
-        if isinstance(linewidth, list): lw = linewidth[i % len(linewidth)]
-        else: lw = linewidth
-            
-        ln, = ax.plot([], [], color=col, linestyle=sty, linewidth=lw, label=fmt_latex(lbl) if lbl else None)
-        lines.append(ln)
-
-    if any(labels): ax.legend()
-
-    # Animation Loop
-    def update_frame(frame_idx):
-        t_curr = t_vals[frame_idx]
-        ax.set_title(f"{fmt_latex(title)} ($t={t_curr:.2f}$)")
-        
-        for i, data in enumerate(all_curves_data):
-            if data['type'] == 'deformation':
-                lines[i].set_data(data['x'][frame_idx], data['y'][frame_idx])
-            else:
-                lines[i].set_data(data['x'][:frame_idx+1], data['y'][:frame_idx+1])
-                
-    ani = matplotlib.animation.FuncAnimation(
-        fig, update_frame, frames=frames, interval=animation_time/frames, blit=False
-    )
-    
-    if show:
-        display(HTML(ani.to_jshtml()))
-        plt.close()
-        
-    return ani