rgwfuncs 0.0.25__tar.gz → 0.0.27__tar.gz

{rgwfuncs-0.0.25/src/rgwfuncs.egg-info → rgwfuncs-0.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.25
+Version: 0.0.27
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -252,6 +252,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.25 → rgwfuncs-0.0.27}/README.md

@@ -226,6 +226,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.25 → rgwfuncs-0.0.27}/pyproject.toml

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

{rgwfuncs-0.0.25 → rgwfuncs-0.0.27}/setup.cfg

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

{rgwfuncs-0.0.25 → rgwfuncs-0.0.27}/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.27/src/rgwfuncs/algebra_lib.py

@@ -0,0 +1,466 @@
+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
+
+
+def compute_algebraic_expression(expression: str) -> float:
+    """
+    Computes the numerical result of a given algebraic expression.
+
+    Evaluates an algebraic 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 algebraic expression to compute. This should be a string consisting
+                      of arithmetic operations and supported math module functions.
+
+    Returns:
+    float: The evaluated numerical result of the expression.
+
+    Raises:
+    ValueError: If the expression cannot be evaluated due to syntax errors or other issues.
+    """
+    try:
+        # Direct numerical evaluation
+        # Safely evaluate the expression using the math module
+        numeric_result = eval(expression, {"__builtins__": None, "math": math})
+
+        # Convert to float if possible
+        return float(numeric_result)
+    except Exception as e:
+        raise ValueError(f"Error computing expression: {e}")
+
+
+def simplify_algebraic_expression(expression: str) -> str:
+    """
+    Simplifies an algebraic expression and returns it in LaTeX format.
+
+    Takes an algebraic expression written in Python syntax and simplifies it. The result is
+    returned as a LaTeX formatted string, suitable for academic or professional documentation.
+
+    Parameters:
+    expression (str): The algebraic expression to simplify.
+
+    Returns:
+    str: The simplified expression represented as a LaTeX string.
+    """
+
+    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}")
+
+        # Match the function name and arguments
+        match = re.match(fr'{prefix}\.(\w+)\((.*)\)', func_call, re.DOTALL)
+        if not match:
+            raise ValueError(f"Invalid function call: {func_call}")
+
+        func_name = match.group(1)
+        args_str = match.group(2)
+
+        # Check if it's a list for np
+        if prefix == 'np' and args_str.startswith(
+                "[") and args_str.endswith("]"):
+            parsed_args = [ast.literal_eval(args_str.strip())]
+        else:
+            parsed_args = []
+            raw_args = re.split(r',(?![^{]*\})', args_str)
+            for arg in raw_args:
+                arg = arg.strip()
+                if re.match(r'\w+\.\w+\(', arg):
+                    # Recursively evaluate the argument if it's another
+                    # function call
+                    arg_val = recursive_eval_func(
+                        re.match(r'\w+\.\w+\(.*\)', arg), sym_vars)
+                    parsed_args.append(
+                        parse_expr(
+                            arg_val,
+                            local_dict=sym_vars))
+                else:
+                    parsed_args.append(parse_expr(arg, local_dict=sym_vars))
+
+        # print(f"Function name: {func_name}, Parsed arguments: {parsed_args}")
+        return func_name, parsed_args
+
+    def recursive_eval_func(match: re.Match, sym_vars: Dict[str, Expr]) -> str:
+        # print("152", match)
+        func_call = match.group(0)
+        # print(f"153 Evaluating function call: {func_call}")
+
+        if func_call.startswith("np."):
+            func_name, args = recursive_parse_function_call(
+                func_call, 'np', sym_vars)
+            if func_name == 'diff':
+                expr = args[0]
+                if isinstance(expr, list):
+                    # Calculate discrete difference
+                    diff_result = [expr[i] - expr[i - 1]
+                                   for i in range(1, len(expr))]
+                    return str(diff_result)
+                # Perform symbolic differentiation
+                diff_result = diff(expr)
+                return str(diff_result)
+
+        if func_call.startswith("math."):
+            func_name, args = recursive_parse_function_call(
+                func_call, 'math', sym_vars)
+            if hasattr(math, func_name):
+                result = getattr(math, func_name)(*args)
+                return str(result)
+
+        if func_call.startswith("sym."):
+            initial_method_match = re.match(
+                r'(sym\.\w+\([^()]*\))(\.(\w+)\((.*?)\))*', func_call, re.DOTALL)
+            if initial_method_match:
+                base_expr_str = initial_method_match.group(1)
+                base_func_name, base_args = recursive_parse_function_call(
+                    base_expr_str, 'sym', sym_vars)
+                if base_func_name == 'solve':
+                    solutions = solve(base_args[0], base_args[1])
+                    # print(f"Solutions found: {solutions}")
+
+                method_chain = re.findall(
+                    r'\.(\w+)\((.*?)\)', func_call, re.DOTALL)
+                final_solutions = [execute_chained_methods(sol, [(m, [method_args.strip(
+                )]) for m, method_args in method_chain], sym_vars) for sol in solutions]
+
+                return "[" + ",".join(latex(simplify(sol))
+                                      for sol in final_solutions) + "]"
+
+        raise ValueError(f"Unknown function call: {func_call}")
+
+    def execute_chained_methods(sym_expr: Expr,
+                                method_chain: List[Tuple[str,
+                                                         List[str]]],
+                                sym_vars: Dict[str,
+                                               Expr]) -> Expr:
+        for method_name, method_args in method_chain:
+            # print(f"Executing method: {method_name} with arguments: {method_args}")
+            method = getattr(sym_expr, method_name, None)
+            if method:
+                if method_name == 'subs' and isinstance(method_args[0], dict):
+                    kwargs = method_args[0]
+                    kwargs = {
+                        parse_expr(
+                            k,
+                            local_dict=sym_vars): parse_expr(
+                            v,
+                            local_dict=sym_vars) for k,
+                        v in kwargs.items()}
+                    sym_expr = method(kwargs)
+                else:
+                    args = [parse_expr(arg.strip(), local_dict=sym_vars)
+                            for arg in method_args]
+                    sym_expr = method(*args)
+            # print(f"Result after {method_name}: {sym_expr}")
+        return sym_expr
+
+    variable_names = set(re.findall(r'\b[a-zA-Z]\w*\b', expression))
+    sym_vars = {var: symbols(var) for var in variable_names}
+
+    patterns = {
+        # "numpy_diff_brackets": r"np\.diff\(\[.*?\]\)",
+        "numpy_diff_no_brackets": r"np\.diff\([^()]*\)",
+        "math_functions": r"math\.\w+\((?:[^()]*(?:\([^()]*\)[^()]*)*)\)",
+        # "sympy_functions": r"sym\.\w+\([^()]*\)(?:\.\w+\([^()]*\))?",
+    }
+
+    function_pattern = '|'.join(patterns.values())
+
+    # Use a lambda function to pass additional arguments
+    processed_expression = re.sub(
+        function_pattern, lambda match: recursive_eval_func(
+            match, sym_vars), expression)
+    # print("Level 2 processed_expression:", processed_expression)
+
+    try:
+        if processed_expression.startswith(
+                '[') and processed_expression.endswith(']'):
+            return processed_expression
+
+        expr = parse_expr(processed_expression, local_dict=sym_vars)
+        final_result = simplify(expr)
+
+        if final_result.free_symbols:
+            latex_result = latex(final_result)
+            return latex_result
+        else:
+            return str(final_result)
+
+    except Exception as e:
+        raise ValueError(f"Error simplifying expression: {e}")
+
+
+def solve_algebraic_expression(
+        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.
+
+    Solves the given equation for a designated variable. May optionally include substitutions
+    for other variables in the equation. The solutions are provided as a LaTeX formatted string.
+
+    Parameters:
+    expression (str): The algebraic equation to solve.
+    variable (str): The variable to solve the equation for.
+    subs (Optional[Dict[str, float]]): An optional dictionary of substitutions for variables
+                                       in the equation.
+
+    Returns:
+    str: The solutions of the equation, formatted as a LaTeX string.
+
+    Raises:
+    ValueError: If the equation cannot be solved due to errors in expression or parameters.
+    """
+
+    try:
+        # Create symbols for the variables in the expression
+        variable_symbols = set(re.findall(r'\b[a-zA-Z]\w*\b', expression))
+        sym_vars = {var: symbols(var) for var in variable_symbols}
+
+        # Parse the expression and solve it
+        expr = parse_expr(expression, local_dict=sym_vars)
+        var_symbol = symbols(variable)
+        solutions = solve(expr, var_symbol)
+
+        # Apply substitutions if provided
+        if subs:
+            subs_symbols = {symbols(k): v for k, v in subs.items()}
+            solutions = [simplify(sol.subs(subs_symbols)) for sol in solutions]
+
+        # Convert solutions to LaTeX strings if possible
+        latex_solutions = [
+            latex(
+                simplify(sol)) if sol.free_symbols else str(sol) for sol in solutions]
+        result = r"\left[" + ", ".join(latex_solutions) + r"\right]"
+        print("158", result)
+        return result
+
+    except Exception as e:
+        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.
+
+    Determines the prime factorization of the given integer. The result is formatted as a LaTeX
+    string, enabling easy integration into documents or presentations that require mathematical notation.
+
+    Parameters:
+    n (int): The number for which to compute prime factors.
+
+    Returns:
+    str: The LaTeX representation of the prime factorization.
+    """
+
+    factors = []
+    while n % 2 == 0:
+        factors.append(2)
+        n //= 2
+    for i in range(3, int(math.sqrt(n)) + 1, 2):
+        while n % i == 0:
+            factors.append(i)
+            n //= i
+    if n > 2:
+        factors.append(n)
+
+    factor_counts = {factor: factors.count(factor) for factor in set(factors)}
+    latex_factors = [f"{factor}^{{{count}}}" if count > 1 else str(
+        factor) for factor, count in factor_counts.items()]
+    return " \\cdot ".join(latex_factors)

{rgwfuncs-0.0.25 → rgwfuncs-0.0.27}/src/rgwfuncs/df_lib.py

@@ -21,8 +21,8 @@ from email.mime.base import MIMEBase
 from email import encoders
 from googleapiclient.discovery import build
 import base64
-import inspect
-from typing import Optional, Callable, Dict, List, Tuple, Any
+# import inspect
+from typing import Optional, Dict, List, Tuple, Any
 import warnings
 
 # Suppress all FutureWarnings
@@ -798,7 +798,12 @@ def print_dataframe(df: pd.DataFrame, source: Optional[str] = None) -> None:
     gc.collect()
 
 
-def send_dataframe_via_telegram(df: pd.DataFrame, bot_name: str, message: Optional[str] = None, as_file: bool = True, remove_after_send: bool = True) -> None:
+def send_dataframe_via_telegram(
+        df: pd.DataFrame,
+        bot_name: str,
+        message: Optional[str] = None,
+        as_file: bool = True,
+        remove_after_send: bool = True) -> None:
     """
     Send a DataFrame via Telegram using a specified bot configuration.
 
@@ -1635,7 +1640,12 @@ def print_n_frequency_cascading(
     report = generate_cascade_report(df, columns, n, order_by)
     print(json.dumps(report, indent=2))
 
-def print_n_frequency_linear(df: pd.DataFrame, n: int, columns: list, order_by: str = "FREQ_DESC") -> None:
+
+def print_n_frequency_linear(
+        df: pd.DataFrame,
+        n: int,
+        columns: list,
+        order_by: str = "FREQ_DESC") -> None:
     """
     Print the linear frequency of top n values for specified columns.
 
@@ -1682,23 +1692,36 @@ def print_n_frequency_linear(df: pd.DataFrame, n: int, columns: list, order_by:
                 return val
 
     def sort_frequency(frequency, order_by):
-        keys = frequency.keys()
+        # keys = frequency.keys()
 
-        # Convert keys to numerical values where possible, leaving `NaN` as a special string
-        parsed_keys = [(try_parse_numeric(key), key) for key in keys]
+        # Convert keys to numerical values where possible, leaving `NaN` as a
+        # special string
+        # parsed_keys = [(try_parse_numeric(key), key) for key in keys]
 
         if order_by in {"BY_KEYS_ASC", "BY_KEYS_DESC"}:
             reverse = order_by == "BY_KEYS_DESC"
-            sorted_items = sorted(frequency.items(), key=lambda item: try_parse_numeric(item[0]), reverse=reverse)
+            sorted_items = sorted(
+                frequency.items(),
+                key=lambda item: try_parse_numeric(
+                    item[0]),
+                reverse=reverse)
         else:
             if order_by == "ASC":
-                sorted_items = sorted(frequency.items(), key=lambda item: item[0])
+                sorted_items = sorted(
+                    frequency.items(), key=lambda item: item[0])
             elif order_by == "DESC":
-                sorted_items = sorted(frequency.items(), key=lambda item: item[0], reverse=True)
+                sorted_items = sorted(
+                    frequency.items(),
+                    key=lambda item: item[0],
+                    reverse=True)
             elif order_by == "FREQ_ASC":
-                sorted_items = sorted(frequency.items(), key=lambda item: item[1])
+                sorted_items = sorted(
+                    frequency.items(), key=lambda item: item[1])
             else:  # Default to "FREQ_DESC"
-                sorted_items = sorted(frequency.items(), key=lambda item: item[1], reverse=True)
+                sorted_items = sorted(
+                    frequency.items(),
+                    key=lambda item: item[1],
+                    reverse=True)
 
         return dict(sorted_items)
 
@@ -1850,7 +1873,10 @@ def right_join(
     return df1.merge(df2, how='right', left_on=left_on, right_on=right_on)
 
 
-def insert_dataframe_in_sqlite_database(db_path: str, tablename: str, df: pd.DataFrame) -> None:
+def insert_dataframe_in_sqlite_database(
+        db_path: str,
+        tablename: str,
+        df: pd.DataFrame) -> None:
     """
     Inserts a Pandas DataFrame into a SQLite database table.
 
@@ -1912,7 +1938,10 @@ def insert_dataframe_in_sqlite_database(db_path: str, tablename: str, df: pd.Dat
         df.to_sql(tablename, conn, if_exists='append', index=False)
 
 
-def sync_dataframe_to_sqlite_database(db_path: str, tablename: str, df: pd.DataFrame) -> None:
+def sync_dataframe_to_sqlite_database(
+        db_path: str,
+        tablename: str,
+        df: pd.DataFrame) -> None:
     """
     Processes and saves a DataFrame to an SQLite database, adding a timestamp column
     and replacing the existing table if needed. Creates the table if it does not exist.

{rgwfuncs-0.0.25 → rgwfuncs-0.0.27}/src/rgwfuncs/docs_lib.py

@@ -1,16 +1,17 @@
 import os
 import inspect
-from typing import Tuple, Optional, Dict, Callable
+from typing import Optional
 import warnings
 
 # Suppress all FutureWarnings
 warnings.filterwarnings("ignore", category=FutureWarning)
 
+
 def docs(method_type_filter: Optional[str] = None) -> None:
     """
     Print a list of function names in alphabetical order from all modules.
     If method_type_filter is specified, print the docstrings of the functions
-    that match the filter based on a substring. Using '*' as a filter will print 
+    that match the filter based on a substring. Using '*' as a filter will print
     the docstrings for all functions.
 
     Parameters:
@@ -41,9 +42,10 @@ def docs(method_type_filter: Optional[str] = None) -> None:
             # List function names
             function_names = sorted(functions.keys())
             for name in function_names:
-                # If a filter is provided or '*', check if the function name contains the filter
-                if method_type_filter and (method_type_filter == '*' or method_type_filter in name):
+                # If a filter is provided or '*', check if the function name
+                # contains the filter
+                if method_type_filter and (
+                        method_type_filter == '*' or method_type_filter in name):
                     docstring: Optional[str] = functions[name].__doc__
                     if docstring:
                         print(f"\n{name}:\n{docstring}")
-

{rgwfuncs-0.0.25 → rgwfuncs-0.0.27}/src/rgwfuncs/str_lib.py

@@ -1,8 +1,7 @@
 import os
 import json
 import requests
-import inspect
-from typing import Tuple, Optional, Dict, Callable
+from typing import Tuple
 import warnings
 
 # Suppress all FutureWarnings
@@ -37,19 +36,20 @@ def send_telegram_message(preset_name: str, message: str) -> None:
                 return preset
         return None
 
-    def get_telegram_bot_details(config: dict, preset_name: str) -> Tuple[str, str]:
+    def get_telegram_bot_details(
+            config: dict, preset_name: str) -> Tuple[str, str]:
         """Retrieve the Telegram bot token and chat ID from the preset."""
         preset = get_telegram_preset(config, preset_name)
         if not preset:
-            raise RuntimeError(f"Telegram bot preset '{preset_name}' not found in the configuration file")
+            raise RuntimeError(
+                f"Telegram bot preset '{preset_name}' not found in the configuration file")
 
         bot_token = preset.get("bot_token")
         chat_id = preset.get("chat_id")
 
         if not bot_token or not chat_id:
             raise RuntimeError(
-                f"Telegram bot token or chat ID for '{preset_name}' not found in the configuration file"
-            )
+                f"Telegram bot token or chat ID for '{preset_name}' not found in the configuration file")
 
         return bot_token, chat_id
 

{rgwfuncs-0.0.25 → rgwfuncs-0.0.27/src/rgwfuncs.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.25
+Version: 0.0.27
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -252,6 +252,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.27/tests/test_algebra_lib.py

@@ -0,0 +1,115 @@
+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 = [
+        ("(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_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.25/src/rgwfuncs/algebra_lib.py

@@ -1,186 +0,0 @@
-import re
-import math
-from sympy import symbols, latex, simplify, solve, diff, Expr
-from sympy.parsing.sympy_parser import parse_expr
-from typing import Tuple, List, Dict, Optional
-
-def compute_algebraic_expression(expression: str) -> float:
-    try:
-        # Direct numerical evaluation
-        # Safely evaluate the expression using the math module
-        numeric_result = eval(expression, {"__builtins__": None, "math": math})
-
-        # Convert to float if possible
-        return float(numeric_result)
-    except Exception as e:
-        raise ValueError(f"Error computing expression: {e}")
-
-def simplify_algebraic_expression(expression: str) -> str:
-
-
-    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}")
-
-        # Match the function name and arguments
-        match = re.match(fr'{prefix}\.(\w+)\((.*)\)', func_call, re.DOTALL)
-        if not match:
-            raise ValueError(f"Invalid function call: {func_call}")
-
-        func_name = match.group(1)
-        args_str = match.group(2)
-
-        # Check if it's a list for np
-        if prefix == 'np' and args_str.startswith("[") and args_str.endswith("]"):
-            parsed_args = [ast.literal_eval(args_str.strip())]
-        else:
-            parsed_args = []
-            raw_args = re.split(r',(?![^{]*\})', args_str)
-            for arg in raw_args:
-                arg = arg.strip()
-                if re.match(r'\w+\.\w+\(', arg):
-                    # Recursively evaluate the argument if it's another function call
-                    arg_val = recursive_eval_func(re.match(r'\w+\.\w+\(.*\)', arg), sym_vars)
-                    parsed_args.append(parse_expr(arg_val, local_dict=sym_vars))
-                else:
-                    parsed_args.append(parse_expr(arg, local_dict=sym_vars))
-
-        # print(f"Function name: {func_name}, Parsed arguments: {parsed_args}")
-        return func_name, parsed_args
-
-
-    def recursive_eval_func(match: re.Match, sym_vars: Dict[str, Expr]) -> str:
-        # print("152", match)
-        func_call = match.group(0)
-        # print(f"153 Evaluating function call: {func_call}")
-
-        if func_call.startswith("np."):
-            func_name, args = recursive_parse_function_call(func_call, 'np', sym_vars)
-            if func_name == 'diff':
-                expr = args[0]
-                if isinstance(expr, list):
-                    # Calculate discrete difference
-                    diff_result = [expr[i] - expr[i - 1] for i in range(1, len(expr))]
-                    return str(diff_result)
-                # Perform symbolic differentiation
-                diff_result = diff(expr)
-                return str(diff_result)
-
-        if func_call.startswith("math."):
-            func_name, args = recursive_parse_function_call(func_call, 'math', sym_vars)
-            if hasattr(math, func_name):
-                result = getattr(math, func_name)(*args)
-                return str(result)
-
-        if func_call.startswith("sym."):
-            initial_method_match = re.match(r'(sym\.\w+\([^()]*\))(\.(\w+)\((.*?)\))*', func_call, re.DOTALL)
-            if initial_method_match:
-                base_expr_str = initial_method_match.group(1)
-                base_func_name, base_args = recursive_parse_function_call(base_expr_str, 'sym', sym_vars)
-                if base_func_name == 'solve':
-                    solutions = solve(base_args[0], base_args[1])
-                    # print(f"Solutions found: {solutions}")
-
-                method_chain = re.findall(r'\.(\w+)\((.*?)\)', func_call, re.DOTALL)
-                final_solutions = [execute_chained_methods(sol, [(m, [method_args.strip()]) for m, method_args in method_chain], sym_vars) for sol in solutions]
-
-                return "[" + ",".join(latex(simplify(sol)) for sol in final_solutions) + "]"
-
-        raise ValueError(f"Unknown function call: {func_call}")
-
-    def execute_chained_methods(sym_expr: Expr, method_chain: List[Tuple[str, List[str]]], sym_vars: Dict[str, Expr]) -> Expr:
-        for method_name, method_args in method_chain:
-            # print(f"Executing method: {method_name} with arguments: {method_args}")
-            method = getattr(sym_expr, method_name, None)
-            if method:
-                if method_name == 'subs' and isinstance(method_args[0], dict):
-                    kwargs = method_args[0]
-                    kwargs = {parse_expr(k, local_dict=sym_vars): parse_expr(v, local_dict=sym_vars) for k, v in kwargs.items()}
-                    sym_expr = method(kwargs)
-                else:
-                    args = [parse_expr(arg.strip(), local_dict=sym_vars) for arg in method_args]
-                    sym_expr = method(*args)
-            # print(f"Result after {method_name}: {sym_expr}")
-        return sym_expr
-
-
-
-    variable_names = set(re.findall(r'\b[a-zA-Z]\w*\b', expression))
-    sym_vars = {var: symbols(var) for var in variable_names}
-
-    patterns = {
-        #"numpy_diff_brackets": r"np\.diff\(\[.*?\]\)",
-        "numpy_diff_no_brackets": r"np\.diff\([^()]*\)",
-        "math_functions": r"math\.\w+\((?:[^()]*(?:\([^()]*\)[^()]*)*)\)",
-        # "sympy_functions": r"sym\.\w+\([^()]*\)(?:\.\w+\([^()]*\))?",
-    }
-
-    function_pattern = '|'.join(patterns.values())
-
-    # Use a lambda function to pass additional arguments
-    processed_expression = re.sub(function_pattern, lambda match: recursive_eval_func(match, sym_vars), expression)
-    # print("Level 2 processed_expression:", processed_expression)
-
-    try:
-        if processed_expression.startswith('[') and processed_expression.endswith(']'):
-            return processed_expression
-
-        expr = parse_expr(processed_expression, local_dict=sym_vars)
-        final_result = simplify(expr)
-
-        if final_result.free_symbols:
-            latex_result = latex(final_result)
-            return latex_result
-        else:
-            return str(final_result)
-
-    except Exception as e:
-        raise ValueError(f"Error simplifying expression: {e}")
-
-def solve_algebraic_expression(expression: str, variable: str, subs: Optional[Dict[str, float]] = None) -> str:
-    try:
-        # Create symbols for the variables in the expression
-        variable_symbols = set(re.findall(r'\b[a-zA-Z]\w*\b', expression))
-        sym_vars = {var: symbols(var) for var in variable_symbols}
-
-        # Parse the expression and solve it
-        expr = parse_expr(expression, local_dict=sym_vars)
-        var_symbol = symbols(variable)
-        solutions = solve(expr, var_symbol)
-
-        # Apply substitutions if provided
-        if subs:
-            subs_symbols = {symbols(k): v for k, v in subs.items()}
-            solutions = [simplify(sol.subs(subs_symbols)) for sol in solutions]
-
-        # Convert solutions to LaTeX strings if possible
-        latex_solutions = [latex(simplify(sol)) if sol.free_symbols else str(sol) for sol in solutions]
-        result = r"\left[" + ", ".join(latex_solutions) + r"\right]"
-        print("158", result)
-        return result
-
-    except Exception as e:
-        raise ValueError(f"Error solving the expression: {e}")
-
-
-
-def get_prime_factors_latex(n: int) -> str:
-    """
-    Return the prime factors of a number as a LaTeX expression.
-    """
-    factors = []
-    while n % 2 == 0:
-        factors.append(2)
-        n //= 2
-    for i in range(3, int(math.sqrt(n)) + 1, 2):
-        while n % i == 0:
-            factors.append(i)
-            n //= i
-    if n > 2:
-        factors.append(n)
-
-    factor_counts = {factor: factors.count(factor) for factor in set(factors)}
-    latex_factors = [f"{factor}^{{{count}}}" if count > 1 else str(factor) for factor, count in factor_counts.items()]
-    return " \\cdot ".join(latex_factors)
-
-
-

rgwfuncs-0.0.25/tests/test_algebra_lib.py

@@ -1,59 +0,0 @@
-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, 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),
-    ]
-
-    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}"
-
-