Laboratoire de l'Informatique et du Parallélisme » Pobyso

        nbw = 0

        icAsInt = int(ic * toIntegerFactor)

        #### The following ratio is always >= 1. In case we may want to

        curTaylErrRat = polyApproxAccur / terr

        intIc = int(ic * toIntegerFactor)

        intLb = int(lb * toIntegerFactor) - intIc

        intUb = int(ub * toIntegerFactor) - intIc

        #

        basisConstructionTime         = cputime()

        ##### To a polynomial with rational coefficients with rational arguments

        ratRatP = slz_float_poly_of_float_to_rat_poly_of_rat_pow_two(floatP)

        ##### To a polynomial with rational coefficients with integer arguments

        ratIntP = \

            slz_rat_poly_of_rat_to_rat_poly_of_int(ratRatP, precision)

        coppersmithTuple = \

            slz_rat_poly_of_int_to_poly_for_coppersmith(ratIntP, 

                                                        precision, 

        basisConstructionsFullTime        += cputime(basisConstructionTime)

        basisConstructionsCount           += 1

        reductionTime                     = cputime()

        ccReducedPolynomialsList =  \

            slz_compute_coppersmith_reduced_polynomials(intIntP, 

                                                        alpha, 

        #### We have at least two polynomials.

        #    Let us try to compute resultants.

        #    For each resultant computed, go for the solutions.

        ##### Build the pairs list.

        polyPairsList           = []

        for polyOuterIndex in xrange(0, len(ccReducedPolynomialsList) - 1):

                                         len(ccReducedPolynomialsList)):

                polyPairsList.append((ccReducedPolynomialsList[polyOuterIndex],

                                      ccReducedPolynomialsList[polyInnerIndex]))

        for polyPair in polyPairsList:

            resultantsComputationsFullTime += cputime(resultantsComputationTime)

            resultantsComputationsCount    += 1

                hasNonNullResultant = True

            if currentResultant.degree() < 1:

                print "Resultant is constant:", currentResultant

            ##### Compute i roots

            iRootsList = Zi(currentResultant).roots()

            for iRoot in iRootsList:

                ####### Roots returned by roots() are (value, multiplicity) 

                #       tuples.

                #print "iRoot:", iRoot

                ###### Use the tRoot against each polynomial, alternatively.

                    ####### If the polynomial is univariate, just drop it.

                    if len(currentPolynomial.variables()) < 2:

                        print "    Current polynomial is not in two variables."

                    tRootsList = \

                        Zt(currentPolynomial.subs({currentPolynomial.variables()[0]:iRoot[0]})).roots()

                    ####### The tRootsList can be empty, hence the test.

                    if len(tRootsList) == 0:

                        print "    No t root."

                    for tRoot in tRootsList:

        intervalResultsList = []

        intervalResultsList.append((lb, ub))

        #### Check roots.

        rootsResultsList = []

            specificRootResultsList = []

            failingBounds = []

            intIntPdivN = intIntP(root[0], root[1]) / N

                specificRootResultsList.append(hardToRoundCaseAsFloat.n().str(base=2))

                # Check the root is in the bounds

                if abs(root[0]) > iBound or abs(root[1]) > tBound:

                    if abs(root[0]) > iBound:

                        print "root[0]:", root[0]

                        print "i bound:", iBound

                rootsResultsList.append(specificRootResultsList)

        if len(rootsResultsList) > 0:

            intervalResultsList.append(rootsResultsList)

        #### An intervalResultsList has at least the bounds.

        globalResultsList.append(intervalResultsList)   

        #### Compute an incremented width for next upper bound, only