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

                                                        degreeSo,

                                                        lb,

                                                        ub,

        if debug:

            print "Approximation polynomial computed."

        if prceSo is None:

#

def slz_compute_polynomial_and_interval(functionSo, degreeSo, lowerBoundSa, 

                                        upperBoundSa, approxAccurSa, 

    """

    Under the assumptions listed for slz_get_intervals_and_polynomials, compute

    a polynomial that approximates the function on a an interval starting

    precision is reached.

    The polynomial, the bounds, the center of the interval and the error

    are returned.

    OUTPUT:

    A tuple made of 4 Sollya objects:

    - a polynomial;

    - the center of the interval;

    - the maximum error in the approximation of the input functionSo by the

      output polynomial ; this error <= approxAccurSaS.

    """

    #print"In slz_compute_polynomial_and_interval..."

    polynomialsList.append(P_RRR(1/7 + 2/7*i + 3/7*i^2)) 

    RRR         = RealField(1024)

    P_RRR       = RRR[i]

    def test(polynomialsList):

        for polynomial in polynomialsList:

            polySo = pobyso_float_poly_sa_so(polynomial)

        precSo = pobyso_constant_from_int(precSa)

        pobyso_set_prec_so_so(precSo)

        sollya_lib_clear_obj(precSo)

    ## Get exponents and coefficients.

    exponentsSa     = polySa.exponents()

    coefficientsSa  = polySa.coefficients()

            polySo = sollya_lib_build_function_add(polySo, polyTermSo)

    if sollyaPrecChanged:

        pobyso_set_prec_so_so(initialSollyaPrecSo)

    return polySo

# End pobyso_float_poly_sa_so    

def pobyso_rat_poly_sa_so(polySa, precSa = None):

    """

    Create a Sollya polynomial from a Sage rational polynomial.

    """

    ## TODO: filter arguments.

    ## Precision. If no precision is given, use the current precision

    P_RRR = RRR[polySa.variables()[0]]

    polyFloatSa = P_RRR(polySa)

    ## Make sure no precision is provided: pobyso_float_poly_sa_so will

    return pobyso_float_poly_sa_so(polyFloatSa)

# End pobyso_rat_poly_sa_so    

                                                currentApproxErrorSo,

                                                approxAccurSo,

                                                debug=False):

    if debug:

        print "Input arguments:"

        print "Polynomial: ", ; pobyso_autoprint(polySo)

    #  no possible gain.

    if currentApproxErrorSa >= approxAccurSa / 2:

        #### Do not return the initial argument but copies: caller may free 

        return (sollya_lib_copy_obj(polySo),

                sollya_lib_copy_obj(currentApproxErrorSo))

    degreeSa             = pobyso_polynomial_degree_so_sa(polySo)

        print "intervalSa            :", intervalSa.str(style='brackets')

        print "currentApproxErrorSa  :", currentApproxErrorSa 

        print "approxAccurSa         :", approxAccurSa 

    radiusSa = intervalSa.absolute_diameter() / 2

    if debug:

        print "log2(radius):", RR(radiusSa).log2()

    iterIndex = 0

    while True: 

        resPolySo = pobyso_constant_0_sa_so()

        roundedPolyApproxAccurSa = approxAccurSa / 2

        currentRadiusPowerSa = 1 

            else:

                roundingPowerSa = \

                    floor(((currentRadiusPowerSa/roundedPolyApproxAccurSa)*(degreeSa+1)).log2())

            if roundingPowerSa < 2:

                roundingPowerSa = 2

            if debug:

                #    free the former as inutile after call.

                return (sollya_lib_copy_obj(polySo), 

                        sollya_lib_copy_obj(currentApproxErrorSo))

                sollya_lib_clear_obj(resPolySo)

                sollya_lib_clear_obj(infNormSo)

                iterIndex += 1

    """

    Compute the Taylor expansion without the variable change

    x -> x-intervalCenter.

    """

    # Change internal Sollya precision, if needed.

    (initialSollyaPrecSo, initialSollyaPrecSa) = pobyso_get_prec_so_so_sa()

    taylorFormSo = sollya_lib_taylorform(functionSo, degreeSo,

                                         intervalCenterSo,

                                         rangeSo, errorTypeSo, None)

    # pobyso_get_list_elements_so_so clears taylorFormSo.

    (taylorFormListSaSo, numElementsSa, isEndEllipticSa) = \

        pobyso_get_list_elements_so_so(taylorFormSo)

    polySo = sollya_lib_copy_obj(taylorFormListSaSo[0])

    #print "Num elements:", numElementsSa

    sollya_lib_clear_obj(taylorFormSo)

    # No copy_obj needed here: a new objects are created.

    absMaxErrorSo = sollya_lib_abs(maxErrorSo)

    absMinErrorSo = sollya_lib_abs(minErrorSo)

    sollya_lib_clear_obj(maxErrorSo)

    sollya_lib_clear_obj(minErrorSo)

    absMaxErrorSa = pobyso_get_constant_as_rn_so_sa(absMaxErrorSo)

    absMinErrorSa = pobyso_get_constant_as_rn_so_sa(absMinErrorSo)

    if sollyaPrecChanged:

        sollya_lib_set_prec(initialSollyaPrecSo)

    sollya_lib_clear_obj(initialSollyaPrecSo)

    if absMaxErrorSa > absMinErrorSa:

        sollya_lib_clear_obj(absMinErrorSo)

        return (polySo, intervalCenterSo, absMaxErrorSo)

    taylorFormSo = sollya_lib_taylorform(functionSo, degreeSo, \

                                         intervalCenterSo, \

                                         rangeSo, errorTypeSo, None)

    # pobyso_get_list_elements_so_so clears taylorFormSo.

        pobyso_get_list_elements_so_so(taylorFormSo)

    absMaxErrorSo = sollya_lib_abs(maxErrorSo)

    absMinErrorSo = sollya_lib_abs(minErrorSo)

    sollya_lib_clear_obj(maxErrorSo)

                       sollya_lib_build_function_free_variable(),\

                       sollya_lib_copy_obj(intervalCenterSo))

    polyVarChangedSo = sollya_lib_evaluate(polySo, changeVarExpSo)

    sollya_lib_clear_obj(changeVarExpSo)

    # If changed, reset the Sollya working precision.

    if sollyaPrecChanged:

    sollya_lib_clear_obj(initialSollyaPrecSo)

    if errorTypeIsNone:

        sollya_lib_clear_obj(errorTypeSo)

    # Do not clear maxErrorSo.

    if absMaxErrorSa > absMinErrorSa:

        sollya_lib_clear_obj(absMinErrorSo)