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

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

def spo_add_polynomial_coeffs_to_matrix_row(pMonomials, 

                                            pCoefficients, 

                                            knownMonomials, 

    return(expressionAsString)

# End spo_expression_as_string.

    """

    Behaves more or less (no infinity defined) as the norm for the

    univariate polynomials.

    Definition: For integer p, the p-norm of a polynomial is the pth root of 

    the sum of the pth powers of the absolute values of the coefficients of 

    the polynomial.

    """

    norm = 0

    for coefficient in poly.coefficients():

# end spo_norm

def spo_polynomial_to_proto_matrix(p, pRing, alpha, N, columnsWidth=0):

    """

    From a (bivariate) polynomial and some other parameters build a proto 

    eventually by reduced by fpLLL.

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

    Parameters

    ----------

    alpha:

    N:

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

    pVariables = p.variables()

    iVariable = pVariables[0]

    tVariable = pVariables[1]

    pIdegree = p.degree(pVariables[0])

    pTdegree = p.degree(pVariables[1])

    nAtPower = N^alpha

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

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

            # possible, one step short of the degree in i of p^(pPower+1) .

            # These "pure" i^k monomials can only show up with i multiplications.

            for iPower in xrange(1, pIdegree):

                currentExpression = i^iPower * nAtPower

                pMonomials = currentPolynomial.monomials()

                pCoefficients = currentPolynomial.coefficients()

                                                        columnsWidth)

            # End for iPower

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

                                                         0,  

                                                         alpha)

                currentExpression = i^(iPower * pIdegree) * t^tPower * nAtPower

                pMonomials = currentPolynomial.monomials()

                pCoefficients = currentPolynomial.coefficients()

                spo_add_polynomial_coeffs_to_matrix_row(pMonomials, 

                                                             0,

                                                             alpha)

                    currentExpression = i^iPower * t^outerTpower * nAtPower

                    pMonomials = currentPolynomial.monomials()

                    pCoefficients = currentPolynomial.coefficients()

                    spo_add_polynomial_coeffs_to_matrix_row(pMonomials, 

                                                                     alpha) 

                            currentExpression = \

                                    i^(iPower) * t^(innerTpower) * nAtPower

                            pMonomials = currentPolynomial.monomials()

                            pCoefficients = currentPolynomial.coefficients()

                            spo_add_polynomial_coeffs_to_matrix_row(pMonomials, 

                                                             pPower,

                                                             alpha)

                    currentExpression = i^iShift * t^outerTpower * nAtPower

                    pMonomials = currentPolynomial.monomials()

                    pCoefficients = currentPolynomial.coefficients()

                    spo_add_polynomial_coeffs_to_matrix_row(pMonomials, 

        polynomialAtPower *= p  

        nAtPower /= N

    # End for pPower loop

# End spo_polynomial_to_proto_matrix

    """

    protoMatrixRows.

    Parameters

    ----------

    """

        return None

    if numColumns == 0:

        return None

    baseMatrix = matrix(ZZ, numRows, numColumns)

    return baseMatrix

# End spo_proto_to_column_matrix.

#

def spo_proto_to_row_matrix(protoMatrixRows):

    """

    protoMatrixRows.

    Parameters

        return None

    baseMatrix = matrix(ZZ, numRows, numColumns)

    for rowIndex in xrange(0, numRows):

        for colIndex in xrange(0, len(protoMatrixRows[rowIndex])):

            baseMatrix[rowIndex, colIndex] = protoMatrixRows[rowIndex][colIndex]

    return baseMatrix

# End spo_proto_to_row_matrix.

#

def smo_is_diagonal_complete_matrix(mat):

    """

    Check that all the element on the diagonal are not 0.

    return True

# End smo_is_upper_triangular_matrix

def slz_compute_polynomial_and_interval(functionSo, degreeSo, lowerBoundSa, 

                                        upperBoundSa, approxPrecSa, 

                                        sollyaPrecSa=None):

    coefficientDenominators = sro_denominators(ratPolyCoefficients)

    coefficientDenominators.append(2^precision)

    coefficientDenominators.append(2^(targetHardnessToRound + 1))

    # Compute the lcm

    # Compute the expression corresponding to the new polynomial

    coefficientNumerators =  sro_numerators(ratPolyCoefficients)

    print coefficientNumerators

    # - 2^K

# End slz_rat_poly_of_rat_to_rat_poly_of_int

- Serge Torres: first operations set (2013-04) 

"""

def sro_denominators(rationalList = None):

    """

    Compute the list of the denominators of a rational numbers list.

def sro_lcmm(rationalList = None):

    """ 

    Compute the lcm of an sequence (list, tuple) of rational numbers.

    """

    # No argument.

    if rationalList is None:

    return(numeratorsList)

# End sro_numerators