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

load "/home/storres/recherche/arithmetique/pobysoPythonSage/src/sageSLZ/sageMatrixOperations.sage"

    """

    For a given polynomial (under the form of monomials and coefficents lists),

    add the coefficients of the protoMatrix (a list of proto matrix rows).

    Coefficients are added to the protoMatrix row in the order imposed by the 

    monomials discovery list (the knownMonomials list) built as construction

    goes on. 

    pMonomials     : the list of the monomials coming form some polynomial;

    pCoefficients  : the list of the corresponding coefficients to add to

                     the protoMatrix in the exact same order as the monomials;

    protoMatrixRows.append(protoMatrixRowCoefficients)

    if columnsWidth != 0:

        print    

def spo_expression_as_string(powI, powT, powP, alpha):

    """

    return pow(norm, 1/degree)

# end spo_norm

    """

    The matrix is such as those found in Boneh-Durphee and Stehl?.

    p: the (bivariate) polynomial

    alpha:

    N:

    """

    knownMonomials = []

    protoMatrixRows = []

                                        polynomialAtPower 

                    pMonomials = currentPolynomial.monomials()

                    pCoefficients = currentPolynomial.coefficients()

                # End tPower.

            # End for iPower.

        else: # pPower > 0: (p^1..p^alpha)

            currentPolynomial = polynomialAtPower * nAtPower

            pMonomials = currentPolynomial.monomials()

            pCoefficients = currentPolynomial.coefficients()

            # The i^iPower * p^pPower polynomials: they add i^k monomials to  

            # p^pPower up to k < pIdegree * pPower. This only introduces i^k 

                currentPolynomial = P(currentExpression) * polynomialAtPower

                pMonomials = currentPolynomial.monomials()

                pCoefficients = currentPolynomial.coefficients()

            # End for iPower

            # We want now to introduce a t * p^pPower polynomial. But before

            # that we must introduce some mixed monomials.

                currentPolynomial = P(currentExpression)

                pMonomials = currentPolynomial.monomials()

                pCoefficients = currentPolynomial.coefficients()

            # End for iPower

            #

            # This is the mixed monomials main loop. It introduces:

                    currentPolynomial = P(currentExpression)

                    pMonomials = currentPolynomial.monomials()

                    pCoefficients = currentPolynomial.coefficients()

                    #print "+++++"

                    # At iShift == 0, the following innerTpower loop adds  

                    # duplicate monomials, since no extra i^l * t^k is needed 

                            currentPolynomial = P(currentExpression)

                            pMonomials = currentPolynomial.monomials()

                            pCoefficients = currentPolynomial.coefficients()

                                                                pCoefficients, 

                                                                knownMonomials, 

                                                                protoMatrixRows, 

                    currentPolynomial = P(currentExpression) * polynomialAtPower

                    pMonomials = currentPolynomial.monomials()

                    pCoefficients = currentPolynomial.coefficients()

                # End for outerTpower 

                #print "++++++++++"

            # End for iShift

        nAtPower /= N

    # End for pPower loop

    return protoMatrixRows

print "sagePolynomialOperations loaded..."

    return True

# End smo_is_lower_triangular_matrix

                    1/scalingCoeff * expVar + 3))

    """

    Compute the Sage version of the Taylor polynomial and it's

    companion data (interval, center...)

    errorSa = \

            pobyso_get_constant_as_rn_with_rf_so_sa(polyRangeCenterErrorSo[4])

    return((polynomialSa, polynomialChangedVarSa, intervalSa, centerSa, errorSa))

def slz_rat_poly_of_int_to_poly_for_coppersmith(ratPolyOfInt, 

                                                precision,

    #print "rnDummy: ", rnDummy

    # Compare the local Sage RealNumber with rnArg.

    return(cmp_rn_value(rnArg, rnLocal))

def pobyso_change_var_in_function_so_so(funcSo, chvarExpSo):

    return(sollya_lib_evaluate(funcSo,chvarExpSo))

def pobyso_chebyshevform_so_so(functionSo, degreeSo, intervalSo):

    resultSo = sollya_lib_chebyshevform(functionSo, degreeSo, intervalSo)

    return(resultSo)

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)

    fMaxSa = pobyso_get_interval_from_range_so_sa(infnormSo)

    # Get the top bound and compute the binade top limit.

    fMaxUpperBoundSa = fMaxSa.upper()

    funcAuxSo = pobyso_parse_string(str(binadeTopLimitSa) +  \

                                    '-(' + f._assume_str() + ')')

    pobyso_autoprint(funcAuxSo)

    sollya_lib_clear_obj(infnormSo)

    infnormSo = pobyso_infnorm_so_so(funcAuxSo,rangeSo)

    fMinSa = pobyso_get_interval_from_range_so_sa(infnormSo)

    # Create a RealIntervalField and create an interval with the "good" bounds.

    RRRI = RealIntervalField(maxPrecSa)

    imageIntervalSa = RRRI(fMinLowerBoundSa, fMaxUpperBoundSa)

    sollya_lib_clear_obj(funcSo)

    sollya_lib_clear_obj(funcAuxSo)

    sollya_lib_clear_obj(rangeSo)

    return(imageIntervalSa)

def pobyso_constant(rnArg):

    """ Legacy function. See pobyso_constant_sa_so. """

    return(sollya_lib_get_constant(get_rn_value(rnArg), soConst))

def pobyso_get_constant_as_rn(ctExpSo):

    return(pobyso_get_constant_as_rn_so_sa(ctExpSo))

def pobyso_get_constant_as_rn_so_sa(constExpSo):

    precisionSa  = pobyso_get_prec_of_constant_so_sa(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(ctExp, realField):

    return(pobyso_get_constant_as_rn_with_rf_so_sa(ctExp, realField))

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_free_variable_name():

    return(pobyso_get_free_variable_name_so_sa())

def pobyso_get_free_variable_name_so_sa():

    return(sollya_lib_get_free_variable_name())

def pobyso_get_function_arity(expressionSo):

    return(pobyso_get_function_arity_so_sa(expressionSo))

def pobyso_get_function_arity_so_sa(expressionSo):

    return(int(arity.value))

def pobyso_get_head_function(expressionSo):

    return(pobyso_get_head_function_so_sa(expressionSo)) 

def pobyso_get_head_function_so_sa(expressionSo):

def pobyso_get_interval_from_range_so_sa(soRange, realIntervalFieldSa = None ):

    """

    Return the Sage interval corresponding to the Sollya range argument.

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

    to hold all the digits.

    """

    """

    #pobyso_autoprint(sollyaExp)

    operator = pobyso_get_head_function_so_sa(sollyaExp)

    # Constants and the free variable are special cases.

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

    if (operator != SOLLYA_BASE_FUNC_CONSTANT) and \

        return pobyso_get_constant_as_rn_with_rf_so_sa(sollyaExp, realField)

    elif operator == SOLLYA_BASE_FUNC_FREE_VARIABLE:

        #print "This is free variable"

    else:

        print "Unexpected"

        return eval('None')

# End pobyso_get_sage_poly_from_sollya_poly

def pobyso_get_poly_sa_so(polySo, realFieldSa=None):

    pass

# pobyso_get_poly_sa_so

    Get the subfunctions of an expression.

    Return the number of subfunctions and the list of subfunctions addresses.

    S.T.: Could not figure out another way than that ugly list of declarations

    """

    subf0 = c_int(0)

    subf1 = c_int(0)

    arity = c_int(0)

    nullPtr = POINTER(c_int)()

    sollya_lib_get_subfunctions(expressionSo, byref(arity), \

#    byref(cast(subfunctions[8], POINTER(c_int))), nullPtr)

    subs = []

    if arity.value > pobyso_max_arity:

        return(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(ctExpSo):

    """ Legacy function. See pobyso_get_prec_of_constant_so_sa. """

    pobyso_name_free_variable_sa_so(freeVariableName)

def pobyso_name_free_variable_sa_so(freeVariableName):

    sollya_lib_name_free_variable(freeVariableName)

def pobyso_parse_string(string):

    return(pobyso_parse_string_sa_so(string))

def pobyso_parse_string_sa_so(string):

    return(sollya_lib_parse_string(string))

def pobyso_range(rnLowerBound, rnUpperBound):

def pobyso_bounds_to_range_sa_so(rnLowerBoundSa, rnUpperBoundSa):

    """

    The Sollya range element has a sufficient precision to hold all

    """

    if rnLowerBoundSa > rnUpperBoundSa:

        return None

    lbPrec = rnLowerBoundSa.parent().precision()

    ubPrec = rnLowerBoundSa.parent().precision()

    currentSollyaPrecSa = pobyso_get_prec_so_sa()

    lowerBoundSo = sollya_lib_constant(get_rn_value(rnLowerBoundSa))

    upperBoundSo = sollya_lib_constant(get_rn_value(rnUpperBoundSa))

    rangeSo = sollya_lib_range(lowerBoundSo, upperBoundSo)

    if maxPrecSa > currentSollyaPrecSa:

        sollya_lib_set_prec(currentPrecSo)

        sollya_lib_clear_obj(currentPrecSo)

    return(rangeSo)

def pobyso_range_to_interval_so_sa(rangeSo, realIntervalField = None):

    if realIntervalField is None:

        precSa = pobyso_get_prec_of_range_so_sa(rangeSo)

        realIntervalField = RealIntervalField(precSa)

    All arguments are Sage/Python.

    The functions (func and weight) must be passed as expressions or strings.

    Otherwise the function fails. 

    """

    polySo = pobyso_remez_canonical_sa_so(func, \

                                 degree, \

                                 lowerBound, \

                                 upperBound, \

                                 weight = None, \

                                 quality = None)

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

        functionSa = eval(func)

    # Expression test.

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

        functionSa = func

    maxPrecision = 0

    if polySo is None:

        return(None)

    polynomialRing = RRRR[functionSa.variables()[0]]

    expSa = pobyso_get_sage_exp_from_sollya_exp_so_sa(polySo, RRRR)

    polySa = polynomial(expSa, polynomialRing)

    return(polySa)

def pobyso_remez_canonical(func, \

    Otherwise the function fails. 

    The return value is a pointer to a Sollya function.

    """

    currentVariableName = None

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

    # symbolic expression...)

        qualitySo= pobyso_constant_sa_so(quality)

    else:

        qualitySo = None

def pobyso_remez_canonical_so_so(funcSo, \

                                 degreeSo, \

                                 rangeSo, \

    # If changed, reset the Sollya working precision.

    if not sollyaPrecSo is None:

        sollya_lib_set_prec(initialPrecSo)

    return((polyVarChangedSo, intervalCenterSo, maxErrorSo))

# end pobyso_taylor_expansion_with_change_var_so_so

    for 'interval' with 'errorType'. 

    point: must be a Real or a Real interval.

    return the Taylor form as an array

          when errorType is not None;

    """

    # Absolute as the default error.

    if errorType is None:

        # TODO: deal with the interval case.

        pass

    # Call Sollya

                                         None)

    (tfsAsList, numElements, isEndElliptic) = \

            pobyso_get_list_elements_so_so(taylorFormSo)