rgwfuncs 0.0.26__tar.gz → 0.0.28__tar.gz

{rgwfuncs-0.0.26/src/rgwfuncs.egg-info → rgwfuncs-0.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.26
+Version: 0.0.28
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -182,24 +182,38 @@ These examples illustrate the ability to handle basic arithmetic, the modulo ope
 
 ### 2. `simplify_algebraic_expression`
 
-Simplifies expressions and returns them in LaTeX format.
+Simplifies expressions and returns them in LaTeX format. Optionally applies substitutions to variables within the expression before simplifying.
 
 - **Parameters:**
-  - `expression` (str): A string of the expression to simplify.
+  - `expression` (str): A string representing the algebraic expression to simplify.
+  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where keys are variable names and values are the numbers to substitute them with.
 
 - **Returns:**
-  - `str`: Simplified expression in LaTeX.
+  - `str`: The simplified expression formatted as a LaTeX string.
 
-- **Example:**
+- **Example Usage:**
 
     from rgwfuncs import simplify_algebraic_expression
+
+    # Example 1: Simplifying a polynomial expression without substitutions
     simplified_expr1 = simplify_algebraic_expression("2*x + 3*x")
     print(simplified_expr1)  # Output: "5 x"
 
-    simplified_expr2 = simplify_algebraic_expression("(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)")
-    print(simplified_expr2)  # Output: "\frac{1}{110 x^{22} y^{3}}"
+    # Example 2: Simplifying a complex expression involving derivatives
+    simplified_expr2 = simplify_algebraic_expression(
+        "(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)"
+    )
+    print(simplified_expr2)  # Output: r"\frac{1}{110 x^{22} y^{3}}"
+
+    # Example 3: Simplifying with substitutions
+    simplified_expr3 = simplify_algebraic_expression("x**2 + y**2", subs={"x": 3, "y": 4})
+    print(simplified_expr3)  # Output: "25"
+
+    # Example 4: Simplifying with partial substitution
+    simplified_expr4 = simplify_algebraic_expression("a*b + b", subs={"b": 2})
+    print(simplified_expr4)  # Output: "a \cdot 2 + 2"
 
-These examples demonstrate simplification of polynomial expressions and more complex ratios involving derivatives.
+These examples demonstrate the simplification of polynomial expressions, handling complex ratios involving derivatives, and applying variable substitutions before simplifying. The function handles expressions both with and without substitutions, providing flexibility in its usage.
 
 --------------------------------------------------------------------------------
 
@@ -252,6 +266,66 @@ Computes prime factors of a number and presents them in LaTeX format.
  
 --------------------------------------------------------------------------------
 
+### 5. `compute_matrix_operation`
+
+Computes the results of 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_operation
+    
+    # Example with addition of 2D matrices
+    result = compute_matrix_operation("[[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_operation("[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_operation("[[4, 3, 51]] + [[1, 1]]")
+    print(result)  # Output: Operations between matrices must involve matrices of the same dimension
+
+This function performs elementwise operations on both 1D and 2D matrices represented as Python lists and formats the result as a LaTeX string. It handles operations sequentially from left to right and gracefully handles dimension mismatches by returning a meaningful message. It utilizes Python's `ast.literal_eval` for safe and robust parsing.
+
+--------------------------------------------------------------------------------
+
+### 6. `compute_ordered_series_operations`
+
+Computes the result of operations on ordered series expressed as 1D lists, including the discrete difference operator `ddd`.
+
+- **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_operations
+
+    # Example with addition and discrete differences
+    result = compute_ordered_series_operations("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_operations("[10, 15, 21] - [5, 5, 5]")
+    print(result)  # Output: [5, 10, 16]
+
+    # Example with length mismatch
+    result = compute_ordered_series_operations("[4, 3, 51] + [1, 1]")
+    print(result)  # Output: Operations between ordered series must involve series of equal length
+
+This function first applies the discrete difference operator to any series where applicable, then evaluates arithmetic operations between series. It returns a string representation of the result or an error message if the series lengths do not match. The function is robust, directly parsing and evaluating given series expressions with safety checks in place.
+
+--------------------------------------------------------------------------------
+
 ## String Based Functions
 
 ### 1. send_telegram_message

{rgwfuncs-0.0.26 → rgwfuncs-0.0.28}/README.md

@@ -156,24 +156,38 @@ These examples illustrate the ability to handle basic arithmetic, the modulo ope
 
 ### 2. `simplify_algebraic_expression`
 
-Simplifies expressions and returns them in LaTeX format.
+Simplifies expressions and returns them in LaTeX format. Optionally applies substitutions to variables within the expression before simplifying.
 
 - **Parameters:**
-  - `expression` (str): A string of the expression to simplify.
+  - `expression` (str): A string representing the algebraic expression to simplify.
+  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where keys are variable names and values are the numbers to substitute them with.
 
 - **Returns:**
-  - `str`: Simplified expression in LaTeX.
+  - `str`: The simplified expression formatted as a LaTeX string.
 
-- **Example:**
+- **Example Usage:**
 
     from rgwfuncs import simplify_algebraic_expression
+
+    # Example 1: Simplifying a polynomial expression without substitutions
     simplified_expr1 = simplify_algebraic_expression("2*x + 3*x")
     print(simplified_expr1)  # Output: "5 x"
 
-    simplified_expr2 = simplify_algebraic_expression("(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)")
-    print(simplified_expr2)  # Output: "\frac{1}{110 x^{22} y^{3}}"
+    # Example 2: Simplifying a complex expression involving derivatives
+    simplified_expr2 = simplify_algebraic_expression(
+        "(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)"
+    )
+    print(simplified_expr2)  # Output: r"\frac{1}{110 x^{22} y^{3}}"
+
+    # Example 3: Simplifying with substitutions
+    simplified_expr3 = simplify_algebraic_expression("x**2 + y**2", subs={"x": 3, "y": 4})
+    print(simplified_expr3)  # Output: "25"
+
+    # Example 4: Simplifying with partial substitution
+    simplified_expr4 = simplify_algebraic_expression("a*b + b", subs={"b": 2})
+    print(simplified_expr4)  # Output: "a \cdot 2 + 2"
 
-These examples demonstrate simplification of polynomial expressions and more complex ratios involving derivatives.
+These examples demonstrate the simplification of polynomial expressions, handling complex ratios involving derivatives, and applying variable substitutions before simplifying. The function handles expressions both with and without substitutions, providing flexibility in its usage.
 
 --------------------------------------------------------------------------------
 
@@ -226,6 +240,66 @@ Computes prime factors of a number and presents them in LaTeX format.
  
 --------------------------------------------------------------------------------
 
+### 5. `compute_matrix_operation`
+
+Computes the results of 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_operation
+    
+    # Example with addition of 2D matrices
+    result = compute_matrix_operation("[[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_operation("[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_operation("[[4, 3, 51]] + [[1, 1]]")
+    print(result)  # Output: Operations between matrices must involve matrices of the same dimension
+
+This function performs elementwise operations on both 1D and 2D matrices represented as Python lists and formats the result as a LaTeX string. It handles operations sequentially from left to right and gracefully handles dimension mismatches by returning a meaningful message. It utilizes Python's `ast.literal_eval` for safe and robust parsing.
+
+--------------------------------------------------------------------------------
+
+### 6. `compute_ordered_series_operations`
+
+Computes the result of operations on ordered series expressed as 1D lists, including the discrete difference operator `ddd`.
+
+- **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_operations
+
+    # Example with addition and discrete differences
+    result = compute_ordered_series_operations("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_operations("[10, 15, 21] - [5, 5, 5]")
+    print(result)  # Output: [5, 10, 16]
+
+    # Example with length mismatch
+    result = compute_ordered_series_operations("[4, 3, 51] + [1, 1]")
+    print(result)  # Output: Operations between ordered series must involve series of equal length
+
+This function first applies the discrete difference operator to any series where applicable, then evaluates arithmetic operations between series. It returns a string representation of the result or an error message if the series lengths do not match. The function is robust, directly parsing and evaluating given series expressions with safety checks in place.
+
+--------------------------------------------------------------------------------
+
 ## String Based Functions
 
 ### 1. send_telegram_message

{rgwfuncs-0.0.26 → rgwfuncs-0.0.28}/pyproject.toml

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

{rgwfuncs-0.0.26 → rgwfuncs-0.0.28}/setup.cfg

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

{rgwfuncs-0.0.26 → rgwfuncs-0.0.28}/src/rgwfuncs/__init__.py

@@ -1,7 +1,7 @@
 # This file is automatically generated
 # Dynamically importing functions from modules
 
-from .algebra_lib import compute_algebraic_expression, get_prime_factors_latex, simplify_algebraic_expression, solve_algebraic_expression
+from .algebra_lib import compute_algebraic_expression, compute_matrix_operation, compute_ordered_series_operation, get_prime_factors_latex, simplify_algebraic_expression, solve_algebraic_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.26 → rgwfuncs-0.0.28}/src/rgwfuncs/algebra_lib.py

@@ -1,6 +1,7 @@
 import re
 import math
 import ast
+# import numpy as np
 from sympy import symbols, latex, simplify, solve, diff, Expr
 from sympy.parsing.sympy_parser import parse_expr
 from typing import Tuple, List, Dict, Optional
@@ -35,7 +36,10 @@ def compute_algebraic_expression(expression: str) -> float:
         raise ValueError(f"Error computing expression: {e}")
 
 
-def simplify_algebraic_expression(expression: str) -> str:
+def simplify_algebraic_expression(
+    expression: str,
+    subs: Optional[Dict[str, float]] = None
+) -> str:
     """
     Simplifies an algebraic expression and returns it in LaTeX format.
 
@@ -44,11 +48,17 @@ def simplify_algebraic_expression(expression: str) -> str:
 
     Parameters:
     expression (str): The algebraic expression to simplify.
+    subs (Optional[Dict[str, float]]): An optional dictionary of substitutions for variables
+                                       in the expression.
 
     Returns:
     str: The simplified expression represented as a LaTeX string.
+
+    Raises:
+    ValueError: If the expression cannot be simplified due to errors in expression or parameters.
     """
 
+
     def recursive_parse_function_call(
             func_call: str, prefix: str, sym_vars: Dict[str, Expr]) -> Tuple[str, List[Expr]]:
         # print(f"Parsing function call: {func_call}")
@@ -177,13 +187,18 @@ def simplify_algebraic_expression(expression: str) -> str:
     # print("Level 2 processed_expression:", processed_expression)
 
     try:
-        if processed_expression.startswith(
-                '[') and processed_expression.endswith(']'):
-            return processed_expression
-
+        # Parse the expression
         expr = parse_expr(processed_expression, local_dict=sym_vars)
+
+        # Apply substitutions if provided
+        if subs:
+            subs_symbols = {symbols(k): v for k, v in subs.items()}
+            expr = expr.subs(subs_symbols)
+
+        # Simplify the expression
         final_result = simplify(expr)
 
+        # Convert the result to LaTeX format
         if final_result.free_symbols:
             latex_result = latex(final_result)
             return latex_result
@@ -195,7 +210,10 @@ def simplify_algebraic_expression(expression: str) -> str:
 
 
 def solve_algebraic_expression(
-        expression: str, variable: str, subs: Optional[Dict[str, float]] = None) -> str:
+        expression: str, 
+        variable: str, 
+        subs: Optional[Dict[str, float]] = None
+    ) -> str:
     """
     Solves an algebraic equation for a specified variable and returns solutions in LaTeX format.
 
@@ -242,6 +260,198 @@ def solve_algebraic_expression(
         raise ValueError(f"Error solving the expression: {e}")
 
 
+def compute_matrix_operation(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_operation(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:
     """
     Computes the prime factors of a number and returns the factorization as a LaTeX string.

{rgwfuncs-0.0.26 → rgwfuncs-0.0.28/src/rgwfuncs.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.26
+Version: 0.0.28
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -182,24 +182,38 @@ These examples illustrate the ability to handle basic arithmetic, the modulo ope
 
 ### 2. `simplify_algebraic_expression`
 
-Simplifies expressions and returns them in LaTeX format.
+Simplifies expressions and returns them in LaTeX format. Optionally applies substitutions to variables within the expression before simplifying.
 
 - **Parameters:**
-  - `expression` (str): A string of the expression to simplify.
+  - `expression` (str): A string representing the algebraic expression to simplify.
+  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where keys are variable names and values are the numbers to substitute them with.
 
 - **Returns:**
-  - `str`: Simplified expression in LaTeX.
+  - `str`: The simplified expression formatted as a LaTeX string.
 
-- **Example:**
+- **Example Usage:**
 
     from rgwfuncs import simplify_algebraic_expression
+
+    # Example 1: Simplifying a polynomial expression without substitutions
     simplified_expr1 = simplify_algebraic_expression("2*x + 3*x")
     print(simplified_expr1)  # Output: "5 x"
 
-    simplified_expr2 = simplify_algebraic_expression("(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)")
-    print(simplified_expr2)  # Output: "\frac{1}{110 x^{22} y^{3}}"
+    # Example 2: Simplifying a complex expression involving derivatives
+    simplified_expr2 = simplify_algebraic_expression(
+        "(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)"
+    )
+    print(simplified_expr2)  # Output: r"\frac{1}{110 x^{22} y^{3}}"
+
+    # Example 3: Simplifying with substitutions
+    simplified_expr3 = simplify_algebraic_expression("x**2 + y**2", subs={"x": 3, "y": 4})
+    print(simplified_expr3)  # Output: "25"
+
+    # Example 4: Simplifying with partial substitution
+    simplified_expr4 = simplify_algebraic_expression("a*b + b", subs={"b": 2})
+    print(simplified_expr4)  # Output: "a \cdot 2 + 2"
 
-These examples demonstrate simplification of polynomial expressions and more complex ratios involving derivatives.
+These examples demonstrate the simplification of polynomial expressions, handling complex ratios involving derivatives, and applying variable substitutions before simplifying. The function handles expressions both with and without substitutions, providing flexibility in its usage.
 
 --------------------------------------------------------------------------------
 
@@ -252,6 +266,66 @@ Computes prime factors of a number and presents them in LaTeX format.
  
 --------------------------------------------------------------------------------
 
+### 5. `compute_matrix_operation`
+
+Computes the results of 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_operation
+    
+    # Example with addition of 2D matrices
+    result = compute_matrix_operation("[[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_operation("[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_operation("[[4, 3, 51]] + [[1, 1]]")
+    print(result)  # Output: Operations between matrices must involve matrices of the same dimension
+
+This function performs elementwise operations on both 1D and 2D matrices represented as Python lists and formats the result as a LaTeX string. It handles operations sequentially from left to right and gracefully handles dimension mismatches by returning a meaningful message. It utilizes Python's `ast.literal_eval` for safe and robust parsing.
+
+--------------------------------------------------------------------------------
+
+### 6. `compute_ordered_series_operations`
+
+Computes the result of operations on ordered series expressed as 1D lists, including the discrete difference operator `ddd`.
+
+- **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_operations
+
+    # Example with addition and discrete differences
+    result = compute_ordered_series_operations("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_operations("[10, 15, 21] - [5, 5, 5]")
+    print(result)  # Output: [5, 10, 16]
+
+    # Example with length mismatch
+    result = compute_ordered_series_operations("[4, 3, 51] + [1, 1]")
+    print(result)  # Output: Operations between ordered series must involve series of equal length
+
+This function first applies the discrete difference operator to any series where applicable, then evaluates arithmetic operations between series. It returns a string representation of the result or an error message if the series lengths do not match. The function is robust, directly parsing and evaluating given series expressions with safety checks in place.
+
+--------------------------------------------------------------------------------
+
 ## String Based Functions
 
 ### 1. send_telegram_message

rgwfuncs-0.0.28/tests/test_algebra_lib.py

@@ -0,0 +1,122 @@
+import sys
+import os
+import math
+
+# flake8: noqa: E402
+# Allow the following import statement to be AFTER sys.path modifications
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from src.rgwfuncs.algebra_lib import (
+    compute_algebraic_expression,
+    simplify_algebraic_expression,
+    solve_algebraic_expression,
+    compute_matrix_operation,
+    compute_ordered_series_operation,
+    get_prime_factors_latex)
+
+
+def test_compute_algebraic_expression():
+    test_cases = [
+        ("2 + 2", 4.0),
+        ("5 - 3", 2.0),
+        ("3 * 3", 9.0),
+        ("8 / 2", 4.0),
+        ("10 % 3", 1.0),
+        ("math.gcd(36, 60) * math.sin(math.radians(45)) * 10000", 84852.8137423857),
+        # ("np.diff([2,6,9,60])", r"\left[\begin{matrix}4\\3\\51\end{matrix}\right]"),
+    ]
+
+    for input_data, expected_output in test_cases:
+        result = compute_algebraic_expression(input_data)
+        assert math.isclose(result, expected_output, rel_tol=1e-9), f"Failed for {input_data}, got {result}"
+
+def test_simplify_algebraic_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_algebraic_expression(expression, subs)
+        assert output == expected_output, (
+            f"Test failed for expression: {expression} with substitutions: {subs}. "
+            f"Expected {expected_output}, got {output}"
+        )
+
+
+def test_solve_algebraic_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_algebraic_expression(expression, variable, subs) == expected_output
+
+
+def test_compute_matrix_operation():
+    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}"),
+        ("[[2, 4],[6, 8]] * [[1, 0.5],[2, 0.25]]", r"\begin{bmatrix}2 & 2.0\\12 & 2.0\end{bmatrix}"),
+        ("[[8, 16],[32, 64]] / [[2, 2],[8, 16]]", r"\begin{bmatrix}4.0 & 8.0\\4.0 & 4.0\end{bmatrix}"),
+        ("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]] - [[1, 1, 1], [1, 1, 1]]", r"\begin{bmatrix}2 & 7 & 11\\4 & 7 & 10\end{bmatrix}"),
+        ("[2, 6, 9] + [1, 2, 3] - [1, 1, 1]", r"\begin{bmatrix}2 & 7 & 11\end{bmatrix}"),
+        ("[[1, 2], [3, 4]] + [[2, 3], [4, 5]] + [[1, 1], [1, 1]]", r"\begin{bmatrix}4 & 6\\8 & 10\end{bmatrix}"),
+        ("[3, 6, 9] - [1, 2, 3] + [5, 5, 5]", r"\begin{bmatrix}7 & 9 & 11\end{bmatrix}"),
+        ("[3, 6, 9] - [1, 2, 3, 4]", r"Operations between matrices must involve matrices of the same dimension"),
+
+        # Edge cases
+        ("[]", r"\begin{bmatrix}\end{bmatrix}"),  # Empty list
+        ("[5]", r"\begin{bmatrix}5\end{bmatrix}"),  # Single-element list
+    ]
+
+    for input_data, expected_output in test_cases:
+        result = compute_matrix_operation(input_data)
+        assert result == expected_output, f"Failed for {input_data}, got {result}"
+
+# Example test function
+
+
+def test_compute_ordered_series_operations():
+    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]"),
+
+        # Edge cases
+        ("ddd([1])", "[]"),  # Single-element list, becomes empty
+        ("ddd([])", "[]"),   # 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_operation(input_data)
+        assert result == expected_output, f"Failed for {input_data}, got {result}"
+
+
+def test_get_prime_factors_latex():
+    test_cases = [
+        (100, "2^{2} \\cdot 5^{2}"),
+        (60, "2^{2} \\cdot 3 \\cdot 5"),
+        (45, "3^{2} \\cdot 5"),
+        (1, ""),  # Handle case with 1, which has no prime factors
+        (17, "17")  # Prime number itself
+    ]
+
+    for n, expected_output in test_cases:
+        result = get_prime_factors_latex(n)
+        assert result == expected_output, f"Failed for {n}, got {result}"

rgwfuncs-0.0.26/tests/test_algebra_lib.py

@@ -1,59 +0,0 @@
-from src.rgwfuncs.algebra_lib import compute_algebraic_expression, simplify_algebraic_expression, solve_algebraic_expression, get_prime_factors_latex
-import sys
-import os
-import math
-
-# flake8: noqa: E402
-# Allow the following import statement to be AFTER sys.path modifications
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
-
-
-def test_compute_algebraic_expression():
-    test_cases = [
-        ("2 + 2", 4.0),
-        ("5 - 3", 2.0),
-        ("3 * 3", 9.0),
-        ("8 / 2", 4.0),
-        ("10 % 3", 1.0),
-        ("math.gcd(36, 60) * math.sin(math.radians(45)) * 10000", 84852.8137423857),
-    ]
-
-    for input_data, expected_output in test_cases:
-        result = compute_algebraic_expression(input_data)
-        assert math.isclose(result, expected_output, rel_tol=1e-9), f"Failed for {input_data}, got {result}"
-
-
-def test_simplify_algebraic_expression():
-    test_cases = [
-        ("(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)", r"\frac{1}{110 x^{22} y^{3}}"),
-    ]
-
-    for input_data, expected_output in test_cases:
-        assert simplify_algebraic_expression(input_data) == expected_output
-
-
-def test_solve_algebraic_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_algebraic_expression(expression, variable, subs) == expected_output
-
-
-def test_get_prime_factors_latex():
-    test_cases = [
-        (100, "2^{2} \\cdot 5^{2}"),
-        (60, "2^{2} \\cdot 3 \\cdot 5"),
-        (45, "3^{2} \\cdot 5"),
-        (1, ""),  # Handle case with 1, which has no prime factors
-        (17, "17")  # Prime number itself
-    ]
-
-    for n, expected_output in test_cases:
-        result = get_prime_factors_latex(n)
-        assert result == expected_output, f"Failed for {n}, got {result}"