rgwfuncs 0.0.50__tar.gz → 0.0.53__tar.gz

{rgwfuncs-0.0.50/src/rgwfuncs.egg-info → rgwfuncs-0.0.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.50
+Version: 0.0.53
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -370,17 +370,17 @@ Converts a polynomial expression written in Python syntax to a LaTeX formatted s
 
 Expands a polynomial expression written in Python syntax and converts it into a LaTeX formatted string. This function takes algebraic expressions provided as strings using Python's syntax, applies polynomial expansion through SymPy, and translates them into LaTeX representations, suitable for academic or professional documentation. It supports expressions with named variables and provides an option to substitute specific values into the expression before expansion.
 
-- Parameters:
+• Parameters:
   - `expression` (str): The algebraic expression to expand and convert to LaTeX. This string should be formatted using Python syntax acceptable by SymPy.
   - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers with which to substitute those variables before expanding.
 
-- Returns:
+• Returns:
   - `str`: The LaTeX formatted string of the expanded expression.
 
-- Raises:
+• Raises:
   - `ValueError`: If the expression cannot be parsed due to syntax errors.
 
-- Example:
+• Example:
 
     from rgwfuncs import expand_polynomial_expression
 
@@ -406,17 +406,17 @@ Expands a polynomial expression written in Python syntax and converts it into a
 
 Factors a polynomial expression written in Python syntax and converts it into a LaTeX formatted string. This function parses an algebraic expression, performs polynomial factoring using SymPy, and converts the factored expression into a LaTeX representation, ideal for academic or professional use. Optional substitutions can be made before factoring.
 
-- Parameters:
+• Parameters:
   - `expression` (str): The polynomial expression to factor and convert to LaTeX. This should be a valid expression formatted using Python syntax.
   - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions. The keys are variable names in the expression, and the values are numbers that replace these variables.
 
-- Returns:
+• Returns:
   - `str`: The LaTeX formatted string representing the factored expression.
 
-- Raises:
+• Raises:
   - `ValueError`: If the expression cannot be parsed due to syntax errors.
 
-- Example:
+• Example:
 
     from rgwfuncs import factor_polynomial_expression
 
@@ -430,35 +430,7 @@ Factors a polynomial expression written in Python syntax and converts it into a
 
 --------------------------------------------------------------------------------
 
-### 8. `cancel_polynomial_expression`
-
-Cancels common factors within a polynomial expression written in Python syntax and converts it to a LaTeX formatted string. This function parses an algebraic expression, cancels common factors using SymPy, and translates the reduced expression into a LaTeX representation. It can also accommodate optional substitutions to be made prior to simplification.
-
-- Parameters:
-  - `expression` (str): The algebraic expression to simplify and convert to LaTeX. This string should be formatted using Python syntax.
-  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers to substitute.
-
-- Returns:
-  - `str`: The LaTeX formatted string of the simplified expression. If the expression involves indeterminate forms due to operations like division by zero, a descriptive error message is returned instead.
-
-- Raises:
-  - `ValueError`: If the expression cannot be parsed due to syntax errors or involves undefined operations, such as division by zero.
-
-- Example:
-
-    from rgwfuncs import cancel_polynomial_expression
-
-    # Cancel common factors within a polynomial expression
-    latex_result1 = cancel_polynomial_expression("(x**2 - 4) / (x - 2)")
-    print(latex_result1)  # Output: "x + 2"
-
-    # Cancel with substituted values
-    latex_result2 = cancel_polynomial_expression("(x**2 - 4) / (x - 2)", {"x": 2})
-    print(latex_result2)  # Output: "Undefined result. This could be a division by zero error."
-
---------------------------------------------------------------------------------
-
-### 9. `simplify_polynomial_expression`
+### 8. `simplify_polynomial_expression`
 
 Simplifies an algebraic expression in polynomial form and returns it in LaTeX format. Takes an algebraic expression, in polynomial form, written in Python syntax and simplifies it. The result is returned as a LaTeX formatted string, suitable for academic or professional documentation.
 
@@ -469,7 +441,7 @@ Simplifies an algebraic expression in polynomial form and returns it in LaTeX fo
 • Returns:
   - `str`: The simplified expression formatted as a LaTeX string.
 
-• Example Usage:
+• Example:
 
     from rgwfuncs import simplify_polynomial_expression
 
@@ -491,6 +463,34 @@ Simplifies an algebraic expression in polynomial form and returns it in LaTeX fo
 
 --------------------------------------------------------------------------------
 
+### 9. `cancel_polynomial_expression`
+
+Cancels common factors within a polynomial expression written in Python syntax and converts it to a LaTeX formatted string. This function parses an algebraic expression, cancels common factors using SymPy, and translates the reduced expression into a LaTeX representation. It can also accommodate optional substitutions to be made prior to simplification.
+
+• Parameters:
+  - `expression` (str): The algebraic expression to simplify and convert to LaTeX. This string should be formatted using Python syntax.
+  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers to substitute.
+
+• Returns:
+  - `str`: The LaTeX formatted string of the simplified expression. If the expression involves indeterminate forms due to operations like division by zero, a descriptive error message is returned instead.
+
+• Raises:
+  - `ValueError`: If the expression cannot be parsed due to syntax errors or involves undefined operations, such as division by zero.
+
+• Example:
+
+    from rgwfuncs import cancel_polynomial_expression
+
+    # Cancel common factors within a polynomial expression
+    latex_result1 = cancel_polynomial_expression("(x**2 - 4) / (x - 2)")
+    print(latex_result1)  # Output: "x + 2"
+
+    # Cancel with substituted values
+    latex_result2 = cancel_polynomial_expression("(x**2 - 4) / (x - 2)", {"x": 2})
+    print(latex_result2)  # Output: "Undefined result. This could be a division by zero error."
+
+--------------------------------------------------------------------------------
+
 ### 10. `solve_homogeneous_polynomial_expression`
 
 Solves a homogeneous polynomial expression for a specified variable and returns solutions in LaTeX format. Assumes that the expression is homoegeneous (i.e. equal to zero), and solves for a designated variable. May optionally include substitutions for other variables in the equation. The solutions are provided as a LaTeX formatted string. The method solves equations for specified variables, with optional substitutions, returning LaTeX-formatted solutions.
@@ -514,6 +514,46 @@ Solves a homogeneous polynomial expression for a specified variable and returns
     
 --------------------------------------------------------------------------------
 
+### 11. `plot_polynomial_functions`
+
+This function plots polynomial functions described by a list of expressions and their corresponding substitution dictionaries. It generates SVG markup of the plots, with options for specifying the domain, axis zoom, and legend display.
+
+• Parameters:
+- `functions` (`List[Dict[str, Dict[str, Any]]]`): A list of dictionaries, each containing:
+  - A key which is a string representing a Python/NumPy expression (e.g., `"x**2"`, `"np.diff(x,2)"`).
+  - A value which is a dictionary containing substitutions for the expression. Must include an `"x"` key, either as `"*"` for default domain or a NumPy array.
+- `zoom` (`float`): Determines the numeric axis range from `-zoom` to `+zoom` for both x and y axes (default is `10.0`).
+- `show_legend` (`bool`): Specifies whether to include a legend in the plot (default is `True`).
+- `open_file` (`bool`): If saving to path is not desireable, opens the svg as a temp file, else opens the file from the actual location using the system's default viewer (defaults to False).
+- `save_path` (`Optional[str]`): If specified, saves the output string as a .svg at the indicated path (defaults to None).
+
+• Returns:
+- `str`: The raw SVG markup of the resulting plot.
+
+• Example:
+
+    from rgwfuncs import plot_polynomial_functions
+
+    # Generate the SVG
+    plot_svg_string = plot_polynomial_functions(
+        functions=[
+            {"x**2": {"x": "*"}},  # Single expression, "*" means plot all discernable points
+            {"x**2/(2 + a) + a": {"x": np.linspace(-3, 4, 101), "a": 1.23}},
+            {"np.diff(x**3, 2)": {"x": np.linspace(-2, 2, 10)}}
+        ],
+        zoom=2
+    )
+
+    # Write the SVG to an actual file
+    with open("plot.svg", "w", encoding="utf-8") as file:
+        file.write(plot_svg_string)
+
+• Displaying the SVG:
+
+    ![Plot](./media/plot_polynomial_functions_example_1.svg)
+
+--------------------------------------------------------------------------------
+
 ## String Based Functions
 
 ### 1. send_telegram_message

{rgwfuncs-0.0.50 → rgwfuncs-0.0.53}/README.md

@@ -343,17 +343,17 @@ Converts a polynomial expression written in Python syntax to a LaTeX formatted s
 
 Expands a polynomial expression written in Python syntax and converts it into a LaTeX formatted string. This function takes algebraic expressions provided as strings using Python's syntax, applies polynomial expansion through SymPy, and translates them into LaTeX representations, suitable for academic or professional documentation. It supports expressions with named variables and provides an option to substitute specific values into the expression before expansion.
 
-- Parameters:
+• Parameters:
   - `expression` (str): The algebraic expression to expand and convert to LaTeX. This string should be formatted using Python syntax acceptable by SymPy.
   - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers with which to substitute those variables before expanding.
 
-- Returns:
+• Returns:
   - `str`: The LaTeX formatted string of the expanded expression.
 
-- Raises:
+• Raises:
   - `ValueError`: If the expression cannot be parsed due to syntax errors.
 
-- Example:
+• Example:
 
     from rgwfuncs import expand_polynomial_expression
 
@@ -379,17 +379,17 @@ Expands a polynomial expression written in Python syntax and converts it into a
 
 Factors a polynomial expression written in Python syntax and converts it into a LaTeX formatted string. This function parses an algebraic expression, performs polynomial factoring using SymPy, and converts the factored expression into a LaTeX representation, ideal for academic or professional use. Optional substitutions can be made before factoring.
 
-- Parameters:
+• Parameters:
   - `expression` (str): The polynomial expression to factor and convert to LaTeX. This should be a valid expression formatted using Python syntax.
   - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions. The keys are variable names in the expression, and the values are numbers that replace these variables.
 
-- Returns:
+• Returns:
   - `str`: The LaTeX formatted string representing the factored expression.
 
-- Raises:
+• Raises:
   - `ValueError`: If the expression cannot be parsed due to syntax errors.
 
-- Example:
+• Example:
 
     from rgwfuncs import factor_polynomial_expression
 
@@ -403,35 +403,7 @@ Factors a polynomial expression written in Python syntax and converts it into a
 
 --------------------------------------------------------------------------------
 
-### 8. `cancel_polynomial_expression`
-
-Cancels common factors within a polynomial expression written in Python syntax and converts it to a LaTeX formatted string. This function parses an algebraic expression, cancels common factors using SymPy, and translates the reduced expression into a LaTeX representation. It can also accommodate optional substitutions to be made prior to simplification.
-
-- Parameters:
-  - `expression` (str): The algebraic expression to simplify and convert to LaTeX. This string should be formatted using Python syntax.
-  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers to substitute.
-
-- Returns:
-  - `str`: The LaTeX formatted string of the simplified expression. If the expression involves indeterminate forms due to operations like division by zero, a descriptive error message is returned instead.
-
-- Raises:
-  - `ValueError`: If the expression cannot be parsed due to syntax errors or involves undefined operations, such as division by zero.
-
-- Example:
-
-    from rgwfuncs import cancel_polynomial_expression
-
-    # Cancel common factors within a polynomial expression
-    latex_result1 = cancel_polynomial_expression("(x**2 - 4) / (x - 2)")
-    print(latex_result1)  # Output: "x + 2"
-
-    # Cancel with substituted values
-    latex_result2 = cancel_polynomial_expression("(x**2 - 4) / (x - 2)", {"x": 2})
-    print(latex_result2)  # Output: "Undefined result. This could be a division by zero error."
-
---------------------------------------------------------------------------------
-
-### 9. `simplify_polynomial_expression`
+### 8. `simplify_polynomial_expression`
 
 Simplifies an algebraic expression in polynomial form and returns it in LaTeX format. Takes an algebraic expression, in polynomial form, written in Python syntax and simplifies it. The result is returned as a LaTeX formatted string, suitable for academic or professional documentation.
 
@@ -442,7 +414,7 @@ Simplifies an algebraic expression in polynomial form and returns it in LaTeX fo
 • Returns:
   - `str`: The simplified expression formatted as a LaTeX string.
 
-• Example Usage:
+• Example:
 
     from rgwfuncs import simplify_polynomial_expression
 
@@ -464,6 +436,34 @@ Simplifies an algebraic expression in polynomial form and returns it in LaTeX fo
 
 --------------------------------------------------------------------------------
 
+### 9. `cancel_polynomial_expression`
+
+Cancels common factors within a polynomial expression written in Python syntax and converts it to a LaTeX formatted string. This function parses an algebraic expression, cancels common factors using SymPy, and translates the reduced expression into a LaTeX representation. It can also accommodate optional substitutions to be made prior to simplification.
+
+• Parameters:
+  - `expression` (str): The algebraic expression to simplify and convert to LaTeX. This string should be formatted using Python syntax.
+  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers to substitute.
+
+• Returns:
+  - `str`: The LaTeX formatted string of the simplified expression. If the expression involves indeterminate forms due to operations like division by zero, a descriptive error message is returned instead.
+
+• Raises:
+  - `ValueError`: If the expression cannot be parsed due to syntax errors or involves undefined operations, such as division by zero.
+
+• Example:
+
+    from rgwfuncs import cancel_polynomial_expression
+
+    # Cancel common factors within a polynomial expression
+    latex_result1 = cancel_polynomial_expression("(x**2 - 4) / (x - 2)")
+    print(latex_result1)  # Output: "x + 2"
+
+    # Cancel with substituted values
+    latex_result2 = cancel_polynomial_expression("(x**2 - 4) / (x - 2)", {"x": 2})
+    print(latex_result2)  # Output: "Undefined result. This could be a division by zero error."
+
+--------------------------------------------------------------------------------
+
 ### 10. `solve_homogeneous_polynomial_expression`
 
 Solves a homogeneous polynomial expression for a specified variable and returns solutions in LaTeX format. Assumes that the expression is homoegeneous (i.e. equal to zero), and solves for a designated variable. May optionally include substitutions for other variables in the equation. The solutions are provided as a LaTeX formatted string. The method solves equations for specified variables, with optional substitutions, returning LaTeX-formatted solutions.
@@ -487,6 +487,46 @@ Solves a homogeneous polynomial expression for a specified variable and returns
     
 --------------------------------------------------------------------------------
 
+### 11. `plot_polynomial_functions`
+
+This function plots polynomial functions described by a list of expressions and their corresponding substitution dictionaries. It generates SVG markup of the plots, with options for specifying the domain, axis zoom, and legend display.
+
+• Parameters:
+- `functions` (`List[Dict[str, Dict[str, Any]]]`): A list of dictionaries, each containing:
+  - A key which is a string representing a Python/NumPy expression (e.g., `"x**2"`, `"np.diff(x,2)"`).
+  - A value which is a dictionary containing substitutions for the expression. Must include an `"x"` key, either as `"*"` for default domain or a NumPy array.
+- `zoom` (`float`): Determines the numeric axis range from `-zoom` to `+zoom` for both x and y axes (default is `10.0`).
+- `show_legend` (`bool`): Specifies whether to include a legend in the plot (default is `True`).
+- `open_file` (`bool`): If saving to path is not desireable, opens the svg as a temp file, else opens the file from the actual location using the system's default viewer (defaults to False).
+- `save_path` (`Optional[str]`): If specified, saves the output string as a .svg at the indicated path (defaults to None).
+
+• Returns:
+- `str`: The raw SVG markup of the resulting plot.
+
+• Example:
+
+    from rgwfuncs import plot_polynomial_functions
+
+    # Generate the SVG
+    plot_svg_string = plot_polynomial_functions(
+        functions=[
+            {"x**2": {"x": "*"}},  # Single expression, "*" means plot all discernable points
+            {"x**2/(2 + a) + a": {"x": np.linspace(-3, 4, 101), "a": 1.23}},
+            {"np.diff(x**3, 2)": {"x": np.linspace(-2, 2, 10)}}
+        ],
+        zoom=2
+    )
+
+    # Write the SVG to an actual file
+    with open("plot.svg", "w", encoding="utf-8") as file:
+        file.write(plot_svg_string)
+
+• Displaying the SVG:
+
+    ![Plot](./media/plot_polynomial_functions_example_1.svg)
+
+--------------------------------------------------------------------------------
+
 ## String Based Functions
 
 ### 1. send_telegram_message

{rgwfuncs-0.0.50 → rgwfuncs-0.0.53}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rgwfuncs"
-version = "0.0.50"
+version = "0.0.53"
 authors = [
   { name = "Ryan Gerard Wilson", email = "ryangerardwilson@gmail.com" },
 ]

{rgwfuncs-0.0.50 → rgwfuncs-0.0.53}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = rgwfuncs
-version = 0.0.50
+version = 0.0.53
 author = Ryan Gerard Wilson
 author_email = ryangerardwilson@gmail.com
 description = A functional programming paradigm for mathematical modelling and data science

{rgwfuncs-0.0.50 → rgwfuncs-0.0.53}/src/rgwfuncs/__init__.py

@@ -1,7 +1,7 @@
 # This file is automatically generated
 # Dynamically importing functions from modules
 
-from .algebra_lib import cancel_polynomial_expression, compute_constant_expression, compute_constant_expression_involving_matrices, compute_constant_expression_involving_ordered_series, compute_prime_factors, expand_polynomial_expression, factor_polynomial_expression, python_polynomial_expression_to_latex, simplify_polynomial_expression, solve_homogeneous_polynomial_expression
+from .algebra_lib import cancel_polynomial_expression, compute_constant_expression, compute_constant_expression_involving_matrices, compute_constant_expression_involving_ordered_series, compute_prime_factors, expand_polynomial_expression, factor_polynomial_expression, plot_polynomial_functions, python_polynomial_expression_to_latex, simplify_polynomial_expression, solve_homogeneous_polynomial_expression
 from .df_lib import append_columns, append_percentile_classification_column, append_ranged_classification_column, append_ranged_date_classification_column, append_rows, append_xgb_labels, append_xgb_logistic_regression_predictions, append_xgb_regression_predictions, bag_union_join, bottom_n_unique_values, cascade_sort, delete_rows, drop_duplicates, drop_duplicates_retain_first, drop_duplicates_retain_last, filter_dataframe, filter_indian_mobiles, first_n_rows, from_raw_data, insert_dataframe_in_sqlite_database, last_n_rows, left_join, limit_dataframe, load_data_from_path, load_data_from_query, load_data_from_sqlite_path, mask_against_dataframe, mask_against_dataframe_converse, numeric_clean, order_columns, print_correlation, print_dataframe, print_memory_usage, print_n_frequency_cascading, print_n_frequency_linear, rename_columns, retain_columns, right_join, send_data_to_email, send_data_to_slack, send_dataframe_via_telegram, sync_dataframe_to_sqlite_database, top_n_unique_values, union_join, update_rows
 from .docs_lib import docs
 from .interactive_shell_lib import interactive_shell

{rgwfuncs-0.0.50 → rgwfuncs-0.0.53}/src/rgwfuncs/algebra_lib.py

@@ -1,14 +1,18 @@
 import re
 import math
 import ast
+import subprocess
+import tempfile
 from sympy import symbols, latex, simplify, solve, diff, Expr, factor, cancel, Eq
 from sympy.core.sympify import SympifyError
 from sympy.core import S
 from sympy.parsing.sympy_parser import parse_expr
 from sympy import __all__ as sympy_functions
 from sympy.parsing.sympy_parser import (standard_transformations, implicit_multiplication_application)
-
-from typing import Tuple, List, Dict, Optional
+from typing import Tuple, List, Dict, Optional, Any
+import numpy as np
+import matplotlib.pyplot as plt
+from io import BytesIO
 
 
 def compute_prime_factors(n: int) -> str:
@@ -285,7 +289,6 @@ def python_polynomial_expression_to_latex(
     Raises:
     ValueError: If the expression cannot be parsed due to syntax errors.
     """
-
     transformations = standard_transformations + (implicit_multiplication_application,)
 
     def parse_and_convert_expression(expr_str: str, sym_vars: Dict[str, Expr]) -> Expr:
@@ -411,69 +414,6 @@ def factor_polynomial_expression(
     return latex_result
 
 
-def cancel_polynomial_expression(
-    expression: str,
-    subs: Optional[Dict[str, float]] = None
-) -> str:
-    """
-    Cancels common factors within a polynomial expression and converts it to LaTeX format.
-
-    This function parses an algebraic expression given in Python syntax, cancels any common factors,
-    and converts the resulting simplified expression into a LaTeX formatted string. The function can
-    also handle optional substitutions of variables before performing the cancellation.
-
-    Parameters:
-    expression (str): The algebraic expression to simplify and convert to LaTeX.
-                      It should be a valid expression formatted using Python syntax.
-    subs (Optional[Dict[str, float]]): An optional dictionary where the keys are variable names in the
-                                       expression, and the values are the corresponding numbers to substitute
-                                       into the expression before simplification.
-
-    Returns:
-    str: The LaTeX formatted string of the simplified expression. If the expression involves
-         indeterminate forms due to operations like division by zero, a descriptive error message is returned instead.
-
-    Raises:
-    ValueError: If the expression cannot be parsed due to syntax errors or if operations result in
-                undefined behavior, such as division by zero.
-
-    """
-    transformations = standard_transformations + (implicit_multiplication_application,)
-
-    def parse_and_cancel_expression(expr_str: str, sym_vars: Dict[str, symbols]) -> symbols:
-        try:
-            expr = parse_expr(expr_str, local_dict=sym_vars, transformations=transformations)
-            if subs:
-                if not isinstance(subs, dict):
-                    raise ValueError(f"Substitutions must be a dictionary. Received: {subs}")
-                subs_symbols = {symbols(k): v for k, v in subs.items()}
-                expr = expr.subs(subs_symbols)
-
-            canceled_expr = cancel(expr)
-
-            # Check for NaN or indeterminate forms
-            if canceled_expr.has(S.NaN) or canceled_expr.has(S.Infinity) or canceled_expr.has(S.ComplexInfinity):
-                return "Undefined result. This could be a division by zero error."
-
-            return canceled_expr
-
-        except (SyntaxError, ValueError, TypeError, AttributeError, ZeroDivisionError, SympifyError) as e:
-            return f"Error: {str(e)}"
-
-    variable_names = set(re.findall(r'\b[a-zA-Z]\w*\b', expression))
-    sym_vars = {var: symbols(var) for var in variable_names}
-
-    expr = parse_and_cancel_expression(expression, sym_vars)
-
-    # If the expression is already a string (i.e., "Undefined" or error message), return it directly
-    if isinstance(expr, str):
-        return expr
-
-    # Otherwise, convert to LaTeX as usual
-    latex_result = latex(expr)
-    return latex_result
-
-
 def simplify_polynomial_expression(
     expression: str,
     subs: Optional[Dict[str, float]] = None
@@ -649,6 +589,69 @@ def simplify_polynomial_expression(
         raise ValueError(f"Error simplifying expression: {e}")
 
 
+def cancel_polynomial_expression(
+    expression: str,
+    subs: Optional[Dict[str, float]] = None
+) -> str:
+    """
+    Cancels common factors within a polynomial expression and converts it to LaTeX format.
+
+    This function parses an algebraic expression given in Python syntax, cancels any common factors,
+    and converts the resulting simplified expression into a LaTeX formatted string. The function can
+    also handle optional substitutions of variables before performing the cancellation.
+
+    Parameters:
+    expression (str): The algebraic expression to simplify and convert to LaTeX.
+                      It should be a valid expression formatted using Python syntax.
+    subs (Optional[Dict[str, float]]): An optional dictionary where the keys are variable names in the
+                                       expression, and the values are the corresponding numbers to substitute
+                                       into the expression before simplification.
+
+    Returns:
+    str: The LaTeX formatted string of the simplified expression. If the expression involves
+         indeterminate forms due to operations like division by zero, a descriptive error message is returned instead.
+
+    Raises:
+    ValueError: If the expression cannot be parsed due to syntax errors or if operations result in
+                undefined behavior, such as division by zero.
+
+    """
+    transformations = standard_transformations + (implicit_multiplication_application,)
+
+    def parse_and_cancel_expression(expr_str: str, sym_vars: Dict[str, symbols]) -> symbols:
+        try:
+            expr = parse_expr(expr_str, local_dict=sym_vars, transformations=transformations)
+            if subs:
+                if not isinstance(subs, dict):
+                    raise ValueError(f"Substitutions must be a dictionary. Received: {subs}")
+                subs_symbols = {symbols(k): v for k, v in subs.items()}
+                expr = expr.subs(subs_symbols)
+
+            canceled_expr = cancel(expr)
+
+            # Check for NaN or indeterminate forms
+            if canceled_expr.has(S.NaN) or canceled_expr.has(S.Infinity) or canceled_expr.has(S.ComplexInfinity):
+                return "Undefined result. This could be a division by zero error."
+
+            return canceled_expr
+
+        except (SyntaxError, ValueError, TypeError, AttributeError, ZeroDivisionError, SympifyError) as e:
+            return f"Error: {str(e)}"
+
+    variable_names = set(re.findall(r'\b[a-zA-Z]\w*\b', expression))
+    sym_vars = {var: symbols(var) for var in variable_names}
+
+    expr = parse_and_cancel_expression(expression, sym_vars)
+
+    # If the expression is already a string (i.e., "Undefined" or error message), return it directly
+    if isinstance(expr, str):
+        return expr
+
+    # Otherwise, convert to LaTeX as usual
+    latex_result = latex(expr)
+    return latex_result
+
+
 def solve_homogeneous_polynomial_expression(
     expression: str,
     variable: str,
@@ -701,3 +704,184 @@ def solve_homogeneous_polynomial_expression(
 
     except Exception as e:
         raise ValueError(f"Error solving the expression: {e}")
+
+
+def plot_polynomial_functions(
+    functions: List[Dict[str, Dict[str, Any]]],
+    zoom: float = 10.0,
+    show_legend: bool = True,
+    open_file: bool = False,
+    save_path: Optional[str] = None,
+) -> str:
+    """
+    Plots expressions described by a list of dictionaries of the form:
+        [
+          { "expression_string": { "x": "*", "a":..., "b":... } },
+          { "expression_string": { "x": np.linspace(...), "a":..., ... } },
+          ...
+        ]
+
+    In each top-level dictionary, there is exactly one key (a string
+    representing a Python/NumPy expression) and one value (a dictionary of
+    substitutions). This substitutions dictionary must have an "x" key:
+      • "x": "*"  -> Use a default domain from -zoom..+zoom.
+      • "x": np.array(...)  -> Use that array as the domain.
+    Other variables (like "a", "b", etc.) may also appear in the same dict.
+
+    Additionally, we use latexify_expression(...) to transform the expression
+    into a nice LaTeX form for the legend, including a special Δ notation for np.diff(...).
+
+    Parameters
+    ----------
+    functions : List[Dict[str, Dict[str, Any]]]
+        A list of items. Each item is a dictionary:
+          key   = expression string (e.g., "x**2", "np.diff(x,2)", etc.)
+          value = a dictionary of substitutions. Must contain "x",
+                  either as "*" or a NumPy array. May contain additional
+                  parameters like "a", "b", etc.
+    zoom : float
+        Sets the numeric axis range from -zoom..+zoom in both x and y.
+    show_legend : bool
+        Whether to add a legend to the plot (defaults to True).
+    open_file : bool
+        If saving to path is not desireable, opens the svg as a temp file, else opens
+        the file from the actual location using the system's default viewer (defaults to
+        False).
+    save_path : Optional[str]
+        If specified, saves the output string as a .svg at the indicated path (defaults to
+        None).
+
+    Returns
+    -------
+    str
+        The raw SVG markup of the resulting plot.
+    """
+
+    def latexify_expression(expr_str: str) -> str:
+        # Regex to locate np.diff(...) with an optional second argument
+        DIFF_PATTERN = r"np\.diff\s*\(\s*([^,\)]+)(?:,\s*(\d+))?\)"
+
+        def diff_replacer(match: re.Match) -> str:
+            inside = match.group(1).strip()
+            exponent = match.group(2)
+            inside_no_np = inside.replace("np.", "")
+            if exponent:
+                return rf"\Delta^{exponent}\left({inside_no_np}\right)"
+            else:
+                return rf"\Delta\left({inside_no_np}\right)"
+
+        expr_tmp = re.sub(DIFF_PATTERN, diff_replacer, expr_str)
+        expr_tmp = expr_tmp.replace("np.", "")
+        try:
+            latex_expr = python_polynomial_expression_to_latex(expr_tmp)
+            return latex_expr
+        except Exception:
+            # Fallback: just do naive **
+            return expr_tmp.replace("**", "^")
+
+    def handle_open_and_save(
+        svg_string: str,
+        open_file: bool,
+        save_path: Optional[str]
+    ) -> None:
+        # Save the SVG to a file if a save path is provided
+        if save_path:
+            try:
+                with open(save_path, 'w', encoding='utf-8') as file:
+                    file.write(svg_string)
+                print(f"[INFO] SVG saved to: {save_path}")
+            except IOError as e:
+                print(f"[ERROR] Failed to save SVG to {save_path}. IOError: {e}")
+
+        # Handle opening the file if requested
+        if open_file and save_path:
+            result = subprocess.run(["xdg-open", save_path], stderr=subprocess.DEVNULL)
+            if result.returncode != 0:
+                print("[ERROR] Failed to open the SVG file with the default viewer.")
+        elif open_file:
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".svg") as tmpfile:
+                temp_svg_path = tmpfile.name
+                tmpfile.write(svg_string.encode('utf-8'))
+            result = subprocess.run(["xdg-open", temp_svg_path], stderr=subprocess.DEVNULL)
+            if result.returncode != 0:
+                print("[ERROR] Failed to open the SVG file with the default viewer.")
+
+    buffer = BytesIO()
+    fig, ax = plt.subplots()
+
+    for entry in functions:
+        if len(entry) != 1:
+            print("Skipping invalid item. Must have exactly 1 expression->substitutions pair.")
+            continue
+
+        expression, sub_dict = list(entry.items())[0]
+        if "x" not in sub_dict:
+            print(f"Skipping '{expression}' because sub-dict lacks 'x' key.")
+            continue
+
+        # If "x" is "*", create a default domain
+        x_val = sub_dict["x"]
+        if isinstance(x_val, str) and x_val == "*":
+            x_values = np.linspace(-zoom, zoom, 1201)
+            sub_dict["x"] = x_values
+        elif isinstance(x_val, np.ndarray):
+            x_values = x_val
+        else:
+            print(f"Skipping '{expression}' because 'x' is neither '*' nor a NumPy array.")
+            continue
+
+        # Evaluate the expression
+        try:
+            eval_context = {"np": np}
+            eval_context.update(sub_dict)
+            y_values = eval(expression, {"np": np}, eval_context)
+        except Exception as e:
+            print(f"Error evaluating expression '{expression}': {e}")
+            continue
+
+        if not isinstance(y_values, np.ndarray):
+            print(f"Skipping '{expression}' because it did not produce a NumPy array.")
+            continue
+
+        # If y_values is shorter than x_values (like np.diff), truncate x
+        if len(y_values) < len(x_values):
+            x_values = x_values[:len(y_values)]
+
+        # Convert expression to a nice LaTeX string
+        label_expr = latexify_expression(expression)
+        ax.plot(x_values, y_values, label=rf"${label_expr}$")
+
+    # Configure axes
+    ax.set_xlim(-zoom, zoom)
+    ax.set_ylim(-zoom, zoom)
+    ax.spines['left'].set_position('zero')
+    ax.spines['bottom'].set_position('zero')
+    ax.spines['right'].set_color('none')
+    ax.spines['top'].set_color('none')
+    ax.set_aspect('equal', 'box')
+    ax.xaxis.set_ticks_position('bottom')
+    ax.yaxis.set_ticks_position('left')
+    ax.grid(True)
+
+    # Show legend
+    if show_legend:
+        leg = ax.legend(
+            loc='upper center',
+            bbox_to_anchor=(0.5, -0.03),
+            fancybox=True,
+            shadow=True,
+            ncol=1
+        )
+        plt.savefig(
+            buffer,
+            format='svg',
+            bbox_inches='tight',
+            bbox_extra_artists=[leg]  # ensures the legend is fully captured
+        )
+    else:
+        plt.savefig(buffer, format='svg', bbox_inches='tight')
+
+    plt.close(fig)
+    svg_string = buffer.getvalue().decode('utf-8')
+    handle_open_and_save(svg_string, open_file, save_path)
+    return svg_string

{rgwfuncs-0.0.50 → rgwfuncs-0.0.53/src/rgwfuncs.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.50
+Version: 0.0.53
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -370,17 +370,17 @@ Converts a polynomial expression written in Python syntax to a LaTeX formatted s
 
 Expands a polynomial expression written in Python syntax and converts it into a LaTeX formatted string. This function takes algebraic expressions provided as strings using Python's syntax, applies polynomial expansion through SymPy, and translates them into LaTeX representations, suitable for academic or professional documentation. It supports expressions with named variables and provides an option to substitute specific values into the expression before expansion.
 
-- Parameters:
+• Parameters:
   - `expression` (str): The algebraic expression to expand and convert to LaTeX. This string should be formatted using Python syntax acceptable by SymPy.
   - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers with which to substitute those variables before expanding.
 
-- Returns:
+• Returns:
   - `str`: The LaTeX formatted string of the expanded expression.
 
-- Raises:
+• Raises:
   - `ValueError`: If the expression cannot be parsed due to syntax errors.
 
-- Example:
+• Example:
 
     from rgwfuncs import expand_polynomial_expression
 
@@ -406,17 +406,17 @@ Expands a polynomial expression written in Python syntax and converts it into a
 
 Factors a polynomial expression written in Python syntax and converts it into a LaTeX formatted string. This function parses an algebraic expression, performs polynomial factoring using SymPy, and converts the factored expression into a LaTeX representation, ideal for academic or professional use. Optional substitutions can be made before factoring.
 
-- Parameters:
+• Parameters:
   - `expression` (str): The polynomial expression to factor and convert to LaTeX. This should be a valid expression formatted using Python syntax.
   - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions. The keys are variable names in the expression, and the values are numbers that replace these variables.
 
-- Returns:
+• Returns:
   - `str`: The LaTeX formatted string representing the factored expression.
 
-- Raises:
+• Raises:
   - `ValueError`: If the expression cannot be parsed due to syntax errors.
 
-- Example:
+• Example:
 
     from rgwfuncs import factor_polynomial_expression
 
@@ -430,35 +430,7 @@ Factors a polynomial expression written in Python syntax and converts it into a
 
 --------------------------------------------------------------------------------
 
-### 8. `cancel_polynomial_expression`
-
-Cancels common factors within a polynomial expression written in Python syntax and converts it to a LaTeX formatted string. This function parses an algebraic expression, cancels common factors using SymPy, and translates the reduced expression into a LaTeX representation. It can also accommodate optional substitutions to be made prior to simplification.
-
-- Parameters:
-  - `expression` (str): The algebraic expression to simplify and convert to LaTeX. This string should be formatted using Python syntax.
-  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers to substitute.
-
-- Returns:
-  - `str`: The LaTeX formatted string of the simplified expression. If the expression involves indeterminate forms due to operations like division by zero, a descriptive error message is returned instead.
-
-- Raises:
-  - `ValueError`: If the expression cannot be parsed due to syntax errors or involves undefined operations, such as division by zero.
-
-- Example:
-
-    from rgwfuncs import cancel_polynomial_expression
-
-    # Cancel common factors within a polynomial expression
-    latex_result1 = cancel_polynomial_expression("(x**2 - 4) / (x - 2)")
-    print(latex_result1)  # Output: "x + 2"
-
-    # Cancel with substituted values
-    latex_result2 = cancel_polynomial_expression("(x**2 - 4) / (x - 2)", {"x": 2})
-    print(latex_result2)  # Output: "Undefined result. This could be a division by zero error."
-
---------------------------------------------------------------------------------
-
-### 9. `simplify_polynomial_expression`
+### 8. `simplify_polynomial_expression`
 
 Simplifies an algebraic expression in polynomial form and returns it in LaTeX format. Takes an algebraic expression, in polynomial form, written in Python syntax and simplifies it. The result is returned as a LaTeX formatted string, suitable for academic or professional documentation.
 
@@ -469,7 +441,7 @@ Simplifies an algebraic expression in polynomial form and returns it in LaTeX fo
 • Returns:
   - `str`: The simplified expression formatted as a LaTeX string.
 
-• Example Usage:
+• Example:
 
     from rgwfuncs import simplify_polynomial_expression
 
@@ -491,6 +463,34 @@ Simplifies an algebraic expression in polynomial form and returns it in LaTeX fo
 
 --------------------------------------------------------------------------------
 
+### 9. `cancel_polynomial_expression`
+
+Cancels common factors within a polynomial expression written in Python syntax and converts it to a LaTeX formatted string. This function parses an algebraic expression, cancels common factors using SymPy, and translates the reduced expression into a LaTeX representation. It can also accommodate optional substitutions to be made prior to simplification.
+
+• Parameters:
+  - `expression` (str): The algebraic expression to simplify and convert to LaTeX. This string should be formatted using Python syntax.
+  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers to substitute.
+
+• Returns:
+  - `str`: The LaTeX formatted string of the simplified expression. If the expression involves indeterminate forms due to operations like division by zero, a descriptive error message is returned instead.
+
+• Raises:
+  - `ValueError`: If the expression cannot be parsed due to syntax errors or involves undefined operations, such as division by zero.
+
+• Example:
+
+    from rgwfuncs import cancel_polynomial_expression
+
+    # Cancel common factors within a polynomial expression
+    latex_result1 = cancel_polynomial_expression("(x**2 - 4) / (x - 2)")
+    print(latex_result1)  # Output: "x + 2"
+
+    # Cancel with substituted values
+    latex_result2 = cancel_polynomial_expression("(x**2 - 4) / (x - 2)", {"x": 2})
+    print(latex_result2)  # Output: "Undefined result. This could be a division by zero error."
+
+--------------------------------------------------------------------------------
+
 ### 10. `solve_homogeneous_polynomial_expression`
 
 Solves a homogeneous polynomial expression for a specified variable and returns solutions in LaTeX format. Assumes that the expression is homoegeneous (i.e. equal to zero), and solves for a designated variable. May optionally include substitutions for other variables in the equation. The solutions are provided as a LaTeX formatted string. The method solves equations for specified variables, with optional substitutions, returning LaTeX-formatted solutions.
@@ -514,6 +514,46 @@ Solves a homogeneous polynomial expression for a specified variable and returns
     
 --------------------------------------------------------------------------------
 
+### 11. `plot_polynomial_functions`
+
+This function plots polynomial functions described by a list of expressions and their corresponding substitution dictionaries. It generates SVG markup of the plots, with options for specifying the domain, axis zoom, and legend display.
+
+• Parameters:
+- `functions` (`List[Dict[str, Dict[str, Any]]]`): A list of dictionaries, each containing:
+  - A key which is a string representing a Python/NumPy expression (e.g., `"x**2"`, `"np.diff(x,2)"`).
+  - A value which is a dictionary containing substitutions for the expression. Must include an `"x"` key, either as `"*"` for default domain or a NumPy array.
+- `zoom` (`float`): Determines the numeric axis range from `-zoom` to `+zoom` for both x and y axes (default is `10.0`).
+- `show_legend` (`bool`): Specifies whether to include a legend in the plot (default is `True`).
+- `open_file` (`bool`): If saving to path is not desireable, opens the svg as a temp file, else opens the file from the actual location using the system's default viewer (defaults to False).
+- `save_path` (`Optional[str]`): If specified, saves the output string as a .svg at the indicated path (defaults to None).
+
+• Returns:
+- `str`: The raw SVG markup of the resulting plot.
+
+• Example:
+
+    from rgwfuncs import plot_polynomial_functions
+
+    # Generate the SVG
+    plot_svg_string = plot_polynomial_functions(
+        functions=[
+            {"x**2": {"x": "*"}},  # Single expression, "*" means plot all discernable points
+            {"x**2/(2 + a) + a": {"x": np.linspace(-3, 4, 101), "a": 1.23}},
+            {"np.diff(x**3, 2)": {"x": np.linspace(-2, 2, 10)}}
+        ],
+        zoom=2
+    )
+
+    # Write the SVG to an actual file
+    with open("plot.svg", "w", encoding="utf-8") as file:
+        file.write(plot_svg_string)
+
+• Displaying the SVG:
+
+    ![Plot](./media/plot_polynomial_functions_example_1.svg)
+
+--------------------------------------------------------------------------------
+
 ## String Based Functions
 
 ### 1. send_telegram_message