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

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<?eclipse-pydev version="1.0"?><pydev_project>

<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>

<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property>

</pydev_project>

print "\nSuperficial pobyso check..."    

def pobyso_get_constant_as_rn_so_sa(constExpSo):

    precisionSa  = pobyso_get_prec_of_constant(constExpSo) 

    RRRR = RealField(precisionSa)

    rnSa = RRRR(0)

    sollya_lib_get_constant(get_rn_value(rnSa), constExpSo)

    return(rnSa)

def pobyso_get_constant_as_rn_with_rf_so_sa(ctExpSo, realFieldSa = None):

    if realFieldSa is None:

        sollyaPrecSa = pobyso_get_prec_so_sa()

        realFieldSa = RealField(sollyaPrecSa)

    rnSa = realFieldSa(0)

    sollya_lib_get_constant(get_rn_value(rnSa), ctExpSo)

    return(rnSa)

def pobyso_get_interval_from_range_so_sa(soRange, realIntervalFieldSa = None ):

    If no reaInterval lField is passed as argument, the interval bounds are not

    rounded: they are elements of RealIntervalField of the "right" precision

    to hold all the digits.

    if realIntervalFieldSa is None:

        retval = sollya_lib_get_prec_of_range(byref(prec), soRange, None)

        if retval == 0:

            return(None)

        realIntervalFieldSa = RealIntervalField(prec.value)

    intervalSa = realIntervalFieldSa(0,0)

# End pobyso_get_interval_from_range_so_sa

    precSo = sollya_lib_get_prec(None)

    precSa = c_int(0)

    sollya_lib_get_constant_as_int(byref(precSa), precSo)

    sollya_lib_clear_obj(precSo)

    return(int(precSa.value))

def pobyso_get_prec_of_constant_so_sa(ctExpSo):

    prec = c_int(0)

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

    if retc == 0:

        return(None)

    return(int(prec.value))

    if retc == 0:

        return(None)

def pobyso_range_sa_so(rnLowerBoundSa, rnUpperBoundSa):

    """

    Return a Sollya range from to 2 RealField elements.

    The Sollya range element has a sufficient precision to hold all

    the digits of the bounds.

    """

    # TODO: check the bounds.

    lbPrec = rnLowerBoundSa.parent().precision()

    ubPrec = rnLowerBoundSa.parent().precision()

    currentSollyaPrecSa = pobyso_get_prec_so_sa()

    maxPrecSa = max(lbPrec, ubPrec, currentSollyaPrecSa)

    # Change the current Sollya precision only if necessary.

    if maxPrecSa > currentSollyaPrecSa:

        currentPrecSo = sollya_lib_get_prec(None)

        newPrecSo = solly_lib_constant_from_uint64(maxPrecSa)

        sollya_lib_set_prec(newPrecSo)

    lowerBoundSo = sollya_lib_constant(get_rn_value(rnLowerBoundSa))

    upperBoundSo = sollya_lib_constant(get_rn_value(rnUpperBoundSa))

    currentPrecSo = sollya_lib_get_prec(None)

    if maxPrecSa > currentSollyaPrecSa:

        sollya_lib_set_prec(currentPrecSo)

        sollya_lib_clear_obj(currentPrecSo)

        sollya_lib_clear_obj(newPrecSo)

    sollya_lib_clear_obj(lowerBoundSo)

    sollya_lib_clear_obj(upperBoundSo)

def pobyso_range_so_sa(rangeSo, realIntervalField = None):

    if realIntervalField is None:

        precSa = pobyso_get_prec_of_range_so_sa(rangeSo)

        realIntervalField = RealIntervalField(precSa)

    intervalSa = \

        pobyso_get_interval_from_range_so_sa(rangeSo, realIntervalField) 

    return(intervalSa)

def pobyso_taylor_expansion_no_change_var_so_so(functionSo, degreeSo, rangeSo, \

                                                errorTypeSo, \

                                                sollyaPrecSo=None):

    # No global change of the working precision.

    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)

    (taylorFormListSo, numElements, isEndElliptic) = \

        pobyso_get_list_elements_so_so(taylorFormSo)

    polySo = taylorFormListSo[0]

    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(initailPrecSo)

    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))

print "Function None (44) as a string: ", pobyso_function_type_as_string(44)

print "...Pobyso check done"

        sollya_lib_inf = sollya.sollya_lib_inf

        sollya_lib_sup = sollya.sollya_lib_sup

print "\nSuperficial Sollya library check..."

print "...Sollya library check done."