Converting All Redundant Floats in a String to Integers

Question

I'm using Sympy to make a custom function which converts complex square roots into their complex numbers. When I input -sqrt(-2 + 2*sqrt(3)*I) I get the expected output of -1 - sqrt(3)*I, however, inputting -sqrt(-2.0 + 2*sqrt(3)*I) (has a -2.0 instead of -2), I get the output -1.0 - 0.707106781186547*sqrt(6)*I.

I've tried to convert the input expression to a string, gotten rid of the '.0 ' and then executed a piece of code to return it to the type sympy.core.add.Mul, which usually works with other strings, but the variable expression is still a string.

expression = str(input_expression).replace('.0 ', '')
exec(f'expression = {expression}')

How do I get rid of the redundant use of floats in my expression, while maintaining its type of sympy.core.add.Mul, so that my function will give a nice output?

P.S. The number 0.707106781186547 is an approximation of 1/sqrt(2). The fact that this number is present in the second output means that my function is running properly, it just isn't outputting in the desired way.

Edit: For whatever reason, unindenting and getting rid of the function as a whole, running the code as its own program gives the expected output. It's only when the code is in function form that it doesn't work.

Code as Requested:

from IPython.display import display, Math
from sympy.abc import *
from sympy import *

def imaginary_square_root(x, y):
    return(sqrt((x + sqrt(x**2 + y**2)) / (2)) + I*((y*sqrt(2)) / (2*sqrt(x + sqrt(x**2 + y**2))))) # calculates the square root of a complex number

def find_imaginary_square_root(polynomial): # 'polynomial' used because this function is meant to change expressions including variables such as 'x'
    polynomial = str(polynomial).replace('.0 ', ' ')
    exec(f'polynomial = {polynomial}')

    list_of_square_roots = [] # list of string instances of square roots and their contents
    list_of_square_root_indexes = [] # list of indexes at which the square roots can be found in the string
    polynomial_string = str(polynomial)
    temp_polynomial_string = polynomial_string # string used and chopped up, hence the prefix 'temp_...'
    current_count = 0 # counter variable used for two seperate jobs

    while 'sqrt' in temp_polynomial_string: # gets indexes of every instance of 'sqrt'
        list_of_square_root_indexes.append(temp_polynomial_string.index('sqrt') + current_count)
        temp_polynomial_string = temp_polynomial_string[list_of_square_root_indexes[-1] + 4:]
        current_count += list_of_square_root_indexes[-1] + 4

    for square_root_location in list_of_square_root_indexes:
        current_count = 1 # second job for 'current_count'

        for index, char in enumerate(polynomial_string[square_root_location + 5:]):
            if char == '(':
                current_count += 1

            elif char == ')':
                current_count -= 1

            if not current_count: # when current_count == 0, we know that the end of the sqrt contents have been reached
                list_of_square_roots.append(polynomial_string[square_root_location:square_root_location + index + 6]) # adds the square root with contents to a list
                break

    for individual_square_root in list_of_square_roots:
        if individual_square_root in str(polynomial):
            evaluate = individual_square_root[5:-1]
            x = re(evaluate)
            y = im(evaluate)

            polynomial = polynomial.replace(eval(individual_square_root), imaginary_square_root(x, y)) # replace function used here is Sympy's replace function for polynomials

    return polynomial

poly = str(-sqrt(-2.0 + 2*sqrt(3)*I))

display(Math(latex(find_imaginary_square_root(poly))))

Answer 1

What exactly are you trying to accomplish? I still do not understand. You have a whole chunck of code. Try this out:

from sympy import *

def parse(expr): print(simplify(expr).evalf().nsimplify())

parse(-sqrt(-2.0 + 2*sqrt(3)*I))
-1 - sqrt(3)*I