rgwfuncs 0.0.30__tar.gz → 0.0.32__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.30
+Version: 0.0.32
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -154,43 +154,27 @@ Print a list of available function names in alphabetical order. If a filter is p
 
 This section provides comprehensive functions for handling algebraic expressions, performing tasks such as computation, simplification, solving equations, and prime factorization, all outputted in LaTeX format.
 
-### 1. `python_polynomial_expression_to_latex`
+### 1. `compute_prime_factors_latex`
 
-Converts a polynomial expression written in Python syntax to a LaTeX formatted string. This function parses algebraic expressions provided as strings using Python’s syntax and translates them into equivalent LaTeX representations, making them suitable for academic or professional documentation. The function supports inclusion of named variables, with an option to substitute specific values into the expression.
+Computes prime factors of a number and presents them in LaTeX format.
 
 • Parameters:
-  - `expression` (str): The algebraic expression to convert to LaTeX. This should be a string formatted with Python syntax acceptable by SymPy.
-  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers with which to substitute those variables.
+  - `n` (int): The integer to factorize.
 
 • Returns:
-  - `str`: The LaTeX formatted string equivalent to the provided expression.
-
-• Raises:
-  - `ValueError`: If the expression cannot be parsed due to syntax errors.
+  - `str`: Prime factorization in LaTeX.
 
 • Example:
 
-    from rgwfuncs import python_polynomial_expression_to_latex
-    
-    # Convert a simple polynomial expression to LaTeX format
-    latex_result1 = python_polynomial_expression_to_latex("x**2 + y**2")
-    print(latex_result1)  # Output: "x^{2} + y^{2}"
-    
-    # Convert polynomial expression with substituted values
-    latex_result2 = python_polynomial_expression_to_latex("x**2 + y**2", {"x": 3, "y": 4})
-    print(latex_result2)  # Output: "25"
-    
-    # Another example with partial substitution
-    latex_result3 = python_polynomial_expression_to_latex("x**2 + y**2", {"x": 3})
-    print(latex_result3)  # Output: "y^{2} + 9"
-    
-    # Trigonometric functions included with symbolic variables
-    latex_result4 = python_polynomial_expression_to_latex("sin(x+z**2) + cos(y)", {"x": 55})
-    print(latex_result4)  # Output: "cos y + sin \\left(z^{2} + 55\\right)"
-    
-    # Simplified trigonometric functions example with substitution
-    latex_result5 = python_polynomial_expression_to_latex("sin(x) + cos(y)", {"x": 0})
-    print(latex_result5)  # Output: "cos y"
+    from rgwfuncs import compute_prime_factors_latex
+    factors_1 = compute_prime_factors_latex(100)
+    print(factors_1)  # Output: "2^{2} \cdot 5^{2}"
+
+    factors_2 = compute_prime_factors_latex(60)
+    print(factors_2)  # Output: "2^{2} \cdot 3 \cdot 5"
+
+    factors_3 = compute_prime_factors_latex(17)
+    print(factors_3)  # Output: "17"
 
 --------------------------------------------------------------------------------
 
@@ -218,140 +202,157 @@ Computes the numerical result of a given expression, which can evaluate to a con
 
 --------------------------------------------------------------------------------
 
-### 3. `simplify_polynomial_expression`
+### 3. `compute_constant_expression_involving_matrices`
 
-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.
+Computes the result of a constant expression involving matrices and returns it as a LaTeX string.
 
 • 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.
+  - `expression` (str): The constant expression involving matrices. Example format includes operations such as "+", "-", "*", "/".
 
 • Returns:
-  - `str`: The simplified expression formatted as a LaTeX string.
-
-• Example Usage:
+  - `str`: The LaTeX-formatted string representation of the computed matrix, or an error message if the operations cannot be performed due to dimensional mismatches.
 
-    from rgwfuncs import simplify_polynomial_expression
+• Example:
 
-    # Example 1: Simplifying a polynomial expression without substitutions
-    simplified_expr1 = simplify_polynomial_expression("2*x + 3*x")
-    print(simplified_expr1)  # Output: "5 x"
+    from rgwfuncs import compute_constant_expression_involving_matrices
 
-    # Example 2: Simplifying a complex expression involving derivatives
-    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 with addition of 2D matrices
+    result = compute_constant_expression_involving_matrices("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
+    print(result)  # Output: \begin{bmatrix}3 & 8 & 12\\5 & 8 & 11\end{bmatrix}
 
-    # Example 3: Simplifying with substitutions
-    simplified_expr3 = simplify_polynomial_expression("x**2 + y**2", subs={"x": 3, "y": 4})
-    print(simplified_expr3)  # Output: "25"
+    # Example of mixed operations with 1D matrices treated as 2D
+    result = compute_constant_expression_involving_matrices("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
+    print(result)  # Output: \begin{bmatrix}2 & 6 & 10\end{bmatrix}
 
-    # Example 4: Simplifying with partial substitution
-    simplified_expr4 = simplify_polynomial_expression("a*b + b", subs={"b": 2})
-    print(simplified_expr4)  # Output: "2 a + 2"
+    # Example with dimension mismatch
+    result = compute_constant_expression_involving_matrices("[[4, 3, 51]] + [[1, 1]]")
+    print(result)  # Output: Operations between matrices must involve matrices of the same dimension
 
 --------------------------------------------------------------------------------
 
-### 4. `solve_homogeneous_polynomial_expression`
+### 4. `compute_constant_expression_involving_ordered_series`
+
+Computes the result of a constant expression involving ordered series, and returns it as a Latex string. 
 
-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 homogeneous polynomial expression to solve.
-  - `variable` (str): The variable to solve for.
-  - `subs` (Optional[Dict[str, float]]): Substitutions for variables.
+  - `expression` (str): A series operation expression. Supports operations such as "+", "-", "*", "/", and `dd()` for discrete differences.
 
 • Returns:
-  - `str`: Solutions formatted in LaTeX.
+  - `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 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]"
+    from rgwfuncs import compute_constant_expression_involving_ordered_series
+
+    # Example with addition and discrete differences
+    result = compute_constant_expression_involving_ordered_series("dd([2, 6, 9, 60]) + dd([78, 79, 80])")
+    print(result)  # Output: [4, 3, 51] + [1, 1]
+
+    # Example with elementwise subtraction
+    result = compute_constant_expression_involving_ordered_series("[10, 15, 21] - [5, 5, 5]")
+    print(result)  # Output: [5, 10, 16]
+
+    # Example with length mismatch
+    result = compute_constant_expression_involving_ordered_series("[4, 3, 51] + [1, 1]")
+    print(result)  # Output: Operations between ordered series must involve series of equal length
 
-    solutions2 = solve_homogeneous_polynomial_expression("x**2 - 4", "x")
-    print(solutions2)  # Output: "\left[-2, 2\right]"
-    
 --------------------------------------------------------------------------------
 
-### 5. `get_prime_factors_latex`
+### 5. `python_polynomial_expression_to_latex`
 
-Computes prime factors of a number and presents them in LaTeX format.
+Converts a polynomial expression written in Python syntax to a LaTeX formatted string. This function parses algebraic expressions provided as strings using Python’s syntax and translates them into equivalent LaTeX representations, making them suitable for academic or professional documentation. The function supports inclusion of named variables, with an option to substitute specific values into the expression.
 
 • Parameters:
-  - `n` (int): The integer to factorize.
+  - `expression` (str): The algebraic expression to convert to LaTeX. This should be a string formatted with Python syntax acceptable by SymPy.
+  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers with which to substitute those variables.
 
 • Returns:
-  - `str`: Prime factorization in LaTeX.
+  - `str`: The LaTeX formatted string equivalent to the provided expression.
 
-• Example:
+• Raises:
+  - `ValueError`: If the expression cannot be parsed due to syntax errors.
 
-    from rgwfuncs import get_prime_factors_latex
-    factors1 = get_prime_factors_latex(100)
-    print(factors1)  # Output: "2^{2} \cdot 5^{2}"
+• Example:
 
-    factors2 = get_prime_factors_latex(60)
-    print(factors2)  # Output: "2^{2} \cdot 3 \cdot 5"
+    from rgwfuncs import python_polynomial_expression_to_latex
+    
+    # Convert a simple polynomial expression to LaTeX format
+    latex_result1 = python_polynomial_expression_to_latex("x**2 + y**2")
+    print(latex_result1)  # Output: "x^{2} + y^{2}"
+    
+    # Convert polynomial expression with substituted values
+    latex_result2 = python_polynomial_expression_to_latex("x**2 + y**2", {"x": 3, "y": 4})
+    print(latex_result2)  # Output: "25"
+    
+    # Another example with partial substitution
+    latex_result3 = python_polynomial_expression_to_latex("x**2 + y**2", {"x": 3})
+    print(latex_result3)  # Output: "y^{2} + 9"
+    
+    # Trigonometric functions included with symbolic variables
+    latex_result4 = python_polynomial_expression_to_latex("sin(x+z**2) + cos(y)", {"x": 55})
+    print(latex_result4)  # Output: "cos y + sin \\left(z^{2} + 55\\right)"
+    
+    # Simplified trigonometric functions example with substitution
+    latex_result5 = python_polynomial_expression_to_latex("sin(x) + cos(y)", {"x": 0})
+    print(latex_result5)  # Output: "cos y"
 
-    factors3 = get_prime_factors_latex(17)
-    print(factors3)  # Output: "17"    
- 
 --------------------------------------------------------------------------------
 
-### 6. `compute_matrix_expression`
+### 6. `simplify_polynomial_expression`
 
-Computes the results of expressions containing 1D or 2D matrix operations and formats them as LaTeX strings.
+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 a sequence of matrix operations involving either 1D or 2D lists. Supported operations include addition (`+`), subtraction (`-`), multiplication (`*`), and division (`/`).
+  - `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:
-  - `str`: The LaTeX-formatted string representation of the computed matrix, or an error message if the operations cannot be performed due to dimensional mismatches.
+  - `str`: The simplified expression formatted as a LaTeX string.
 
-• Example:
+• Example Usage:
 
-    from rgwfuncs import compute_matrix_expression
-    
-    # Example with addition of 2D matrices
-    result = compute_matrix_expression("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
-    print(result)  # Output: \begin{bmatrix}3 & 8 & 12\\5 & 8 & 11\end{bmatrix}
-    
-    # Example of mixed operations with 1D matrices treated as 2D
-    result = compute_matrix_expression("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
-    print(result)  # Output: \begin{bmatrix}2 & 6 & 10\end{bmatrix}
+    from rgwfuncs import simplify_polynomial_expression
 
-    # Example with dimension mismatch
-    result = compute_matrix_expression("[[4, 3, 51]] + [[1, 1]]")
-    print(result)  # Output: Operations between matrices must involve matrices of the same dimension
+    # Example 1: Simplifying a polynomial expression without substitutions
+    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_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_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_polynomial_expression("a*b + b", subs={"b": 2})
+    print(simplified_expr4)  # Output: "2 a + 2"
 
 --------------------------------------------------------------------------------
 
-### 7. `compute_ordered_series_expression`
+### 7. `solve_homogeneous_polynomial_expression`
 
-Computes the result of expressions containing operations on ordered series expressed as 1D lists. The syntax of the expression supports the discrete difference operator via the `ddd()` method.
+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 series operation expression. Supports operations such as "+", "-", "*", "/", and `ddd()` for discrete differences.
+  - `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:
-  - `str`: The string representation of the resultant series after performing operations, or an error message if series lengths do not match.
+  - `str`: Solutions formatted in LaTeX.
 
 • Example:
 
-    from rgwfuncs import compute_ordered_series_expression
+    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]"
 
-    # Example with addition and discrete differences
-    result = compute_ordered_series_expression("ddd([2, 6, 9, 60]) + ddd([78, 79, 80])")
-    print(result)  # Output: [4, 3, 51] + [1, 1]
+    solutions2 = solve_homogeneous_polynomial_expression("x**2 - 4", "x")
+    print(solutions2)  # Output: "\left[-2, 2\right]"
     
-    # Example with elementwise subtraction
-    result = compute_ordered_series_expression("[10, 15, 21] - [5, 5, 5]")
-    print(result)  # Output: [5, 10, 16]
-
-    # Example with length mismatch
-    result = compute_ordered_series_expression("[4, 3, 51] + [1, 1]")
-    print(result)  # Output: Operations between ordered series must involve series of equal length
-
 --------------------------------------------------------------------------------
 
 ## String Based Functions

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

@@ -128,43 +128,27 @@ Print a list of available function names in alphabetical order. If a filter is p
 
 This section provides comprehensive functions for handling algebraic expressions, performing tasks such as computation, simplification, solving equations, and prime factorization, all outputted in LaTeX format.
 
-### 1. `python_polynomial_expression_to_latex`
+### 1. `compute_prime_factors_latex`
 
-Converts a polynomial expression written in Python syntax to a LaTeX formatted string. This function parses algebraic expressions provided as strings using Python’s syntax and translates them into equivalent LaTeX representations, making them suitable for academic or professional documentation. The function supports inclusion of named variables, with an option to substitute specific values into the expression.
+Computes prime factors of a number and presents them in LaTeX format.
 
 • Parameters:
-  - `expression` (str): The algebraic expression to convert to LaTeX. This should be a string formatted with Python syntax acceptable by SymPy.
-  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers with which to substitute those variables.
+  - `n` (int): The integer to factorize.
 
 • Returns:
-  - `str`: The LaTeX formatted string equivalent to the provided expression.
-
-• Raises:
-  - `ValueError`: If the expression cannot be parsed due to syntax errors.
+  - `str`: Prime factorization in LaTeX.
 
 • Example:
 
-    from rgwfuncs import python_polynomial_expression_to_latex
-    
-    # Convert a simple polynomial expression to LaTeX format
-    latex_result1 = python_polynomial_expression_to_latex("x**2 + y**2")
-    print(latex_result1)  # Output: "x^{2} + y^{2}"
-    
-    # Convert polynomial expression with substituted values
-    latex_result2 = python_polynomial_expression_to_latex("x**2 + y**2", {"x": 3, "y": 4})
-    print(latex_result2)  # Output: "25"
-    
-    # Another example with partial substitution
-    latex_result3 = python_polynomial_expression_to_latex("x**2 + y**2", {"x": 3})
-    print(latex_result3)  # Output: "y^{2} + 9"
-    
-    # Trigonometric functions included with symbolic variables
-    latex_result4 = python_polynomial_expression_to_latex("sin(x+z**2) + cos(y)", {"x": 55})
-    print(latex_result4)  # Output: "cos y + sin \\left(z^{2} + 55\\right)"
-    
-    # Simplified trigonometric functions example with substitution
-    latex_result5 = python_polynomial_expression_to_latex("sin(x) + cos(y)", {"x": 0})
-    print(latex_result5)  # Output: "cos y"
+    from rgwfuncs import compute_prime_factors_latex
+    factors_1 = compute_prime_factors_latex(100)
+    print(factors_1)  # Output: "2^{2} \cdot 5^{2}"
+
+    factors_2 = compute_prime_factors_latex(60)
+    print(factors_2)  # Output: "2^{2} \cdot 3 \cdot 5"
+
+    factors_3 = compute_prime_factors_latex(17)
+    print(factors_3)  # Output: "17"
 
 --------------------------------------------------------------------------------
 
@@ -192,140 +176,157 @@ Computes the numerical result of a given expression, which can evaluate to a con
 
 --------------------------------------------------------------------------------
 
-### 3. `simplify_polynomial_expression`
+### 3. `compute_constant_expression_involving_matrices`
 
-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.
+Computes the result of a constant expression involving matrices and returns it as a LaTeX string.
 
 • 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.
+  - `expression` (str): The constant expression involving matrices. Example format includes operations such as "+", "-", "*", "/".
 
 • Returns:
-  - `str`: The simplified expression formatted as a LaTeX string.
-
-• Example Usage:
+  - `str`: The LaTeX-formatted string representation of the computed matrix, or an error message if the operations cannot be performed due to dimensional mismatches.
 
-    from rgwfuncs import simplify_polynomial_expression
+• Example:
 
-    # Example 1: Simplifying a polynomial expression without substitutions
-    simplified_expr1 = simplify_polynomial_expression("2*x + 3*x")
-    print(simplified_expr1)  # Output: "5 x"
+    from rgwfuncs import compute_constant_expression_involving_matrices
 
-    # Example 2: Simplifying a complex expression involving derivatives
-    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 with addition of 2D matrices
+    result = compute_constant_expression_involving_matrices("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
+    print(result)  # Output: \begin{bmatrix}3 & 8 & 12\\5 & 8 & 11\end{bmatrix}
 
-    # Example 3: Simplifying with substitutions
-    simplified_expr3 = simplify_polynomial_expression("x**2 + y**2", subs={"x": 3, "y": 4})
-    print(simplified_expr3)  # Output: "25"
+    # Example of mixed operations with 1D matrices treated as 2D
+    result = compute_constant_expression_involving_matrices("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
+    print(result)  # Output: \begin{bmatrix}2 & 6 & 10\end{bmatrix}
 
-    # Example 4: Simplifying with partial substitution
-    simplified_expr4 = simplify_polynomial_expression("a*b + b", subs={"b": 2})
-    print(simplified_expr4)  # Output: "2 a + 2"
+    # Example with dimension mismatch
+    result = compute_constant_expression_involving_matrices("[[4, 3, 51]] + [[1, 1]]")
+    print(result)  # Output: Operations between matrices must involve matrices of the same dimension
 
 --------------------------------------------------------------------------------
 
-### 4. `solve_homogeneous_polynomial_expression`
+### 4. `compute_constant_expression_involving_ordered_series`
+
+Computes the result of a constant expression involving ordered series, and returns it as a Latex string. 
 
-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 homogeneous polynomial expression to solve.
-  - `variable` (str): The variable to solve for.
-  - `subs` (Optional[Dict[str, float]]): Substitutions for variables.
+  - `expression` (str): A series operation expression. Supports operations such as "+", "-", "*", "/", and `dd()` for discrete differences.
 
 • Returns:
-  - `str`: Solutions formatted in LaTeX.
+  - `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 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]"
+    from rgwfuncs import compute_constant_expression_involving_ordered_series
+
+    # Example with addition and discrete differences
+    result = compute_constant_expression_involving_ordered_series("dd([2, 6, 9, 60]) + dd([78, 79, 80])")
+    print(result)  # Output: [4, 3, 51] + [1, 1]
+
+    # Example with elementwise subtraction
+    result = compute_constant_expression_involving_ordered_series("[10, 15, 21] - [5, 5, 5]")
+    print(result)  # Output: [5, 10, 16]
+
+    # Example with length mismatch
+    result = compute_constant_expression_involving_ordered_series("[4, 3, 51] + [1, 1]")
+    print(result)  # Output: Operations between ordered series must involve series of equal length
 
-    solutions2 = solve_homogeneous_polynomial_expression("x**2 - 4", "x")
-    print(solutions2)  # Output: "\left[-2, 2\right]"
-    
 --------------------------------------------------------------------------------
 
-### 5. `get_prime_factors_latex`
+### 5. `python_polynomial_expression_to_latex`
 
-Computes prime factors of a number and presents them in LaTeX format.
+Converts a polynomial expression written in Python syntax to a LaTeX formatted string. This function parses algebraic expressions provided as strings using Python’s syntax and translates them into equivalent LaTeX representations, making them suitable for academic or professional documentation. The function supports inclusion of named variables, with an option to substitute specific values into the expression.
 
 • Parameters:
-  - `n` (int): The integer to factorize.
+  - `expression` (str): The algebraic expression to convert to LaTeX. This should be a string formatted with Python syntax acceptable by SymPy.
+  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers with which to substitute those variables.
 
 • Returns:
-  - `str`: Prime factorization in LaTeX.
+  - `str`: The LaTeX formatted string equivalent to the provided expression.
 
-• Example:
+• Raises:
+  - `ValueError`: If the expression cannot be parsed due to syntax errors.
 
-    from rgwfuncs import get_prime_factors_latex
-    factors1 = get_prime_factors_latex(100)
-    print(factors1)  # Output: "2^{2} \cdot 5^{2}"
+• Example:
 
-    factors2 = get_prime_factors_latex(60)
-    print(factors2)  # Output: "2^{2} \cdot 3 \cdot 5"
+    from rgwfuncs import python_polynomial_expression_to_latex
+    
+    # Convert a simple polynomial expression to LaTeX format
+    latex_result1 = python_polynomial_expression_to_latex("x**2 + y**2")
+    print(latex_result1)  # Output: "x^{2} + y^{2}"
+    
+    # Convert polynomial expression with substituted values
+    latex_result2 = python_polynomial_expression_to_latex("x**2 + y**2", {"x": 3, "y": 4})
+    print(latex_result2)  # Output: "25"
+    
+    # Another example with partial substitution
+    latex_result3 = python_polynomial_expression_to_latex("x**2 + y**2", {"x": 3})
+    print(latex_result3)  # Output: "y^{2} + 9"
+    
+    # Trigonometric functions included with symbolic variables
+    latex_result4 = python_polynomial_expression_to_latex("sin(x+z**2) + cos(y)", {"x": 55})
+    print(latex_result4)  # Output: "cos y + sin \\left(z^{2} + 55\\right)"
+    
+    # Simplified trigonometric functions example with substitution
+    latex_result5 = python_polynomial_expression_to_latex("sin(x) + cos(y)", {"x": 0})
+    print(latex_result5)  # Output: "cos y"
 
-    factors3 = get_prime_factors_latex(17)
-    print(factors3)  # Output: "17"    
- 
 --------------------------------------------------------------------------------
 
-### 6. `compute_matrix_expression`
+### 6. `simplify_polynomial_expression`
 
-Computes the results of expressions containing 1D or 2D matrix operations and formats them as LaTeX strings.
+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 a sequence of matrix operations involving either 1D or 2D lists. Supported operations include addition (`+`), subtraction (`-`), multiplication (`*`), and division (`/`).
+  - `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:
-  - `str`: The LaTeX-formatted string representation of the computed matrix, or an error message if the operations cannot be performed due to dimensional mismatches.
+  - `str`: The simplified expression formatted as a LaTeX string.
 
-• Example:
+• Example Usage:
 
-    from rgwfuncs import compute_matrix_expression
-    
-    # Example with addition of 2D matrices
-    result = compute_matrix_expression("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
-    print(result)  # Output: \begin{bmatrix}3 & 8 & 12\\5 & 8 & 11\end{bmatrix}
-    
-    # Example of mixed operations with 1D matrices treated as 2D
-    result = compute_matrix_expression("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
-    print(result)  # Output: \begin{bmatrix}2 & 6 & 10\end{bmatrix}
+    from rgwfuncs import simplify_polynomial_expression
 
-    # Example with dimension mismatch
-    result = compute_matrix_expression("[[4, 3, 51]] + [[1, 1]]")
-    print(result)  # Output: Operations between matrices must involve matrices of the same dimension
+    # Example 1: Simplifying a polynomial expression without substitutions
+    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_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_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_polynomial_expression("a*b + b", subs={"b": 2})
+    print(simplified_expr4)  # Output: "2 a + 2"
 
 --------------------------------------------------------------------------------
 
-### 7. `compute_ordered_series_expression`
+### 7. `solve_homogeneous_polynomial_expression`
 
-Computes the result of expressions containing operations on ordered series expressed as 1D lists. The syntax of the expression supports the discrete difference operator via the `ddd()` method.
+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 series operation expression. Supports operations such as "+", "-", "*", "/", and `ddd()` for discrete differences.
+  - `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:
-  - `str`: The string representation of the resultant series after performing operations, or an error message if series lengths do not match.
+  - `str`: Solutions formatted in LaTeX.
 
 • Example:
 
-    from rgwfuncs import compute_ordered_series_expression
+    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]"
 
-    # Example with addition and discrete differences
-    result = compute_ordered_series_expression("ddd([2, 6, 9, 60]) + ddd([78, 79, 80])")
-    print(result)  # Output: [4, 3, 51] + [1, 1]
+    solutions2 = solve_homogeneous_polynomial_expression("x**2 - 4", "x")
+    print(solutions2)  # Output: "\left[-2, 2\right]"
     
-    # Example with elementwise subtraction
-    result = compute_ordered_series_expression("[10, 15, 21] - [5, 5, 5]")
-    print(result)  # Output: [5, 10, 16]
-
-    # Example with length mismatch
-    result = compute_ordered_series_expression("[4, 3, 51] + [1, 1]")
-    print(result)  # Output: Operations between ordered series must involve series of equal length
-
 --------------------------------------------------------------------------------
 
 ## String Based Functions

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

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

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

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