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

    lowerBoundSo = sollya_lib_constant(get_rn_value(rnLowerBoundSa),

                                       maxPrecSa)

    upperBoundSo = sollya_lib_constant(get_rn_value(rnUpperBoundSa),

                                       maxPrecSa)

    return rangeSo

        pobyso_set_prec_so_so(currentSollyaPrecisionSo)

    return constantSo

    return int(precSa.value)

def pobyso_guess_degree_sa_sa(functionSa, intervalSa, errorSa, weightSa=None, \

                              degreeBoundSa=None):

    functionAsStringSa = functionSa._assume_str()

    functionSo = pobyso_parse_string_sa_so(functionAsStringSa)

    rangeSo = pobyso_interval_to_range_sa_so(intervalSa)

    errorSo = pobyso_constant_sa_so(errorSa)

    if not weightSa is None:

        weightAsStringSa = weightSa._assume_str()

        weightSo = pobyso_parse_string_sa_so(weightAsStringSa)

    else:

        weightSo = None

    if not degreeBoundSa is None:

        degreeBoundSo = pobyso_constant_from_int_sa_so(degreeBoundSa)

    else:

        degreeBoundSo = None

    guessedDegreeSa = pobyso_guess_degree_so_sa(functionSo,

                                              rangeSo,

                                              errorSo,

                                              weightSo,

                                              degreeBoundSo)

    sollya_lib_clear_obj(functionSo)

    sollya_lib_clear_obj(rangeSo)

    sollya_lib_clear_obj(errorSo)

    if not weightSo is None:

        sollya_lib_clear_obj(weightSo)

    if not degreeBoundSo is None:

        sollya_lib_clear_obj(degreeBoundSo)

    return guessedDegreeSa

# End poyso_guess_degree_sa_sa

                              degreeBoundSo=None):

    """

    Thin wrapper around the guessdegree function.

    Nevertheless, some precision control stuff has been appended.

    """

    # Deal with Sollya internal precision issues: if it is too small, 

    # compared with the error, increases it to about twice -log2(error).

    errorSa = pobyso_get_constant_as_rn_with_rf_so_sa(errorSo)

    log2ErrorSa = errorSa.log2()

    if log2ErrorSa < 0:

        neededPrecisionSa = int(2 * int(-log2ErrorSa) / 64) * 64

    else:

        neededPrecisionSa = int(2 * int(log2ErrorSa) / 64) * 64

    #print "Needed precision:", neededPrecisionSa

    currentPrecSa = pobyso_get_prec_so_sa()

    if neededPrecisionSa > currentPrecSa:

        currentPrecSo = pobyso_get_prec_so()

        pobyso_set_prec_sa_so(neededPrecisionSa)

        degreeRangeSo = sollya_lib_guessdegree(functionSo, rangeSo, errorSo, None)

    elif degreeBoundSo is None:

                                                errorSo, weightSo, None)

                                                weightSo, degreeBoundSo, None)

    # Restore internal precision, if applicable.

    if neededPrecisionSa > currentPrecSa:

        pobyso_set_prec_so_so(currentPrecSo)

        sollya_lib_clear_obj(currentPrecSo)

    degreeIntervalSa = pobyso_range_to_interval_so_sa(degreeRangeSo)

    sollya_lib_clear_obj(degreeRangeSo)

    # When ok, both bounds match.

    # When the degree bound is too low, the upper bound is the degree

    # for which the error can be honored.

    # When it really goes wrong, the upper bound is infinity. 

    if degreeIntervalSa.lower() == degreeIntervalSa.upper():

        return int(degreeIntervalSa.lower())

    else:

        if degreeIntervalSa.upper().is_infinity():

            return None

        else:

            return int(degreeIntervalSa.upper())

    # End pobyso_guess_degree_so_sa