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

    return(sollya_lib_absolute(None))

def pobyso_autoprint(arg):

def pobyso_autoprint_so_so(arg):

    sollya_lib_autoprint(arg,None)

    ## Precision. If a precision is given, convert the polynomial

    #  into the right polynomial field. If not convert it straight

    #  to Sollya.

        precSa = polySa.parent().base_ring().precision()

    ## Get exponents and coefficients.

    ## Build the polynomial.

    polySo = None

    for coefficientSa, exponentSa in zip(coefficientsSa, exponentsSa):

        monomialSo = sollya_lib_build_function_pow(

                       sollya_lib_build_function_free_variable(),

                       exponentSo)

        if polySo is None:

        else:

            polySo = sollya_lib_build_function_add(polySo, polyTermSo)

    return polySo

# End pobyso_float_poly_sa_so    

def pobyso_float_poly_so_sa(polySo, realFieldSa=None):

    """

    Convert a Sollya polynomial into a Sage floating-point polynomial.

    If no realField is given, a RealField corresponding to the maximum 

    precision of the coefficients is internally computed.

    The real field is not returned but can be easily retrieved from 

    - (optional) compute the RealField of the coefficients;

    - convert the Sollya expression into a Sage expression;

    - convert the Sage expression into a Sage polynomial

    """    

    if realFieldSa is None:

        expressionPrecSa = pobyso_get_max_prec_of_exp_so_sa(polySo)

        realFieldSa      = RealField(expressionPrecSa)

    #print "Sollya expression before...",

    #pobyso_autoprint(polySo)

    expressionSa = pobyso_get_sage_exp_from_sollya_exp_so_sa(polySo,

                                                             realFieldSa)

    #pobyso_autoprint(polySo)

    polyVariableSa = expressionSa.variables()[0]

    polyRingSa     = realFieldSa[str(polyVariableSa)]

    The precision of the floating-point number returned is that of the Sollya

    constant.

    """

    precisionSa  = pobyso_get_prec_of_constant_so_sa(constExpSo)

    ## If the expression can not be exactly converted, None is returned.

    #  In this case opt for the Sollya current expression.

    if precisionSa is None:

def pobyso_get_head_function_so_sa(expressionSo):

    functionType = c_int(0)

    return int(functionType.value)

def pobyso_get_interval_from_range_so_sa(soRange, realIntervalFieldSa = None ):

    Tries to find a precision to represent ctExpSo without rounding.

    If not possible, returns None.

    """

    prec = c_int(0)

    retc = sollya_lib_get_prec_of_constant(byref(prec), ctExpSo, None)

    if retc == 0:

        return None

    return int(prec.value)

def pobyso_get_prec_of_range_so_sa(rangeSo):

        #print "This is a constant"

        return pobyso_get_constant_as_rn_with_rf_so_sa(sollyaExpSo, realFieldSa)

    elif operatorSa == SOLLYA_BASE_FUNC_FREE_VARIABLE:

        return eval(sollyaLibFreeVariableName)

    else:

        print "Unexpected"

                                                           maxPrecSo,

                                                           maxErrSo):

    print "Input arguments:"

    ## Higher order function see: 

    #  http://effbot.org/pyfaq/how-do-you-make-a-higher-order-function-in-python.htm

    #

    degreeSa        = pobyso_polynomial_degree_so_sa(polySo)

    ratio           = precision_decay_ratio_function(degreeSa)

    itpSa           = pobyso_constant_from_int_so_sa(itpSo)

    ftpSa           = pobyso_constant_from_int_so_sa(ftpSo)

    maxPrecSa       = pobyso_constant_from_int_so_sa(maxPrecSo)

    maxErrSa        = pobyso_get_constant_as_rn_so_sa(maxErrSo)

    lastResPolySo   = None

    while True: 

        pDeltaSa    = ftpSa - itpSa

        for indexSa in reversed(xrange(0,degreeSa+1)):

            indexSo = pobyso_constant_from_int_sa_so(indexSa)

            #pobyso_autoprint(indexSo)

            #print ratio(indexSa)

            #pobyso_autoprint(cmonrSo)

            resPolySo = sollya_lib_build_function_add(resPolySo,

                                                      cmonrSo)

        # End for index

        freeVarSo     = sollya_lib_build_function_free_variable()

        changeVarSo   = sollya_lib_sub(freeVarSo, icSo)

        resPolyCvSo   = sollya_lib_evaluate(resPolySo, changeVarSo)

        cerrSa    = pobyso_get_constant_as_rn_so_sa(infNormSo)

        if (cerrSa > maxErrSa):

            print "Error is too large."

                print "Enlarging prec."

                ntpSa = floor(ftpSa + ftpSa/50)

                ## Can't enlarge (numerical)

                if ntpSa == ftpSa:

                    sollya_lib_clear_obj(resPolySo)

                    return None

                ## Can't enlarge (not enough precision left)

                if ntpSa > maxPrecSa:

                    sollya_lib_clear_obj(resPolySo)

                    return None

                ftpSa = ntpSa

                continue

            ## One enlargement took place.

            else:

                sollya_lib_clear_obj(resPolySo)

        else:

                if not lastResPolySo is None:

                    sollya_lib_clear_obj(lastResPolySo)

                if not lastResPolySo is None:

                    sollya_lib_clear_obj(lastResPolySo)

    # End wile True

    return None

# End pobyso_polynomial_coefficients_progressive_truncate_so_so.