IBB-Helper 0.1.2__tar.gz

ibb_helper-0.1.2/IBB_Helper/__init__.py

@@ -0,0 +1,8 @@
+__version__ = "0.1.2"
+from .dmat import DMAT
+from .dis import DIS
+from .dis_ei import DIS_EI
+from .plot_2d import plot_2d
+from .plot_3d import plot_3d
+from .extend_plots import extend_plots
+from .append_plots import append_plots

ibb_helper-0.1.2/IBB_Helper/append_plots.py

@@ -0,0 +1,111 @@
+import matplotlib.pyplot    as     plt
+import plotly.graph_objects as     go
+
+def append_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.
+    
+    Parameters same as before.
+    
+    Returns:
+    - matplotlib Axes object OR plotly Figure object depending on input.
+    """
+
+    if not plot_list:
+        raise ValueError("plot_list cannot be empty")
+
+    first_plot = plot_list[0]
+
+    # Check if matplotlib plot (Axes)
+    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()
+
+                linestyle = line.get_linestyle()
+                if line_styles and i < len(line_styles):
+                    linestyle = line_styles[i]
+
+                color = line.get_color()
+                if colors and i < len(colors):
+                    color = colors[i]
+
+                if swap_axes:
+                    ax.plot(y, x, color=color, linestyle=linestyle,
+                            label=labels[i] if first_line and labels and i < len(labels) else None)
+                else:
+                    ax.plot(x, y, color=color, linestyle=linestyle,
+                            label=labels[i] if first_line and labels and i < len(labels) else None)
+
+                first_line = False
+
+        if xlim:
+            ax.set_xlim(xlim)
+        if ylim:
+            ax.set_ylim(ylim)
+        if title:
+            ax.set_title(title)
+        if xlabel:
+            ax.set_xlabel(xlabel)
+        if ylabel:
+            ax.set_ylabel(ylabel)
+        if grid:
+            ax.grid()
+        if labels:
+            ax.legend()
+        if show:
+            plt.show()
+        else:
+            plt.close()
+
+        return ax
+
+    # Check if plotly figure
+    elif hasattr(first_plot, 'data'):
+        combined_fig = go.Figure()
+        for i, fig in enumerate(plot_list):
+            for trace in fig.data:
+                # Clone the trace to avoid mutating original
+                new_trace = 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]
+                    elif hasattr(new_trace, 'marker'):
+                        new_trace.marker.color = colors[i]
+
+                # Apply line styles if provided and trace supports it (only for scatter lines)
+                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 if available and applicable
+                if labels and i < len(labels):
+                    new_trace.name = labels[i]
+
+                combined_fig.add_trace(new_trace)
+
+        if title:
+            combined_fig.update_layout(title=title)
+        if xlabel or ylabel:
+            combined_fig.update_layout(xaxis_title=xlabel if xlabel else None,
+                                      yaxis_title=ylabel if ylabel else None)
+        if xlim:
+            combined_fig.update_xaxes(range=xlim)
+        if ylim:
+            combined_fig.update_yaxes(range=ylim)
+        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 append_plots.")

ibb_helper-0.1.2/IBB_Helper/dis.py

@@ -0,0 +1,44 @@
+import numpy                as     np
+import sympy                as     sp
+from   sympy                import latex
+from   IPython.display      import Math, display
+
+def DIS(obj, name="obj", evalf=False, tol=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
+        rational: If T, result shown as fraction; if F, decimal
+        x       : Optional. If given, sets tolerance as 1e-x (e.g., x=3 → tol=1e-3)
+        tol     : Optional tolerance value (overrides x if both given)
+    """
+
+    def safe_eval_entry(x):
+        try:
+            return sp.sympify(x).evalf(tol)
+        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)
+
+    display(Math(f"{name} = {latex(obj)}"))

ibb_helper-0.1.2/IBB_Helper/dis_ei.py

@@ -0,0 +1,83 @@
+import numpy                as     np
+import sympy                as     sp
+from   sympy                import latex
+from   IPython.display      import Math, display
+import matplotlib.pyplot    as     plt
+import plotly.graph_objects as     go
+
+def DIS_EI(A, name="Matrix", evalf=False, tol=5, return_data=False, show=True, show_which="both"):
+    """
+    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)
+        tol        : Tolerance for decimal rounding (default=5)
+        return_data: If True, also returns eigenvalues and eigenvectors (default=False)
+        show       : If True, displays the output (default=True)
+        show_which : What to display ("both", "eigvals", or "eigvecs") (default="both")
+
+    Returns (if return_data=True):
+        - eigvals: List of eigenvalues
+        - eigvecs: List of corresponding eigenvectors (each as a SymPy Matrix)
+    """
+
+    threshold = 10**(-10)
+
+    def safe_eval(x):
+        try:
+            val = x.evalf(tol)
+            if abs(val) < threshold:
+                return sp.Integer(0)
+            return round(float(val), tol)
+        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_which parameter
+    show_which = show_which.lower()
+    valid_options = ["both", "eigvals", "eigvecs"]
+    if show_which not in valid_options:
+        raise ValueError(f"show_which must be one of {valid_options}")
+
+    # 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
+
+    # Build LaTeX string based on options
+    if show_which == "both":
+        latex_str = f"\\text{{Eigenvalues and Eigenvectors of }} {name}: \\\\"
+        for i, (val, vec) in enumerate(zip(eigvals, eigvecs)):
+            latex_str += f"\\lambda_{{{i+1}}} = {latex(val)}, \\quad v_{{{i+1}}} = {latex(vec)} \\\\"
+    
+    elif show_which == "eigvals":
+        # Default vector display for eigenvalues only
+        latex_str = f"\\text{{Eigenvalues of }} {name}: \\quad \\lambda = {latex(sp.Matrix(eigvals))}"
+    
+    elif show_which == "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)}"
+
+    if show:
+        display(Math(latex_str))
+
+    if return_data:
+        return eigvals, eigvecs

ibb_helper-0.1.2/IBB_Helper/dmat.py

@@ -0,0 +1,43 @@
+import numpy                as     np
+import sympy                as     sp
+from   sympy                import latex
+from   IPython.display      import Math, display
+import matplotlib.pyplot    as     plt
+import plotly.graph_objects as     go
+
+def DMAT(matrix, name="Matrix", r=5, c=5, evalf=False, tol=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: 5)
+        c       : Max columns to display (default: 5)
+        evalf   : If T, apply numerical evaluation (default: F)
+        rational: If T, display as fraction; else as decimal (default: T)
+        x       : Optional. If given, sets tolerance as 1e-x
+        tol     : Optional tolerance value (overrides x if both are given)
+    """
+    
+    # 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(tol))
+    else:
+        processed = submatrix
+
+    # Display matrix
+    display(Math(f"{name} = {latex(processed)}"))
+
+    m = matrix.rows
+    n = matrix.cols
+    # Show truncation message if applicable
+    if matrix.rows > r or matrix.cols > c:
+        display(Math(rf"\text{{... Truncated to first {r}x{c} out of {m}x{n} matrix}}"))

ibb_helper-0.1.2/IBB_Helper/extend_plots.py

@@ -0,0 +1,52 @@
+import matplotlib.pyplot    as     plt
+import plotly.graph_objects as     go
+
+def extend_plots(plot_list, dx=0, colors=None, show=True):
+    if not plot_list:
+        raise ValueError("Plot list cannot be empty")
+    
+    # Detect if first plot is matplotlib or plotly
+    first_plot = plot_list[0]
+
+    # Check for matplotlib plot: look for .lines or .get_lines()
+    if hasattr(first_plot, 'lines') or hasattr(first_plot, 'get_lines'):
+        # Matplotlib branch
+        # Assume plot_list are matplotlib Axes or Figures with lines
+        fig, ax = plt.subplots()
+        for p in plot_list:
+            # Support Axes or Figure input:
+            if hasattr(p, 'lines'):
+                lines = p.lines
+            elif hasattr(p, 'get_lines'):
+                lines = p.get_lines()
+            else:
+                lines = []
+            for line in lines:
+                x, y = line.get_data()
+                ax.plot(x + dx, y, color=colors)
+        if show:
+            plt.show()
+        else:
+            plt.close()
+        return ax
+    
+    # Check for Plotly plot: look for .data attribute (list of traces)
+    elif hasattr(first_plot, 'data'):
+        # Plotly branch
+        # Combine traces from all figures into one figure
+        combined_fig = go.Figure()
+        for fig in plot_list:
+            for trace in fig.data:
+                # Optionally shift trace x by dx if it has x data
+                # This requires modifying trace.x which may be tuple/list/np.array
+                if hasattr(trace, 'x') and trace.x is not None:
+                    shifted_x = [xi + dx for xi in trace.x] if isinstance(trace.x, (list, tuple)) else trace.x
+                    trace = trace.update(x=shifted_x)
+                combined_fig.add_trace(trace)
+        if show:
+            combined_fig.show()
+    
+        return combined_fig
+
+    else:
+        raise TypeError("Unknown plot object type passed to extend_plots.")

ibb_helper-0.1.2/IBB_Helper/plot_2d.py

@@ -0,0 +1,81 @@
+import numpy as np
+import sympy as sp
+import matplotlib.pyplot as plt
+from sympy import latex
+
+def plot_2d(exprs, var, labels=None, line_styles=None, colors=None,
+            title="2D Plot", xlabel="x", ylabel="y",
+            xlim=None, ylim=None, resolution=400, show=True):
+    """
+    Plots 2D curves from symbolic expressions or (x, y) datasets using Matplotlib.
+    Automatically detects whether labels and axis titles should be symbolic (LaTeX)
+    or plain text.
+
+    Rules:
+        - Strings containing '\' are treated as LaTeX symbols.
+        - Strings without '\' are treated as plain text.
+        - SymPy symbols or expressions are automatically converted to LaTeX.
+    """
+
+    def smart_label(lbl):
+        """Return string for Matplotlib: LaTeX if symbolic, plain text otherwise"""
+        if isinstance(lbl, str):
+            if "\\" in lbl:
+                return f"${lbl}$"   # LaTeX
+            else:
+                return lbl           # plain text
+        else:
+            return f"${latex(lbl)}$"  # SymPy expression → LaTeX
+
+    if not isinstance(exprs, list):
+        exprs = [exprs]
+
+    # Determine symbol and range
+    if isinstance(var, tuple):
+        x_sym = var[0]
+        x_range = var[1]
+    else:
+        x_sym = var
+        x_range = (-1, 1)
+
+    x_vals = np.linspace(float(x_range[0]), float(x_range[1]), resolution)
+
+    fig, ax = plt.subplots()
+
+    for i, expr in enumerate(exprs):
+        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 = smart_label(labels[i]) if labels and i < len(labels) else None
+
+        # If expr is (x_data, y_data)
+        if isinstance(expr, (tuple, list)) and len(expr) == 2:
+            x_data, y_data = expr
+            ax.plot(x_data, y_data, label=label, linestyle=style, color=color)
+        else:
+            expr = sp.sympify(expr)
+            if not expr.has(x_sym):
+                y_vals = np.full_like(x_vals, float(expr))
+            else:
+                f = sp.lambdify(x_sym, expr, modules='numpy')
+                y_vals = np.array(f(x_vals)).flatten()
+            ax.plot(x_vals, y_vals, label=label, linestyle=style, color=color)
+
+    ax.set_title(smart_label(title))
+    ax.set_xlabel(smart_label(xlabel))
+    ax.set_ylabel(smart_label(ylabel))
+
+    if xlim:
+        ax.set_xlim(xlim)
+    if ylim:
+        ax.set_ylim(ylim)
+    if labels:
+        ax.legend()
+    ax.grid(True)
+
+    if show:
+        plt.show()
+    else:
+        plt.close()
+
+    return ax

ibb_helper-0.1.2/IBB_Helper/plot_3d.py

@@ -0,0 +1,83 @@
+import numpy                as     np
+import sympy                as     sp
+from   sympy                import latex
+from   IPython.display      import Math, display
+import matplotlib.pyplot    as     plt
+import plotly.graph_objects as     go
+
+def plot_3d(exprs, var, labels=None, colors=None,
+            title="3D Plot", xlabel="x", ylabel="y", zlabel="Value",
+            xlim=None, ylim=None, zlim=None,
+            resolution=100, show=True):
+    """
+    Plots 3D surfaces from symbolic expressions using Plotly.
+
+    Parameters:
+    - exprs     : List of SymPy expressions or a single expression
+    - var       : Tuple (x_sym, x_range, y_sym, y_range)
+    - labels    : List of labels (LaTeX strings) for each surface
+    - colors    : List of colors per surface
+    - title     : Plot title
+    - xlabel, ylabel, zlabel: Axis labels
+    - xlim, ylim, zlim: Axis limit tuples
+    - resolution: Grid resolution (default: 100x100)
+    - show      : If True, shows the plot immediately
+
+    Returns:
+    - fig       : Plotly Figure object (if show=False)
+    """
+
+    if not isinstance(exprs, list):
+        exprs = [exprs]
+
+    if not isinstance(var, tuple) or len(var) != 4:
+        raise ValueError("`var` must be a tuple: (x_sym, x_range, y_sym, y_range)")
+
+    x_sym, x_range, y_sym, y_range = var
+
+    x_vals = np.linspace(float(x_range[0]), float(x_range[1]), resolution)
+    y_vals = np.linspace(float(y_range[0]), float(y_range[1]), resolution)
+    X, Y   = np.meshgrid(x_vals, y_vals)
+
+    fig = go.Figure()
+
+    for i, expr in enumerate(exprs):
+        expr  = sp.sympify(expr)
+        color = colors[i] if colors and i < len(colors) else None
+        label = labels[i] if labels and i < len(labels) else f"Expr {i+1}"
+
+        f = sp.lambdify((x_sym, y_sym), expr, modules="numpy")
+        Z = f(X, Y)
+        if np.isscalar(Z):
+            # Convert scalar zero (or any scalar) into a 2D array matching X,Y shape
+            Z = np.zeros_like(X, dtype=float)
+
+        fig.add_trace(go.Surface(
+            x=X, y=Y, z=Z,
+            name=label,
+            colorscale='Turbo' if color is None else [[0, color], [1, color]],
+            showscale=False,
+            opacity=0.9
+        ))
+
+    fig.update_layout(
+        title=title,
+        width=800, height=600,
+        scene=dict(
+            xaxis_title=xlabel,
+            yaxis_title=ylabel,
+            zaxis_title=zlabel,
+            xaxis=dict(range=list(xlim) if xlim else None),
+            yaxis=dict(range=list(ylim) if ylim else None),
+            zaxis=dict(range=list(zlim) if zlim else None),
+            aspectratio=dict(x=1, y=1, z=0.5),
+            camera=dict(eye=dict(x=1.2, y=1.2, z=0.6))
+        ),
+        margin=dict(l=10, r=10, t=50, b=10),
+        legend=dict(x=0, y=1)
+    )
+
+    if show:
+        fig.show()
+        
+    return fig

ibb_helper-0.1.2/IBB_Helper.egg-info/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: IBB_Helper
+Version: 0.1.2
+Summary: helper functions
+Home-page: https://github.tik.uni-stuttgart.de/st193984/IBB_helper.git
+Author: IBB
+Author-email: stud193984@stud.uni-stuttgart.de
+License: custom
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: summary
+
+Matrix and Plotting Helper Toolkit
+===================================
+
+Author: Institut fuer Baustatik und Baudynamik,Universitaet Stuttgart
+License: ADD LICENSE here
+Version: 1.0
+Date: July 2025
+
+Description:
+------------
+This helper module provides a set of tools to make symbolic math, matrix visualization,
+and plotting (2D/3D) more intuitive and presentation-friendly, especially when working 
+with SymPy, NumPy, Matplotlib, and Plotly in Jupyter Notebooks or other Python environments.
+
+Modules Included:
+-----------------
+
+1. DMAT
+   - Pretty-prints a truncated matrix with optional decimal or rational evaluation.
+
+2. DIS
+   - Nicely formats scalars, vectors, or matrices in LaTeX for display.
+
+3. DIS_EI
+   - Computes and displays eigenvalues and eigenvectors using clean LaTeX formatting.
+
+4. plot_2d
+   - Plots symbolic expressions or numeric datasets in 2D using Matplotlib.
+
+5. plot_3d
+   - Plots symbolic 3D surfaces using Plotly for interactive visualization.
+
+6. extend_plots
+   - Merges multiple plots side-by-side (e.g., shifted versions).
+
+7. append_plots
+   - Stacks multiple Matplotlib or Plotly plots into one combined figure.
+
+Dependencies:
+-------------
+- Python 3.8+
+- numpy
+- sympy
+- matplotlib
+- plotly
+- IPython (for LaTeX rendering in notebooks)
+
+How to Use:
+-----------
+1. Import the helper script:
+   >>> from your_module_name import *
+
+2. Visualize a matrix:
+   >>> DMAT(np.array([[1, 2], [3, 4]]), name="A")
+
+3. Display a symbolic expression:
+   >>> x = sp.Symbol('x')
+   >>> DIS(sp.sin(x)**2 + sp.cos(x)**2, name="Identity")
+
+4. Plot a symbolic 2D graph:
+   >>> plot_2d([sp.sin(x), sp.cos(x)], var=(x, (-np.pi, np.pi)), labels=["sin(x)", "cos(x)"])
+
+5. Plot a 3D surface:
+   >>> plot_3d(sp.sin(x*y), var=(x, (-2, 2), y, (-2, 2)), title="sin(xy) surface")
+
+Notes:
+------
+- This toolkit is especially suited for education, math research, or lab reports
+  where symbolic clarity and visualization are critical.
+- Functions are designed to handle both SymPy and NumPy formats seamlessly.
+
+License:
+--------
+ADD RELEVANT 
+
+Contact:
+--------
+Name/Email

ibb_helper-0.1.2/IBB_Helper.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE.txt
+README.md
+pyproject.toml
+setup.py
+IBB_Helper/__init__.py
+IBB_Helper/append_plots.py
+IBB_Helper/dis.py
+IBB_Helper/dis_ei.py
+IBB_Helper/dmat.py
+IBB_Helper/extend_plots.py
+IBB_Helper/plot_2d.py
+IBB_Helper/plot_3d.py
+IBB_Helper.egg-info/PKG-INFO
+IBB_Helper.egg-info/SOURCES.txt
+IBB_Helper.egg-info/dependency_links.txt
+IBB_Helper.egg-info/top_level.txt

ibb_helper-0.1.2/IBB_Helper.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ibb_helper-0.1.2/IBB_Helper.egg-info/top_level.txt

@@ -0,0 +1 @@
+IBB_Helper

ibb_helper-0.1.2/LICENSE.txt

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, IBB
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

ibb_helper-0.1.2/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: IBB_Helper
+Version: 0.1.2
+Summary: helper functions
+Home-page: https://github.tik.uni-stuttgart.de/st193984/IBB_helper.git
+Author: IBB
+Author-email: stud193984@stud.uni-stuttgart.de
+License: custom
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: summary
+
+Matrix and Plotting Helper Toolkit
+===================================
+
+Author: Institut fuer Baustatik und Baudynamik,Universitaet Stuttgart
+License: ADD LICENSE here
+Version: 1.0
+Date: July 2025
+
+Description:
+------------
+This helper module provides a set of tools to make symbolic math, matrix visualization,
+and plotting (2D/3D) more intuitive and presentation-friendly, especially when working 
+with SymPy, NumPy, Matplotlib, and Plotly in Jupyter Notebooks or other Python environments.
+
+Modules Included:
+-----------------
+
+1. DMAT
+   - Pretty-prints a truncated matrix with optional decimal or rational evaluation.
+
+2. DIS
+   - Nicely formats scalars, vectors, or matrices in LaTeX for display.
+
+3. DIS_EI
+   - Computes and displays eigenvalues and eigenvectors using clean LaTeX formatting.
+
+4. plot_2d
+   - Plots symbolic expressions or numeric datasets in 2D using Matplotlib.
+
+5. plot_3d
+   - Plots symbolic 3D surfaces using Plotly for interactive visualization.
+
+6. extend_plots
+   - Merges multiple plots side-by-side (e.g., shifted versions).
+
+7. append_plots
+   - Stacks multiple Matplotlib or Plotly plots into one combined figure.
+
+Dependencies:
+-------------
+- Python 3.8+
+- numpy
+- sympy
+- matplotlib
+- plotly
+- IPython (for LaTeX rendering in notebooks)
+
+How to Use:
+-----------
+1. Import the helper script:
+   >>> from your_module_name import *
+
+2. Visualize a matrix:
+   >>> DMAT(np.array([[1, 2], [3, 4]]), name="A")
+
+3. Display a symbolic expression:
+   >>> x = sp.Symbol('x')
+   >>> DIS(sp.sin(x)**2 + sp.cos(x)**2, name="Identity")
+
+4. Plot a symbolic 2D graph:
+   >>> plot_2d([sp.sin(x), sp.cos(x)], var=(x, (-np.pi, np.pi)), labels=["sin(x)", "cos(x)"])
+
+5. Plot a 3D surface:
+   >>> plot_3d(sp.sin(x*y), var=(x, (-2, 2), y, (-2, 2)), title="sin(xy) surface")
+
+Notes:
+------
+- This toolkit is especially suited for education, math research, or lab reports
+  where symbolic clarity and visualization are critical.
+- Functions are designed to handle both SymPy and NumPy formats seamlessly.
+
+License:
+--------
+ADD RELEVANT 
+
+Contact:
+--------
+Name/Email

ibb_helper-0.1.2/README.md

@@ -0,0 +1,78 @@
+Matrix and Plotting Helper Toolkit
+===================================
+
+Author: Institut fuer Baustatik und Baudynamik,Universitaet Stuttgart
+License: ADD LICENSE here
+Version: 1.0
+Date: July 2025
+
+Description:
+------------
+This helper module provides a set of tools to make symbolic math, matrix visualization,
+and plotting (2D/3D) more intuitive and presentation-friendly, especially when working 
+with SymPy, NumPy, Matplotlib, and Plotly in Jupyter Notebooks or other Python environments.
+
+Modules Included:
+-----------------
+
+1. DMAT
+   - Pretty-prints a truncated matrix with optional decimal or rational evaluation.
+
+2. DIS
+   - Nicely formats scalars, vectors, or matrices in LaTeX for display.
+
+3. DIS_EI
+   - Computes and displays eigenvalues and eigenvectors using clean LaTeX formatting.
+
+4. plot_2d
+   - Plots symbolic expressions or numeric datasets in 2D using Matplotlib.
+
+5. plot_3d
+   - Plots symbolic 3D surfaces using Plotly for interactive visualization.
+
+6. extend_plots
+   - Merges multiple plots side-by-side (e.g., shifted versions).
+
+7. append_plots
+   - Stacks multiple Matplotlib or Plotly plots into one combined figure.
+
+Dependencies:
+-------------
+- Python 3.8+
+- numpy
+- sympy
+- matplotlib
+- plotly
+- IPython (for LaTeX rendering in notebooks)
+
+How to Use:
+-----------
+1. Import the helper script:
+   >>> from your_module_name import *
+
+2. Visualize a matrix:
+   >>> DMAT(np.array([[1, 2], [3, 4]]), name="A")
+
+3. Display a symbolic expression:
+   >>> x = sp.Symbol('x')
+   >>> DIS(sp.sin(x)**2 + sp.cos(x)**2, name="Identity")
+
+4. Plot a symbolic 2D graph:
+   >>> plot_2d([sp.sin(x), sp.cos(x)], var=(x, (-np.pi, np.pi)), labels=["sin(x)", "cos(x)"])
+
+5. Plot a 3D surface:
+   >>> plot_3d(sp.sin(x*y), var=(x, (-2, 2), y, (-2, 2)), title="sin(xy) surface")
+
+Notes:
+------
+- This toolkit is especially suited for education, math research, or lab reports
+  where symbolic clarity and visualization are critical.
+- Functions are designed to handle both SymPy and NumPy formats seamlessly.
+
+License:
+--------
+ADD RELEVANT 
+
+Contact:
+--------
+Name/Email

ibb_helper-0.1.2/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

ibb_helper-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ibb_helper-0.1.2/setup.py

@@ -0,0 +1,20 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='IBB_Helper', 
+    version='0.1.2',
+    packages=find_packages(), 
+    install_requires=[],
+    author='IBB',
+    author_email='stud193984@stud.uni-stuttgart.de',
+    description='helper functions',
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+    url='https://github.tik.uni-stuttgart.de/st193984/IBB_helper.git',
+    license="custom",
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: Other/Proprietary License',
+        'Operating System :: OS Independent',
+    ],
+)