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

def cvp_polynomial_error_func_maxis(funcSa,

                                    polySa, 

                                    lowerBoundSa, 

                                    upperBoundSa,

                                    realField = None,

                                    contFracMaxErr = None):

    """

    For a given function, approximation polynomial and interval (given 

    as bounds) compute the maxima of the functSa - polySo on the interval.

    Also computes the infnorm of the error function.

    """

    ## Arguments check.

    # @todo.

    ## If no realField argument is given try to retrieve it from the 

    #  bounds. If impossible (e.g. rational bound), fall back on RR. 

    if realField is None:

        try:

            ### Force failure if parent does not have prec() member.

            lowerBound.parent().prec()

            ### If no exception is thrown, set realField.

            realField = lowerBound.parent()

        except:

            realField = RR

    #print "Real field:", realField

    ## Compute the Sollya version of the function.

    funcAsStringSa = funcSa._assume_str().replace("_SAGE_VAR_","",100)

    funcSo  = pobyso_parse_string(funcAsStringSa)

    if pobyso_is_error_so_sa(funcSo):

        pobyso_clear_obj(funcSo)

        return None

    ## Compute the Sollya version of the polynomial.

    ## The conversion is made from a floating-point coefficients polynomial.

    try:

        polySa.base_ring().prec()

        convFloatPolySa = polySa

    except:

        convFloatPolySa = realField[polySa.variables()[0]](polySa)

    polySo = pobyso_float_poly_sa_so(convFloatPolySa)

    if pobyso_is_error_so_sa(funcSo):

        pobyso_clear_obj(funcSo)

        pobyso_clear_obj(polySo)

        return None

    ## Copy both funcSo and polySo as they are needed later for the infnorm..

    errorFuncSo = sollya_lib_build_function_sub(sollya_lib_copy_obj(funcSo), 

                                                sollya_lib_copy_obj(polySo))

    if pobyso_is_error_so_sa(errorFuncSo):

        pobyso_clear_obj(errorFuncSo)

        return None

    ## Compute the derivative.

    diffErrorFuncSo = pobyso_diff_so_so(errorFuncSo)

    pobyso_clear_obj(errorFuncSo)

    if pobyso_is_error_so_sa(diffErrorFuncSo):

        pobyso_clear_obj(diffErrorFuncSo)

        return None

    ## Compute the interval.

    intervalSo = pobyso_range_from_bounds_sa_so(lowerBound, upperBound)

    if pobyso_is_error_so_sa(intervalSo):

        pobyso_clear_obj(diffErrorFuncSo)

        pobyso_clear_obj(intervalSo)

        return None

    ## Compute the infnorm of the error function.

    errFuncSupNormSa = pobyso_supnorm_so_sa(polySo, 

                                            funcSo, 

                                            intervalSo, 

                                            realFieldSa = realField)

    pobyso_clear_obj(polySo)

    pobyso_clear_obj(funcSo)

    ## Compute the zeros of the derivative.

    errorFuncMaxisSo = pobyso_dirty_find_zeros_so_so(diffErrorFuncSo, intervalSo)

    pobyso_clear_obj(diffErrorFuncSo)

    pobyso_clear_obj(intervalSo)

    if pobyso_is_error_so_sa(errorFuncMaxisSo):

        pobyso_clear_obj(errorFuncMaxisSo)

        return None

    errorFuncMaxisSa = pobyso_float_list_so_sa(errorFuncMaxisSo)

    pobyso_clear_obj(errorFuncMaxisSo)

    ## If required, convert the numbers to rational numbers.

    if not contFracMaxErr is None:

        for index in xrange(0, len(errorFuncMaxisSa)):

            errorFuncMaxisSa[index] = \

                errorFuncMaxisSa[index].nearby_rational(contFracMaxErr)

    return (errorFuncMaxisSa, errFuncSupNormSa)

# End cvp_polynomial_error_func_maxis

#

    errorFuncMaxisSo = pobyso_dirty_find_zeros_so_so(diffErrorFuncSo, intervalSo)

    errorFuncMaxisSa = pobyso_float_list_so_sa(errorFuncMaxisSo)

    pobyso_clear_obj(errorFuncMaxisSo)

    errorFuncMaxisSo = pobyso_dirty_find_zeros_so_so(diffErrorFuncSo, intervalSo)

    errorFuncTruncMaxisSa = pobyso_float_list_so_sa(errorFuncMaxisSo)

    pobyso_clear_obj(errorFuncMaxisSo)

    ## Merge with the first list, removing duplicates if any.

    errorFuncMaxisSa.extend(elem for elem in errorFuncTruncMaxisSa \

                            if elem not in errorFuncMaxisSa)

    errorFuncMaxisSa.sort()

        for index in xrange(0, len(errorFuncMaxisSa)):

            errorFuncMaxisSa[index] = \

                errorFuncMaxisSa[index].nearby_rational(contFracMaxErr)

    return errorFuncMaxisSa