add mathematical solver engine based on sympy

math_ast.py

@@ -0,0 +1,130 @@
+
+import math_lexer as lexer
+from math_lexer import Token
+
+
+class Statement:
+    pass
+
+class Expression(Statement):
+    def __init__(self, value: str):
+        self.value = value
+
+class Equation:
+    def __init__(self, lhs: Expression, rhs: Expression):
+        self.lhs = lhs
+        self.rhs = rhs
+
+class Solve(Statement):
+    def __init__(self, equations: list[Equation], variables: list[Expression]):
+        self.equations = equations
+        self.variables = variables
+
+
+
+
+class Parser:
+    def __init__(self):
+        self.tokens: list[Token]  # tokens from lexer
+        self._last_eaten = None
+
+    def not_eof(self) -> bool:
+        return self.tokens[0].type is not lexer.END_OF_INPUT
+
+    def at(self) -> Token:
+        return self.tokens[0]
+
+    def at_last(self) -> Token:
+        return self._last_eaten
+
+    def eat(self) -> Token:
+        self._last_eaten = self.tokens.pop(0)
+        return self._last_eaten
+
+    def backtrack(self):
+        if not self._last_eaten:
+            raise Exception("Cannot backtrack.")
+        self.tokens.insert(0, self._last_eaten)
+        self._last_eaten = None
+
+    def eat_expect(self, token_type: int | str) -> Token:
+        prev = self.eat()
+        if prev.type is not token_type:
+            raise Exception("expected to consume '%s' but '%s' encountered." % (str(token_type), str(prev.type)))
+        return prev
+
+    def at_expect(self, token_type: int | str) -> Token:
+        prev = self.at()
+        if prev.type is not token_type:
+            raise Exception("expected to be at '%s' but '%s' encountered." % (str(token_type), str(prev.type)))
+        return prev
+
+    def parse(self, tokens: list[Token]) -> Statement:
+        self.tokens = tokens
+        statement = self.parse_statement()
+        self.at_expect(lexer.END_OF_INPUT)
+        return statement
+
+    def parse_statement(self) -> Statement:
+        type = self.at().type
+        if type is lexer.SOLVE:
+            return self.parse_solve()
+        return self.parse_expression(merge_commas=True)
+
+    def parse_solve(self) -> Solve:
+        """
+        solve x = 1 for x
+        solve x = y and y = 2 for x and y
+        """
+        self.eat_expect(lexer.SOLVE)
+        equations = []  # list of equations
+        variables = []  # list of variables to solve for
+
+        while self.not_eof() and self.at().type is not lexer.FOR:
+            equations.append(self.parse_equation())
+            selfattype = self.at().type
+            if selfattype is lexer.AND or selfattype is lexer.COMMA:
+                self.eat()
+
+        self.eat_expect(lexer.FOR)
+
+        while self.not_eof():
+            variables.append(self.parse_expression(merge_commas=False))
+            selfattype = self.at().type
+            if selfattype is lexer.AND or selfattype is lexer.COMMA:
+                self.eat()
+
+        return Solve(equations, variables)
+
+    def parse_equation(self) -> Equation:
+        lhs = self.parse_expression(merge_commas=False)
+        self.eat_expect(lexer.EQUALS)
+        rhs = self.parse_expression(merge_commas=False)
+        return Equation(lhs, rhs)
+
+    def parse_expression(self, merge_commas) -> Expression:
+        """
+        math expression
+        e.g:
+            sin(45) / 4 * pi
+        """
+
+        if merge_commas == True:
+            values = []
+            while self.not_eof():
+                token = self.eat()
+                if token.type is lexer.COMMA:
+                    values.append(lexer.COMMA)
+                elif token.type is lexer.EQUALS:
+                    values.append(lexer.EQUALS)
+                else:
+                    values.append(token.value)
+                # token = self.eat_expect(lexer.EXPRESSION)
+                # values.append(token.value)
+                # if self.at() is lexer.COMMA:
+                #     token = self.eat()
+                #     values.append(lexer.COMMA)
+            return Expression("".join(values))
+        else:
+            token = self.eat_expect(lexer.EXPRESSION)
+            return Expression(token.value)

math_interpreter.py

@@ -0,0 +1,108 @@
+import math_ast as ast
+
+
+from sympy.parsing.sympy_parser import parse_expr
+from sympy.core.numbers import Integer, One, Zero
+from sympy import symbols, Eq, solveset, linsolve, nonlinsolve
+from sympy.core.symbol import Symbol
+
+
+def interpret(statement: ast.Statement) -> str:
+    if isinstance(statement, ast.Solve):
+        return interpret_solve(statement)
+    elif isinstance(statement, ast.Expression):
+        return interpret_expression(statement)
+    return "interpretation error"
+
+
+def interpret_solve(statement: ast.Solve) -> str:
+    eqs = statement.equations
+    var = statement.variables
+
+    # convert equations to list of sympy Eq objects
+    equations = [Eq(_math_expression_sanitation_and_parse(e.lhs.value), _math_expression_sanitation_and_parse(e.rhs.value)) for e in eqs]
+
+    variables = [symbols(v.value) for v in var]
+
+    if len(equations) == 1 and len(variables) == 1:
+        return solve_simple_equation(equations[0], variables[0])
+    else:
+        return solve_multi_equation(equations, variables)
+
+
+
+def solve_simple_equation(equation, variable):
+    result = solveset(equation, variable)
+    return "solved %s = %s for %s = %s" % (equation.lhs, equation.rhs, variable, result)
+
+def solve_multi_equation(equations, variables):
+    if is_linear(equations, variables):
+        solution = linsolve(equations, variables)
+    else:
+        solution = nonlinsolve(equations, variables)
+
+    solutionpairs = []
+    for variable, value in zip(variables, list(solution)[0]):
+        value_str = str(value)
+        if not isinstance(value, Integer):
+            try:
+                float_value = value.evalf()
+                if len(value_str) > 20:
+                    value_str = "~%.3f" % float_value
+                else:
+                    value_str += "=~%.3f" % float_value
+            except:
+                pass
+
+        solutionpairs.append(f"{variable}={value_str}")
+
+    # solutionpairs = [f"{variable}={value.doit()}" for variable, value in zip(variables, list(solution)[0])]
+
+    return "solved equation system for " + ", ".join(solutionpairs[:-1]) + " and " + solutionpairs[-1]
+
+
+
+
+
+def is_linear(equations, variables):
+    return False
+    """Checks if a system of equations is linear."""
+    for eq in equations:
+        for var in variables:
+            deriv = eq.diff(var)  # Partial derivative
+            if not (deriv.is_number or (isinstance(deriv, Symbol) and deriv.free_symbols.isdisjoint({var}))):  # If the derivative is not a number or a symbol independent of the variable, the system is non-linear
+                return False
+    return True
+
+
+
+
+def interpret_expression(statement: ast.Expression) -> str:
+    return _math_evaluate_expression(statement.value)
+
+
+def _math_evaluate_expression(expression: str):
+    """evaluate a simple mathematical expression using sympy expression evaluation."""
+    therm, simple, result = _math_evaluate_internal(expression)
+    if isinstance(simple, Integer):
+        return _build_equation_pair([therm, simple])
+    if therm == simple or simple == result:
+        return _build_equation_pair([therm, result])
+    return _build_equation_pair([therm, simple, result])
+
+
+def _math_evaluate_internal(expression: str):
+    therm = _math_expression_sanitation_and_parse(expression)
+    simple = therm.doit()
+    numerical = therm.evalf()
+    return therm, simple, numerical
+
+
+def _math_expression_sanitation_and_parse(expression: str):
+    expression = expression.replace("^", "**")
+    return parse_expr(expression, evaluate=False)
+
+
+def _build_equation_pair(expressions: list[any]) -> str:
+    expressions = [str(e) for e in expressions]
+    return " = ".join(expressions)

math_lexer.py

@@ -0,0 +1,61 @@
+
+
+
+EXPRESSION = 0
+END_OF_INPUT = 1
+
+SOLVE = "solve"
+FOR = "for"
+AND = "and"
+EQUALS = "="
+COMMA = ","
+
+keyword_tokens = [SOLVE, FOR, AND, EQUALS, COMMA]
+
+
+
+class Token:
+    def __init__(self, type: int|str, value: str = None):
+        self.type = type
+        self.value = value
+
+    def __repr__(self):
+        if self.value == None:
+            return f"{self.type}"
+        return f"{self.type}|'{self.value}'"
+
+
+def tokenize(expression: str) -> list[Token]:
+    """
+    this splits a math instruction into tokens.
+    example:
+        "solve x + 1 = 5 and y = 2*x for x, y"
+    result:
+        ["solve", "x + 1", "=", "5", "and", "y", "=", "2*x", "for", "x", "and", "y", "end_of_input"]
+    """
+
+    tokens = []   # output list of tokens
+
+    symbols = expression.replace(",", " , ").replace("=", " = ").split(" ")
+
+    current_token = []  # everything that is not directly in math_keyword_tokens gets binned here
+    for s in symbols:
+        found = False
+
+        for keyword in keyword_tokens:
+            if s.lower() == keyword:
+                if len(current_token) != 0:
+                    tokens.append(Token(EXPRESSION, " ".join(current_token)))
+                    current_token = []
+                tokens.append(Token(keyword))
+                found = True
+                break
+
+        if found == False:
+            current_token.append(s)
+    if len(current_token) != 0:
+        tokens.append(Token(EXPRESSION, " ".join(current_token)))
+        current_token = []
+
+    tokens.append(Token(END_OF_INPUT))
+    return tokens

tests/test_tool_function_decorator.py

@@ -3,19 +3,16 @@ import tool_helper
 import tests.helper as helper
 
 
-def test_tool_function_decorator_if_clean_tool_list():
-    """ tests for the tool list to be empty. NOT strictly nessesary,
-    but I want to be warned if this is not the case anymore. Could be not the intention """
-    start_len = len(tool_helper.tool_list)
-    assert start_len == 0
 
 def test_tool_function_decorator():
     # get length before adding tools
     start_len = len(tool_helper.tool_list)
 
     # add tools like it would be a decorator
-    tool_helper.tool(helper.tool_dummy)
+    res = tool_helper.tool(helper.tool_dummy)
-    tool_helper.tool(helper.tool_dummy2)
+    assert res == helper.tool_dummy  # decorator should return the function itself, so it is usable just in case.
+    res = tool_helper.tool(helper.tool_dummy2)
+    assert res == helper.tool_dummy2  # decorator should return the function itself, so it is usable just in case.
 
     # get length after adding tools
     end_len = len(tool_helper.tool_list)
@@ -28,3 +25,4 @@ def test_tool_function_decorator():
 
 
 
+

tests/test_tool_functions.py

@@ -0,0 +1,57 @@
+import pytest
+import tool_functions
+
+
+
+def test_math_evaluate_1():
+    result = tool_functions.math_evaluate("1+2*pi")
+    assert result == "1 + 2*pi = 7.28318530717959"
+
+def test_math_evaluate_2a():
+    result = tool_functions.math_evaluate("2**4")
+    assert result == "2**4 = 16"
+
+def test_math_evaluate_2b():
+    """ test that ^ notation is also working, original sympy cannot do this """
+    result = tool_functions.math_evaluate("2^4")
+    assert result == "2**4 = 16"
+
+def test_math_evaluate_3():
+    result = tool_functions.math_evaluate("Integral(exp(-x**2), (x, -oo, oo))")
+    assert result == "Integral(exp(-x**2), (x, -oo, oo)) = sqrt(pi) = 1.77245385090552"
+
+def test_math_evaluate_4():
+    result = tool_functions.math_evaluate("(2**x)**2")
+    assert result == "(2**x)**2 = 2**(2*x) = 2.0**(2*x)"
+
+def test_math_evaluate_5():
+    result = tool_functions.math_evaluate("sin(pi/2) + cos(0)")
+    assert result == "sin(pi/2) + cos(0) = 2"
+
+
+
+
+
+
+
+
+def test_math_solver_1():
+    result = tool_functions.math_evaluate("solve x = 1 for x")
+    assert result == "solved x = 1 for x = {1}"
+
+def test_math_solver_2():
+    result = tool_functions.math_evaluate("solve (x + 1)*(x - 1) = 1 for x")
+    assert result == "solved (x + 1)*(x - 1*1) = 1 for x = {-sqrt(2), sqrt(2)}"
+
+def test_math_solver_3a():
+    result = tool_functions.math_evaluate("solve 2*x + 3*y = 7 and x - y = 1 for x, y")
+    assert result == "solved equation system for x=2 and y=1"
+
+def test_math_solver_3b():
+    result = tool_functions.math_evaluate("solve 2*x + 3*y = 7, x - y = 1 for x and y")
+    assert result == "solved equation system for x=2 and y=1"
+
+def test_math_solver_4():
+    result = tool_functions.math_evaluate("solve 2*x**3 + 3*y = 7 and x - y = 1 for x, y")
+    assert result == "solved equation system for x=~1.421 and y=~0.421"
+

tool_functions.py

@@ -1,24 +1,29 @@
 import random
 import datetime
 from tool_helper import tool
+import math_lexer
+import math_ast
+import math_interpreter
+
 
 @tool
 def current_time():
     """Get the current local date and time as a string."""
     return datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
 
+@tool
+def random_float():
+    """Generate a random float from 0..1."""
+    return str(random.random())
+
 # @tool
-# def random_float():
+# def random_float(a: float=0.0, b: float=1.0):
-#     """Generate a random float from 0..1."""
+#     """Generate a random float in range [a, b], including both end points. Optional pass no parameter and range 0..1 will be used.
-#     return str(random.random())
+# Args:
+#     a: minimum possible value
+#     b: maximum possible value"""
+#     return str(random.randint(a, b))
 
-@tool
-def random_float(a: float=0.0, b: float=1.0):
-    """Generate a random float in range [a, b], including both end points. Optional pass no parameter and range 0..1 will be used.
-Args:
-    a: minimum possible value
-    b: maximum possible value"""
-    return str(random.randint(a, b))
 
 @tool
 def random_int(a: int, b: int):
@@ -31,5 +36,37 @@ Args:
 
 
 
+@tool
+def math_evaluate(expression: str):
+    """evaluate and reduce a mathematical expression.
+Args:
+    expression: Reduce mathematic expression (without '=') algebraically..
+    """
+
+    tokens = math_lexer.tokenize(expression)
+    parser = math_ast.Parser()
+    ast = parser.parse(tokens)
+    return math_interpreter.interpret(ast)
+
+
+@tool
+def math_solve(equations: list[str], variables: list[str]):
+    """evaluate a mathematical equation system and solve equation systems. Can be used to solve (x + 1)*(x - 1) = 1 for x as an example.
+Args:
+    equations: list of mathematical equations containing a '='.
+    variables: list of variables to solve for. Must be lower or equal the number of given equations.
+        """
+
+    expression = "solve " + " and ".join(equations) + " for " + " and ".join(variables)
+    print(expression)
+
+    tokens = math_lexer.tokenize(expression)
+    parser = math_ast.Parser()
+    ast = parser.parse(tokens)
+    return math_interpreter.interpret(ast)
+
+
+
+
 def register_dummy():
     pass  # dummy function to run and be sure the decorators have run

tool_helper.py

@@ -11,6 +11,7 @@ def tool(fn):
     """tool function decorator"""
     print("register tool '%s'" % fn.__name__)
     tool_list.append(fn)
+    return fn
 
 # def parse_and_execute_tool_call(message: str, tools: list[function]) -> str | None:
 #     """execute tool call if needed accordint <tool_call> tag and return the content of the tool call or None if no call happened."""