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

@file pobyso.py

    The sollya_lib_constant() function creates a constant

    with the same precision as the source.

    ## Precision stuff. If one wants to change precisions,

    #  everything takes place in Sage. That only makes

    #  sense if one wants to reduce the precision.

    if not precisionSa is None:

        RRR = RealField(precisionSa)

        rnArgSa = RRR(rnArgSa)

    #print rnArgSa, rnArgSa.precision()

    return sollya_lib_constant(get_rn_value(rnArgSa))

def pobyso_constant_from_mpq_sa_so(rationalSa):

    The Sollya constant is an unevaluated expression.

    Hence no precision argument is needed.

    It is better to leave this way since Sollya has its own

    optimized evaluation mecanism that tries very hard to

    return exact values or at least faithful ones.

    return ratExprSo

def pobyso_constant_sollya_prec_sa_so(rnArgSa):

    """

    Create a Sollya constant from a Sage RealNumber at the

    current precision in Sollya.

    """

    currentSollyaPrecSa = pobyso_get_prec_so_sa()

    return pobyso_constant_sa_so(rnArgSa, currentSollyaPrecSa)

# End pobyso_constant_sollya_prec_sa_so

def pobyso_float_poly_sa_so(polySa, precSa = None):

    """

    Create a Sollya polynomial from a Sage RealField polynomial.

    """

    ## TODO: filter arguments.

    ## Precision. If a precision is given, convert the polynomial

    #  into the right polynomial field. If not convert it straight

    #  to Sollya.

    if not precSa is None:

        RRR = RealField(precSa)

        ## Create a Sage polynomial in the "right" precision.

        P_RRR = RRR[polySa.variables()[0]]

        polyFloatSa = P_RRR(polySa)

    else:

        polyFloatSa = polySa

        precSa = polySa.parent().base_ring().precision()

    ## Get exponents and coefficients.

    exponentSa = polyFloatSa.exponents()

    coefficientsSa = polyFloatSa.coefficients()

    ## Build the polynomial.

    polySo = None

    for coefficientSa, exponentSa in zip(coefficientsSa, exponentSa):

        #print coefficientSa.n(prec=precSa), exponentSa

        coefficientSo = \

            pobyso_constant_sa_so(coefficientSa)

        #pobyso_autoprint(coefficientSo)

        exponentSo = \

            pobyso_constant_from_int_sa_so(exponentSa)

        #pobyso_autoprint(exponentSo)

        monomialSo = sollya_lib_build_function_pow(

                       sollya_lib_build_function_free_variable(),

                       exponentSo)

        if polySo is None:

            polySo = sollya_lib_build_function_mul(coefficientSo,

                                                   monomialSo)

        else:

            polyTermSo = sollya_lib_build_function_mul(coefficientSo,

                                                       monomialSo)

            polySo = sollya_lib_build_function_add(polySo, polyTermSo)

    return polySo

# End pobyso_float_poly_sa_so    

def pobyso_float_poly_so_sa(polySo, realFieldSa=None):

    """

    Convert a Sollya polynomial into a Sage floating-point polynomial.

    We assume that the polynomial is in canonical form.

    If no realField is given, a RealField corresponding to the maximum 

    precision of the coefficients is internally computed.

    The real field is not returned but can be easily retrieved from 

    the polynomial itself.

    ALGORITHM:

    - (optional) compute the RealField of the coefficients;

    - convert the Sollya expression into a Sage expression;

    - convert the Sage expression into a Sage polynomial

    TODO: the canonical thing for the polynomial.

    """    

    if realFieldSa is None:

        expressionPrecSa = pobyso_get_max_prec_of_exp_so_sa(polySo)

        realFieldSa      = RealField(expressionPrecSa)

    #print "Sollya expression before...",

    #pobyso_autoprint(polySo)

    expressionSa = pobyso_get_sage_exp_from_sollya_exp_so_sa(polySo,

                                                             realFieldSa)

    #print "...Sollya expression after.",

    #pobyso_autoprint(polySo)

    polyVariableSa = expressionSa.variables()[0]

    polyRingSa     = realFieldSa[str(polyVariableSa)]

    #print polyRingSa

    # Do not use the polynomial(expressionSa, ring=polyRingSa) form!

    polynomialSa = polyRingSa(expressionSa)

    return polynomialSa

# End pobyso_float_poly_so_sa

    return pobyso_get_constant_so_sa(rnArgSa, constSo)

# End pobyso_get_constant

    outcome = sollya_lib_get_constant(get_rn_value(rnArgSa), constSo)

    if outcome == 0: # Failure because constSo is not a constant expression.

        return None

    else:

        return outcome

# End  pobyso_get_constant_so_sa

    precisionSa  = pobyso_get_prec_of_constant_so_sa(constExpSo)

    ## If the expression can not be exactly converted, None is returned.

    #  In this case opt for the Sollya current expression.

    if precisionSa is None:

        precisionSa = pobyso_get_prec_so_sa()

    outcome = sollya_lib_get_constant(get_rn_value(rnSa), constExpSo)

    if outcome == 0:

        return None

    else:

        return rnSa

    return pobyso_get_constant_as_rn_with_rf_so_sa(ctExp, realField)

# End pobyso_get_constant_as_rn_with_rf

        return pobyso_get_constant_as_rn_so_sa(ctExpSo)

    outcome = sollya_lib_get_constant(get_rn_value(rnSa), ctExpSo)

    if outcome == 0:

        return None

    else:

        return rnSa

    return sollya_lib_get_free_variable_name()

    return int(arity.value)

    return int(functionType.value)

            return None

        return None

    return intervalSa

    return pobyso_get_list_elements_so_so(soObj)

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

    return pobyso_get_max_prec_of_exp_so_sa(soExp)

        return maxPrecision

        return pobyso_get_min_prec_of_constant_so_sa(expSo)

        return 0

        return 0

    We assume that constExpSo is a pointer to a Sollay constant expression.

    Legacy function. Use pobyso_float_poly_so_sa() instead.

    return pobyso_float_poly_so_sa(polySo,realField)

    return pobyso_get_prec_so_sa()

    return sollya_lib_get_prec(None)

def pobyso_get_prec_so_so_sa():

    """

    Return the current precision both as a Sollya object and a

    Sage integer as hybrid tuple.

    To avoid multiple calls for precision manipulations. 

    """

    precSo = sollya_lib_get_prec(None)

    precSa = c_int(0)

    sollya_lib_get_constant_as_int(byref(precSa), precSo)

    return (precSo, precSa)

    return pobyso_get_prec_of_constant_so_sa(ctExpSo)

        return None

    return int(prec.value)

    return int(prec.value)

    return pobyso_get_sage_exp_from_sollya_exp_so_sa(sollyaExpSo, 

                                                     realField = RR)

        return sageExpSa

        return eval(sollyaLibFreeVariableName)

    return pobyso_get_subfunctions_so_sa(expressionSo) 

    return (int(arity.value), subs)

    return None

    return intervalSo

    Check whether a Sage number is floating point.

    Exception stuff added because numbers other than

    floating-point ones do not have the is_real() attribute.

    try:

        return numberSa.is_real()

    except AttributeError:

        return False

# End pobyso_is_floating_piont_number_sa_sa

    return pobyso_parse_string_sa_so(string)

    return sollya_lib_parse_string(string)

    """

    Computes the necessary precision to represent a number.

    If x is not zero, it can be uniquely written as x = m · 2e 

    where m is an odd integer and e is an integer. 

    precision(x) returns the number of bits necessary to write m 

    in binary (i.e. ceil(log2(m))).

    """

    #TODO: take care of the special case: 0, @NaN@, @Inf@

    return pobyso_range_sa_so(rnLowerBound, rnUpperBound) 

    return intervalSa

# End pobyso_range_to_interval_so_sa

def pobyso_rat_poly_sa_so(polySa, precSa = None):

    """

    Create a Sollya polynomial from a Sage rational polynomial.

    """

    ## TODO: filter arguments.

    ## Precision. If no precision is given, use the current precision

    #  of Sollya.

    if precSa is None:

        precSa =  pobyso_get_prec_so_sa()

    #print "Precision:",  precSa

    RRR = RealField(precSa)

    ## Create a Sage polynomial in the "right" precision.

    P_RRR = RRR[polySa.variables()[0]]

    polyFloatSa = P_RRR(polySa)

    ## Make sure no precision is provided.

    return pobyso_float_poly_sa_so(polyFloatSa)

# End pobyso_rat_poly_sa_so