rgwfuncs 0.0.42__py3-none-any.whl → 0.0.47__py3-none-any.whl

rgwfuncs/__init__.py

@@ -1,7 +1,7 @@
 # This file is automatically generated
 # Dynamically importing functions from modules
 
-from .algebra_lib import compute_constant_expression, compute_constant_expression_involving_matrices, compute_constant_expression_involving_ordered_series, compute_prime_factors, expand_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, 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/algebra_lib.py

@@ -2,7 +2,9 @@ import re
 import math
 import ast
 # import numpy as np
-from sympy import symbols, latex, simplify, solve, diff, Expr
+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)
@@ -320,6 +322,7 @@ def python_polynomial_expression_to_latex(
     latex_result = latex(expr)
     return latex_result
 
+
 def expand_polynomial_expression(
     expression: str,
     subs: Optional[Dict[str, float]] = None
@@ -327,15 +330,15 @@ def expand_polynomial_expression(
     """
     Expands a polynomial expression written in Python syntax and converts it to LaTeX format.
 
-    This function takes an algebraic expression written in Python syntax, 
-    applies polynomial expansion, and converts the expanded expression 
+    This function takes an algebraic expression written in Python syntax,
+    applies polynomial expansion, and converts the expanded expression
     to a LaTeX formatted string. The expression should be compatible with sympy.
 
     Parameters:
-    expression (str): The algebraic expression to expand and convert to LaTeX. 
+    expression (str): The algebraic expression to expand and convert to LaTeX.
                       The expression should be written using Python syntax.
-    subs (Optional[Dict[str, float]]): An optional dictionary of substitutions 
-                                       to apply to variables in the expression 
+    subs (Optional[Dict[str, float]]): An optional dictionary of substitutions
+                                       to apply to variables in the expression
                                        before expansion.
 
     Returns:
@@ -345,15 +348,18 @@ def expand_polynomial_expression(
     ValueError: If the expression cannot be parsed due to syntax errors.
     """
     transformations = standard_transformations + (implicit_multiplication_application,)
-    
+
     def parse_and_expand_expression(expr_str: str, sym_vars: Dict[str, symbols]) -> symbols:
         try:
             expr = parse_expr(expr_str, local_dict=sym_vars, transformations=transformations)
             if subs:
+                # Ensure that subs is a dictionary
+                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)
             return expr.expand()
-        except (SyntaxError, ValueError, TypeError) as e:
+        except (SyntaxError, ValueError, TypeError, AttributeError) as e:
             raise ValueError(f"Error parsing expression: {expr_str}. Error: {e}")
 
     variable_names = set(re.findall(r'\b[a-zA-Z]\w*\b', expression))
@@ -364,6 +370,110 @@ def expand_polynomial_expression(
     return latex_result
 
 
+def factor_polynomial_expression(
+    expression: str,
+    subs: Optional[Dict[str, float]] = None
+) -> str:
+    """
+    Factors a polynomial expression written in Python syntax and converts it to LaTeX format.
+
+    This function accepts an algebraic expression in Python syntax, performs polynomial factoring,
+    and translates the factored expression into a LaTeX formatted string.
+
+    Parameters:
+    expression (str): The algebraic expression to factor and convert to LaTeX.
+    subs (Optional[Dict[str, float]]): An optional dictionary of substitutions to apply before factoring.
+
+    Returns:
+    str: The LaTeX formatted string of the factored expression.
+
+    Raises:
+    ValueError: If the expression cannot be parsed due to syntax errors.
+    """
+    transformations = standard_transformations + (implicit_multiplication_application,)
+
+    def parse_and_factor_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)
+            return factor(expr)
+        except (SyntaxError, ValueError, TypeError, AttributeError) as e:
+            raise ValueError(f"Error parsing expression: {expr_str}. Error: {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_factor_expression(expression, sym_vars)
+    latex_result = latex(expr)
+    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,
@@ -566,28 +676,35 @@ def solve_homogeneous_polynomial_expression(
     ValueError: If the equation cannot be solved due to errors in expression or parameters.
     """
 
+    print("679", expression)
+    print("681", variable)
+    print("682", subs)
     try:
         # Create symbols for the variables in the expression
         variable_symbols = set(re.findall(r'\b[a-zA-Z]\w*\b', expression))
         sym_vars = {var: symbols(var) for var in variable_symbols}
 
-        # Parse the expression and solve it
+        # Parse the expression
         expr = parse_expr(expression, local_dict=sym_vars)
-        var_symbol = symbols(variable)
-        solutions = solve(expr, var_symbol)
 
-        # Apply substitutions if provided
+        # If substitutions are provided, apply them
         if subs:
-            subs_symbols = {symbols(k): v for k, v in subs.items()}
-            solutions = [simplify(sol.subs(subs_symbols)) for sol in solutions]
+            expr = expr.subs({symbols(k): v for k, v in subs.items()})
+
+        # Ensure the variable is treated as a symbol for solving
+        var_symbol = symbols(variable)
+
+        # Solve for the variable
+        eq = Eq(expr, 0)
+        solutions = solve(eq, var_symbol)
 
         # Convert solutions to LaTeX strings if possible
-        latex_solutions = [
-            latex(
-                simplify(sol)) if sol.free_symbols else str(sol) for sol in solutions]
+        latex_solutions = [latex(simplify(sol)) for sol in solutions]
         result = r"\left[" + ", ".join(latex_solutions) + r"\right]"
-        print("158", result)
+
+        print("704", result)
         return result
 
     except Exception as e:
         raise ValueError(f"Error solving the expression: {e}")
+

rgwfuncs/df_lib.py

@@ -400,7 +400,6 @@ def load_data_from_query(db_preset_name: str, query: str) -> pd.DataFrame:
 
         return pd.DataFrame(rows, columns=columns)
 
-
     def query_athena(db_preset: Dict[str, Any], query: str) -> pd.DataFrame:
 
         def execute_athena_query(athena_client, query: str, database: str, output_bucket: str) -> str:
@@ -434,11 +433,10 @@ def load_data_from_query(db_preset_name: str, query: str) -> pd.DataFrame:
             data = [[col.get("VarCharValue", None) for col in row["Data"]] for row in rows[1:]]
             return pd.DataFrame(data, columns=columns)
 
-
         aws_region = db_preset['aws_region']
         database = db_preset['database']
         output_bucket = db_preset['output_bucket']
-        
+
         athena_client = boto3.client(
             'athena',
             region_name=aws_region,

{rgwfuncs-0.0.42.dist-info → rgwfuncs-0.0.47.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.42
+Version: 0.0.47
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -402,7 +402,63 @@ Expands a polynomial expression written in Python syntax and converts it into a
 
 --------------------------------------------------------------------------------
 
-### 6. `simplify_polynomial_expression`
+### 7. `factor_polynomial_expression`
+
+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:
+  - `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:
+  - `str`: The LaTeX formatted string representing the factored expression.
+
+- Raises:
+  - `ValueError`: If the expression cannot be parsed due to syntax errors.
+
+- Example:
+
+    from rgwfuncs import factor_polynomial_expression
+
+    # Factor a polynomial expression and convert to LaTeX
+    latex_result1 = factor_polynomial_expression("x**2 - 4")
+    print(latex_result1)  # Output: "\left(x - 2\right) \left(x + 2\right)"
+
+    # Factor with substituted values
+    latex_result2 = factor_polynomial_expression("x**2 - y**2", {"y": 3})
+    print(latex_result2)  # Output: "\left(x - 3\right) \left(x + 3\right)"
+
+--------------------------------------------------------------------------------
+
+### 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`
 
 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.
 
@@ -435,7 +491,7 @@ Simplifies an algebraic expression in polynomial form and returns it in LaTeX fo
 
 --------------------------------------------------------------------------------
 
-### 7. `solve_homogeneous_polynomial_expression`
+### 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.
 

rgwfuncs-0.0.47.dist-info/RECORD

@@ -0,0 +1,12 @@
+rgwfuncs/__init__.py,sha256=vs8xv3IVx7KGpPxEXrIePD3gb_QI1XTXpD_n9817foA,1610
+rgwfuncs/algebra_lib.py,sha256=9nnpF0dk3_EuLRlhACUXMQCg2uFbIAy6Fbk1CCssL_c,28423
+rgwfuncs/df_lib.py,sha256=qqRQdakheLy8wMZRBfHwKyIp8DmdZIWfAiLKWgq03QU,68977
+rgwfuncs/docs_lib.py,sha256=y3wSAOPO3qsA4HZ7xAtW8HimM8w-c8hjcEzMRLJ96ao,1960
+rgwfuncs/interactive_shell_lib.py,sha256=A7EWsYxAfDev_N0-2GjRvAtp0bAwBPHIczXb8Gu9fzI,1107
+rgwfuncs/str_lib.py,sha256=rtAdRlnSJIu3JhI-tA_A0wCiPK2m-zn5RoGpBxv_g-4,2228
+rgwfuncs-0.0.47.dist-info/LICENSE,sha256=7EI8xVBu6h_7_JlVw-yPhhOZlpY9hP8wal7kHtqKT_E,1074
+rgwfuncs-0.0.47.dist-info/METADATA,sha256=thxImUJuWvB1GTzLs1bCTt6jOOqhXYUehUs8uJLGd0w,55152
+rgwfuncs-0.0.47.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+rgwfuncs-0.0.47.dist-info/entry_points.txt,sha256=j-c5IOPIQ0252EaOV6j6STio56sbXl2C4ym_fQ0lXx0,43
+rgwfuncs-0.0.47.dist-info/top_level.txt,sha256=aGuVIzWsKiV1f2gCb6mynx0zx5ma0B1EwPGFKVEMTi4,9
+rgwfuncs-0.0.47.dist-info/RECORD,,

rgwfuncs-0.0.42.dist-info/RECORD

@@ -1,12 +0,0 @@
-rgwfuncs/__init__.py,sha256=j1SH_GGf9EPXWvhKd_RWDMUI8GXvJGniq4whdmC-tRk,1550
-rgwfuncs/algebra_lib.py,sha256=OWltGhJqlP7mS0VszjeSICKQZjNlCrLjWVlaKwrb4Og,23435
-rgwfuncs/df_lib.py,sha256=b6uMBbj7JrTUusbBGSlGI6jJ37yCN5lb6Oiq-C9oGzg,68987
-rgwfuncs/docs_lib.py,sha256=y3wSAOPO3qsA4HZ7xAtW8HimM8w-c8hjcEzMRLJ96ao,1960
-rgwfuncs/interactive_shell_lib.py,sha256=A7EWsYxAfDev_N0-2GjRvAtp0bAwBPHIczXb8Gu9fzI,1107
-rgwfuncs/str_lib.py,sha256=rtAdRlnSJIu3JhI-tA_A0wCiPK2m-zn5RoGpBxv_g-4,2228
-rgwfuncs-0.0.42.dist-info/LICENSE,sha256=7EI8xVBu6h_7_JlVw-yPhhOZlpY9hP8wal7kHtqKT_E,1074
-rgwfuncs-0.0.42.dist-info/METADATA,sha256=xxKivycP7sQ5oLN65i5CIzl3H_yAMTf7HgO9uLUM_Vk,52072
-rgwfuncs-0.0.42.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-rgwfuncs-0.0.42.dist-info/entry_points.txt,sha256=j-c5IOPIQ0252EaOV6j6STio56sbXl2C4ym_fQ0lXx0,43
-rgwfuncs-0.0.42.dist-info/top_level.txt,sha256=aGuVIzWsKiV1f2gCb6mynx0zx5ma0B1EwPGFKVEMTi4,9
-rgwfuncs-0.0.42.dist-info/RECORD,,