rgwfuncs 0.0.27__tar.gz → 0.0.28__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.27
+Version: 0.0.28
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -182,24 +182,38 @@ These examples illustrate the ability to handle basic arithmetic, the modulo ope
 
 ### 2. `simplify_algebraic_expression`
 
-Simplifies expressions and returns them in LaTeX format.
+Simplifies expressions and returns them in LaTeX format. Optionally applies substitutions to variables within the expression before simplifying.
 
 - **Parameters:**
-  - `expression` (str): A string of the expression to simplify.
+  - `expression` (str): A string representing the algebraic expression to simplify.
+  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where keys are variable names and values are the numbers to substitute them with.
 
 - **Returns:**
-  - `str`: Simplified expression in LaTeX.
+  - `str`: The simplified expression formatted as a LaTeX string.
 
-- **Example:**
+- **Example Usage:**
 
     from rgwfuncs import simplify_algebraic_expression
+
+    # Example 1: Simplifying a polynomial expression without substitutions
     simplified_expr1 = simplify_algebraic_expression("2*x + 3*x")
     print(simplified_expr1)  # Output: "5 x"
 
-    simplified_expr2 = simplify_algebraic_expression("(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)")
-    print(simplified_expr2)  # Output: "\frac{1}{110 x^{22} y^{3}}"
+    # Example 2: Simplifying a complex expression involving derivatives
+    simplified_expr2 = simplify_algebraic_expression(
+        "(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)"
+    )
+    print(simplified_expr2)  # Output: r"\frac{1}{110 x^{22} y^{3}}"
+
+    # Example 3: Simplifying with substitutions
+    simplified_expr3 = simplify_algebraic_expression("x**2 + y**2", subs={"x": 3, "y": 4})
+    print(simplified_expr3)  # Output: "25"
+
+    # Example 4: Simplifying with partial substitution
+    simplified_expr4 = simplify_algebraic_expression("a*b + b", subs={"b": 2})
+    print(simplified_expr4)  # Output: "a \cdot 2 + 2"
 
-These examples demonstrate simplification of polynomial expressions and more complex ratios involving derivatives.
+These examples demonstrate the simplification of polynomial expressions, handling complex ratios involving derivatives, and applying variable substitutions before simplifying. The function handles expressions both with and without substitutions, providing flexibility in its usage.
 
 --------------------------------------------------------------------------------
 

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

@@ -156,24 +156,38 @@ These examples illustrate the ability to handle basic arithmetic, the modulo ope
 
 ### 2. `simplify_algebraic_expression`
 
-Simplifies expressions and returns them in LaTeX format.
+Simplifies expressions and returns them in LaTeX format. Optionally applies substitutions to variables within the expression before simplifying.
 
 - **Parameters:**
-  - `expression` (str): A string of the expression to simplify.
+  - `expression` (str): A string representing the algebraic expression to simplify.
+  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where keys are variable names and values are the numbers to substitute them with.
 
 - **Returns:**
-  - `str`: Simplified expression in LaTeX.
+  - `str`: The simplified expression formatted as a LaTeX string.
 
-- **Example:**
+- **Example Usage:**
 
     from rgwfuncs import simplify_algebraic_expression
+
+    # Example 1: Simplifying a polynomial expression without substitutions
     simplified_expr1 = simplify_algebraic_expression("2*x + 3*x")
     print(simplified_expr1)  # Output: "5 x"
 
-    simplified_expr2 = simplify_algebraic_expression("(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)")
-    print(simplified_expr2)  # Output: "\frac{1}{110 x^{22} y^{3}}"
+    # Example 2: Simplifying a complex expression involving derivatives
+    simplified_expr2 = simplify_algebraic_expression(
+        "(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)"
+    )
+    print(simplified_expr2)  # Output: r"\frac{1}{110 x^{22} y^{3}}"
+
+    # Example 3: Simplifying with substitutions
+    simplified_expr3 = simplify_algebraic_expression("x**2 + y**2", subs={"x": 3, "y": 4})
+    print(simplified_expr3)  # Output: "25"
+
+    # Example 4: Simplifying with partial substitution
+    simplified_expr4 = simplify_algebraic_expression("a*b + b", subs={"b": 2})
+    print(simplified_expr4)  # Output: "a \cdot 2 + 2"
 
-These examples demonstrate simplification of polynomial expressions and more complex ratios involving derivatives.
+These examples demonstrate the simplification of polynomial expressions, handling complex ratios involving derivatives, and applying variable substitutions before simplifying. The function handles expressions both with and without substitutions, providing flexibility in its usage.
 
 --------------------------------------------------------------------------------
 

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

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

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

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

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

@@ -36,7 +36,10 @@ def compute_algebraic_expression(expression: str) -> float:
         raise ValueError(f"Error computing expression: {e}")
 
 
-def simplify_algebraic_expression(expression: str) -> str:
+def simplify_algebraic_expression(
+    expression: str,
+    subs: Optional[Dict[str, float]] = None
+) -> str:
     """
     Simplifies an algebraic expression and returns it in LaTeX format.
 
@@ -45,11 +48,17 @@ def simplify_algebraic_expression(expression: str) -> str:
 
     Parameters:
     expression (str): The algebraic expression to simplify.
+    subs (Optional[Dict[str, float]]): An optional dictionary of substitutions for variables
+                                       in the expression.
 
     Returns:
     str: The simplified expression represented as a LaTeX string.
+
+    Raises:
+    ValueError: If the expression cannot be simplified due to errors in expression or parameters.
     """
 
+
     def recursive_parse_function_call(
             func_call: str, prefix: str, sym_vars: Dict[str, Expr]) -> Tuple[str, List[Expr]]:
         # print(f"Parsing function call: {func_call}")
@@ -178,13 +187,18 @@ def simplify_algebraic_expression(expression: str) -> str:
     # print("Level 2 processed_expression:", processed_expression)
 
     try:
-        if processed_expression.startswith(
-                '[') and processed_expression.endswith(']'):
-            return processed_expression
-
+        # Parse the expression
         expr = parse_expr(processed_expression, local_dict=sym_vars)
+
+        # Apply substitutions if provided
+        if subs:
+            subs_symbols = {symbols(k): v for k, v in subs.items()}
+            expr = expr.subs(subs_symbols)
+
+        # Simplify the expression
         final_result = simplify(expr)
 
+        # Convert the result to LaTeX format
         if final_result.free_symbols:
             latex_result = latex(final_result)
             return latex_result
@@ -196,7 +210,10 @@ def simplify_algebraic_expression(expression: str) -> str:
 
 
 def solve_algebraic_expression(
-        expression: str, variable: str, subs: Optional[Dict[str, float]] = None) -> str:
+        expression: str, 
+        variable: str, 
+        subs: Optional[Dict[str, float]] = None
+    ) -> str:
     """
     Solves an algebraic equation for a specified variable and returns solutions in LaTeX format.
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.27
+Version: 0.0.28
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -182,24 +182,38 @@ These examples illustrate the ability to handle basic arithmetic, the modulo ope
 
 ### 2. `simplify_algebraic_expression`
 
-Simplifies expressions and returns them in LaTeX format.
+Simplifies expressions and returns them in LaTeX format. Optionally applies substitutions to variables within the expression before simplifying.
 
 - **Parameters:**
-  - `expression` (str): A string of the expression to simplify.
+  - `expression` (str): A string representing the algebraic expression to simplify.
+  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where keys are variable names and values are the numbers to substitute them with.
 
 - **Returns:**
-  - `str`: Simplified expression in LaTeX.
+  - `str`: The simplified expression formatted as a LaTeX string.
 
-- **Example:**
+- **Example Usage:**
 
     from rgwfuncs import simplify_algebraic_expression
+
+    # Example 1: Simplifying a polynomial expression without substitutions
     simplified_expr1 = simplify_algebraic_expression("2*x + 3*x")
     print(simplified_expr1)  # Output: "5 x"
 
-    simplified_expr2 = simplify_algebraic_expression("(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)")
-    print(simplified_expr2)  # Output: "\frac{1}{110 x^{22} y^{3}}"
+    # Example 2: Simplifying a complex expression involving derivatives
+    simplified_expr2 = simplify_algebraic_expression(
+        "(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)"
+    )
+    print(simplified_expr2)  # Output: r"\frac{1}{110 x^{22} y^{3}}"
+
+    # Example 3: Simplifying with substitutions
+    simplified_expr3 = simplify_algebraic_expression("x**2 + y**2", subs={"x": 3, "y": 4})
+    print(simplified_expr3)  # Output: "25"
+
+    # Example 4: Simplifying with partial substitution
+    simplified_expr4 = simplify_algebraic_expression("a*b + b", subs={"b": 2})
+    print(simplified_expr4)  # Output: "a \cdot 2 + 2"
 
-These examples demonstrate simplification of polynomial expressions and more complex ratios involving derivatives.
+These examples demonstrate the simplification of polynomial expressions, handling complex ratios involving derivatives, and applying variable substitutions before simplifying. The function handles expressions both with and without substitutions, providing flexibility in its usage.
 
 --------------------------------------------------------------------------------
 

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

@@ -30,14 +30,23 @@ def test_compute_algebraic_expression():
         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}}"),
+        # Without substitutions
+        (("(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)", None), r"\frac{1}{110 x^{22} y^{3}}"),
+
+        # With substitutions
+        (("x**2 + y**2", {"x": 3, "y": 4}), "25"),
+        (("a*b + b", {"b": 2}), r"2 a + 2"),  # Assumes no simplification of `a*b`
+        (("(x**2 + y**2 + z**2)", {"x": 1, "y": 0, "z": 0}), "1")
     ]
 
-    for input_data, expected_output in test_cases:
-        assert simplify_algebraic_expression(input_data) == expected_output
+    for (expression, subs), expected_output in test_cases:
+        output = simplify_algebraic_expression(expression, subs)
+        assert output == expected_output, (
+            f"Test failed for expression: {expression} with substitutions: {subs}. "
+            f"Expected {expected_output}, got {output}"
+        )
 
 
 def test_solve_algebraic_expression():
@@ -59,13 +68,10 @@ def test_compute_matrix_operation():
         ("[[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
@@ -88,6 +94,7 @@ def test_compute_ordered_series_operations():
         ("[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