coerce_maps.pyx

"""
Coerce maps
"""
include "../ext/stdsage.pxi"

import re
import types

from parent import Set_PythonType
from sage.structure.parent cimport Parent
from sage.structure.element cimport Element

cdef object BuiltinMethodType = type(repr)

# COERCE TODO: remove or integrate better (as this bit is only checked on an error)
cdef bint print_warnings = 0


cdef class DefaultConvertMap(Map):
    """
    This morphism simply calls the codomain's element_constructor method, 
    passing in the codomain as the first argument. 
    """
    def __init__(self, domain, codomain, force_use=False):
        if not PY_TYPE_CHECK(domain, Parent):
            domain = Set_PythonType(domain)
        Map.__init__(self, domain, codomain)
        self._coerce_cost = 100
        self._force_use = force_use
        if self._codomain._element_constructor is None:
            raise RuntimeError, "BUG in coercion model, no element constructor for %s" % type(self._codomain)
        self._repr_type_str = "Coercion" if self._is_coercion else "Conversion"

    cpdef Element _call_(self, x):
        try:
            return self._codomain._element_constructor(self._codomain, x)
        except:
            if print_warnings:
                print type(self._codomain), self._codomain
                print type(self._codomain._element_constructor), self._codomain._element_constructor
            raise

    cpdef Element _call_with_args(self, x, args=(), kwds={}):
        try:
            if len(args) == 0:
                if len(kwds) == 0:
                    # This line is apparently never used in any tests (hivert, 2009-04-28)
                    return self._codomain._element_constructor(self._codomain, x)
                else:
                    return self._codomain._element_constructor(self._codomain, x, **kwds)
            else:
                if len(kwds) == 0:
                    return self._codomain._element_constructor(self._codomain, x, *args)
                else:
                    return self._codomain._element_constructor(self._codomain, x, *args, **kwds)
        except:
            if print_warnings:
                print type(self._codomain), self._codomain
                print type(self._codomain._element_constructor), self._codomain._element_constructor
            raise


cdef class DefaultConvertMap_unique(DefaultConvertMap):
    """
    This morphism simply defers action to the codomain's
    element_constructor method, WITHOUT passing in the codomain as the
    first argument.

    This is used for creating elements that don't take a parent as the
    first argument to their __init__ method, for example, Integers,
    Rationals, Algebraic Reals... all have a unique parent. It is also
    used when the element_constructor is a bound method (whose self
    argument is assumed to be bound to the codomain).
    """
    cpdef Element _call_(self, x):
        try:
            return self._codomain._element_constructor(x)
        except:
            if print_warnings:
                print type(self._codomain), self._codomain
                print type(self._codomain._element_constructor), self._codomain._element_constructor
            raise

    cpdef Element _call_with_args(self, x, args=(), kwds={}):
        try:
            if len(args) == 0:
                if len(kwds) == 0:
                    return self._codomain._element_constructor(x)
                else:
                    return self._codomain._element_constructor(x, **kwds)
            else:
                if len(kwds) == 0:
                    return self._codomain._element_constructor(x, *args)
                else:
                    return self._codomain._element_constructor(x, *args, **kwds)
        except:
            if print_warnings:
                print type(self._codomain), self._codomain
                print type(self._codomain._element_constructor), self._codomain._element_constructor
            raise


cdef class NamedConvertMap(Map):
    """
    This is used for creating a elements via the _xxx_ methods. 
    
    For example, many elements implement an _integer_ method to
    convert to ZZ, or a _rational_ method to convert to QQ.
    """
    
    def __init__(self, domain, codomain, method_name, force_use=False):
        """
        EXAMPLES::
        
            sage: from sage.structure.coerce_maps import NamedConvertMap
            sage: var('t')
            t
            sage: mor = NamedConvertMap(SR, QQ['t'], '_polynomial_')
            sage: mor(t^2/4+1)
            1/4*t^2 + 1
            sage: mor = NamedConvertMap(SR, GF(7)[['t']], '_polynomial_')
            sage: mor(t^2/4+1)
            1 + 2*t^2
        """
        if PY_TYPE_CHECK(domain, type):
            domain = Set_PythonType(domain)
        Map.__init__(self, domain, codomain)
        self._coerce_cost = 400
        self._force_use = force_use
        self.method_name = method_name
        self._repr_type_str = "Conversion via %s method" % self.method_name
    
    cpdef Element _call_(self, x):
        """
        EXAMPLES::
        
            sage: from sage.structure.coerce_maps import NamedConvertMap
            sage: f = NamedConvertMap(GF(5), QQ, '_integer_'); f
            Conversion via _integer_ method map:
              From: Finite Field of size 5
              To:   Rational Field
            sage: f(19)
            4
            sage: f(19).parent()
            Rational Field
        """
        try:
            method = getattr(x, self.method_name)
        except AttributeError:
            if print_warnings:
                print type(x), x
                print type(self._codomain), self._codomain
                print self.method_name
            raise TypeError, "Cannot coerce %s to %s"%(x, self._codomain)
        cdef Map m
        cdef Element e = method(self._codomain)
        if e is None:
            raise RuntimeError, "BUG in coercion model: %s method of %s returned None" % (self.method_name, type(x))
        if e._parent is not self._codomain:
            m = self._codomain.convert_map_from(e._parent)
            if m is None or m is self:
                raise TypeError 
            e = m._call_(e)
        return e

    cpdef Element _call_with_args(self, x, args=(), kwds={}):
        """
        EXAMPLES::
        
            sage: from sage.structure.coerce_maps import NamedConvertMap
            sage: f = NamedConvertMap(SR, ZZ['x'], '_polynomial_')
            sage: f(x^2+1, check=True)
            x^2 + 1
        """
        return self._codomain._element_constructor(self._call_(x), *args, **kwds)


# Perhaps this could be a method, extracting (<PyMethodDescrObject *>(<object>Parent).coerce_map_from).d_method.ml_meth and/or PyCFunction_GET_FUNCTION(method)
# and constructing a CCallableConvertMap_class if it is bound to the codomain.

cdef class CallableConvertMap(Map):
    cdef bint _parent_as_first_arg
    cdef _func
    
    def __init__(self, domain, codomain, func, parent_as_first_arg=None):
        """
        This lets one easily create maps from any callable object.
        
        This is especially useful to create maps from bound methods. 
        
        EXAMPLES::
        
            sage: from sage.structure.coerce_maps import CallableConvertMap
            sage: def foo(P, x): return x/2
            sage: f = CallableConvertMap(ZZ, QQ, foo)
            sage: f(3)
            3/2
            sage: f
            Conversion via foo map:
              From: Integer Ring
              To:   Rational Field
            
        Create a homomorphism from $\RR$ to $\RR^+$ viewed as additive groups.

        ::
        
            sage: f = CallableConvertMap(RR, RR, exp, parent_as_first_arg=False)
            sage: f(0)
            1.00000000000000
            sage: f(1)
            2.71828182845905
            sage: f(-3)
            0.0497870683678639
        """
        if PY_TYPE_CHECK(domain, type):
            domain = Set_PythonType(domain)
        Map.__init__(self, domain, codomain)
        self._coerce_cost = 100
        self._func = func
        if parent_as_first_arg is None:
            if PY_TYPE_CHECK(func, types.MethodType):
                # can't easily access self
                parent_as_first_arg = False
            elif PY_TYPE_CHECK(func, BuiltinMethodType):
                parent_as_first_arg = codomain is func.__self__
            else:
                parent_as_first_arg = True
        self._parent_as_first_arg = parent_as_first_arg
        try:
            self._repr_type_str = "Conversion via %s" % self._func.__name__
        except AttributeError:
            self._repr_type_str = "Conversion via %s" % self._func
    
    cpdef Element _call_(self, x):
        """
        Because self._func may be anything we do a little bit of sanity
        checking (the return value must be an element with the correct parent).
                
        TESTS::
        
            sage: from sage.structure.coerce_maps import CallableConvertMap
            sage: def foo(P, x): return x
            sage: f = CallableConvertMap(ZZ, ZZ, foo)
            sage: f(0)
            0
            sage: f = CallableConvertMap(ZZ, QQ, foo)
            sage: f(0)
            Traceback (most recent call last):
            ...
            RuntimeError: BUG in coercion model: <function foo at ...> returned element with wrong parent (expected Rational Field got Integer Ring)
            sage: def foo(P, x): return None
            sage: f = CallableConvertMap(ZZ, QQ, foo)
            sage: f(0)
            Traceback (most recent call last):
            ...
            RuntimeError: BUG in coercion model: <function foo at ...> returned None
        """
        cdef Element y
        try:
            if self._parent_as_first_arg:
                y = self._func(self._codomain, x)
            else:
                y = self._func(x)
        except:
            if print_warnings:
                print self._func
                print self._codomain
            raise
        if y is None:
            raise RuntimeError, "BUG in coercion model: %s returned None" % (self._func)
        elif y._parent is not self._codomain:
            raise RuntimeError, "BUG in coercion model: %s returned element with wrong parent (expected %s got %s)" % (self._func, self._codomain, y._parent)
        return y
        
    cpdef Element _call_with_args(self, x, args=(), kwds={}):
        """
        TESTS::
        
            sage: from sage.structure.coerce_maps import CallableConvertMap
            sage: def foo(P, x, y): return x or y
            sage: f = CallableConvertMap(ZZ, ZZ, foo)
            sage: f(0, 3)
            3
            sage: f = CallableConvertMap(ZZ, QQ, foo)
            sage: f(0, 3)
            Traceback (most recent call last):
            ...
            RuntimeError: BUG in coercion model: <function foo at ...> returned element with wrong parent (expected Rational Field got Integer Ring)
            sage: f(None, None)
            Traceback (most recent call last):
            ...
            RuntimeError: BUG in coercion model: <function foo at ...> returned None
        """
        cdef Element y
        try:
            if self._parent_as_first_arg:
                y = self._func(self._codomain, x, *args, **kwds)
            else:
                y = self._func(x, *args, **kwds)
        except:
            if print_warnings:
                print self._func
                print self._codomain
            raise
        if y is None:
            raise RuntimeError, "BUG in coercion model: %s returned None" % (self._func)
        elif y._parent is not self._codomain:
            raise RuntimeError, "BUG in coercion model: %s returned element with wrong parent (expected %s got %s)" % (self._func, self._codomain, y._parent)
        return y
            
            
cdef class CCallableConvertMap_class(Map):
    cdef Element (*_func)(Parent, object)
    cdef public _name
    
    def __init__(self, domain, codomain, name):
        if PY_TYPE_CHECK(domain, type):
            domain = Set_PythonType(domain)
        Map.__init__(self, domain, codomain)
        self._coerce_cost = 10
        self._name = name

    cpdef Element _call_(self, x):
        """
        TESTS::
        
            sage: from sage.structure.coerce_maps import test_CCallableConvertMap
            sage: f = test_CCallableConvertMap(QQ, 'test')
            sage: f(1/3)
            -8/27
        """
        return self._func(self._codomain, x)

    def _repr_type(self):
        """
        EXAMPLES::
        
            sage: from sage.structure.coerce_maps import test_CCallableConvertMap
            sage: test_CCallableConvertMap(ZZ, 'any name')
            Conversion via c call 'any name' map:
              From: Integer Ring
              To:   Integer Ring
            sage: test_CCallableConvertMap(ZZ, None)  # random address
            Conversion via c call at 0xc339000 map:
              From: Integer Ring
              To:   Integer Ring
        """
        if self._name is None:
            return "Conversion via c call at 0x%x" % <long>self._func
        else:
            return "Conversion via c call '%s'" % self._name
        

cdef Map CCallableConvertMap(domain, codomain, void* func, name):
    """
    Use this to create a map from domain to codomain by calling func
    (which must be a function pointer taking a Parent and object, and 
    returning an Element in the given Parent). 
    
    This is the c analogue of CallableConvertMap. 
    """
    # Cython doesn't yet accept function pointers as arguments, 
    # change this when it does. 
    cdef CCallableConvertMap_class map = CCallableConvertMap_class(domain, codomain, name)
    map._func = <Element (*)(Parent, object)>func
    return map
    
cpdef Element _ccall_test_function(codomain, x):
    """
    For testing CCallableConvertMap_class. Returns x*x*x-x in the codomain. 
    
    TESTS::
    
        sage: from sage.structure.coerce_maps import _ccall_test_function
        sage: _ccall_test_function(ZZ, 1)
        0
        sage: _ccall_test_function(ZZ, 2)
        6
        sage: _ccall_test_function(ZZ, -3)
        -24
    """
    return codomain(x*x*x-x)

def test_CCallableConvertMap(domain, name=None):
    """
    For testing CCallableConvertMap_class. 
    
    TESTS::
    
        sage: from sage.structure.coerce_maps import test_CCallableConvertMap
        sage: f = test_CCallableConvertMap(ZZ, 'test'); f
        Conversion via c call 'test' map:
          From: Integer Ring
          To:   Integer Ring
        sage: f(3)
        24
        sage: f(9)
        720
    """
    return CCallableConvertMap(domain, domain, <void*>&_ccall_test_function, name)

    
cdef class ListMorphism(Map):

    cdef Map _real_morphism

    def __init__(self, domain, Map real_morphism):
        if not PY_TYPE_CHECK(domain, Parent):
            domain = Set_PythonType(domain)
        Map.__init__(self, domain, real_morphism.codomain())
        self._coerce_cost = real_morphism._coerce_cost + 3
        self._real_morphism = real_morphism
        self._repr_type_str = "List"

    cpdef Element _call_(self, x):
        try:
            x = x._data
        except AttributeError:
            x = list(x)
        return self._real_morphism._call_(x)
        
    cpdef Element _call_with_args(self, x, args=(), kwds={}):
        try:
            x = x._data
        except AttributeError:
            x = list(x)
        return self._real_morphism._call_with_args(x, args, kwds)
        

cdef class TryMap(Map):
    def __init__(self, Map morphism_preferred, Map morphism_backup, error_types=None):
        """
        TESTS::
        
            sage: sage.structure.coerce_maps.TryMap(RDF.coerce_map_from(QQ), RDF.coerce_map_from(ZZ))
            Traceback (most recent call last):
            ...
            TypeError: incorrectly matching parent
        """
        if (morphism_preferred.domain() is not morphism_backup.domain()
             or morphism_preferred.codomain() is not morphism_backup.codomain()):
            raise TypeError, "incorrectly matching parent"
        Map.__init__(self, morphism_preferred.parent())
        self._map_p = morphism_preferred
        self._map_b = morphism_backup
        if error_types is None:
            self._error_types = (ValueError, TypeError, AttributeError)
        else:
            self._error_types = error_types

    cpdef Element _call_(self, x):
        """
        EXAMPLES::
        
            sage: map1 = sage.structure.coerce_maps.CallableConvertMap(ZZ, QQ, lambda parent, x: 1/x)
            sage: map2 = QQ.coerce_map_from(ZZ)
            sage: map = sage.structure.coerce_maps.TryMap(map1, map2, error_types=(ZeroDivisionError,))
            sage: map(3)
            1/3
            sage: map(-7)
            -1/7
            sage: map(0)
            0
        """
        try:
            return self._map_p._call_(x)
        except self._error_types:
            return self._map_b._call_(x)

    cpdef Element _call_with_args(self, x, args=(), kwds={}):
        """
        EXAMPLES::
        
            sage: map1 = sage.structure.coerce_maps.CallableConvertMap(ZZ, QQ, lambda parent, x, y:  y/x)
            sage: map2 = sage.structure.coerce_maps.CallableConvertMap(ZZ, QQ, lambda parent, x, y: 23/1)
            sage: map = sage.structure.coerce_maps.TryMap(map1, map2, error_types=(ZeroDivisionError,))
            sage: map._call_with_args(3, (2,))
            2/3
            sage: map._call_with_args(-7, (5,))
            -5/7
            sage: map._call_with_args(0, (1,))
            23
        """
        try:
            return self._map_p._call_with_args(x, args, kwds)
        except self._error_types:
            return self._map_b._call_with_args(x, args, kwds)