test_expression.py

import unittest 
from expression import *

class PaserTests(unittest.TestCase):
    def test_init(self):
        self.assertIsNotNone(Expression("1+2"))

    def setUp(self):
        Expression.reset_global_variables()
        super().setUp()

    def test_tokenize_variables(self):
        possible = ['a','b','A','Z','abcd','ABC','a1']
        for some_token in possible:
            token, work_string = Expression.next_token(work_string=some_token)
            self.assertIsNotNone(token, f"Fail: {some_token}")
            self.assertTrue(token.type == TokenType.VAR)
            self.assertTrue(token.text == some_token)

    def test_tokenize_add(self):
        possible = ['+']
        for some_token in possible:
            token, work_string = Expression.next_token(work_string=some_token)
            self.assertIsNotNone(token)
            self.assertTrue(token.type == TokenType.ADD)
            self.assertTrue(token.text == some_token)

    def test_tokenize_sub(self):
        possible = ['-']
        for some_token in possible:
            token, work_string = Expression.next_token(work_string=some_token)
            self.assertIsNotNone(token)
            self.assertTrue(token.type == TokenType.SUB)
            self.assertTrue(token.text == some_token)

    def test_tokenize_mul(self):
        possible = ['*']
        for some_token in possible:
            token, work_string = Expression.next_token(work_string=some_token)
            self.assertIsNotNone(token)
            self.assertTrue(token.type == TokenType.MUL)
            self.assertTrue(token.text == some_token)

    def test_tokenize_div(self):
        possible = ['/','÷']
        for some_token in possible:
            token, work_string = Expression.next_token(work_string=some_token)
            self.assertIsNotNone(token)
            self.assertTrue(token.type == TokenType.DIV)
            self.assertTrue(token.text == some_token)

    def test_tokenize_plusminus(self):
        possible = ['±']
        for some_token in possible:
            token, work_string = Expression.next_token(work_string=some_token)
            self.assertIsNotNone(token)
            self.assertTrue(token.type == TokenType.PLUSMINUS)
            self.assertTrue(token.text == some_token)

    def test_tokenize_parenthesis(self):
        possible = ['(']
        for some_token in possible:
            token, work_string = Expression.next_token(work_string=some_token)
            self.assertIsNotNone(token)
            self.assertTrue(token.type == TokenType.LEFT_PAR)
            self.assertTrue(token.text == some_token)

        possible = [')']
        for some_token in possible:
            token, work_string = Expression.next_token(work_string=some_token)
            self.assertIsNotNone(token)
            self.assertTrue(token.type == TokenType.RIGHT_PAR)
            self.assertTrue(token.text == some_token)

    def test_tokenize_number(self):
        possible = ['1.0','12','123','123.123','123e-3']
        for some_token in possible:
            token, work_string = Expression.next_token(work_string=some_token)
            self.assertIsNotNone(token)
            self.assertTrue(token.type == TokenType.NUMBER)
            self.assertTrue(token.text == some_token)

    def test_tokenize_assign(self):
        possible = ['=']
        for some_token in possible:
            token, work_string = Expression.next_token(work_string=some_token)
            self.assertIsNotNone(token)
            self.assertTrue(token.type == TokenType.ASSIGN)
            self.assertTrue(token.text == some_token)

    def test_tokenize(self):
        possible = ['a+b','a-b','a*b','a/b','a+12','a+b-c*d/f']
        for expression in possible:
            Expression(expression)

    def test_rpn_stack(self):
        # possible = ['1+2-3','1+2*3','1*2+3']
        possible = ['1+2*3']
        for expression in possible:
            p = Expression(expression)

    def test_evaluate(self):
        possible = [('1+2-3',0),('1+2*3',7),('1*2+3',5),('1/3',1/3)]
        for expression, result in possible:
            p = Expression(expression)
            self.assertEqual(p.evaluate({}), result)


    def test_evaluate_plusminus(self):
        m = Expression("5±1")
        mean, std = m.evaluate_uncertainty()
        self.assertAlmostEqual(mean, 5, 1)
        self.assertAlmostEqual(std, 1, 1)

    def test_evaluate_variables_values(self):
        m = Expression("5±a")
        mean, std = m.evaluate_uncertainty(variables={"a":2})
        self.assertAlmostEqual(mean, 5, 1)
        self.assertAlmostEqual(std, 2, 1)

        m = Expression("5±a%")

        mean, std = m.evaluate_uncertainty(variables={"a":2})
        self.assertAlmostEqual(mean, 5, 1)
        self.assertAlmostEqual(std, 0.02*5, 1)

    def test_evaluate_assignment(self):
        m = Expression("a=5")
        mean, std = m.evaluate_uncertainty()
        self.assertAlmostEqual(mean, 5, 1)
        self.assertAlmostEqual(std, 0, 1)

        self.assertEqual(m.evaluate(), 5)
        m = Expression("b=5+a")
        mean, std = m.evaluate_uncertainty()
        self.assertAlmostEqual(mean, 10, 1)
        self.assertAlmostEqual(std, 0, 1)

        m = Expression("b±(a/5)")
        mean, std = m.evaluate_uncertainty()
        self.assertAlmostEqual(mean, 10, 1)
        self.assertAlmostEqual(std, 1, 1)

        m = Expression("(b±a)/5)")
        mean, std = m.evaluate_uncertainty()
        self.assertAlmostEqual(mean, 2, 1)
        self.assertAlmostEqual(std, 1, 1)

    def test_check_assignment(self):
        m = Expression("a=5")
        m2 = Expression("b=a")
        self.assertEqual(m.evaluate(), m2.evaluate())

    def test_split(self):
        self.assertTrue("a=1".split('=') == ['a','1'])

    def test_check_assignment_with_uncertainty(self):
        m = Expression("a=5±1")
        m2 = Expression("a+a")
        # self.assertEqual(m.evaluate(), m2.evaluate())

    def test_regex_neg(self):
        m = re.match(r'(±)(?!%)',"±%1")
        self.assertIsNone(m)
        m = re.match(r'(±)(?!%)',"±%")
        self.assertIsNone(m)

        m = re.match(r'(±%)',"±%")
        self.assertIsNotNone(m)

        m = re.match(r'(±)(?!%)',"±1")
        self.assertIsNotNone(m)
        m = re.match(r'(±)(?!%)',"±1")
        self.assertIsNotNone(m)


    def test_uncertainty_in_percent(self):
        m = Expression("1±1%")
        mean, std = m.evaluate_uncertainty()
        self.assertAlmostEqual(mean, 1, 1)
        self.assertAlmostEqual(std, 0.01, 1)

        m = Expression("1±%1")
        mean, std = m.evaluate_uncertainty()
        self.assertAlmostEqual(mean, 1, 1)
        self.assertAlmostEqual(std, 0.01, 1)

        m = Expression("1±(0.5+0.5)%")
        mean, std = m.evaluate_uncertainty()
        self.assertAlmostEqual(mean, 1, 1)
        self.assertAlmostEqual(std, 0.01, 1)

    def test_uncertainty_in_absolute(self):
        m = Expression("1±0.5")
        mean, std = m.evaluate_uncertainty()
        self.assertAlmostEqual(mean, 1, 1)
        self.assertAlmostEqual(std, 0.5, 1)

        m = Expression("1±(0.25+0.25)")
        mean, std = m.evaluate_uncertainty()
        self.assertAlmostEqual(mean, 1, 1)
        self.assertAlmostEqual(std, 0.5, 1)

    def test_uncertainty_with_calculation(self):
        m = Expression("(1±0.5)+1")
        mean, std = m.evaluate_uncertainty()
        self.assertAlmostEqual(mean, 2, 1)
        self.assertAlmostEqual(std, 0.5, 1)

        m = Expression("(1±(0.25+0.25))+1")
        mean, std = m.evaluate_uncertainty()
        self.assertAlmostEqual(mean, 2, 1)
        self.assertAlmostEqual(std, 0.5, 1)

    def test_comma(self):
        m = Expression("1,1")
        self.assertEqual(m.evaluate(), 1)

    def test_function(self):
        m = Expression("sin(1)")
        self.assertAlmostEqual(m.evaluate(), np.sin(1))
        m = Expression("cos(1)")
        self.assertAlmostEqual(m.evaluate(), np.cos(1))
        m = Expression("sqrt(2)")
        self.assertAlmostEqual(m.evaluate(), np.sqrt(2))

    def test_function_with_uncertainty(self):
        m = Expression("sin(1±0.1)")

    def test_constants(self):
        self.assertAlmostEqual(Expression("pi").evaluate(), np.pi)
        self.assertAlmostEqual(Expression("π").evaluate(), np.pi)
        self.assertAlmostEqual(Expression("e").evaluate(), np.exp(1))

    def test_function_decfinition(self):
        fct = Expression("f(x) := x*2")
        m = Expression("f(2)")
        self.assertEqual(m.evaluate(), 4)

    def test_error_no_value(self):
        with self.assertRaises(Expression.VariableUndefined):
            m = Expression("a").evaluate()

    def test_error_invalid_lvalue(self):
        with self.assertRaises(Expression.InvalidLeftValue):
            m = Expression("1=2").evaluate()

    def test_error_unrecognized_token(self):
        invalid_strings = [':','.']

        for work_string in invalid_strings:
            with self.assertRaises(Expression.UnrecognizedToken):
                print(Expression.next_token(work_string))

    def test_history(self):
        Expression("a=10")
        Expression("b=20")
        Expression("f(x):=x*x")
        self.assertEqual(Expression("a+b").evaluate(), 30)
        self.assertEqual(Expression("f(a+b)").evaluate(), 30*30)

    def test_priority(self):
        """
        I am writing a mathematical parser that evaluates mathematical
        expressions, including assignment of variables and functions. I need
        to unittest many different expressions to confirm its validity. Give
        me a list of strings of mathematical expression that cover all cases
        for priority of operations (+ - * /)
        """
        operations = [
                "3 + 4 * 2",              # multiplication before addition
                "(3 + 4) * 2",            # parentheses change priority
                "6 / 3 - 2",              # division before subtraction
                "6 / (3 - 2)",            # parentheses change priority
                "2 + 3 * 4 / 2",          # mixed multiplication and division
                "2 * 3 + 4 / 2",          # multiplication and division before addition
                "2 * (3 + 4) / 2",        # parentheses with multiplication and division
                "2 * ((3 + 4) / 2)",      # nested parentheses
                "3 + 4 * 2 - 1",          # multiple operations, multiplication first
                "3 - 4 * 2 + 1",          # subtraction and addition, multiplication first
                "(3 - 4) * 2 + 1",        # parentheses change order
                "5 + 6 * (3 / 2)",        # parentheses, division inside
                "5 * 6 / 2 + 3",          # multiplication and division before addition
                "4 + 3 - 2 * 2 / 1",      # subtraction and addition after multiplication/division
                "2 / 2 + 3 * 3 - 1",      # division and multiplication before addition/subtraction
                "(2 + 3) * (5 - 2)",      # multiple parentheses
                "10 - 4 / 2 * 3",         # division and multiplication before subtraction
                "(10 - 4) / (2 * 3)",     # parentheses with division and multiplication
                "8 / 2 * (2 + 2)",        # division and multiplication with parentheses
                "7 + 3 * 4 - (10 / 5)",   # parentheses affect division first
                "(7 + 3) * (5 / 2)",      # combination of operations with parentheses
                "2 + 3 * (5 - 2) / 2",    # expression with mixed operations inside parentheses
                "100 / (5 * 2) + 6",      # division before addition with parentheses
                "6 + (4 * 3) / 2 - 7"     # addition and subtraction with parentheses
            ]
        for expression in operations:
            m = Expression(expression)
            self.assertEqual(m.evaluate(), eval(expression), f"{expression} {m.rpn_list}")

    def test_distribution(self):
        m=Expression("10±1")
        print(m.evaluate())

    def test_define_vs_assign(self):
        # := stores Expression (independent on each reference)
        Expression("a := 10±2")
        self.assertIsInstance(Expression.global_variables['a'], Expression)
        m = Expression("a + a")
        mean, std = m.evaluate_uncertainty(N=500_000)
        self.assertAlmostEqual(mean, 20, 0)
        self.assertAlmostEqual(std, 2*np.sqrt(2), 0)  # independent: sqrt(4+4)

    def test_assign_stores_result(self):
        # = evaluates immediately, stores ndarray (correlated on reuse)
        Expression("a = 10±2")
        self.assertIsInstance(Expression.global_variables['a'], np.ndarray)
        m = Expression("a + a")
        mean, std = m.evaluate_uncertainty(N=500_000)
        self.assertAlmostEqual(mean, 20, 0)
        self.assertAlmostEqual(std, 4, 0)  # correlated: 2*2 = 4

    def test_assign_two_variables_independent(self):
        Expression("a = 10±2")
        Expression("b = 10±2")
        m = Expression("a + b")
        mean, std = m.evaluate_uncertainty(N=500_000)
        self.assertAlmostEqual(mean, 20, 0)
        self.assertAlmostEqual(std, 2*np.sqrt(2), 0)

    def test_has_distributions_true(self):
        m = Expression("10±1")
        self.assertTrue(m.has_distributions)

    def test_has_distributions_false(self):
        m = Expression("10+1")
        self.assertFalse(m.has_distributions)

    def test_has_distributions_with_variable(self):
        Expression("a := 10±1")
        m = Expression("a + 1")
        self.assertTrue(m.has_distributions)

    def test_evaluate_scalar_with_assign(self):
        # = stores ndarray, scalar mode should return mean
        Expression("a = 10±2")
        m = Expression("a + 5")
        scalar = m.evaluate_scalar()
        self.assertAlmostEqual(scalar, 15, 0)
        self.assertIsInstance(scalar, (int, float, np.floating))

    def test_evaluate_scalar_with_define(self):
        Expression("a := 10±2")
        m = Expression("a * 2")
        scalar = m.evaluate_scalar()
        self.assertAlmostEqual(scalar, 20, 0)

    def test_define_function(self):
        Expression("f(x) := x*x")
        self.assertIsInstance(Expression.functions['f'], Expression)
        m = Expression("f(3)")
        self.assertEqual(m.evaluate(), 9)

    def test_define_is_definition(self):
        m = Expression("a := 5")
        self.assertTrue(m.is_definition)
        self.assertTrue(m.is_assignment)

    def test_assign_is_not_definition(self):
        m = Expression("a = 5")
        self.assertFalse(m.is_definition)
        self.assertTrue(m.is_assignment)

    def test_no_assignment(self):
        m = Expression("1+2")
        self.assertFalse(m.is_assignment)
        self.assertFalse(m.is_definition)
        self.assertIsNone(m.lvalue)

    def test_define_function_with_uncertainty(self):
        Expression("f(x) := x*2")
        m = Expression("f(5±1)")
        mean, std = m.evaluate_uncertainty(N=500_000)
        self.assertAlmostEqual(mean, 10, 0)
        self.assertAlmostEqual(std, 2, 0)

    def test_random_function(self):
        m = Expression("random(10, 2)")
        mean, std = m.evaluate_uncertainty(N=500_000)
        self.assertAlmostEqual(mean, 10, 0)
        self.assertAlmostEqual(std, 2, 0)

    def test_random_scalar(self):
        m = Expression("random(10, 2)")
        scalar = m.evaluate_scalar()
        self.assertAlmostEqual(scalar, 10, 5)

    def test_random_independence(self):
        m = Expression("random(10, 2) + random(10, 2)")
        mean, std = m.evaluate_uncertainty(N=500_000)
        self.assertAlmostEqual(mean, 20, 0)
        self.assertAlmostEqual(std, 2*np.sqrt(2), 0)

    def test_numbers_token(self):
        token, rest = Expression.next_token("[10, 11, 12.3]")
        self.assertEqual(token.type, TokenType.NUMBERS)
        self.assertEqual(len(token.value), 3)
        self.assertAlmostEqual(token.value[0], 10)
        self.assertAlmostEqual(token.value[2], 12.3)

    def test_numbers_evaluate(self):
        m = Expression("[10, 11, 12]")
        result = m.evaluate()
        self.assertIsInstance(result, np.ndarray)
        self.assertEqual(len(result), 3)

    def test_numbers_scalar(self):
        m = Expression("[10, 20, 30]")
        scalar = m.evaluate_scalar()
        self.assertAlmostEqual(scalar, 20, 5)

    def test_numbers_assign(self):
        Expression("a = [8, 10, 12]")
        m = Expression("a")
        mean, std = m.evaluate_uncertainty()
        self.assertAlmostEqual(mean, 10, 0)
        self.assertAlmostEqual(std, np.std([8, 10, 12], ddof=1), 1)

    def test_numbers_operations(self):
        Expression("a = [10, 20, 30]")
        m = Expression("a * 2")
        scalar = m.evaluate_scalar()
        self.assertAlmostEqual(scalar, 40, 0)

    def test_comma_in_function(self):
        """Test that comma works correctly in multi-arg context."""
        m = Expression("random(5, 1)")
        mean, std = m.evaluate_uncertainty(N=500_000)
        self.assertAlmostEqual(mean, 5, 0)
        self.assertAlmostEqual(std, 1, 0)

if __name__ == "__main__":
    # unittest.main(defaultTest=["PaserTests.test_evaluate_variables_values"])
    unittest.main()