rgwfuncs 0.0.42__tar.gz → 0.0.44__tar.gz

{rgwfuncs-0.0.42/src/rgwfuncs.egg-info → rgwfuncs-0.0.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.42
+Version: 0.0.44
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson

{rgwfuncs-0.0.42 → rgwfuncs-0.0.44}/pyproject.toml

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

{rgwfuncs-0.0.42 → rgwfuncs-0.0.44}/setup.cfg

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

{rgwfuncs-0.0.42 → rgwfuncs-0.0.44}/src/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-0.0.42 → rgwfuncs-0.0.44}/src/rgwfuncs/algebra_lib.py

@@ -320,6 +320,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 +328,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 +346,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 +368,90 @@ 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 takes an algebraic expression written in Python syntax,
+    cancels common factors, and converts the reduced expression into a LaTeX formatted string.
+
+    Parameters:
+    expression (str): The algebraic expression to cancel and convert to LaTeX.
+    subs (Optional[Dict[str, float]]): An optional dictionary of substitutions to apply before canceling.
+
+    Returns:
+    str: The LaTeX formatted string of the canceled expression.
+
+    Raises:
+    ValueError: If the expression cannot be parsed due to syntax errors.
+    """
+    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)
+            return cancel(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_cancel_expression(expression, sym_vars)
+    latex_result = latex(expr)
+    return latex_result
+
+
 
 def simplify_polynomial_expression(
     expression: str,

{rgwfuncs-0.0.42 → rgwfuncs-0.0.44/src/rgwfuncs.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.42
+Version: 0.0.44
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson