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

import re

from sage.symbolic.expression_conversions import polynomial

def pobyso_lib_init():

    sollya_lib_init(None)

def pobyso_name_free_variable(freeVariableName):

    sollya_lib_name_free_variable(freeVariableName)

# TODO: take care of the interval and of point when it is an interval;

#       when errorType is not None;

#       take care of the other elements of the Taylor form (coefficients errors and

#       delta.

    """

    Compute the Taylor form of 'degre' for 'function' at 'point' 

    for 'interval' with 'errorType'. 

    point: must be a Real or a Real interval.

    return the Taylor form as an array

    """

    # Absolute as the default error.

        errorTypeSo = sollya_lib_absolute()

    else:

        #TODO: deal with the other case.

        pass

    varSa = function.variables()[0]

    pointBaseRingString = str(point.base_ring())

    if not re.search('Real', pointBaseRingString):

        return None

    # Call Sollya but first "sollyafy" the arguments.

    sollya_lib_init(None)

    pobyso_name_free_variable(str(varSa))

    # Sollyafy the function.

    functionSo = pobyso_parse_string(function._assume_str())

    if sollya_lib_obj_is_error(functionSo):

        print "pobyso_tailorform: function string can't be parsed!"

        return None

    # Sollyafy the degree

    degreeSo = sollya_lib_constant_from_int(int(degree))

    # Sollyafy the point

    if not re.search('Interval', pointBaseRingString):

        pointSo  = pobyso_constant(point)

    else:

        # TODO: deal with the interval case.

        pass

    # Call Sollya

    taylorFormSo = sollya_lib_taylorform(functionSo, degreeSo, pointSo, errorTypeSo,\

                                         None)

    (tfsAsList, numElements, isEndElliptic) = pobyso_get_list_elements(taylorFormSo)

    polySo = tfsAsList[0]

    maxPrecision = pobyso_get_max_prec_of_exp(polySo)

    polyRealField = RealField(maxPrecision)

    expSa = pobyso_get_sage_exp_from_sollya_exp(polySo, polyRealField)

    sollya_lib_close()

    polynomialRing = polyRealField[str(varSa)]

    polySa = polynomial(expSa, polynomialRing)

    taylorFormSa = [polySa]

    return(taylorFormSa)                    

def pobyso_univar_polynomial_print_reverse(polySa):

    """

    Return the string representation of a univariate polynomial with

    monomial ordered in the x^0..x^n order of the monomials.

    Remember: Sage

    """

    polynomialRing = polySa.base_ring()

    # A very expensive solution:

    # -create a fake multivariate polynomial field with only one variable,

    #   specifying a negative lexicographical order;

    mpolynomialRing = PolynomialRing(polynomialRing.base(), \

                                     polynomialRing.variable_name(), \

                                     1, order='neglex')

    # - convert the univariate argument polynomial into a multivariate

    #   version;

    p = mpolynomialRing(polySa)

    # - return the string representation of the converted form.

    # There is no simple str() method defined for p's class.

    return(p.__str__())

        sollya_lib_init= sollya.sollya_lib_init

        sollya_lib_name_free_variable = \

            sollya.sollya_lib_name_free_variable

        sollya_lib_obj_is_error = sollya.sollya_lib_obj_is_error

    sollya_lib_name_free_variable.argtypes   = [POINTER(c_char)]