'Evaluate this complex root to the given precision.'

def _eval_evalf(self, prec):

    with workprec(prec):
        g = self.poly.gen
        if (not g.is_Symbol):
            d = Dummy('x')
            func = lambdify(d, self.expr.subs(g, d))
        else:
            func = lambdify(g, self.expr)
        interval = self._get_interval()
        if (not self.is_real):
            ay = interval.ay
            by = interval.by
            while ((interval.ay == ay) or (interval.by == by)):
                interval = interval.refine()
        while True:
            if self.is_real:
                a = mpf(str(interval.a))
                b = mpf(str(interval.b))
                if (a == b):
                    root = a
                    break
                x0 = mpf(str(interval.center))
            else:
                ax = mpf(str(interval.ax))
                bx = mpf(str(interval.bx))
                ay = mpf(str(interval.ay))
                by = mpf(str(interval.by))
                if ((ax == bx) and (ay == by)):
                    deg = self.poly.degree()
                    i = self.index
                    if ((deg - i) % 2):
                        if (ay < 0):
                            ay = (- ay)
                    elif (ay > 0):
                        ay = (- ay)
                    root = mpc(ax, ay)
                    break
                x0 = mpc(*map(str, interval.center))
            try:
                root = findroot(func, x0)
                if self.is_real:
                    if (a <= root <= b):
                        break
                elif ((ax <= root.real <= bx) and (ay <= root.imag <= by)):
                    break
            except (UnboundLocalError, ValueError):
                pass
            interval = interval.refine()
    return (Float._new(root.real._mpf_, prec) + (I * Float._new(root.imag._mpf_, prec)))
