def test_round_expression_with_symbolic_expressions(self):
        x = Symbol('x')
        self.assertEqual(round_expression(x),x)
        expr = 2.1*x**2.9-3.3*x+4.7
        expr_round = 2*x**3-3*x+5
        self.assertEqual(round_expression(expr),expr_round)
        from sympy import sin, exp
        from sympy import Symbol as sympy_Symbol
        z = sympy_Symbol('z')

        # round expressions can take strings, as it calls sympify first
        self.assertEqual(round_expression("3.93*sin(3.1*z)"), 4*sin(3*z))
        
        # round rationals inside function
        self.assertEqual(round_expression("cos(3*y/7)",3),
                          sympify("cos(0.429*y)"))
        
        # number will be taken out of exponential before rounding
        # in this case, the exponential should be multiplied by
        # zero after the rounding
        self.assertEqual(round_expression("43/11+exp(z/3-47/5)", 3),
                          3.909)

        # some bug or something that gives different result is -exp
        # self.assertEqual(round_expression("7/5-3*exp(5*z/6-7/3)/13", 5),
        #                   1.4-0.02238*exp(0.83333*z))

        self.assertEqual(round_expression("sqrt(x-3.512114)/3",2),
                          round_expression("(x-3.512114)**0.5/3",2))
    def test_normalize_floats_with_symbolic_expressions(self):
        x = Symbol('x')
        self.assertEqual(normalize_floats(x),x)
        expr = 0.1213*x**2.239-332.323*x+23.72
        expr_normalize = 0.1213*x**2.239-332.323*x+23.72
        self.assertEqual(normalize_floats(expr),expr_normalize)
        expr = 0.1219372103487213*x**2.2328104785329-332.3283102574243*x+23.433712364579320
        expr_normalize = -332.32831025742*x + 0.12193721034872*x**2.2328104785329 + 23.433712364579
        self.assertEqual(normalize_floats(expr),expr_normalize)


        from sympy import sin, exp
        from sympy import Symbol as sympy_Symbol
        z = sympy_Symbol('z')

        # normalize expressions can take strings, as it calls sympify first
        self.assertEqual(normalize_floats("3.99*sin(3.12*z)"), 3.99*sin(3.12*z))
        
        # don't normalize rationals inside function
        expr = sympify("cos(3*y/7)")
        self.assertEqual(normalize_floats(expr),expr)
        
        # number won't taken out of exponential
        expr = sympify("43/11+exp(z/3-47/5)")
        self.assertEqual(normalize_floats(expr), expr)

        fivesixths = sympify("5/6")
        self.assertEqual(normalize_floats("7./5-3*exp(5*z/6-7/3.)/13"),
                          1.4-0.022378146430247*exp(fivesixths*z))

        self.assertEqual(normalize_floats("sqrt(x-3.512114)/3"),
                          normalize_floats("(x-3.512114)**0.5/3"))
    def test_evalf_expression_with_symbolic_expressions(self):
        x = Symbol('x')
        self.assertEqual(evalf_expression(x),x)
        expr = 0.1213*x**2.239-332.323*x+23.72
        expr_evalf = 0.121*x**2.24-332.0*x+23.7
        self.assertEqual(evalf_expression(expr,3),expr_evalf)

        from sympy import sin, exp
        from sympy import Symbol as sympy_Symbol
        z = sympy_Symbol('z')

        # evalf expressions can take strings, as it calls sympify first
        self.assertEqual(evalf_expression("3.99*sin(3.12*z)",2), 4*sin(3.1*z))
        
        # evalf rationals inside function
        self.assertEqual(evalf_expression("cos(3*y/7)",3),
                          sympify("cos(0.429*y)"))
        
        # number will be taken out of exponential before evalf
        self.assertEqual(evalf_expression("43/11+exp(z/3-47/5)", 3),
                          8.27e-5*exp(0.333*z)+3.91)

        # some bug or something that gives different result is -exp
        # self.assertEqual(evalf_expression("7/5-3*exp(5*z/6-7/3)/13", 5),
        #                   1.4-0.23077*exp(0.83333*z-2.3333))

        self.assertEqual(evalf_expression("sqrt(x-3.512114)/3",2),
                          evalf_expression("(x-3.512114)**0.5/3",2))