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

def pobyso_error_so():

    return sollya_lib_error(None)

# End pobyso_error().

def pobyso_guess_degree_sa_sa(functionSa, intervalSa, approxErrorSa, 

                              weightSa=None, degreeBoundSa=None):

    """

    Sa_sa variant of the solly_guessdegree function.

    Return 0 if something goes wrong.

    """

    if pobyso_is_error_so_sa(functionSo):

        sollya_lib_clear_obj(functionSo)

        return 0

    # The approximation error is expected to be a floating point number.

    if pobyso_is_floating_point_number_sa_sa(approxErrorSa):

        approxErrorSo = pobyso_constant_sa_so(approxErrorSa)

    else:

        approxErrorSo = pobyso_constant_sa_so(RR(approxErrorSa))

        if pobyso_is_error(weightSo):

            sollya_lib_clear_obj(functionSo)

            sollya_lib_clear_obj(rangeSo)

            sollya_lib_clear_obj(approxErrorSo)   

            sollya_lib_clear_obj(weightSo)

            return 0   

                                              approxErrorSo,

    sollya_lib_clear_obj(approxErrorSo)

def pobyso_is_error_so_sa(objSo):

    """

    Thin wrapper around the sollya_lib_obj_is_error() function.

    """

    if sollya_lib_obj_is_error(objSo) != 0:

        return True

    else:

        return False

# End pobyso_is_error-so_sa

def pobyso_is_floating_point_number_sa_sa(numberSa):

    """

    Check whether a Sage number is floating point

    """

    return numberSa.parent().__class__ is RR.__class__

    Get the Sollya expression computed from a Sage string or

    a Sollya error object if parsing failed.

        sollya_lib_error=sollya.sollya_lib_error

                # Add the coefficient to the proto matrix row and delete the 

def spo_polynomial_to_polynomials_list_6(p, alpha, N, iBound, tBound,

                                         columnsWidth=0):

    """

    From p, alpha, N build a list of polynomials use to create a base

    that will eventually be reduced with LLL.

    The bounds are computed for the coefficients that will be used to

    form the base.

    We try to introduce only one new monomial at a time, whithout trying to

    obtain a triangular matrix.

    There are many possibilities to introduce the monomials: our goal is also 

    to introduce each of them on the diagonal with the smallest coefficient.

    The method depends on the structure of the polynomial. Here it is adapted

    to the a_n*i^n + ... + a_1 * i - t + b form.     

    Parameters

    ----------

    p: the (bivariate) polynomial;

    alpha:

    N:

    iBound:

    tBound:

    columsWidth: if == 0, no information is displayed, otherwise data is 

                 printed in colums of columnsWitdth width.

    """

    pRing = p.parent()

    polynomialsList = []

    pVariables = p.variables()

    iVariable = pVariables[0]

    tVariable = pVariables[1]

    polynomialAtPower = copy(p)

    currentPolynomial = pRing(1)     # Constant term.

    pIdegree = p.degree(iVariable)

    pTdegree = p.degree(tVariable)

    maxIdegree = pIdegree * alpha

    currentIdegree = currentPolynomial.degree(iVariable)

    nAtAlpha = N^alpha

    nAtPower = nAtAlpha

    polExpStr = ""

    #

    ## Shouldn't we start at tPower == 1 because polynomials without 

    #  t monomials are useless?

    for tPower in xrange(0, alpha+1):

        ## Start at iPower == 0 because here there are i monomials

        #  in p even if iPower is zero.

        for iPower in xrange(0, alpha-tPower+1):

            if iPower + tPower <= alpha:

                print "iPower:", iPower, " tPower:", tPower

                q = pRing(iVariable * iBound)^iPower * ((p * N)^tPower)

                print q.monomials()

                polynomialsList.append(q)

    return polynomialsList

    """

    # We first introduce all the monomials in i alone multiplied by N^alpha.

    for iPower in xrange(0, maxIdegree + 1):

        if columnsWidth !=0:

            polExpStr = spo_expression_as_string(iPower, iBound,

                                                 0, tBound, 

                                                 0, alpha)

            print "->", polExpStr

        currentExpression = iVariable^iPower * nAtAlpha * iBound^iPower

        currentPolynomial = pRing(currentExpression)

        polynomialsList.append(currentPolynomial)

    # End for iPower

    # We work from p^1 * N^alpha-1 to p^alpha * N^0

    for pPower in xrange(1, alpha + 1):

        # First of all the p^pPower * N^(alpha-pPower) polynomial.

        nAtPower /= N

        if columnsWidth !=0:

            polExpStr = spo_expression_as_string(0, iBound,

                                                 0, tBound,

                                                 pPower, alpha-pPower)

            print "->", polExpStr

        currentPolynomial = polynomialAtPower * nAtPower

        polynomialsList.append(currentPolynomial)

        # Exit when pPower == alpha

        if pPower == alpha:

            return polynomialsList

        for iPower in xrange(1, pIdegree + 1):

            iCurrentPower = pIdegree + iPower

            for tPower in xrange(pPower-1, 0, -1):

                #print "tPower:", tPower

                if columnsWidth != 0:

                    polExpStr = spo_expression_as_string(iCurrentPower, iBound,

                                                         tPower, tBound, 

                                                         0, alpha)

                    print "->", polExpStr

                currentExpression = i^iCurrentPower * iBound^iCurrentPower * t^tPower * tBound^tPower *nAtAlpha 

                currentPolynomial = pRing(currentExpression)

                polynomialsList.append(currentPolynomial)

                iCurrentPower += pIdegree 

            # End for tPower 

        # We now introduce the mixed i^k * t^l monomials by i^m * p^n * N^(alpha-n)

            if columnsWidth != 0:

                polExpStr = spo_expression_as_string(iPower, iBound,

                                                     0, tBound, 

                                                     pPower, alpha-pPower)

                print "->", polExpStr

            currentExpression = i^iPower * iBound^iPower * nAtPower

            currentPolynomial = pRing(currentExpression) * polynomialAtPower

            polynomialsList.append(currentPolynomial) 

        # End for iPower

        polynomialAtPower *= p  

    # End for pPower loop

    """

    return polynomialsList 

# End spo_polynomial_to_proto_matrix_6

def test_pobyso_error_so(repeat=1000, number=10):

    functionName =  inspect.stack()[0][3]

    print "Running", inspect.stack()[0][3], "..."

    #

    def test():

        errorSo = pobyso_error_so()

        sollya_lib_clear_obj(errorSo)

    #

    wrapped = test_pobyso_wrapper(test)

    timing = min(timeit.repeat(wrapped, repeat=repeat, number=number))

    print "\t...", functionName, "done."

    return timing

# End test_pobyso_error_so

                                  degreeBoundSo)                              

    """    

        pobyso_guess_degree_so_sa(funcExpSo, 

                                  intervalSo, 

                                  errorSo, 

                                  None, 

                                  None)

    """    

def test_pobyso_is_error_so_sa(repeat=1000, number=10):

    functionName =  inspect.stack()[0][3]

    print "Running", inspect.stack()[0][3], "..."

    #

    def test():

        errorSo = pobyso_error_so()

        if not pobyso_is_error_so_sa(errorSo):

            print "Error!"

        sollya_lib_clear_obj(errorSo)

    #

    wrapped = test_pobyso_wrapper(test)

    timing = min(timeit.repeat(wrapped, repeat=repeat, number=number))

    print "\t...", functionName, "done."

    return timing

# End test_pobyso_error_so