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

pobyso_max_arity = 9

def pobyso_autoprint(arg):

    sollya_lib_autoprint(arg,None)

def pobyso_autoprint_so_so(arg):

    sollya_lib_autoprint(arg,None)

def pobyso_bounds_to_range_sa_so(rnLowerBoundSa, rnUpperBoundSa, \

                                 precisionSa=None):

    """

    # Sanity check.

    if rnLowerBoundSa > rnUpperBoundSa:

        return None

        # Check for the largest precision.

        lbPrecSa = rnLowerBoundSa.parent().precision()

        ubPrecSa = rnLowerBoundSa.parent().precision()

def pobyso_build_function_sub_so_so(exp1So, exp2So):

    return(sollya_lib_build_function_sub(exp1So, exp2So))

    """

    Compare the MPFR value a RealNumber with that of a Sollya constant.

    Get the value of the Sollya constant into a RealNumber and compare

    """

    precisionOfCte = c_int(0)

    # From the Sollya constant, create a local Sage RealNumber.

    #print "Precision of constant: ", precisionOfCte

    RRRR = RealField(precisionOfCte.value)

    # Compare the local Sage RealNumber with rnArg.

# End pobyso_smp

def pobyso_compute_pos_function_abs_val_bounds_sa_sa(funcSa, lowerBoundSa, \

                                                     upperBoundSa):

    """

    """

    funcSo = pobyso_parse_string(funcSa._assume_str())

    rangeSo = pobyso_range_sa_so(lowerBoundSa, upperBoundSa)

    infnormSo = pobyso_infnorm_so_so(funcSo,rangeSo)

    infnormSo = pobyso_infnorm_so_so(funcAuxSo,rangeSo)

    fMinSa = pobyso_get_interval_from_range_so_sa(infnormSo)

    sollya_lib_clear_obj(infnormSo)

    # Compute the maximum of the precisions of the different bounds.

    maxPrecSa = max([fMinLowerBoundSa.parent().precision(), \

                     fMaxUpperBoundSa.parent().precision()])

    # Precision stuff

    if precisionSa is None:

        precisionSa = rnArgSa.parent().precision()

    if precisionSa > currentSollyaPrecisionSa:

        pobyso_set_prec_sa_so(precisionSa)

        constantSo = sollya_lib_constant(get_rn_value(rnArgSa))

        pobyso_set_prec_sa_so(currentSollyaPrecision)

    else:

        constantSo = sollya_lib_constant(get_rn_value(rnArgSa))

    return(constantSo)

def pobyso_constant_0_sa_so():

    else:

        return None

    """ Legacy function. See pobyso_get_constant_so_sa. """

def pobyso_get_constant_so_sa(rnArgSa, constSo):

    """

    rnArg must already exist and belong to some RealField.

    """

    return(sollya_lib_get_constant(get_rn_value(rnArgSa), constSo))

    """

    Get a Sollya constant as a Sage "real number".

    If no real field is specified, the precision of the floating-point number 

    Otherwise is is that of the real field. Hence rounding may happen.

    """

    if realFieldSa is None:

        realFieldSa = RealField(sollyaPrecSa)

    rnSa = realFieldSa(0)

    sollya_lib_get_constant(get_rn_value(rnSa), ctExpSo)

    """ Legacy function. See pobyso_get_list_elements_so_so. """

    return(pobyso_get_list_elements_so_so(soObj))

    """

    Get the list elements as a Sage/Python array of Sollya objects.

    """

    listAddress = POINTER(c_longlong)()

    numElements = c_int(0)

    result = sollya_lib_get_list_elements(byref(listAddress),\

                                          byref(numElements),\

                                          byref(isEndElliptic),\

    if result == 0 :

        return None

    for i in xrange(0, numElements.value, 1):

    return(listAsList, numElements.value, isEndElliptic.value)

def pobyso_get_max_prec_of_exp(soExp):

    """ Legacy function. See pobyso_get_max_prec_of_exp_so_sa. """

    return(pobyso_get_max_prec_of_exp_so_sa(soExp))

    """

    Get the maximum precision used for the numbers in a Sollya expression.

    maxPrecision = 0

    minConstPrec = 0

    currentConstPrec = 0

    if (operator != SOLLYA_BASE_FUNC_CONSTANT) and \

    (operator != SOLLYA_BASE_FUNC_FREE_VARIABLE):

        for i in xrange(arity):

            maxPrecisionCandidate = \

                pobyso_get_max_prec_of_exp_so_sa(subexpressions[i])

                maxPrecision = maxPrecisionCandidate

        return(maxPrecision)

    elif operator == SOLLYA_BASE_FUNC_CONSTANT:

        #currentConstPrec = pobyso_get_min_prec_of_constant_so_sa(soExp)

        #print minConstPrec, " - ", currentConstPrec 

    elif operator == SOLLYA_BASE_FUNC_FREE_VARIABLE:

        return(0)

        print "pobyso_get_max_prec_of_exp_so_sa: unexepected operator."

        return(0)

    """

    Get the minimum precision necessary to represent the value of a Sollya

    constant.

    MPFR_MIN_PREC and powers of 2 are taken into account.

    """

    """ Legacy function. See pobyso_get_sage_exp_from_sollya_exp_so_sa. """

    """

    Get a Sage expression from a Sollya expression. 

    Currently only tested with polynomials with floating-point coefficients.

    Notice that, in the returned polynomial, the exponents are RealNumbers.

    """

    #pobyso_autoprint(sollyaExp)

    sollyaLibFreeVariableName = sollya_lib_get_free_variable_name()

    # Constants and the free variable are special cases.

    # All other operator are dealt with in the same way.

            # We do not get through the preprocessor.

            # The "^" operator is then a special case.

            else:

        # We do not know yet how to deal with arity >= 3 

        # (is there any in Sollya anyway?).

        else:

        #print "This is a constant"

        #print "This is free variable"

        return(eval(sollyaLibFreeVariableName))

    else:

def pobyso_lib_init():

    sollya_lib_init(None)

    """ Legacy function. See pobyso_name_free_variable_sa_so. """

    """

    Set the free variable name in Sollya from a Sage string.

    """

def pobyso_parse_string(string):

    """ Legacy function. See pobyso_parse_string_sa_so. """

    return(pobyso_range_sa_so(rnLowerBound, rnUpperBound)) 

    """

    Get a Sage interval from a Sollya range.

    If no realIntervalField is given as a parameter, the Sage interval

    precision is that of the Sollya range.

    """

        precSa = pobyso_get_prec_of_range_so_sa(rangeSo)

    intervalSa = \

    return(intervalSa)

def pobyso_remez_canonical_sa_sa(func, \

                                 degree, \

                                 lowerBound, \

                                 upperBound, \

    # String test

    if parent(func) == parent("string"):

        functionSa = eval(func)

    if polySo is None:

        return(None)

    maxPrecision = pobyso_get_max_prec_of_exp_so_sa(polySo)

    sollya_lib_clear_obj(polySo)

    return(polySa)

def pobyso_remez_canonical(func, \

                           degree, \

    """

    var('zorglub')    # Dummy variable name for type check only. Type of

    # zorglub is "symbolic expression".

    # The func argument can be of different types (string, 

    # symbolic expression...)

    if parent(func) == parent("string"):

    # Expression test.

    elif type(func) == type(zorglub):

        # Until we are able to translate Sage expressions into Sollya 

        # expressions : parse the string version.

    else:

        return(None)

        weightSo = pobyso_constant_1_sa_so()

        weightSo = sollya_lib_parse_string(func)

        functionSo = sollya_lib_parse_string_sa_so(weight._assume_str())

    else:

        return(None)

    degreeSo = pobyso_constant_from_int(degree)

    if not quality is None:

        qualitySo= pobyso_constant_sa_so(quality)

    else:

    sollya_lib_clear_obj(rangeSo)

    sollya_lib_clear_obj(weightSo)

    if not qualitySo is None:

    return(remezPolySo)

# End pobyso_remez_canonical_sa_so

def pobyso_set_prec(p):

    """ Legacy function. See pobyso_set_prec_sa_so. """

def pobyso_set_prec_sa_so(p):

    a = c_int(p)

    precSo = c_void_p(sollya_lib_constant_from_int(a))

    """

    Compute the Taylor expansion with the variable change

    x -> (x-intervalCenter) included.

    """

        initialPrecSo = sollya_lib_get_prec(None)

        sollya_lib_set_prec(sollyaPrecSo)

    #

    intervalCenterSo = sollya_lib_mid(rangeSo)

    taylorFormSo = sollya_lib_taylorform(functionSo, degreeSo, \

                                         intervalCenterSo, \

    if not sollyaPrecSo is None:

        sollya_lib_set_prec(initialPrecSo)

        sollya_lib_clear_obj(initialPrecSo)

    return((polyVarChangedSo, intervalCenterSo, maxErrorSo))

# end pobyso_taylor_expansion_with_change_var_so_so

def pobyso_taylor_expansion_no_change_var_so_so(functionSo, degreeSo, rangeSo, \

                                                sollyaPrecSo=None):

    """

    Compute the Taylor expansion without the variable change

    if not sollyaPrecSo is None:

        initialPrecSo = sollya_lib_get_prec(None)

        sollya_lib_set_prec(sollyaPrecSo)

    intervalCenterSo = sollya_lib_mid(rangeSo)

    taylorFormSo = sollya_lib_taylorform(functionSo, degreeSo, \

                                         intervalCenterSo, \

                                         rangeSo, errorTypeSo, None)

        pobyso_get_list_elements_so_so(taylorFormSo)

    errorRangeSo = taylorFormListSo[2]

    maxErrorSo = sollya_lib_sup(errorRangeSo)

    # If changed, reset the Sollya working precision.

    if not sollyaPrecSo is None:

        sollya_lib_set_prec(initialPrecSo)

        sollya_lib_clear_obj(initialPrecSo)

    return((polySo, intervalCenterSo, maxErrorSo))

# end pobyso_taylor_expansion_no_change_var_so_so

def pobyso_taylor_so_so(functionSo, degreeSo, pointSo):

    return(sollya_lib_taylor(functionSo, degreeSo, pointSo))

def pobyso_taylorform_sa_sa(functionSa, \

                            degreeSa, \

                            errorTypeSa=None, \

                            precisionSa=None):

    """

    point: must be a Real or a Real interval.

    return the Taylor form as an array

    TODO: take care of the interval and of the point when it is an interval;

            pobyso_set_prec_sa_so(precisionSa)

            precisionChangedSa = True

    # In any case (point or interval) the parent of pointSa has a precision

    # method.

    pointPrecSa = pointSa.parent().precision()

    taylorFormSo = \

        sollya_lib_taylorform(functionSo, degreeSo, pointSo, errorTypeSo,\

                                         None)

    (tfsAsList, numElements, isEndElliptic) = \

            pobyso_get_list_elements_so_so(taylorFormSo)

    polySo = tfsAsList[0]

    if precisionChangedSa:

        sollya_lib_set_prec(currentSollyaPrecSo)

        sollya_lib_clear_obj(currentSollyaPrecSo)

    polynomialRing = polyRealField[str(varSa)]

    polySa = polynomial(expSa, polynomialRing)

    taylorFormSa = [polySa]

    return(taylorFormSa)

# End pobyso_taylor_form_sa_sa

        sollya_lib_infnorm = sollya.sollya_lib_infnorm

        sollya_lib_init= sollya.sollya_lib_init

        sollya_lib_is_absolute = sollya.sollya_lib_is_absolute

        sollya_lib_mid = sollya.sollya_lib_mid

        sollya_lib_name_free_variable = \

            sollya.sollya_lib_name_free_variable

        sollya_lib_obj_is_function = sollya.sollya_lib_obj_is_function

        sollya_lib_obj_is_list = sollya.sollya_lib_obj_is_list

        sollya_lib_obj_is_error = sollya.sollya_lib_obj_is_error

        sollya_lib_obj_is_range = sollya.sollya_lib_obj_is_range

        sollya_lib_obj_is_structure = sollya.sollya_lib_obj_is_structure

        sollya_lib_off = sollya.sollya_lib_off

        sollya_lib_clear_obj(polySo)

        currentRangeSo = pobyso_bounds_to_range_sa_so(currentLowerBoundSa, 

                                                      currentUpperBoundSa)

        (polySo, intervalCenterSo, maxErrorSo) = \

            pobyso_taylor_expansion_no_change_var_so_so(functionSo, degreeSo, 

                                                        currentRangeSo, 

                                                        absoluteErrorTypeSo)

        #maxErrorSa = pobyso_get_constant_as_rn_with_rf_so_sa(maxErrorSo, RRR)

        maxErrorSa = pobyso_get_constant_as_rn_with_rf_so_sa(maxErrorSo)

    sollya_lib_clear_obj(absoluteErrorTypeSo)

    return((polySo, currentRangeSo, intervalCenterSo, maxErrorSo))

# End slz_compute_polynomial_and_interval

    - the center, x0, of the interval;

    - the corresponding approximation error.

    """

    x = functionSa.variables()[0] # Actual variable name can be anything.

    (fff, scaledLowerBoundSa, scaledUpperBoundSa, \

            scaledLowerBoundImageSa, scaledUpperBoundImageSa) = \

                            boundsSa.endpoints()[1] + \

                            (boundsSa.endpoints()[1] - boundsSa.endpoints()[0]) \

                             * currentErrorRatio.log2() * 2

        if currentScaledUpperBoundSa > scaledUpperBoundSa:

            currentScaledUpperBoundSa = scaledUpperBoundSa

    sollya_lib_clear_obj(functionSo)

    sollya_lib_clear_obj(degreeSo)

    sollya_lib_clear_obj(scaledBoundsSo)

    return(resultArray)

# End slz_get_intervals_and_polynomials