rgwfuncs 0.0.30__tar.gz → 0.0.31__tar.gz

{rgwfuncs-0.0.30/src/rgwfuncs.egg-info → rgwfuncs-0.0.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.30
+Version: 0.0.31
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -154,7 +154,88 @@ Print a list of available function names in alphabetical order. If a filter is p
 
 This section provides comprehensive functions for handling algebraic expressions, performing tasks such as computation, simplification, solving equations, and prime factorization, all outputted in LaTeX format.
 
-### 1. `python_polynomial_expression_to_latex`
+### 1. `compute_constant_expression`
+
+Computes the numerical result of a given expression, which can evaluate to a constant, represented as a float. Evaluates an constant expression provided as a string and returns the computed result. Supports various arithmetic operations, including addition, subtraction, multiplication, division, and modulo, as well as mathematical functions from the math module.
+
+• Parameters:
+  - `expression` (str): The constant expression to compute. This should be a string consisting of arithmetic operations and Python's math module functions.
+
+• Returns:
+  - `float`: The computed numerical result.
+
+• Example:
+
+    from rgwfuncs import compute_constant_expression
+    result1 = compute_constant_expression("2 + 2")
+    print(result1)  # Output: 4.0
+
+    result2 = compute_constant_expression("10 % 3")
+    print(result2)  # Output: 1.0
+
+    result3 = compute_constant_expression("math.gcd(36, 60) * math.sin(math.radians(45)) * 10000")
+    print(result3)  # Output: 84852.8137423857
+
+--------------------------------------------------------------------------------
+
+### 2. `compute_constant_expression_involving_matrices`
+
+Computes the result of a constant expression involving matrices and returns it as a LaTeX string.
+
+• Parameters:
+  - `expression` (str): The constant expression involving matrices. Example format includes operations such as "+", "-", "*", "/".
+
+• Returns:
+  - `str`: The LaTeX-formatted string representation of the computed matrix, or an error message if the operations cannot be performed due to dimensional mismatches.
+
+• Example:
+
+    from rgwfuncs import compute_constant_expression_involving_matrices
+
+    # Example with addition of 2D matrices
+    result = compute_constant_expression_involving_matrices("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
+    print(result)  # Output: \begin{bmatrix}3 & 8 & 12\\5 & 8 & 11\end{bmatrix}
+
+    # Example of mixed operations with 1D matrices treated as 2D
+    result = compute_constant_expression_involving_matrices("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
+    print(result)  # Output: \begin{bmatrix}2 & 6 & 10\end{bmatrix}
+
+    # Example with dimension mismatch
+    result = compute_constant_expression_involving_matrices("[[4, 3, 51]] + [[1, 1]]")
+    print(result)  # Output: Operations between matrices must involve matrices of the same dimension
+
+--------------------------------------------------------------------------------
+
+### 3. `compute_constant_expression_involving_ordered_series`
+
+Computes the result of a constant expression involving ordered series, and returns it as a Latex string. 
+
+
+• Parameters:
+  - `expression` (str): A series operation expression. Supports operations such as "+", "-", "*", "/", and `dd()` for discrete differences.
+
+• Returns:
+  - `str`: The string representation of the resultant series after performing operations, or an error message if series lengths do not match.
+
+• Example:
+
+    from rgwfuncs import compute_constant_expression_involving_ordered_series
+
+    # Example with addition and discrete differences
+    result = compute_constant_expression_involving_ordered_series("dd([2, 6, 9, 60]) + dd([78, 79, 80])")
+    print(result)  # Output: [4, 3, 51] + [1, 1]
+
+    # Example with elementwise subtraction
+    result = compute_constant_expression_involving_ordered_series("[10, 15, 21] - [5, 5, 5]")
+    print(result)  # Output: [5, 10, 16]
+
+    # Example with length mismatch
+    result = compute_constant_expression_involving_ordered_series("[4, 3, 51] + [1, 1]")
+    print(result)  # Output: Operations between ordered series must involve series of equal length
+
+--------------------------------------------------------------------------------
+
+### 4. `python_polynomial_expression_to_latex`
 
 Converts a polynomial expression written in Python syntax to a LaTeX formatted string. This function parses algebraic expressions provided as strings using Python’s syntax and translates them into equivalent LaTeX representations, making them suitable for academic or professional documentation. The function supports inclusion of named variables, with an option to substitute specific values into the expression.
 
@@ -194,31 +275,7 @@ Converts a polynomial expression written in Python syntax to a LaTeX formatted s
 
 --------------------------------------------------------------------------------
 
-### 2. `compute_constant_expression`
-
-Computes the numerical result of a given expression, which can evaluate to a constant, represented as a float. Evaluates an constant expression provided as a string and returns the computed result. Supports various arithmetic operations, including addition, subtraction, multiplication, division, and modulo, as well as mathematical functions from the math module.
-
-• Parameters:
-  - `expression` (str): The constant expression to compute. This should be a string consisting of arithmetic operations and Python's math module functions.
-
-• Returns:
-  - `float`: The computed numerical result.
-
-• Example:
-
-    from rgwfuncs import compute_constant_expression
-    result1 = compute_constant_expression("2 + 2")
-    print(result1)  # Output: 4.0
-
-    result2 = compute_constant_expression("10 % 3")
-    print(result2)  # Output: 1.0
-
-    result3 = compute_constant_expression("math.gcd(36, 60) * math.sin(math.radians(45)) * 10000")
-    print(result3)  # Output: 84852.8137423857
-
---------------------------------------------------------------------------------
-
-### 3. `simplify_polynomial_expression`
+### 5. `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.
 
@@ -251,7 +308,7 @@ Simplifies an algebraic expression in polynomial form and returns it in LaTeX fo
 
 --------------------------------------------------------------------------------
 
-### 4. `solve_homogeneous_polynomial_expression`
+### 6. `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.
 
@@ -274,7 +331,7 @@ Solves a homogeneous polynomial expression for a specified variable and returns
     
 --------------------------------------------------------------------------------
 
-### 5. `get_prime_factors_latex`
+### 7. `get_prime_factors_latex`
 
 Computes prime factors of a number and presents them in LaTeX format.
 
@@ -298,62 +355,6 @@ Computes prime factors of a number and presents them in LaTeX format.
  
 --------------------------------------------------------------------------------
 
-### 6. `compute_matrix_expression`
-
-Computes the results of expressions containing 1D or 2D matrix operations and formats them as LaTeX strings.
-
-• Parameters:
-  - `expression` (str): A string representing a sequence of matrix operations involving either 1D or 2D lists. Supported operations include addition (`+`), subtraction (`-`), multiplication (`*`), and division (`/`).
-
-• Returns:
-  - `str`: The LaTeX-formatted string representation of the computed matrix, or an error message if the operations cannot be performed due to dimensional mismatches.
-
-• Example:
-
-    from rgwfuncs import compute_matrix_expression
-    
-    # Example with addition of 2D matrices
-    result = compute_matrix_expression("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
-    print(result)  # Output: \begin{bmatrix}3 & 8 & 12\\5 & 8 & 11\end{bmatrix}
-    
-    # Example of mixed operations with 1D matrices treated as 2D
-    result = compute_matrix_expression("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
-    print(result)  # Output: \begin{bmatrix}2 & 6 & 10\end{bmatrix}
-
-    # Example with dimension mismatch
-    result = compute_matrix_expression("[[4, 3, 51]] + [[1, 1]]")
-    print(result)  # Output: Operations between matrices must involve matrices of the same dimension
-
---------------------------------------------------------------------------------
-
-### 7. `compute_ordered_series_expression`
-
-Computes the result of expressions containing operations on ordered series expressed as 1D lists. The syntax of the expression supports the discrete difference operator via the `ddd()` method.
-
-• Parameters:
-  - `expression` (str): A series operation expression. Supports operations such as "+", "-", "*", "/", and `ddd()` for discrete differences.
-
-• Returns:
-  - `str`: The string representation of the resultant series after performing operations, or an error message if series lengths do not match.
-
-• Example:
-
-    from rgwfuncs import compute_ordered_series_expression
-
-    # Example with addition and discrete differences
-    result = compute_ordered_series_expression("ddd([2, 6, 9, 60]) + ddd([78, 79, 80])")
-    print(result)  # Output: [4, 3, 51] + [1, 1]
-    
-    # Example with elementwise subtraction
-    result = compute_ordered_series_expression("[10, 15, 21] - [5, 5, 5]")
-    print(result)  # Output: [5, 10, 16]
-
-    # Example with length mismatch
-    result = compute_ordered_series_expression("[4, 3, 51] + [1, 1]")
-    print(result)  # Output: Operations between ordered series must involve series of equal length
-
---------------------------------------------------------------------------------
-
 ## String Based Functions
 
 ### 1. send_telegram_message

{rgwfuncs-0.0.30 → rgwfuncs-0.0.31}/README.md

@@ -128,7 +128,88 @@ Print a list of available function names in alphabetical order. If a filter is p
 
 This section provides comprehensive functions for handling algebraic expressions, performing tasks such as computation, simplification, solving equations, and prime factorization, all outputted in LaTeX format.
 
-### 1. `python_polynomial_expression_to_latex`
+### 1. `compute_constant_expression`
+
+Computes the numerical result of a given expression, which can evaluate to a constant, represented as a float. Evaluates an constant expression provided as a string and returns the computed result. Supports various arithmetic operations, including addition, subtraction, multiplication, division, and modulo, as well as mathematical functions from the math module.
+
+• Parameters:
+  - `expression` (str): The constant expression to compute. This should be a string consisting of arithmetic operations and Python's math module functions.
+
+• Returns:
+  - `float`: The computed numerical result.
+
+• Example:
+
+    from rgwfuncs import compute_constant_expression
+    result1 = compute_constant_expression("2 + 2")
+    print(result1)  # Output: 4.0
+
+    result2 = compute_constant_expression("10 % 3")
+    print(result2)  # Output: 1.0
+
+    result3 = compute_constant_expression("math.gcd(36, 60) * math.sin(math.radians(45)) * 10000")
+    print(result3)  # Output: 84852.8137423857
+
+--------------------------------------------------------------------------------
+
+### 2. `compute_constant_expression_involving_matrices`
+
+Computes the result of a constant expression involving matrices and returns it as a LaTeX string.
+
+• Parameters:
+  - `expression` (str): The constant expression involving matrices. Example format includes operations such as "+", "-", "*", "/".
+
+• Returns:
+  - `str`: The LaTeX-formatted string representation of the computed matrix, or an error message if the operations cannot be performed due to dimensional mismatches.
+
+• Example:
+
+    from rgwfuncs import compute_constant_expression_involving_matrices
+
+    # Example with addition of 2D matrices
+    result = compute_constant_expression_involving_matrices("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
+    print(result)  # Output: \begin{bmatrix}3 & 8 & 12\\5 & 8 & 11\end{bmatrix}
+
+    # Example of mixed operations with 1D matrices treated as 2D
+    result = compute_constant_expression_involving_matrices("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
+    print(result)  # Output: \begin{bmatrix}2 & 6 & 10\end{bmatrix}
+
+    # Example with dimension mismatch
+    result = compute_constant_expression_involving_matrices("[[4, 3, 51]] + [[1, 1]]")
+    print(result)  # Output: Operations between matrices must involve matrices of the same dimension
+
+--------------------------------------------------------------------------------
+
+### 3. `compute_constant_expression_involving_ordered_series`
+
+Computes the result of a constant expression involving ordered series, and returns it as a Latex string. 
+
+
+• Parameters:
+  - `expression` (str): A series operation expression. Supports operations such as "+", "-", "*", "/", and `dd()` for discrete differences.
+
+• Returns:
+  - `str`: The string representation of the resultant series after performing operations, or an error message if series lengths do not match.
+
+• Example:
+
+    from rgwfuncs import compute_constant_expression_involving_ordered_series
+
+    # Example with addition and discrete differences
+    result = compute_constant_expression_involving_ordered_series("dd([2, 6, 9, 60]) + dd([78, 79, 80])")
+    print(result)  # Output: [4, 3, 51] + [1, 1]
+
+    # Example with elementwise subtraction
+    result = compute_constant_expression_involving_ordered_series("[10, 15, 21] - [5, 5, 5]")
+    print(result)  # Output: [5, 10, 16]
+
+    # Example with length mismatch
+    result = compute_constant_expression_involving_ordered_series("[4, 3, 51] + [1, 1]")
+    print(result)  # Output: Operations between ordered series must involve series of equal length
+
+--------------------------------------------------------------------------------
+
+### 4. `python_polynomial_expression_to_latex`
 
 Converts a polynomial expression written in Python syntax to a LaTeX formatted string. This function parses algebraic expressions provided as strings using Python’s syntax and translates them into equivalent LaTeX representations, making them suitable for academic or professional documentation. The function supports inclusion of named variables, with an option to substitute specific values into the expression.
 
@@ -168,31 +249,7 @@ Converts a polynomial expression written in Python syntax to a LaTeX formatted s
 
 --------------------------------------------------------------------------------
 
-### 2. `compute_constant_expression`
-
-Computes the numerical result of a given expression, which can evaluate to a constant, represented as a float. Evaluates an constant expression provided as a string and returns the computed result. Supports various arithmetic operations, including addition, subtraction, multiplication, division, and modulo, as well as mathematical functions from the math module.
-
-• Parameters:
-  - `expression` (str): The constant expression to compute. This should be a string consisting of arithmetic operations and Python's math module functions.
-
-• Returns:
-  - `float`: The computed numerical result.
-
-• Example:
-
-    from rgwfuncs import compute_constant_expression
-    result1 = compute_constant_expression("2 + 2")
-    print(result1)  # Output: 4.0
-
-    result2 = compute_constant_expression("10 % 3")
-    print(result2)  # Output: 1.0
-
-    result3 = compute_constant_expression("math.gcd(36, 60) * math.sin(math.radians(45)) * 10000")
-    print(result3)  # Output: 84852.8137423857
-
---------------------------------------------------------------------------------
-
-### 3. `simplify_polynomial_expression`
+### 5. `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.
 
@@ -225,7 +282,7 @@ Simplifies an algebraic expression in polynomial form and returns it in LaTeX fo
 
 --------------------------------------------------------------------------------
 
-### 4. `solve_homogeneous_polynomial_expression`
+### 6. `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.
 
@@ -248,7 +305,7 @@ Solves a homogeneous polynomial expression for a specified variable and returns
     
 --------------------------------------------------------------------------------
 
-### 5. `get_prime_factors_latex`
+### 7. `get_prime_factors_latex`
 
 Computes prime factors of a number and presents them in LaTeX format.
 
@@ -272,62 +329,6 @@ Computes prime factors of a number and presents them in LaTeX format.
  
 --------------------------------------------------------------------------------
 
-### 6. `compute_matrix_expression`
-
-Computes the results of expressions containing 1D or 2D matrix operations and formats them as LaTeX strings.
-
-• Parameters:
-  - `expression` (str): A string representing a sequence of matrix operations involving either 1D or 2D lists. Supported operations include addition (`+`), subtraction (`-`), multiplication (`*`), and division (`/`).
-
-• Returns:
-  - `str`: The LaTeX-formatted string representation of the computed matrix, or an error message if the operations cannot be performed due to dimensional mismatches.
-
-• Example:
-
-    from rgwfuncs import compute_matrix_expression
-    
-    # Example with addition of 2D matrices
-    result = compute_matrix_expression("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
-    print(result)  # Output: \begin{bmatrix}3 & 8 & 12\\5 & 8 & 11\end{bmatrix}
-    
-    # Example of mixed operations with 1D matrices treated as 2D
-    result = compute_matrix_expression("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
-    print(result)  # Output: \begin{bmatrix}2 & 6 & 10\end{bmatrix}
-
-    # Example with dimension mismatch
-    result = compute_matrix_expression("[[4, 3, 51]] + [[1, 1]]")
-    print(result)  # Output: Operations between matrices must involve matrices of the same dimension
-
---------------------------------------------------------------------------------
-
-### 7. `compute_ordered_series_expression`
-
-Computes the result of expressions containing operations on ordered series expressed as 1D lists. The syntax of the expression supports the discrete difference operator via the `ddd()` method.
-
-• Parameters:
-  - `expression` (str): A series operation expression. Supports operations such as "+", "-", "*", "/", and `ddd()` for discrete differences.
-
-• Returns:
-  - `str`: The string representation of the resultant series after performing operations, or an error message if series lengths do not match.
-
-• Example:
-
-    from rgwfuncs import compute_ordered_series_expression
-
-    # Example with addition and discrete differences
-    result = compute_ordered_series_expression("ddd([2, 6, 9, 60]) + ddd([78, 79, 80])")
-    print(result)  # Output: [4, 3, 51] + [1, 1]
-    
-    # Example with elementwise subtraction
-    result = compute_ordered_series_expression("[10, 15, 21] - [5, 5, 5]")
-    print(result)  # Output: [5, 10, 16]
-
-    # Example with length mismatch
-    result = compute_ordered_series_expression("[4, 3, 51] + [1, 1]")
-    print(result)  # Output: Operations between ordered series must involve series of equal length
-
---------------------------------------------------------------------------------
-
 ## String Based Functions
 
 ### 1. send_telegram_message

{rgwfuncs-0.0.30 → rgwfuncs-0.0.31}/pyproject.toml

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

{rgwfuncs-0.0.30 → rgwfuncs-0.0.31}/setup.cfg

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

{rgwfuncs-0.0.30 → rgwfuncs-0.0.31}/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_matrix_expression, compute_ordered_series_expression, get_prime_factors_latex, python_polynomial_expression_to_latex, simplify_polynomial_expression, solve_homogeneous_polynomial_expression
+from .algebra_lib import compute_constant_expression, compute_constant_expression_involving_matrices, compute_constant_expression_involving_ordered_series, get_prime_factors_latex, 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 .str_lib import send_telegram_message

{rgwfuncs-0.0.30 → rgwfuncs-0.0.31}/src/rgwfuncs/algebra_lib.py

@@ -40,6 +40,198 @@ def compute_constant_expression(expression: str) -> float:
         raise ValueError(f"Error computing expression: {e}")
 
 
+def compute_constant_expression_involving_matrices(expression: str) -> str:
+    """
+    Computes the result of a constant expression involving matrices and returns it as a LaTeX string.
+
+    Parameters:
+    expression (str): The constant expression involving matrices. Example format includes operations such as "+", 
+    "-", "*", "/".
+
+    Returns:
+    str: The LaTeX-formatted string representation of the result or a message indicating an error in dimensions.
+    """
+
+    def elementwise_operation(matrix1: List[List[float]], matrix2: List[List[float]], operation: str) -> List[List[float]]:
+        if len(matrix1) != len(matrix2) or any(len(row1) != len(row2) for row1, row2 in zip(matrix1, matrix2)):
+            return "Operations between matrices must involve matrices of the same dimension"
+
+        if operation == '+':
+            return [[a + b for a, b in zip(row1, row2)] for row1, row2 in zip(matrix1, matrix2)]
+        elif operation == '-':
+            return [[a - b for a, b in zip(row1, row2)] for row1, row2 in zip(matrix1, matrix2)]
+        elif operation == '*':
+            return [[a * b for a, b in zip(row1, row2)] for row1, row2 in zip(matrix1, matrix2)]
+        elif operation == '/':
+            return [[a / b for a, b in zip(row1, row2) if b != 0] for row1, row2 in zip(matrix1, matrix2)]
+        else:
+            return f"Unsupported operation {operation}"
+
+    try:
+        # Use a stack-based method to properly parse matrices
+        elements = []
+        buffer = ''
+        bracket_level = 0
+        operators = set('+-*/')
+
+        for char in expression:
+            if char == '[':
+                if bracket_level == 0 and buffer.strip():
+                    elements.append(buffer.strip())
+                    buffer = ''
+                bracket_level += 1
+            elif char == ']':
+                bracket_level -= 1
+                if bracket_level == 0:
+                    buffer += char
+                    elements.append(buffer.strip())
+                    buffer = ''
+                    continue
+            if bracket_level == 0 and char in operators:
+                if buffer.strip():
+                    elements.append(buffer.strip())
+                    buffer = ''
+                elements.append(char)
+            else:
+                buffer += char
+
+        if buffer.strip():
+            elements.append(buffer.strip())
+
+        result = ast.literal_eval(elements[0])
+
+        if not any(isinstance(row, list) for row in result):
+            result = [result]  # Convert 1D matrix to 2D
+
+        i = 1
+        while i < len(elements):
+            operation = elements[i]
+            matrix = ast.literal_eval(elements[i + 1])
+
+            if not any(isinstance(row, list) for row in matrix):
+                matrix = [matrix]
+
+            operation_result = elementwise_operation(result, matrix, operation)
+
+            # Check if the operation resulted in an error message
+            if isinstance(operation_result, str):
+                return operation_result
+
+            result = operation_result
+            i += 2
+
+        # Create a LaTeX-style matrix representation
+        matrix_entries = '\\\\'.join(' & '.join(str(x) for x in row) for row in result)
+        return r"\begin{bmatrix}" + f"{matrix_entries}" + r"\end{bmatrix}"
+
+    except Exception as e:
+        return f"Error computing matrix operation: {e}"
+
+
+def compute_constant_expression_involving_ordered_series(expression: str) -> str:
+    """
+    Computes the result of a constant expression involving ordered series, and returns it as a Latex string. 
+    Supports operations lile "+", "-", "*", "/", as well as "dd()" (the discrete difference operator).
+  
+    The function first applies the discrete difference operator to any series where applicable, then evaluates
+    arithmetic operations between series.
+
+    Parameters:
+    expression (str): The series operation expression to compute. Includes operations "+", "-", "*", "/", and "dd()".
+
+    Returns:
+    str: The string representation of the resultant series after performing operations, or an error message
+    if the series lengths do not match.
+
+    Raises:
+    ValueError: If the expression cannot be evaluated.
+    """
+
+    def elementwise_operation(series1: List[float], series2: List[float], operation: str) -> List[float]:
+        if len(series1) != len(series2):
+            return "Operations between ordered series must involve series of equal length"
+
+        if operation == '+':
+            return [a + b for a, b in zip(series1, series2)]
+        elif operation == '-':
+            return [a - b for a, b in zip(series1, series2)]
+        elif operation == '*':
+            return [a * b for a, b in zip(series1, series2)]
+        elif operation == '/':
+            return [a / b for a, b in zip(series1, series2) if b != 0]
+        else:
+            return f"Unsupported operation {operation}"
+
+    def discrete_difference(series: list) -> list:
+        """Computes the discrete difference of a series."""
+        return [series[i + 1] - series[i] for i in range(len(series) - 1)]
+
+    try:
+        # First, apply the discrete difference operator where applicable
+        pattern = r'dd\((\[[^\]]*\])\)'
+        matches = re.findall(pattern, expression)
+
+        for match in matches:
+            if match.strip() == '[]':
+                result_series = []  # Handle the empty list case
+            else:
+                series = ast.literal_eval(match)
+                result_series = discrete_difference(series)
+            expression = expression.replace(f'dd({match})', str(result_series))
+
+        # Now parse and evaluate the full expression with basic operations
+        elements = []
+        buffer = ''
+        bracket_level = 0
+        operators = set('+-*/')
+
+        for char in expression:
+            if char == '[':
+                if bracket_level == 0 and buffer.strip():
+                    elements.append(buffer.strip())
+                    buffer = ''
+                bracket_level += 1
+            elif char == ']':
+                bracket_level -= 1
+                if bracket_level == 0:
+                    buffer += char
+                    elements.append(buffer.strip())
+                    buffer = ''
+                    continue
+            if bracket_level == 0 and char in operators:
+                if buffer.strip():
+                    elements.append(buffer.strip())
+                    buffer = ''
+                elements.append(char)
+            else:
+                buffer += char
+
+        if buffer.strip():
+            elements.append(buffer.strip())
+
+        result = ast.literal_eval(elements[0])
+
+        i = 1
+        while i < len(elements):
+            operation = elements[i]
+            series = ast.literal_eval(elements[i + 1])
+            operation_result = elementwise_operation(result, series, operation)
+
+            # Check if the operation resulted in an error message
+            if isinstance(operation_result, str):
+                return operation_result
+
+            result = operation_result
+            i += 2
+
+        return str(result)
+
+    except Exception as e:
+        return f"Error computing ordered series operation: {e}"
+
+
+
+
 def python_polynomial_expression_to_latex(
     expression: str,
     subs: Optional[Dict[str, float]] = None
@@ -100,7 +292,6 @@ def python_polynomial_expression_to_latex(
     return latex_result
 
 
-
 def simplify_polynomial_expression(
     expression: str,
     subs: Optional[Dict[str, float]] = None
@@ -109,7 +300,7 @@ def 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 
+    The result is returned as a LaTeX formatted string, suitable for academic or professional
     documentation.
 
     Parameters:
@@ -282,11 +473,11 @@ def solve_homogeneous_polynomial_expression(
     subs: Optional[Dict[str, float]] = None
 ) -> str:
     """
-    Solves a homogeneous polynomial expression for a specified variable and returns solutions 
+    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 
+    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.
 
     Parameters:
@@ -329,196 +520,6 @@ def solve_homogeneous_polynomial_expression(
         raise ValueError(f"Error solving the expression: {e}")
 
 
-def compute_matrix_expression(expression: str) -> str:
-    """
-    Computes the result of a matrix-like operation on 1D or 2D list inputs and returns it as a LaTeX string.
-
-    Evaluates an operation where lists are treated as matrices, performs operations on them sequentially, and
-    returns the result formatted as a LaTeX-style string.
-
-    Parameters:
-    expression (str): The matrix operation expression to compute. Example format includes operations such as "+", "-", "*", "/".
-
-    Returns:
-    str: The LaTeX-formatted string representation of the result or a message indicating an error in dimensions.
-    """
-
-    def elementwise_operation(matrix1: List[List[float]], matrix2: List[List[float]], operation: str) -> List[List[float]]:
-        if len(matrix1) != len(matrix2) or any(len(row1) != len(row2) for row1, row2 in zip(matrix1, matrix2)):
-            return "Operations between matrices must involve matrices of the same dimension"
-
-        if operation == '+':
-            return [[a + b for a, b in zip(row1, row2)] for row1, row2 in zip(matrix1, matrix2)]
-        elif operation == '-':
-            return [[a - b for a, b in zip(row1, row2)] for row1, row2 in zip(matrix1, matrix2)]
-        elif operation == '*':
-            return [[a * b for a, b in zip(row1, row2)] for row1, row2 in zip(matrix1, matrix2)]
-        elif operation == '/':
-            return [[a / b for a, b in zip(row1, row2) if b != 0] for row1, row2 in zip(matrix1, matrix2)]
-        else:
-            return f"Unsupported operation {operation}"
-
-    try:
-        # Use a stack-based method to properly parse matrices
-        elements = []
-        buffer = ''
-        bracket_level = 0
-        operators = set('+-*/')
-
-        for char in expression:
-            if char == '[':
-                if bracket_level == 0 and buffer.strip():
-                    elements.append(buffer.strip())
-                    buffer = ''
-                bracket_level += 1
-            elif char == ']':
-                bracket_level -= 1
-                if bracket_level == 0:
-                    buffer += char
-                    elements.append(buffer.strip())
-                    buffer = ''
-                    continue
-            if bracket_level == 0 and char in operators:
-                if buffer.strip():
-                    elements.append(buffer.strip())
-                    buffer = ''
-                elements.append(char)
-            else:
-                buffer += char
-
-        if buffer.strip():
-            elements.append(buffer.strip())
-
-        result = ast.literal_eval(elements[0])
-
-        if not any(isinstance(row, list) for row in result):
-            result = [result]  # Convert 1D matrix to 2D
-
-        i = 1
-        while i < len(elements):
-            operation = elements[i]
-            matrix = ast.literal_eval(elements[i + 1])
-
-            if not any(isinstance(row, list) for row in matrix):
-                matrix = [matrix]
-
-            operation_result = elementwise_operation(result, matrix, operation)
-
-            # Check if the operation resulted in an error message
-            if isinstance(operation_result, str):
-                return operation_result
-
-            result = operation_result
-            i += 2
-
-        # Create a LaTeX-style matrix representation
-        matrix_entries = '\\\\'.join(' & '.join(str(x) for x in row) for row in result)
-        return r"\begin{bmatrix}" + f"{matrix_entries}" + r"\end{bmatrix}"
-
-    except Exception as e:
-        return f"Error computing matrix operation: {e}"
-
-
-def compute_ordered_series_expression(expression: str) -> str:
-    """
-    Computes the result of operations on ordered series expressed as 1D lists, including discrete difference (ddd),
-    and returns it as a string.
-
-    The function first applies the discrete difference operator to any series where applicable, then evaluates
-    arithmetic operations between series.
-
-    Parameters:
-    expression (str): The series operation expression to compute. Includes operations "+", "-", "*", "/", and "ddd".
-
-    Returns:
-    str: The string representation of the resultant series after performing operations, or an error message
-    if the series lengths do not match.
-
-    Raises:
-    ValueError: If the expression cannot be evaluated.
-    """
-
-    def elementwise_operation(series1: List[float], series2: List[float], operation: str) -> List[float]:
-        if len(series1) != len(series2):
-            return "Operations between ordered series must involve series of equal length"
-
-        if operation == '+':
-            return [a + b for a, b in zip(series1, series2)]
-        elif operation == '-':
-            return [a - b for a, b in zip(series1, series2)]
-        elif operation == '*':
-            return [a * b for a, b in zip(series1, series2)]
-        elif operation == '/':
-            return [a / b for a, b in zip(series1, series2) if b != 0]
-        else:
-            return f"Unsupported operation {operation}"
-
-    def discrete_difference(series: list) -> list:
-        """Computes the discrete difference of a series."""
-        return [series[i + 1] - series[i] for i in range(len(series) - 1)]
-
-    try:
-        # First, apply the discrete difference operator where applicable
-        pattern = r'ddd\((\[[^\]]*\])\)'
-        matches = re.findall(pattern, expression)
-
-        for match in matches:
-            if match.strip() == '[]':
-                result_series = []  # Handle the empty list case
-            else:
-                series = ast.literal_eval(match)
-                result_series = discrete_difference(series)
-            expression = expression.replace(f'ddd({match})', str(result_series))
-
-        # Now parse and evaluate the full expression with basic operations
-        elements = []
-        buffer = ''
-        bracket_level = 0
-        operators = set('+-*/')
-
-        for char in expression:
-            if char == '[':
-                if bracket_level == 0 and buffer.strip():
-                    elements.append(buffer.strip())
-                    buffer = ''
-                bracket_level += 1
-            elif char == ']':
-                bracket_level -= 1
-                if bracket_level == 0:
-                    buffer += char
-                    elements.append(buffer.strip())
-                    buffer = ''
-                    continue
-            if bracket_level == 0 and char in operators:
-                if buffer.strip():
-                    elements.append(buffer.strip())
-                    buffer = ''
-                elements.append(char)
-            else:
-                buffer += char
-
-        if buffer.strip():
-            elements.append(buffer.strip())
-
-        result = ast.literal_eval(elements[0])
-
-        i = 1
-        while i < len(elements):
-            operation = elements[i]
-            series = ast.literal_eval(elements[i + 1])
-            operation_result = elementwise_operation(result, series, operation)
-
-            # Check if the operation resulted in an error message
-            if isinstance(operation_result, str):
-                return operation_result
-
-            result = operation_result
-            i += 2
-
-        return str(result)
-
-    except Exception as e:
-        return f"Error computing ordered series operation: {e}"
 
 
 def get_prime_factors_latex(n: int) -> str:

{rgwfuncs-0.0.30 → rgwfuncs-0.0.31/src/rgwfuncs.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.30
+Version: 0.0.31
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -154,7 +154,88 @@ Print a list of available function names in alphabetical order. If a filter is p
 
 This section provides comprehensive functions for handling algebraic expressions, performing tasks such as computation, simplification, solving equations, and prime factorization, all outputted in LaTeX format.
 
-### 1. `python_polynomial_expression_to_latex`
+### 1. `compute_constant_expression`
+
+Computes the numerical result of a given expression, which can evaluate to a constant, represented as a float. Evaluates an constant expression provided as a string and returns the computed result. Supports various arithmetic operations, including addition, subtraction, multiplication, division, and modulo, as well as mathematical functions from the math module.
+
+• Parameters:
+  - `expression` (str): The constant expression to compute. This should be a string consisting of arithmetic operations and Python's math module functions.
+
+• Returns:
+  - `float`: The computed numerical result.
+
+• Example:
+
+    from rgwfuncs import compute_constant_expression
+    result1 = compute_constant_expression("2 + 2")
+    print(result1)  # Output: 4.0
+
+    result2 = compute_constant_expression("10 % 3")
+    print(result2)  # Output: 1.0
+
+    result3 = compute_constant_expression("math.gcd(36, 60) * math.sin(math.radians(45)) * 10000")
+    print(result3)  # Output: 84852.8137423857
+
+--------------------------------------------------------------------------------
+
+### 2. `compute_constant_expression_involving_matrices`
+
+Computes the result of a constant expression involving matrices and returns it as a LaTeX string.
+
+• Parameters:
+  - `expression` (str): The constant expression involving matrices. Example format includes operations such as "+", "-", "*", "/".
+
+• Returns:
+  - `str`: The LaTeX-formatted string representation of the computed matrix, or an error message if the operations cannot be performed due to dimensional mismatches.
+
+• Example:
+
+    from rgwfuncs import compute_constant_expression_involving_matrices
+
+    # Example with addition of 2D matrices
+    result = compute_constant_expression_involving_matrices("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
+    print(result)  # Output: \begin{bmatrix}3 & 8 & 12\\5 & 8 & 11\end{bmatrix}
+
+    # Example of mixed operations with 1D matrices treated as 2D
+    result = compute_constant_expression_involving_matrices("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
+    print(result)  # Output: \begin{bmatrix}2 & 6 & 10\end{bmatrix}
+
+    # Example with dimension mismatch
+    result = compute_constant_expression_involving_matrices("[[4, 3, 51]] + [[1, 1]]")
+    print(result)  # Output: Operations between matrices must involve matrices of the same dimension
+
+--------------------------------------------------------------------------------
+
+### 3. `compute_constant_expression_involving_ordered_series`
+
+Computes the result of a constant expression involving ordered series, and returns it as a Latex string. 
+
+
+• Parameters:
+  - `expression` (str): A series operation expression. Supports operations such as "+", "-", "*", "/", and `dd()` for discrete differences.
+
+• Returns:
+  - `str`: The string representation of the resultant series after performing operations, or an error message if series lengths do not match.
+
+• Example:
+
+    from rgwfuncs import compute_constant_expression_involving_ordered_series
+
+    # Example with addition and discrete differences
+    result = compute_constant_expression_involving_ordered_series("dd([2, 6, 9, 60]) + dd([78, 79, 80])")
+    print(result)  # Output: [4, 3, 51] + [1, 1]
+
+    # Example with elementwise subtraction
+    result = compute_constant_expression_involving_ordered_series("[10, 15, 21] - [5, 5, 5]")
+    print(result)  # Output: [5, 10, 16]
+
+    # Example with length mismatch
+    result = compute_constant_expression_involving_ordered_series("[4, 3, 51] + [1, 1]")
+    print(result)  # Output: Operations between ordered series must involve series of equal length
+
+--------------------------------------------------------------------------------
+
+### 4. `python_polynomial_expression_to_latex`
 
 Converts a polynomial expression written in Python syntax to a LaTeX formatted string. This function parses algebraic expressions provided as strings using Python’s syntax and translates them into equivalent LaTeX representations, making them suitable for academic or professional documentation. The function supports inclusion of named variables, with an option to substitute specific values into the expression.
 
@@ -194,31 +275,7 @@ Converts a polynomial expression written in Python syntax to a LaTeX formatted s
 
 --------------------------------------------------------------------------------
 
-### 2. `compute_constant_expression`
-
-Computes the numerical result of a given expression, which can evaluate to a constant, represented as a float. Evaluates an constant expression provided as a string and returns the computed result. Supports various arithmetic operations, including addition, subtraction, multiplication, division, and modulo, as well as mathematical functions from the math module.
-
-• Parameters:
-  - `expression` (str): The constant expression to compute. This should be a string consisting of arithmetic operations and Python's math module functions.
-
-• Returns:
-  - `float`: The computed numerical result.
-
-• Example:
-
-    from rgwfuncs import compute_constant_expression
-    result1 = compute_constant_expression("2 + 2")
-    print(result1)  # Output: 4.0
-
-    result2 = compute_constant_expression("10 % 3")
-    print(result2)  # Output: 1.0
-
-    result3 = compute_constant_expression("math.gcd(36, 60) * math.sin(math.radians(45)) * 10000")
-    print(result3)  # Output: 84852.8137423857
-
---------------------------------------------------------------------------------
-
-### 3. `simplify_polynomial_expression`
+### 5. `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.
 
@@ -251,7 +308,7 @@ Simplifies an algebraic expression in polynomial form and returns it in LaTeX fo
 
 --------------------------------------------------------------------------------
 
-### 4. `solve_homogeneous_polynomial_expression`
+### 6. `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.
 
@@ -274,7 +331,7 @@ Solves a homogeneous polynomial expression for a specified variable and returns
     
 --------------------------------------------------------------------------------
 
-### 5. `get_prime_factors_latex`
+### 7. `get_prime_factors_latex`
 
 Computes prime factors of a number and presents them in LaTeX format.
 
@@ -298,62 +355,6 @@ Computes prime factors of a number and presents them in LaTeX format.
  
 --------------------------------------------------------------------------------
 
-### 6. `compute_matrix_expression`
-
-Computes the results of expressions containing 1D or 2D matrix operations and formats them as LaTeX strings.
-
-• Parameters:
-  - `expression` (str): A string representing a sequence of matrix operations involving either 1D or 2D lists. Supported operations include addition (`+`), subtraction (`-`), multiplication (`*`), and division (`/`).
-
-• Returns:
-  - `str`: The LaTeX-formatted string representation of the computed matrix, or an error message if the operations cannot be performed due to dimensional mismatches.
-
-• Example:
-
-    from rgwfuncs import compute_matrix_expression
-    
-    # Example with addition of 2D matrices
-    result = compute_matrix_expression("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
-    print(result)  # Output: \begin{bmatrix}3 & 8 & 12\\5 & 8 & 11\end{bmatrix}
-    
-    # Example of mixed operations with 1D matrices treated as 2D
-    result = compute_matrix_expression("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
-    print(result)  # Output: \begin{bmatrix}2 & 6 & 10\end{bmatrix}
-
-    # Example with dimension mismatch
-    result = compute_matrix_expression("[[4, 3, 51]] + [[1, 1]]")
-    print(result)  # Output: Operations between matrices must involve matrices of the same dimension
-
---------------------------------------------------------------------------------
-
-### 7. `compute_ordered_series_expression`
-
-Computes the result of expressions containing operations on ordered series expressed as 1D lists. The syntax of the expression supports the discrete difference operator via the `ddd()` method.
-
-• Parameters:
-  - `expression` (str): A series operation expression. Supports operations such as "+", "-", "*", "/", and `ddd()` for discrete differences.
-
-• Returns:
-  - `str`: The string representation of the resultant series after performing operations, or an error message if series lengths do not match.
-
-• Example:
-
-    from rgwfuncs import compute_ordered_series_expression
-
-    # Example with addition and discrete differences
-    result = compute_ordered_series_expression("ddd([2, 6, 9, 60]) + ddd([78, 79, 80])")
-    print(result)  # Output: [4, 3, 51] + [1, 1]
-    
-    # Example with elementwise subtraction
-    result = compute_ordered_series_expression("[10, 15, 21] - [5, 5, 5]")
-    print(result)  # Output: [5, 10, 16]
-
-    # Example with length mismatch
-    result = compute_ordered_series_expression("[4, 3, 51] + [1, 1]")
-    print(result)  # Output: Operations between ordered series must involve series of equal length
-
---------------------------------------------------------------------------------
-
 ## String Based Functions
 
 ### 1. send_telegram_message

{rgwfuncs-0.0.30 → rgwfuncs-0.0.31}/tests/test_algebra_lib.py

@@ -7,35 +7,14 @@ import math
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 
 from src.rgwfuncs.algebra_lib import (
-    python_polynomial_expression_to_latex,
     compute_constant_expression,
+    compute_constant_expression_involving_matrices,
+    compute_constant_expression_involving_ordered_series,
+    python_polynomial_expression_to_latex,
     simplify_polynomial_expression,
     solve_homogeneous_polynomial_expression,
-    compute_matrix_expression,
-    compute_ordered_series_expression,
     get_prime_factors_latex)
 
-def test_python_polynomial_expression_to_latex():
-    test_cases = [
-        # Without substitutions
-        ("x**2 + y**2", None, r"x^{2} + y^{2}"),
-        ("3*a + 4*b", None, r"3 a + 4 b"),
-
-        # With substitutions
-        ("x**2 + y**2", {"x": 3, "y": 4}, r"25"),  # Shows substitution but not simplification
-        ("x**2 + y**2", {"x": 3}, r"y^{2} + 9"),
-        ("a*b + b", {"b": 2}, r"2 a + 2"),
-        ("sin(x+z**2) + cos(y)", {"x": 55}, r"cos y + sin \left(z^{2} + 55\right)"),
-        ("sin(x) + cos(y)", {"x": 0}, r"cos y")
-    ]
-
-    for expression, subs, expected_output in test_cases:
-        output = python_polynomial_expression_to_latex(expression, subs)
-        assert output == expected_output, (
-            f"Test failed for expression: {expression} with substitutions: {subs}. "
-            f"Expected {expected_output}, got {output}"
-        )
-
 
 def test_compute_constant_expression():
     test_cases = [
@@ -52,34 +31,7 @@ def test_compute_constant_expression():
         result = compute_constant_expression(input_data)
         assert math.isclose(result, expected_output, rel_tol=1e-9), f"Failed for {input_data}, got {result}"
 
-
-def test_simplify_polynomial_expression():
-    test_cases = [
-        # Without substitutions
-        (("(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)", None), r"\frac{1}{110 x^{22} y^{3}}"),
-
-        # With substitutions
-        (("x**2 + y**2", {"x": 3, "y": 4}), "25"),
-        (("a*b + b", {"b": 2}), r"2 a + 2"),  # Assumes no simplification of `a*b`
-        (("(x**2 + y**2 + z**2)", {"x": 1, "y": 0, "z": 0}), "1")
-    ]
-
-    for (expression, subs), expected_output in test_cases:
-        output = simplify_polynomial_expression(expression, subs)
-        assert output == expected_output, (f"Test failed for expression: {expression} with substitutions: {subs}. Expected {expected_output}, got {output}")
-
-
-def test_solve_homogeneous_polynomial_expression():
-    test_cases = [
-        # Test case with substitutions
-        (("a*x**2 + b*x + c", "x", {"a": 3, "b": 7, "c": 5}), r"\left[-7/6 - sqrt(11)*I/6, -7/6 + sqrt(11)*I/6\right]"),
-    ]
-
-    for (expression, variable, subs), expected_output in test_cases:
-        assert solve_homogeneous_polynomial_expression(expression, variable, subs) == expected_output
-
-
-def test_compute_matrix_expression():
+def test_compute_constant_expression_involving_matrices():
     test_cases = [
         ("[[2, 6, 9],[1, 3, 5]] + [[1, 2, 3],[4, 5, 6]]", r"\begin{bmatrix}3 & 8 & 12\\5 & 8 & 11\end{bmatrix}"),
         ("[[10, 10, 10],[2, 4, 6]] - [[5, 3, 2],[1, 2, 1]]", r"\begin{bmatrix}5 & 7 & 8\\1 & 2 & 5\end{bmatrix}"),
@@ -97,34 +49,84 @@ def test_compute_matrix_expression():
     ]
 
     for input_data, expected_output in test_cases:
-        result = compute_matrix_expression(input_data)
+        result = compute_constant_expression_involving_matrices(input_data)
         assert result == expected_output, f"Failed for {input_data}, got {result}"
 
 # Example test function
 
 
-def test_compute_ordered_series_expression():
+def test_compute_constant_expression_involving_ordered_series():
     test_cases = [
         ("[2, 6, 9] + [1, 2, 3]", "[3, 8, 12]"),
         ("[10, 15, 21] - [5, 5, 5]", "[5, 10, 16]"),
         ("[2, 4, 6] * [1, 2, 3]", "[2, 8, 18]"),
         ("[8, 16, 32] / [2, 2, 8]", "[4.0, 8.0, 4.0]"),
-        ("ddd([2, 6, 9, 60]) + ddd([78, 79, 80])", "Operations between ordered series must involve series of equal length"),
-        ("ddd([1, 3, 6, 10]) - ddd([0, 1, 1, 2])", "[1, 3, 3]"),
+        ("dd([2, 6, 9, 60]) + dd([78, 79, 80])", "Operations between ordered series must involve series of equal length"),
+        ("dd([1, 3, 6, 10]) - dd([0, 1, 1, 2])", "[1, 3, 3]"),
 
         # Edge cases
-        ("ddd([1])", "[]"),  # Single-element list, becomes empty
-        ("ddd([])", "[]"),   # Empty list case
+        ("dd([1])", "[]"),  # Single-element list, becomes empty
+        ("dd([])", "[]"),   # Empty list case
         ("[5]", "[5]"),  # Single-element list, unchanged
         ("[]", "[]"),    # Empty list
         ("[4, 3, 51] + [1, 1]", "Operations between ordered series must involve series of equal length"),  # Test unequal lengths
     ]
 
     for input_data, expected_output in test_cases:
-        result = compute_ordered_series_expression(input_data)
+        result = compute_constant_expression_involving_ordered_series(input_data)
         assert result == expected_output, f"Failed for {input_data}, got {result}"
 
 
+def test_python_polynomial_expression_to_latex():
+    test_cases = [
+        # Without substitutions
+        ("x**2 + y**2", None, r"x^{2} + y^{2}"),
+        ("3*a + 4*b", None, r"3 a + 4 b"),
+        ("3*x**3 / (7*y*m**(n+2) + 103)", None, r"\frac{3 x^{3}}{7 m^{n + 2} y + 103}"),
+
+        # With substitutions
+        ("x**2 + y**2", {"x": 3, "y": 4}, r"25"),
+        ("x**2 + y**2", {"x": 3}, r"y^{2} + 9"),
+        ("a*b + b", {"b": 2}, r"2 a + 2"),
+        ("sin(x+z**2) + cos(y)", {"x": 55}, r"cos y + sin \left(z^{2} + 55\right)"),
+        ("sin(x) + cos(y)", {"x": 0}, r"cos y")
+    ]
+
+    for expression, subs, expected_output in test_cases:
+        output = python_polynomial_expression_to_latex(expression, subs)
+        assert output == expected_output, (
+            f"Test failed for expression: {expression} with substitutions: {subs}. "
+            f"Expected {expected_output}, got {output}"
+        )
+
+
+
+def test_simplify_polynomial_expression():
+    test_cases = [
+        # Without substitutions
+        (("(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)", None), r"\frac{1}{110 x^{22} y^{3}}"),
+
+        # With substitutions
+        (("x**2 + y**2", {"x": 3, "y": 4}), "25"),
+        (("a*b + b", {"b": 2}), r"2 a + 2"),  # Assumes no simplification of `a*b`
+        (("(x**2 + y**2 + z**2)", {"x": 1, "y": 0, "z": 0}), "1")
+    ]
+
+    for (expression, subs), expected_output in test_cases:
+        output = simplify_polynomial_expression(expression, subs)
+        assert output == expected_output, (f"Test failed for expression: {expression} with substitutions: {subs}. Expected {expected_output}, got {output}")
+
+
+def test_solve_homogeneous_polynomial_expression():
+    test_cases = [
+        # Test case with substitutions
+        (("a*x**2 + b*x + c", "x", {"a": 3, "b": 7, "c": 5}), r"\left[-7/6 - sqrt(11)*I/6, -7/6 + sqrt(11)*I/6\right]"),
+    ]
+
+    for (expression, variable, subs), expected_output in test_cases:
+        assert solve_homogeneous_polynomial_expression(expression, variable, subs) == expected_output
+
+
 def test_get_prime_factors_latex():
     test_cases = [
         (100, "2^{2} \\cdot 5^{2}"),