rgwfuncs 0.0.28__tar.gz → 0.0.29__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.28
+Version: 0.0.29
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -154,105 +154,97 @@ Print a list of available function names in alphabetical order. If a filter is p
 
 This section provides comprehensive functions for handling algebraic expressions, performing tasks such as computation, simplification, solving equations, and prime factorization, all outputted in LaTeX format.
 
-### 1. `compute_algebraic_expression`
+### 1. `compute_constant_expression`
 
-Evaluates complex algebraic expressions and provides numerical results.
+Computes the numerical result of a given expression, which can evaluate to a constant, represented as a float. Evaluates an constant expression provided as a string and returns the computed result. Supports various arithmetic operations, including addition, subtraction, multiplication, division, and modulo, as well as mathematical functions from the math module.
 
-- **Parameters:**
-  - `expression` (str): A string representing an arithmetic operation.
+• Parameters:
+  - `expression` (str): The constant expression to compute. This should be a string consisting of arithmetic operations and Python's math module functions.
 
-- **Returns:**
+• Returns:
   - `float`: The computed numerical result.
 
-- **Example:**
+• Example:
 
-    from rgwfuncs import compute_algebraic_expression
-    result1 = compute_algebraic_expression("2 + 2")
+    from rgwfuncs import compute_constant_expression
+    result1 = compute_constant_expression("2 + 2")
     print(result1)  # Output: 4.0
 
-    result2 = compute_algebraic_expression("10 % 3")
+    result2 = compute_constant_expression("10 % 3")
     print(result2)  # Output: 1.0
 
-    result3 = compute_algebraic_expression("math.gcd(36, 60) * math.sin(math.radians(45)) * 10000")
+    result3 = compute_constant_expression("math.gcd(36, 60) * math.sin(math.radians(45)) * 10000")
     print(result3)  # Output: 84852.8137423857
 
-These examples illustrate the ability to handle basic arithmetic, the modulo operator, and functions utilizing the Python math module.
-
 --------------------------------------------------------------------------------
 
-### 2. `simplify_algebraic_expression`
+### 2. `simplify_polynomial_expression`
 
-Simplifies expressions and returns them in LaTeX format. Optionally applies substitutions to variables within the expression before simplifying.
+Simplifies an algebraic expression in polynomial form and returns it in LaTeX format. Takes an algebraic expression, in polynomial form, written in Python syntax and simplifies it. The result is returned as a LaTeX formatted string, suitable for academic or professional documentation.
 
-- **Parameters:**
-  - `expression` (str): A string representing the algebraic expression to simplify.
+• Parameters:
+  - `expression` (str): The algebraic expression, in polynomial form, to simplify. For instance, the expression 'np.diff(8*x**30) where as 'np.diff([2,5,9,11)' is not a polynomial.
   - `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:**
+• Returns:
   - `str`: The simplified expression formatted as a LaTeX string.
 
-- **Example Usage:**
+• Example Usage:
 
-    from rgwfuncs import simplify_algebraic_expression
+    from rgwfuncs import simplify_polynomial_expression
 
     # Example 1: Simplifying a polynomial expression without substitutions
-    simplified_expr1 = simplify_algebraic_expression("2*x + 3*x")
+    simplified_expr1 = simplify_polynomial_expression("2*x + 3*x")
     print(simplified_expr1)  # Output: "5 x"
 
     # 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)"
-    )
+    simplified_expr2 = simplify_polynomial_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})
+    simplified_expr3 = simplify_polynomial_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 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.
+    simplified_expr4 = simplify_polynomial_expression("a*b + b", subs={"b": 2})
+    print(simplified_expr4)  # Output: "2 a + 2"
 
 --------------------------------------------------------------------------------
 
-### 3. `solve_algebraic_expression`
+### 3. `solve_homogeneous_polynomial_expression`
 
-Solves equations for specified variables, with optional substitutions, returning LaTeX-formatted solutions.
+Solves a homogeneous polynomial expression for a specified variable and returns solutions in LaTeX format. Assumes that the expression is homoegeneous (i.e. equal to zero), and solves for a designated variable. May optionally include substitutions for other variables in the equation. The solutions are provided as a LaTeX formatted string. The method solves equations for specified variables, with optional substitutions, returning LaTeX-formatted solutions.
 
-- **Parameters:**
-  - `expression` (str): A string of the equation to solve.
+• Parameters:
+  - `expression` (str): A string of the homogeneous polynomial expression to solve.
   - `variable` (str): The variable to solve for.
   - `subs` (Optional[Dict[str, float]]): Substitutions for variables.
 
-- **Returns:**
+• Returns:
   - `str`: Solutions formatted in LaTeX.
 
-- **Example:**
+• Example:
 
-    from rgwfuncs import solve_algebraic_expression
-    solutions1 = solve_algebraic_expression("a*x**2 + b*x + c", "x", {"a": 3, "b": 7, "c": 5})
+    from rgwfuncs import solve_homogeneous_polynomial_expression
+    solutions1 = solve_homogeneous_polynomial_expression("a*x**2 + b*x + c", "x", {"a": 3, "b": 7, "c": 5})
     print(solutions1)  # Output: "\left[-7/6 - sqrt(11)*I/6, -7/6 + sqrt(11)*I/6\right]"
 
-    solutions2 = solve_algebraic_expression("x**2 - 4", "x")
+    solutions2 = solve_homogeneous_polynomial_expression("x**2 - 4", "x")
     print(solutions2)  # Output: "\left[-2, 2\right]"
     
-Here, we solve both a quadratic equation with complex solutions and a simpler polynomial equation.
-
 --------------------------------------------------------------------------------
 
 ### 4. `get_prime_factors_latex`
 
 Computes prime factors of a number and presents them in LaTeX format.
 
-- **Parameters:**
+• Parameters:
   - `n` (int): The integer to factorize.
 
-- **Returns:**
+• Returns:
   - `str`: Prime factorization in LaTeX.
 
-- **Example:**
+• Example:
 
     from rgwfuncs import get_prime_factors_latex
     factors1 = get_prime_factors_latex(100)
@@ -266,64 +258,60 @@ Computes prime factors of a number and presents them in LaTeX format.
  
 --------------------------------------------------------------------------------
 
-### 5. `compute_matrix_operation`
+### 5. `compute_matrix_expression`
 
-Computes the results of 1D or 2D matrix operations and formats them as LaTeX strings.
+Computes the results of expressions containing 1D or 2D matrix operations and formats them as LaTeX strings.
 
-- **Parameters:**
+• 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:**
+• 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:**
+• Example:
 
-    from rgwfuncs import compute_matrix_operation
+    from rgwfuncs import compute_matrix_expression
     
     # Example with addition of 2D matrices
-    result = compute_matrix_operation("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
+    result = compute_matrix_expression("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
     print(result)  # Output: \begin{bmatrix}3 & 8 & 12\\5 & 8 & 11\end{bmatrix}
     
     # Example of mixed operations with 1D matrices treated as 2D
-    result = compute_matrix_operation("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
+    result = compute_matrix_expression("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
     print(result)  # Output: \begin{bmatrix}2 & 6 & 10\end{bmatrix}
 
     # Example with dimension mismatch
-    result = compute_matrix_operation("[[4, 3, 51]] + [[1, 1]]")
+    result = compute_matrix_expression("[[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`
+### 6. `compute_ordered_series_expression`
 
-Computes the result of operations on ordered series expressed as 1D lists, including the discrete difference operator `ddd`.
+Computes the result of expressions containing operations on ordered series expressed as 1D lists. The syntax of the expression supports the discrete difference operator via the `ddd()` method.
 
-- **Parameters:**
-  - `expression` (str): A series operation expression. Supports operations such as "+", "-", "*", "/", and `ddd` for discrete differences.
+• Parameters:
+  - `expression` (str): A series operation expression. Supports operations such as "+", "-", "*", "/", and `ddd()` for discrete differences.
 
-- **Returns:**
+• Returns:
   - `str`: The string representation of the resultant series after performing operations, or an error message if series lengths do not match.
 
-- **Example:**
+• Example:
 
-    from rgwfuncs import compute_ordered_series_operations
+    from rgwfuncs import compute_ordered_series_expression
 
     # Example with addition and discrete differences
-    result = compute_ordered_series_operations("ddd([2, 6, 9, 60]) + ddd([78, 79, 80])")
+    result = compute_ordered_series_expression("ddd([2, 6, 9, 60]) + ddd([78, 79, 80])")
     print(result)  # Output: [4, 3, 51] + [1, 1]
     
     # Example with elementwise subtraction
-    result = compute_ordered_series_operations("[10, 15, 21] - [5, 5, 5]")
+    result = compute_ordered_series_expression("[10, 15, 21] - [5, 5, 5]")
     print(result)  # Output: [5, 10, 16]
 
     # Example with length mismatch
-    result = compute_ordered_series_operations("[4, 3, 51] + [1, 1]")
+    result = compute_ordered_series_expression("[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

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

@@ -128,105 +128,97 @@ Print a list of available function names in alphabetical order. If a filter is p
 
 This section provides comprehensive functions for handling algebraic expressions, performing tasks such as computation, simplification, solving equations, and prime factorization, all outputted in LaTeX format.
 
-### 1. `compute_algebraic_expression`
+### 1. `compute_constant_expression`
 
-Evaluates complex algebraic expressions and provides numerical results.
+Computes the numerical result of a given expression, which can evaluate to a constant, represented as a float. Evaluates an constant expression provided as a string and returns the computed result. Supports various arithmetic operations, including addition, subtraction, multiplication, division, and modulo, as well as mathematical functions from the math module.
 
-- **Parameters:**
-  - `expression` (str): A string representing an arithmetic operation.
+• Parameters:
+  - `expression` (str): The constant expression to compute. This should be a string consisting of arithmetic operations and Python's math module functions.
 
-- **Returns:**
+• Returns:
   - `float`: The computed numerical result.
 
-- **Example:**
+• Example:
 
-    from rgwfuncs import compute_algebraic_expression
-    result1 = compute_algebraic_expression("2 + 2")
+    from rgwfuncs import compute_constant_expression
+    result1 = compute_constant_expression("2 + 2")
     print(result1)  # Output: 4.0
 
-    result2 = compute_algebraic_expression("10 % 3")
+    result2 = compute_constant_expression("10 % 3")
     print(result2)  # Output: 1.0
 
-    result3 = compute_algebraic_expression("math.gcd(36, 60) * math.sin(math.radians(45)) * 10000")
+    result3 = compute_constant_expression("math.gcd(36, 60) * math.sin(math.radians(45)) * 10000")
     print(result3)  # Output: 84852.8137423857
 
-These examples illustrate the ability to handle basic arithmetic, the modulo operator, and functions utilizing the Python math module.
-
 --------------------------------------------------------------------------------
 
-### 2. `simplify_algebraic_expression`
+### 2. `simplify_polynomial_expression`
 
-Simplifies expressions and returns them in LaTeX format. Optionally applies substitutions to variables within the expression before simplifying.
+Simplifies an algebraic expression in polynomial form and returns it in LaTeX format. Takes an algebraic expression, in polynomial form, written in Python syntax and simplifies it. The result is returned as a LaTeX formatted string, suitable for academic or professional documentation.
 
-- **Parameters:**
-  - `expression` (str): A string representing the algebraic expression to simplify.
+• Parameters:
+  - `expression` (str): The algebraic expression, in polynomial form, to simplify. For instance, the expression 'np.diff(8*x**30) where as 'np.diff([2,5,9,11)' is not a polynomial.
   - `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:**
+• Returns:
   - `str`: The simplified expression formatted as a LaTeX string.
 
-- **Example Usage:**
+• Example Usage:
 
-    from rgwfuncs import simplify_algebraic_expression
+    from rgwfuncs import simplify_polynomial_expression
 
     # Example 1: Simplifying a polynomial expression without substitutions
-    simplified_expr1 = simplify_algebraic_expression("2*x + 3*x")
+    simplified_expr1 = simplify_polynomial_expression("2*x + 3*x")
     print(simplified_expr1)  # Output: "5 x"
 
     # 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)"
-    )
+    simplified_expr2 = simplify_polynomial_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})
+    simplified_expr3 = simplify_polynomial_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 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.
+    simplified_expr4 = simplify_polynomial_expression("a*b + b", subs={"b": 2})
+    print(simplified_expr4)  # Output: "2 a + 2"
 
 --------------------------------------------------------------------------------
 
-### 3. `solve_algebraic_expression`
+### 3. `solve_homogeneous_polynomial_expression`
 
-Solves equations for specified variables, with optional substitutions, returning LaTeX-formatted solutions.
+Solves a homogeneous polynomial expression for a specified variable and returns solutions in LaTeX format. Assumes that the expression is homoegeneous (i.e. equal to zero), and solves for a designated variable. May optionally include substitutions for other variables in the equation. The solutions are provided as a LaTeX formatted string. The method solves equations for specified variables, with optional substitutions, returning LaTeX-formatted solutions.
 
-- **Parameters:**
-  - `expression` (str): A string of the equation to solve.
+• Parameters:
+  - `expression` (str): A string of the homogeneous polynomial expression to solve.
   - `variable` (str): The variable to solve for.
   - `subs` (Optional[Dict[str, float]]): Substitutions for variables.
 
-- **Returns:**
+• Returns:
   - `str`: Solutions formatted in LaTeX.
 
-- **Example:**
+• Example:
 
-    from rgwfuncs import solve_algebraic_expression
-    solutions1 = solve_algebraic_expression("a*x**2 + b*x + c", "x", {"a": 3, "b": 7, "c": 5})
+    from rgwfuncs import solve_homogeneous_polynomial_expression
+    solutions1 = solve_homogeneous_polynomial_expression("a*x**2 + b*x + c", "x", {"a": 3, "b": 7, "c": 5})
     print(solutions1)  # Output: "\left[-7/6 - sqrt(11)*I/6, -7/6 + sqrt(11)*I/6\right]"
 
-    solutions2 = solve_algebraic_expression("x**2 - 4", "x")
+    solutions2 = solve_homogeneous_polynomial_expression("x**2 - 4", "x")
     print(solutions2)  # Output: "\left[-2, 2\right]"
     
-Here, we solve both a quadratic equation with complex solutions and a simpler polynomial equation.
-
 --------------------------------------------------------------------------------
 
 ### 4. `get_prime_factors_latex`
 
 Computes prime factors of a number and presents them in LaTeX format.
 
-- **Parameters:**
+• Parameters:
   - `n` (int): The integer to factorize.
 
-- **Returns:**
+• Returns:
   - `str`: Prime factorization in LaTeX.
 
-- **Example:**
+• Example:
 
     from rgwfuncs import get_prime_factors_latex
     factors1 = get_prime_factors_latex(100)
@@ -240,64 +232,60 @@ Computes prime factors of a number and presents them in LaTeX format.
  
 --------------------------------------------------------------------------------
 
-### 5. `compute_matrix_operation`
+### 5. `compute_matrix_expression`
 
-Computes the results of 1D or 2D matrix operations and formats them as LaTeX strings.
+Computes the results of expressions containing 1D or 2D matrix operations and formats them as LaTeX strings.
 
-- **Parameters:**
+• 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:**
+• 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:**
+• Example:
 
-    from rgwfuncs import compute_matrix_operation
+    from rgwfuncs import compute_matrix_expression
     
     # Example with addition of 2D matrices
-    result = compute_matrix_operation("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
+    result = compute_matrix_expression("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
     print(result)  # Output: \begin{bmatrix}3 & 8 & 12\\5 & 8 & 11\end{bmatrix}
     
     # Example of mixed operations with 1D matrices treated as 2D
-    result = compute_matrix_operation("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
+    result = compute_matrix_expression("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
     print(result)  # Output: \begin{bmatrix}2 & 6 & 10\end{bmatrix}
 
     # Example with dimension mismatch
-    result = compute_matrix_operation("[[4, 3, 51]] + [[1, 1]]")
+    result = compute_matrix_expression("[[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`
+### 6. `compute_ordered_series_expression`
 
-Computes the result of operations on ordered series expressed as 1D lists, including the discrete difference operator `ddd`.
+Computes the result of expressions containing operations on ordered series expressed as 1D lists. The syntax of the expression supports the discrete difference operator via the `ddd()` method.
 
-- **Parameters:**
-  - `expression` (str): A series operation expression. Supports operations such as "+", "-", "*", "/", and `ddd` for discrete differences.
+• Parameters:
+  - `expression` (str): A series operation expression. Supports operations such as "+", "-", "*", "/", and `ddd()` for discrete differences.
 
-- **Returns:**
+• Returns:
   - `str`: The string representation of the resultant series after performing operations, or an error message if series lengths do not match.
 
-- **Example:**
+• Example:
 
-    from rgwfuncs import compute_ordered_series_operations
+    from rgwfuncs import compute_ordered_series_expression
 
     # Example with addition and discrete differences
-    result = compute_ordered_series_operations("ddd([2, 6, 9, 60]) + ddd([78, 79, 80])")
+    result = compute_ordered_series_expression("ddd([2, 6, 9, 60]) + ddd([78, 79, 80])")
     print(result)  # Output: [4, 3, 51] + [1, 1]
     
     # Example with elementwise subtraction
-    result = compute_ordered_series_operations("[10, 15, 21] - [5, 5, 5]")
+    result = compute_ordered_series_expression("[10, 15, 21] - [5, 5, 5]")
     print(result)  # Output: [5, 10, 16]
 
     # Example with length mismatch
-    result = compute_ordered_series_operations("[4, 3, 51] + [1, 1]")
+    result = compute_ordered_series_expression("[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

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

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

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

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

{rgwfuncs-0.0.28 → rgwfuncs-0.0.29}/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, compute_matrix_operation, compute_ordered_series_operation, get_prime_factors_latex, simplify_algebraic_expression, solve_algebraic_expression
+from .algebra_lib import compute_constant_expression, compute_matrix_expression, compute_ordered_series_expression, get_prime_factors_latex, simplify_polynomial_expression, solve_homogeneous_polynomial_expression
 from .df_lib import append_columns, append_percentile_classification_column, append_ranged_classification_column, append_ranged_date_classification_column, append_rows, append_xgb_labels, append_xgb_logistic_regression_predictions, append_xgb_regression_predictions, bag_union_join, bottom_n_unique_values, cascade_sort, delete_rows, drop_duplicates, drop_duplicates_retain_first, drop_duplicates_retain_last, filter_dataframe, filter_indian_mobiles, first_n_rows, from_raw_data, insert_dataframe_in_sqlite_database, last_n_rows, left_join, limit_dataframe, load_data_from_path, load_data_from_query, load_data_from_sqlite_path, mask_against_dataframe, mask_against_dataframe_converse, numeric_clean, order_columns, print_correlation, print_dataframe, print_memory_usage, print_n_frequency_cascading, print_n_frequency_linear, rename_columns, retain_columns, right_join, send_data_to_email, send_data_to_slack, send_dataframe_via_telegram, sync_dataframe_to_sqlite_database, top_n_unique_values, union_join, update_rows
 from .docs_lib import docs
 from .str_lib import send_telegram_message

{rgwfuncs-0.0.28 → rgwfuncs-0.0.29}/src/rgwfuncs/algebra_lib.py

@@ -7,17 +7,18 @@ from sympy.parsing.sympy_parser import parse_expr
 from typing import Tuple, List, Dict, Optional
 
 
-def compute_algebraic_expression(expression: str) -> float:
+def compute_constant_expression(expression: str) -> float:
     """
-    Computes the numerical result of a given algebraic expression.
+    Computes the numerical result of a given expression, which can evaluate to a constant,
+    represented as a float.
 
-    Evaluates an algebraic expression provided as a string and returns the computed result.
+    Evaluates an constant expression provided as a string and returns the computed result.
     Supports various arithmetic operations, including addition, subtraction, multiplication,
     division, and modulo, as well as mathematical functions from the math module.
 
     Parameters:
-    expression (str): The algebraic expression to compute. This should be a string consisting
-                      of arithmetic operations and supported math module functions.
+    expression (str): The constant expression to compute. This should be a string consisting
+                      of arithmetic operations and Python's math module functions.
 
     Returns:
     float: The evaluated numerical result of the expression.
@@ -36,18 +37,21 @@ def compute_algebraic_expression(expression: str) -> float:
         raise ValueError(f"Error computing expression: {e}")
 
 
-def simplify_algebraic_expression(
+def simplify_polynomial_expression(
     expression: str,
     subs: Optional[Dict[str, float]] = None
 ) -> str:
     """
-    Simplifies an algebraic expression and returns it in LaTeX format.
+    Simplifies an algebraic expression in polynomial form 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.
+    Takes an algebraic expression, in polynomial form, written in Python syntax and simplifies it.
+    The result is returned as a LaTeX formatted string, suitable for academic or professional 
+    documentation.
 
     Parameters:
-    expression (str): The algebraic expression to simplify.
+    expression (str): The algebraic expression, in polynomial form, to simplify. For instance,
+                      the expression `np.diff(8*x**30)` is a polynomial, whereas np.diff([2,5,9,11)
+                      is not a polynomial.
     subs (Optional[Dict[str, float]]): An optional dictionary of substitutions for variables
                                        in the expression.
 
@@ -58,7 +62,6 @@ def simplify_algebraic_expression(
     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}")
@@ -209,19 +212,21 @@ def simplify_algebraic_expression(
         raise ValueError(f"Error simplifying expression: {e}")
 
 
-def solve_algebraic_expression(
-        expression: str, 
-        variable: str, 
-        subs: Optional[Dict[str, float]] = None
-    ) -> str:
+def solve_homogeneous_polynomial_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 a homogeneous polynomial expression 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.
+    Assumes that the expression is homoegeneous (i.e. equal to zero), and solves for a 
+    designated variable. May optionally include substitutions for other variables in the 
+    equation. The solutions are provided as a LaTeX formatted string.
 
     Parameters:
-    expression (str): The algebraic equation to solve.
+    expression (str): The homogeneous polynomial expression 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.
@@ -260,7 +265,7 @@ def solve_algebraic_expression(
         raise ValueError(f"Error solving the expression: {e}")
 
 
-def compute_matrix_operation(expression: str) -> str:
+def compute_matrix_expression(expression: str) -> str:
     """
     Computes the result of a matrix-like operation on 1D or 2D list inputs and returns it as a LaTeX string.
 
@@ -350,7 +355,7 @@ def compute_matrix_operation(expression: str) -> str:
         return f"Error computing matrix operation: {e}"
 
 
-def compute_ordered_series_operation(expression: str) -> str:
+def compute_ordered_series_expression(expression: str) -> str:
     """
     Computes the result of operations on ordered series expressed as 1D lists, including discrete difference (ddd),
     and returns it as a string.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.28
+Version: 0.0.29
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -154,105 +154,97 @@ Print a list of available function names in alphabetical order. If a filter is p
 
 This section provides comprehensive functions for handling algebraic expressions, performing tasks such as computation, simplification, solving equations, and prime factorization, all outputted in LaTeX format.
 
-### 1. `compute_algebraic_expression`
+### 1. `compute_constant_expression`
 
-Evaluates complex algebraic expressions and provides numerical results.
+Computes the numerical result of a given expression, which can evaluate to a constant, represented as a float. Evaluates an constant expression provided as a string and returns the computed result. Supports various arithmetic operations, including addition, subtraction, multiplication, division, and modulo, as well as mathematical functions from the math module.
 
-- **Parameters:**
-  - `expression` (str): A string representing an arithmetic operation.
+• Parameters:
+  - `expression` (str): The constant expression to compute. This should be a string consisting of arithmetic operations and Python's math module functions.
 
-- **Returns:**
+• Returns:
   - `float`: The computed numerical result.
 
-- **Example:**
+• Example:
 
-    from rgwfuncs import compute_algebraic_expression
-    result1 = compute_algebraic_expression("2 + 2")
+    from rgwfuncs import compute_constant_expression
+    result1 = compute_constant_expression("2 + 2")
     print(result1)  # Output: 4.0
 
-    result2 = compute_algebraic_expression("10 % 3")
+    result2 = compute_constant_expression("10 % 3")
     print(result2)  # Output: 1.0
 
-    result3 = compute_algebraic_expression("math.gcd(36, 60) * math.sin(math.radians(45)) * 10000")
+    result3 = compute_constant_expression("math.gcd(36, 60) * math.sin(math.radians(45)) * 10000")
     print(result3)  # Output: 84852.8137423857
 
-These examples illustrate the ability to handle basic arithmetic, the modulo operator, and functions utilizing the Python math module.
-
 --------------------------------------------------------------------------------
 
-### 2. `simplify_algebraic_expression`
+### 2. `simplify_polynomial_expression`
 
-Simplifies expressions and returns them in LaTeX format. Optionally applies substitutions to variables within the expression before simplifying.
+Simplifies an algebraic expression in polynomial form and returns it in LaTeX format. Takes an algebraic expression, in polynomial form, written in Python syntax and simplifies it. The result is returned as a LaTeX formatted string, suitable for academic or professional documentation.
 
-- **Parameters:**
-  - `expression` (str): A string representing the algebraic expression to simplify.
+• Parameters:
+  - `expression` (str): The algebraic expression, in polynomial form, to simplify. For instance, the expression 'np.diff(8*x**30) where as 'np.diff([2,5,9,11)' is not a polynomial.
   - `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:**
+• Returns:
   - `str`: The simplified expression formatted as a LaTeX string.
 
-- **Example Usage:**
+• Example Usage:
 
-    from rgwfuncs import simplify_algebraic_expression
+    from rgwfuncs import simplify_polynomial_expression
 
     # Example 1: Simplifying a polynomial expression without substitutions
-    simplified_expr1 = simplify_algebraic_expression("2*x + 3*x")
+    simplified_expr1 = simplify_polynomial_expression("2*x + 3*x")
     print(simplified_expr1)  # Output: "5 x"
 
     # 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)"
-    )
+    simplified_expr2 = simplify_polynomial_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})
+    simplified_expr3 = simplify_polynomial_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 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.
+    simplified_expr4 = simplify_polynomial_expression("a*b + b", subs={"b": 2})
+    print(simplified_expr4)  # Output: "2 a + 2"
 
 --------------------------------------------------------------------------------
 
-### 3. `solve_algebraic_expression`
+### 3. `solve_homogeneous_polynomial_expression`
 
-Solves equations for specified variables, with optional substitutions, returning LaTeX-formatted solutions.
+Solves a homogeneous polynomial expression for a specified variable and returns solutions in LaTeX format. Assumes that the expression is homoegeneous (i.e. equal to zero), and solves for a designated variable. May optionally include substitutions for other variables in the equation. The solutions are provided as a LaTeX formatted string. The method solves equations for specified variables, with optional substitutions, returning LaTeX-formatted solutions.
 
-- **Parameters:**
-  - `expression` (str): A string of the equation to solve.
+• Parameters:
+  - `expression` (str): A string of the homogeneous polynomial expression to solve.
   - `variable` (str): The variable to solve for.
   - `subs` (Optional[Dict[str, float]]): Substitutions for variables.
 
-- **Returns:**
+• Returns:
   - `str`: Solutions formatted in LaTeX.
 
-- **Example:**
+• Example:
 
-    from rgwfuncs import solve_algebraic_expression
-    solutions1 = solve_algebraic_expression("a*x**2 + b*x + c", "x", {"a": 3, "b": 7, "c": 5})
+    from rgwfuncs import solve_homogeneous_polynomial_expression
+    solutions1 = solve_homogeneous_polynomial_expression("a*x**2 + b*x + c", "x", {"a": 3, "b": 7, "c": 5})
     print(solutions1)  # Output: "\left[-7/6 - sqrt(11)*I/6, -7/6 + sqrt(11)*I/6\right]"
 
-    solutions2 = solve_algebraic_expression("x**2 - 4", "x")
+    solutions2 = solve_homogeneous_polynomial_expression("x**2 - 4", "x")
     print(solutions2)  # Output: "\left[-2, 2\right]"
     
-Here, we solve both a quadratic equation with complex solutions and a simpler polynomial equation.
-
 --------------------------------------------------------------------------------
 
 ### 4. `get_prime_factors_latex`
 
 Computes prime factors of a number and presents them in LaTeX format.
 
-- **Parameters:**
+• Parameters:
   - `n` (int): The integer to factorize.
 
-- **Returns:**
+• Returns:
   - `str`: Prime factorization in LaTeX.
 
-- **Example:**
+• Example:
 
     from rgwfuncs import get_prime_factors_latex
     factors1 = get_prime_factors_latex(100)
@@ -266,64 +258,60 @@ Computes prime factors of a number and presents them in LaTeX format.
  
 --------------------------------------------------------------------------------
 
-### 5. `compute_matrix_operation`
+### 5. `compute_matrix_expression`
 
-Computes the results of 1D or 2D matrix operations and formats them as LaTeX strings.
+Computes the results of expressions containing 1D or 2D matrix operations and formats them as LaTeX strings.
 
-- **Parameters:**
+• 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:**
+• 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:**
+• Example:
 
-    from rgwfuncs import compute_matrix_operation
+    from rgwfuncs import compute_matrix_expression
     
     # Example with addition of 2D matrices
-    result = compute_matrix_operation("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
+    result = compute_matrix_expression("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
     print(result)  # Output: \begin{bmatrix}3 & 8 & 12\\5 & 8 & 11\end{bmatrix}
     
     # Example of mixed operations with 1D matrices treated as 2D
-    result = compute_matrix_operation("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
+    result = compute_matrix_expression("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
     print(result)  # Output: \begin{bmatrix}2 & 6 & 10\end{bmatrix}
 
     # Example with dimension mismatch
-    result = compute_matrix_operation("[[4, 3, 51]] + [[1, 1]]")
+    result = compute_matrix_expression("[[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`
+### 6. `compute_ordered_series_expression`
 
-Computes the result of operations on ordered series expressed as 1D lists, including the discrete difference operator `ddd`.
+Computes the result of expressions containing operations on ordered series expressed as 1D lists. The syntax of the expression supports the discrete difference operator via the `ddd()` method.
 
-- **Parameters:**
-  - `expression` (str): A series operation expression. Supports operations such as "+", "-", "*", "/", and `ddd` for discrete differences.
+• Parameters:
+  - `expression` (str): A series operation expression. Supports operations such as "+", "-", "*", "/", and `ddd()` for discrete differences.
 
-- **Returns:**
+• Returns:
   - `str`: The string representation of the resultant series after performing operations, or an error message if series lengths do not match.
 
-- **Example:**
+• Example:
 
-    from rgwfuncs import compute_ordered_series_operations
+    from rgwfuncs import compute_ordered_series_expression
 
     # Example with addition and discrete differences
-    result = compute_ordered_series_operations("ddd([2, 6, 9, 60]) + ddd([78, 79, 80])")
+    result = compute_ordered_series_expression("ddd([2, 6, 9, 60]) + ddd([78, 79, 80])")
     print(result)  # Output: [4, 3, 51] + [1, 1]
     
     # Example with elementwise subtraction
-    result = compute_ordered_series_operations("[10, 15, 21] - [5, 5, 5]")
+    result = compute_ordered_series_expression("[10, 15, 21] - [5, 5, 5]")
     print(result)  # Output: [5, 10, 16]
 
     # Example with length mismatch
-    result = compute_ordered_series_operations("[4, 3, 51] + [1, 1]")
+    result = compute_ordered_series_expression("[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

{rgwfuncs-0.0.28 → rgwfuncs-0.0.29}/tests/test_algebra_lib.py

@@ -7,15 +7,15 @@ import math
 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,
+    compute_constant_expression,
+    simplify_polynomial_expression,
+    solve_homogeneous_polynomial_expression,
+    compute_matrix_expression,
+    compute_ordered_series_expression,
     get_prime_factors_latex)
 
 
-def test_compute_algebraic_expression():
+def test_compute_constant_expression():
     test_cases = [
         ("2 + 2", 4.0),
         ("5 - 3", 2.0),
@@ -27,10 +27,11 @@ def test_compute_algebraic_expression():
     ]
 
     for input_data, expected_output in test_cases:
-        result = compute_algebraic_expression(input_data)
+        result = compute_constant_expression(input_data)
         assert math.isclose(result, expected_output, rel_tol=1e-9), f"Failed for {input_data}, got {result}"
 
-def test_simplify_algebraic_expression():
+
+def test_simplify_polynomial_expression():
     test_cases = [
         # Without substitutions
         (("(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)", None), r"\frac{1}{110 x^{22} y^{3}}"),
@@ -42,27 +43,21 @@ def test_simplify_algebraic_expression():
     ]
 
     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}"
-        )
+        output = simplify_polynomial_expression(expression, subs)
+        assert output == expected_output, (f"Test failed for expression: {expression} with substitutions: {subs}. Expected {expected_output}, got {output}")
 
 
-def test_solve_algebraic_expression():
+def test_solve_homogeneous_polynomial_expression():
     test_cases = [
         # Test case with substitutions
-        (
-            ("a*x**2 + b*x + c", "x", {"a": 3, "b": 7, "c": 5}),
-            r"\left[-7/6 - sqrt(11)*I/6, -7/6 + sqrt(11)*I/6\right]"
-        ),
+        (("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
+        assert solve_homogeneous_polynomial_expression(expression, variable, subs) == expected_output
 
 
-def test_compute_matrix_operation():
+def test_compute_matrix_expression():
     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}"),
@@ -80,13 +75,13 @@ def test_compute_matrix_operation():
     ]
 
     for input_data, expected_output in test_cases:
-        result = compute_matrix_operation(input_data)
+        result = compute_matrix_expression(input_data)
         assert result == expected_output, f"Failed for {input_data}, got {result}"
 
 # Example test function
 
 
-def test_compute_ordered_series_operations():
+def test_compute_ordered_series_expression():
     test_cases = [
         ("[2, 6, 9] + [1, 2, 3]", "[3, 8, 12]"),
         ("[10, 15, 21] - [5, 5, 5]", "[5, 10, 16]"),
@@ -104,7 +99,7 @@ def test_compute_ordered_series_operations():
     ]
 
     for input_data, expected_output in test_cases:
-        result = compute_ordered_series_operation(input_data)
+        result = compute_ordered_series_expression(input_data)
         assert result == expected_output, f"Failed for {input_data}, got {result}"