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

sys.stderr.write(str(poly) + "\n")

sys.stdout.write(str(maxErrPoint) + " " + str(maxErr.n(prec=53)) + "\n")

def cvp_chebyshev_maxis_1k(numPoints, realField, contFracMaxErr = None):

    """

    Compute the Chebyshev maxis for some polynomial degree (numPoints, for the

    zeros) scaled to the [lowerBound, upperBound] interval.

    The list is returned as row floating-point numbers is contFracMaxErr is None.

    Otherwise elements are transformed into rational numbers. 

    """

    if numPoints < 1:

        return None

    if numPoints == 0:

        return [0]

    ## Check that realField has a "prec()" member.

    try:

        realField.prec()

    except:

        return None

    #

    maxisList = []

    ## n extrema are given by a degree (n-1) Chebyshev polynomial.

    #  formulas: cos ((i * pi) / (numPoints - 1)) for i = 0,...,numPoints-1.

    #  Source: https://en.wikipedia.org/wiki/Chebyshev_polynomials

    for index in xrange(0, numPoints):

        ## When number of points is odd (then, the Chebyshev degree is odd two), 

        #  the central point is 0. */

        if (numPoints % 2 == 1) and ((2 * index + 1) == numPoints):

            if contFracMaxErr is None:

                maxisList.append(realField(0))

            else:

                maxisList.append(0)

        else:

            currentCheby = \

                ((realField(index) * realField(pi)) / 

                 realField(numPoints-1)).cos()

            #print  "Current Cheby:", currentCheby

            ## Result is negated to have an increasing order list.

            if contFracMaxErr is None:

                maxisList.append(-currentCheby)

            else:

                maxisList.append(-currentCheby.nearby_rational(contFracMaxErr))

            #print "Relative error:", (currentCheby/maxisList[index])

    return maxisList

# End cvp_chebyshev_maxis_1k.

#

def cvp_chebyshev_maxis_for_interval(lowerBound, 

                                     upperBound, 

                                     numPoints,

                                     realField = None, 

                                     contFracMaxErr = None):

    """

    Compute the Chebyshev maxis for some polynomial degree (numPoints, for the

    maxis) scaled to the [lowerBound, upperBound] interval.

    If no contFracMaxErr argument is given, we return the list as "raw"

    floating-points. Otherwise, rational numbers are returned.

    """

    ## Arguments check.

    if lowerBound >= upperBound:

        return None

    if numPoints < 1:

        return None

    ## If no realField argument is given try to retrieve it from the 

    #  bounds. If impossible (e.g. rational bound), fall back on RR. 

    if realField is None:

        try:

            ### Force failure if parent does not have prec() member.

            lowerBound.parent().prec()

            ### If no exception is thrown, set realField.

            realField = lowerBound.parent()

        except:

            realField = RR

    #print "Real field:", realField

    ## We want "raw"floating-point nodes to only have one final rounding.

    chebyshevMaxisList = \

        cvp_chebyshev_maxis_1k(numPoints, realField)

    scalingFactor, offset = cvp_affine_from_chebyshev(lowerBound, upperBound)

    for index in xrange(0, len(chebyshevMaxisList)):

        chebyshevMaxisList[index] = \

            chebyshevMaxisList[index] * scalingFactor + offset

        if not contFracMaxErr is None:

            chebyshevMaxisList[index] = \

                chebyshevMaxisList[index].nearby_rational(contFracMaxErr)

    return chebyshevMaxisList                                                             

# End cvp_chebyshev_maxis_for_interval.

#