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

    print "\t...", functionName, "done."

def test_pobyso_guess_degree_sa_sa(repeat=1000, number=10):

    functionName = inspect.stack()[0][3]

    print "Running", functionName, "..."

    funcExpSa(x) = exp(x)

    RRIF = RealIntervalField(113)

    intervalSa = RRIF(3/8 - 2^-68, 3/8 + 2^-68)

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

    errorSa = RR(2^-227)

    weightSa(x) = 1

    degreeBoundSa = 150

    # Function definition

    def test():

        pobyso_guess_degree_sa_sa(funcExpSa, 

                                  intervalSa, 

                                  errorSa, 

                                  weightSa, 

                                  degreeBoundSa)

    wrapped = test_pobyso_wrapper(test)

    timing = min(timeit.repeat(wrapped, repeat=repeat, number=number))

    print "\t...", functionName, "done."

    return timing

# End test_pobyso_guess_degree_sa_sa

def test_pobyso_guess_degree_so_sa(repeat=1000, number=10):

    functionName = inspect.stack()[0][3]

    print "Running", functionName, "..."

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

    errorSo = pobyso_constant_sa_so(RR(2^-227))

    weightSo=pobyso_parse_string_sa_so("1")

    degreeBoundSo = pobyso_constant_from_int_sa_so(150)

    # Function definition

    def test():

        pobyso_guess_degree_so_sa(funcExpSo, 

                                  intervalSo, 

                                  errorSo, 

                                  weightSo, 

                                  degreeBoundSo)

    wrapped = test_pobyso_wrapper(test)

    timing = min(timeit.repeat(wrapped, repeat=repeat, number=number))

    print "\t...", functionName, "done."

    sollya_lib_clear_obj(funcExpSo)

    sollya_lib_clear_obj(intervalSo)

    sollya_lib_clear_obj(errorSo)

    sollya_lib_clear_obj(weightSo)

    sollya_lib_clear_obj(degreeBoundSo)

    return timing

# End test_pobyso_guess_degree_so_sa

    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