Coverage for local/lib/python2.7/site-packages/sage/structure/coerce.pyx: 81%

TypeError: no common canonical parent for objects with parents: 'Multivariate Polynomial Ring in x, y over Rational Field' and 'Multivariate Polynomial Ring in z, t over Rational Field'

"""

base = None

for x in args:

if not isinstance(x, Parent) and not isinstance(x, type):

x = parent(x)

if base is None:

base = x

if isinstance(base, Parent) and (<Parent>base).has_coerce_map_from(x):

continue

elif isinstance(x, Parent) and (<Parent>x).has_coerce_map_from(base):

base = x

else:

a = base.an_element() if isinstance(base, Parent) else base(1)

b = x.an_element() if isinstance(x, Parent) else x(1)

base = parent(self.canonical_coercion(a, b)[0])

return base

cpdef division_parent(self, Parent P):

r"""

Deduces where the result of division in ``P`` lies by

calculating the inverse of ``P.one()`` or ``P.an_element()``.

The result is cached.

EXAMPLES::

sage: cm = sage.structure.element.get_coercion_model()

sage: cm.division_parent(ZZ)

Rational Field

sage: cm.division_parent(QQ)

Rational Field

sage: ZZx = ZZ['x']

sage: cm.division_parent(ZZx)

Fraction Field of Univariate Polynomial Ring in x over Integer Ring

sage: K = GF(41)

sage: cm.division_parent(K)

Finite Field of size 41

sage: Zmod100 = Integers(100)

sage: cm.division_parent(Zmod100)

Ring of integers modulo 100

sage: S5 = SymmetricGroup(5)

sage: cm.division_parent(S5)

Symmetric group of order 5! as a permutation group

"""

try:

return self._division_parents.get(P, None, None)

except KeyError:

pass

try:

ret = parent(~P.one())

except Exception:

self._record_exception()

ret = parent(~P.an_element())

self._division_parents.set(P, None, None, ret)

return ret

cpdef bin_op(self, x, y, op):

"""

Execute the operation op on x and y. It first looks for an action

corresponding to op, and failing that, it tries to coerces x and y

into a common parent and calls op on them.

If it cannot make sense of the operation, a TypeError is raised.

INPUT:

- ``x`` - the left operand

- ``y`` - the right operand

- ``op`` - a python function taking 2 arguments

.. NOTE::

op is often an arithmetic operation, but need not be so.

EXAMPLES::

sage: cm = sage.structure.element.get_coercion_model()

sage: cm.bin_op(1/2, 5, operator.mul)

5/2

The operator can be any callable::

sage: R.<x> = ZZ['x']

sage: cm.bin_op(x^2-1, x+1, gcd)

x + 1

Actions are detected and performed::

sage: M = matrix(ZZ, 2, 2, range(4))

sage: V = vector(ZZ, [5,7])

sage: cm.bin_op(M, V, operator.mul)

(7, 31)

TESTS::

sage: class Foo(object):

....: def __rmul__(self, left):

....: return 'hello'

sage: H = Foo()

sage: print(int(3)*H)

hello

sage: print(Integer(3)*H)

hello

sage: print(H*3)

Traceback (most recent call last):

...

TypeError: unsupported operand parent(s) for *: '<class '__main__.Foo'>' and 'Integer Ring'

sage: class Nonsense(object):

....: def __init__(self, s):

....: self.s = s

....: def __repr__(self):

....: return self.s

....: def __mul__(self, x):

....: return Nonsense(self.s + chr(x%256))

....: __add__ = __mul__

....: def __rmul__(self, x):

....: return Nonsense(chr(x%256) + self.s)

....: __radd__ = __rmul__

sage: a = Nonsense('blahblah')

sage: a*80

blahblahP

sage: 80*a

Pblahblah

sage: a+80

blahblahP

sage: 80+a

Pblahblah

"""

self._exceptions_cleared = False

if (op is not sub) and (op is not isub):

# Actions take preference over common-parent coercions.

xp = parent(x)

yp = parent(y)

if xp is yp:

return op(x,y)

action = self.get_action(xp, yp, op, x, y)

if action is not None:

return (<Action>action)._call_(x, y)

try:

xy = self.canonical_coercion(x, y)

except TypeError:

self._record_exception()

else:

return PyObject_CallObject(op, xy)

if op is mul or op is imul:

# elements may also act on non-elements

# (e.g. sequences or parents)

if not isinstance(y, Element) or not isinstance(x, Element):

try:

if hasattr(x, '_act_on_'):

res = x._act_on_(y, True)

if res is not None: return res

except CoercionException:

self._record_exception()

try:

if hasattr(x, '_acted_upon_'):

res = x._acted_upon_(y, True)

if res is not None: return res

except CoercionException:

self._record_exception()

try:

if hasattr(y, '_act_on_'):

res = y._act_on_(x, False)

if res is not None: return res

except CoercionException:

self._record_exception()

try:

if hasattr(y, '_acted_upon_'):

res = y._acted_upon_(x, False)

if res is not None: return res

except CoercionException:

self._record_exception()

if not isinstance(y, Element):

op_name = op.__name__

if op_name[0] == 'i':

op_name = op_name[1:]

mul_method = getattr(y, '__r%s__'%op_name, None)

if mul_method is not None:

res = mul_method(x)

if res is not None and res is not NotImplemented:

return res

# We should really include the underlying error.

# This causes so much headache.

raise bin_op_exception(op, x, y)

cpdef canonical_coercion(self, x, y):

r"""

Given two elements x and y, with parents S and R respectively,

find a common parent Z such that there are coercions

`f: S \mapsto Z` and `g: R \mapsto Z` and return `f(x), g(y)`

which will have the same parent.

Raises a type error if no such Z can be found.

EXAMPLES::

sage: cm = sage.structure.element.get_coercion_model()

sage: cm.canonical_coercion(mod(2, 10), 17)

(2, 7)

sage: x, y = cm.canonical_coercion(1/2, matrix(ZZ, 2, 2, range(4)))

sage: x

[1/2 0]

[ 0 1/2]

sage: y

[0 1]

[2 3]

sage: parent(x) is parent(y)

True

There is some support for non-Sage datatypes as well::

sage: x, y = cm.canonical_coercion(int(5), 10)

sage: type(x), type(y)

(<type 'sage.rings.integer.Integer'>, <type 'sage.rings.integer.Integer'>)

sage: x, y = cm.canonical_coercion(int(5), complex(3))

sage: type(x), type(y)

(<type 'complex'>, <type 'complex'>)

sage: class MyClass:

....: def _sage_(self):

....: return 13

sage: a, b = cm.canonical_coercion(MyClass(), 1/3)

sage: a, b

(13, 1/3)

sage: type(a)

We also make an exception for 0, even if $\ZZ$ does not map in::

sage: canonical_coercion(vector([1, 2, 3]), 0)

((1, 2, 3), (0, 0, 0))

sage: canonical_coercion(GF(5)(0), float(0))

(0, 0)

"""

xp = parent(x)

yp = parent(y)

if xp is yp:

return x,y

cdef Element x_elt, y_elt

coercions = self.coercion_maps(xp, yp)

if coercions is not None:

x_map, y_map = coercions

if x_map is not None:

x_elt = (<Map>x_map)._call_(x)

else:

x_elt = x

if y_map is not None:

y_elt = (<Map>y_map)._call_(y)

else:

y_elt = y

if x_elt is None:

raise RuntimeError("BUG in map, returned None %s %s %s" % (x, type(x_map), x_map))

elif y_elt is None:

raise RuntimeError("BUG in map, returned None %s %s %s" % (y, type(y_map), y_map))

if x_elt._parent is y_elt._parent:

# We must verify this as otherwise we are prone to

# getting into an infinite loop in c, and the above

# maps may be written by (imperfect) users.

return x_elt,y_elt

elif x_elt._parent == y_elt._parent:

# TODO: Non-uniqueness of parents strikes again!

y_elt = parent(x_elt)(y_elt)

if x_elt._parent is y_elt._parent:

return x_elt,y_elt

self._coercion_error(x, x_map, x_elt, y, y_map, y_elt)

cdef bint x_numeric = isinstance(x, (int, long, float, complex))

cdef bint y_numeric = isinstance(y, (int, long, float, complex))

if not x_numeric and is_numpy_type(type(x)):

import numpy

x_numeric = isinstance(x, numpy.number)

if not y_numeric and is_numpy_type(type(y)):

import numpy

y_numeric = isinstance(y, numpy.number)

if x_numeric and y_numeric:

ty = type(x + y)

return ty(x), ty(y)

# Now handle the native python + sage object cases

# that were not taken care of above.

elif x_numeric:

try:

sage_parent = py_scalar_parent(type(x))

if sage_parent is None or sage_parent.has_coerce_map_from(yp):

return x, x.__class__(y)

else:

return self.canonical_coercion(sage_parent(x), y)

except (TypeError, ValueError):

self._record_exception()

elif y_numeric:

try:

sage_parent = py_scalar_parent(type(y))

if sage_parent is None or sage_parent.has_coerce_map_from(xp):

return y.__class__(x), y

else:

return self.canonical_coercion(x, sage_parent(y))

except (TypeError, ValueError):

self._record_exception()

# See if the non-objects define a _sage_ method.

if not isinstance(x, SageObject) or not isinstance(y, SageObject):

try:

x = x._sage_()

y = y._sage_()

except AttributeError:

self._record_exception()

else:

return self.canonical_coercion(x, y)

# Allow coercion of 0 even if no coercion from Z

if (x_numeric or is_Integer(x)) and not x and type(yp) is not type:

try:

return yp(0), y

except Exception:

self._record_exception()

if (y_numeric or is_Integer(y)) and not y and type(xp) is not type:

try:

return x, xp(0)

except Exception:

self._record_exception()

raise TypeError("no common canonical parent for objects with parents: '%s' and '%s'"%(xp, yp))

cpdef coercion_maps(self, R, S):

r"""

Give two parents `R` and `S`, return a pair of coercion maps

`f: R \rightarrow Z` and `g: S \rightarrow Z` , if such a `Z`

can be found.

In the (common) case that `R=Z` or `S=Z` then ``None`` is returned

for `f` or `g` respectively rather than constructing (and subsequently

calling) the identity morphism.

If no suitable `f, g` can be found, a single ``None`` is returned.

This result is cached.

.. NOTE::

By :trac:`14711`, coerce maps should be copied when using them

outside of the coercion system, because they may become defunct

by garbage collection.

EXAMPLES::

sage: cm = sage.structure.element.get_coercion_model()

sage: f, g = cm.coercion_maps(ZZ, QQ)

sage: print(copy(f))

Natural morphism:

From: Integer Ring

To: Rational Field

sage: print(g)

None

sage: ZZx = ZZ['x']

sage: f, g = cm.coercion_maps(ZZx, QQ)

sage: print(f)

(map internal to coercion system -- copy before use)

Ring morphism:

From: Univariate Polynomial Ring in x over Integer Ring

To: Univariate Polynomial Ring in x over Rational Field

sage: print(g)

(map internal to coercion system -- copy before use)

Polynomial base injection morphism:

From: Rational Field

To: Univariate Polynomial Ring in x over Rational Field

sage: K = GF(7)

sage: cm.coercion_maps(QQ, K) is None

True

Note that to break symmetry, if there is a coercion map in both

directions, the parent on the left is used::

sage: V = QQ^3

sage: W = V.__class__(QQ, 3)

sage: V == W

True

sage: V is W

False

sage: cm = sage.structure.element.get_coercion_model()

sage: cm.coercion_maps(V, W)

(None, (map internal to coercion system -- copy before use)

Coercion map:

From: Vector space of dimension 3 over Rational Field

To: Vector space of dimension 3 over Rational Field)

sage: cm.coercion_maps(W, V)

(None, (map internal to coercion system -- copy before use)

Coercion map:

From: Vector space of dimension 3 over Rational Field

To: Vector space of dimension 3 over Rational Field)

sage: v = V([1,2,3])

sage: w = W([1,2,3])

sage: parent(v+w) is V

True

sage: parent(w+v) is W

True

TESTS:

We check that with :trac:`14058`, parents are still eligible for

garbage collection after being involved in binary operations::

sage: import gc

sage: T=type(GF(2))

sage: gc.collect() #random

852

sage: N0=len(list(o for o in gc.get_objects() if type(o) is T))

sage: L=[ZZ(1)+GF(p)(1) for p in prime_range(2,50)]

sage: N1=len(list(o for o in gc.get_objects() if type(o) is T))

sage: N1 > N0

True

sage: del L

sage: gc.collect() #random

3939

sage: N2=len(list(o for o in gc.get_objects() if type(o) is T))

sage: N2-N0

"""

try:

refs = self._coercion_maps.get(R, S, None)

if refs is None:

return None

R_map_ref, S_map_ref = refs

if R_map_ref is None:

S_map = <object>PyWeakref_GET_OBJECT(S_map_ref)

if S_map is not None:

return None, S_map

elif S_map_ref is None:

R_map = <object>PyWeakref_GET_OBJECT(R_map_ref)

if R_map is not None:

return R_map, None

else:

R_map = <object>PyWeakref_GET_OBJECT(R_map_ref)

S_map = <object>PyWeakref_GET_OBJECT(S_map_ref)

if R_map is not None and S_map is not None:

return R_map, S_map

except KeyError:

pass

homs = self.discover_coercion(R, S)

if 0:

# This breaks too many things that are going to change

# in the new coercion model anyways.

# COERCE TODO: Enable it then.

homs = self.verify_coercion_maps(R, S, homs)

else:

if homs is not None:

x_map, y_map = homs

if x_map is not None and not isinstance(x_map, Map):

raise RuntimeError("BUG in coercion model: coerce_map_from must return a Map")

if y_map is not None and not isinstance(y_map, Map):

raise RuntimeError("BUG in coercion model: coerce_map_from must return a Map")

if homs is None:

refs = None

swap = None

else:

R_map, S_map = homs

R_map_ref = None if R_map is None else PyWeakref_NewRef(R_map, None)

S_map_ref = None if S_map is None else PyWeakref_NewRef(S_map, None)

refs = R_map_ref, S_map_ref

if R_map is None and isinstance(S, Parent) and (<Parent>S).has_coerce_map_from(R):

swap = None, PyWeakref_NewRef((<Parent>S).coerce_map_from(R), None)

else:

swap = S_map_ref, R_map_ref

self._coercion_maps.set(R, S, None, refs)

self._coercion_maps.set(S, R, None, swap)

return homs

cpdef verify_coercion_maps(self, R, S, homs, bint fix=False):

"""

Make sure this is a valid pair of homomorphisms from R and S to a common parent.

This function is used to protect the user against buggy parents.

EXAMPLES::

sage: cm = sage.structure.element.get_coercion_model()

sage: homs = QQ.coerce_map_from(ZZ), None

sage: cm.verify_coercion_maps(ZZ, QQ, homs) == homs

True

sage: homs = QQ.coerce_map_from(ZZ), RR.coerce_map_from(QQ)

sage: cm.verify_coercion_maps(ZZ, QQ, homs) == homs

Traceback (most recent call last):

...

RuntimeError: ('BUG in coercion model, codomains must be identical', Natural morphism:

From: Integer Ring

To: Rational Field, Generic map:

From: Rational Field

To: Real Field with 53 bits of precision)

"""

if homs is None:

return None

cdef Map x_map, y_map

R_map, S_map = homs

if isinstance(R, type):

R = Set_PythonType(R)

elif isinstance(S, type):

S = Set_PythonType(S)

if R_map is None:

R_map = IdentityMorphism(R)

elif S_map is None:

S_map = IdentityMorphism(S)

# Make sure the domains are correct

if R_map.domain() is not R:

if fix:

connecting = R_map.domain()._internal_coerce_map_from(R)

if connecting is not None:

R_map = R_map * connecting

if R_map.domain() is not R:

raise RuntimeError("BUG in coercion model, left domain must be original parent", R, R_map)

if S_map is not None and S_map.domain() is not S:

if fix:

connecting = S_map.domain()._internal_coerce_map_from(S)

if connecting is not None:

S_map = S_map * connecting

if S_map.domain() is not S:

raise RuntimeError("BUG in coercion model, right domain must be original parent", S, S_map)

# Make sure the codomains are correct

if R_map.codomain() is not S_map.codomain():

if fix:

connecting = R_map.codomain()._internal_coerce_map_from(S_map.codomain())

if connecting is not None:

S_map = connecting * S_map

else:

connecting = S_map.codomain()._internal_coerce_map_from(R_map.codomain())

if connecting is not None:

R_map = connecting * R_map

if R_map.codomain() is not S_map.codomain():

raise RuntimeError("BUG in coercion model, codomains must be identical", R_map, S_map)

if isinstance(R_map, IdentityMorphism):

R_map = None

elif isinstance(S_map, IdentityMorphism):

S_map = None

return R_map, S_map

cpdef discover_coercion(self, R, S):

"""

This actually implements the finding of coercion maps as described in

the ``coercion_maps`` method.

EXAMPLES::

sage: cm = sage.structure.element.get_coercion_model()

If R is S, then two identity morphisms suffice::

sage: cm.discover_coercion(SR, SR)

(None, None)

If there is a coercion map either direction, use that::

sage: cm.discover_coercion(ZZ, QQ)

((map internal to coercion system -- copy before use)

Natural morphism:

From: Integer Ring

To: Rational Field, None)

sage: cm.discover_coercion(RR, QQ)

(None, (map internal to coercion system -- copy before use)

Generic map:

From: Rational Field

To: Real Field with 53 bits of precision)

Otherwise, try and compute an appropriate cover::

sage: ZZxy = ZZ['x,y']

sage: cm.discover_coercion(ZZxy, RDF)

((map internal to coercion system -- copy before use)

Call morphism:

From: Multivariate Polynomial Ring in x, y over Integer Ring

To: Multivariate Polynomial Ring in x, y over Real Double Field,

Polynomial base injection morphism:

From: Real Double Field

To: Multivariate Polynomial Ring in x, y over Real Double Field)

Sometimes there is a reasonable "cover," but no canonical coercion::

sage: sage.categories.pushout.pushout(QQ, QQ^3)

Vector space of dimension 3 over Rational Field

sage: print(cm.discover_coercion(QQ, QQ^3))

None

"""

from sage.categories.homset import Hom

if R is S:

return None, None

# See if there is a natural coercion from R to S

if isinstance(R, Parent):

mor = (<Parent>R)._internal_coerce_map_from(S)

if mor is not None:

return None, mor

# See if there is a natural coercion from S to R

if isinstance(S, Parent):

mor = (<Parent>S)._internal_coerce_map_from(R)

if mor is not None:

return mor, None

# Try base extending

if isinstance(R, Parent) and isinstance(S, Parent):

from sage.categories.pushout import pushout

try:

Z = pushout(R, S)

coerce_R = Z._internal_coerce_map_from(R)

coerce_S = Z._internal_coerce_map_from(S)

if coerce_R is None:

raise TypeError("No coercion from %s to pushout %s" % (R, Z))

if coerce_S is None:

raise TypeError("No coercion from %s to pushout %s" % (S, Z))

return coerce_R, coerce_S

except Exception:

self._record_exception()

return None

cpdef get_action(self, R, S, op, r=None, s=None):

"""

Get the action of R on S or S on R associated to the operation op.

EXAMPLES::

sage: cm = sage.structure.element.get_coercion_model()

sage: ZZx = ZZ['x']

sage: cm.get_action(ZZx, ZZ, operator.mul)

Right scalar multiplication by Integer Ring on Univariate Polynomial Ring in x over Integer Ring

sage: cm.get_action(ZZx, ZZ, operator.imul)

Right scalar multiplication by Integer Ring on Univariate Polynomial Ring in x over Integer Ring

sage: cm.get_action(ZZx, QQ, operator.mul)

Right scalar multiplication by Rational Field on Univariate Polynomial Ring in x over Integer Ring

sage: QQx = QQ['x']

sage: cm.get_action(QQx, int, operator.mul)

Right scalar multiplication by Integer Ring on Univariate Polynomial Ring in x over Rational Field

with precomposition on right by Native morphism:

From: Set of Python objects of class 'int'

To: Integer Ring

sage: A = cm.get_action(QQx, ZZ, operator.truediv); A

Right inverse action by Rational Field on Univariate Polynomial Ring in x over Rational Field

with precomposition on right by Natural morphism:

From: Integer Ring

To: Rational Field

sage: x = QQx.gen()

sage: A(x+10, 5)

1/5*x + 2

TESTS:

In Python 2, ``operator.div`` still works::

sage: from six import PY2

sage: div = getattr(operator, "div" if PY2 else "truediv")

sage: cm.get_action(QQx, ZZ, div)

Right inverse action by Rational Field on Univariate Polynomial Ring in x over Rational Field

with precomposition on right by Natural morphism:

From: Integer Ring

To: Rational Field

"""

try:

return self._action_maps.get(R, S, op)

except KeyError:

pass

action = self.discover_action(R, S, op, r, s)

action = self.verify_action(action, R, S, op)

self._action_maps.set(R, S, op, action)

return action

cpdef verify_action(self, action, R, S, op, bint fix=True):

r"""

Verify that ``action`` takes an element of R on the left and S

on the right, raising an error if not.

This is used for consistency checking in the coercion model.

EXAMPLES::

sage: R.<x> = ZZ['x']

sage: cm = sage.structure.element.get_coercion_model()

sage: cm.verify_action(R.get_action(QQ), R, QQ, operator.mul)

Right scalar multiplication by Rational Field on Univariate Polynomial Ring in x over Integer Ring

sage: cm.verify_action(R.get_action(QQ), RDF, R, operator.mul)

Traceback (most recent call last):

...

RuntimeError: There is a BUG in the coercion model:

Action found for R <built-in function mul> S does not have the correct domains

R = Real Double Field

S = Univariate Polynomial Ring in x over Integer Ring

(should be Univariate Polynomial Ring in x over Integer Ring, Rational Field)

action = Right scalar multiplication by Rational Field on

Univariate Polynomial Ring in x over Integer Ring (<type 'sage.structure.coerce_actions.RightModuleAction'>)

"""

if action is None:

return action

cdef bint ok = True

try:

if action.left_domain() is not R:

ok &= isinstance(R, type) and action.left_domain()._type is R

if action.right_domain() is not S:

ok &= isinstance(S, type) and action.right_domain()._type is S

except AttributeError:

ok = False

if not ok:

if isinstance(R, type):

R = Set_PythonType(R)

if isinstance(S, type):

S = Set_PythonType(S)

# Non-unique parents

if fix and action.left_domain() is not R and action.left_domain() == R:

action = PrecomposedAction(action, action.left_domain()._internal_coerce_map_from(R), None)

if fix and action.right_domain() is not S and action.right_domain() == S:

action = PrecomposedAction(action, None, action.right_domain()._internal_coerce_map_from(S))

if action.left_domain() is not R or action.right_domain() is not S:

raise RuntimeError("""There is a BUG in the coercion model:

Action found for R %s S does not have the correct domains

R = %s

S = %s

(should be %s, %s)

action = %s (%s)

""" % (op, R, S, action.left_domain(), action.right_domain(), action, type(action)))

return action

cpdef discover_action(self, R, S, op, r=None, s=None):

"""

INPUT:

- ``R`` - the left Parent (or type)

- ``S`` - the right Parent (or type)

- ``op`` - the operand, typically an element of the operator module

- ``r`` - (optional) element of R

- ``s`` - (optional) element of S.

OUTPUT:

- An action A such that s op r is given by A(s,r).

The steps taken are illustrated below.

EXAMPLES::

sage: P.<x> = ZZ['x']

sage: P.get_action(ZZ)

Right scalar multiplication by Integer Ring on Univariate Polynomial Ring in x over Integer Ring

sage: ZZ.get_action(P) is None

True

sage: cm = sage.structure.element.get_coercion_model()

If R or S is a Parent, ask it for an action by/on R::

sage: cm.discover_action(ZZ, P, operator.mul)

Left scalar multiplication by Integer Ring on Univariate Polynomial Ring in x over Integer Ring

If R or S a type, recursively call get_action with the Sage versions of R and/or S::

sage: cm.discover_action(P, int, operator.mul)

Right scalar multiplication by Integer Ring on Univariate Polynomial Ring in x over Integer Ring

with precomposition on right by Native morphism:

From: Set of Python objects of class 'int'

To: Integer Ring

If op in an inplace operation, look for the non-inplace action::

sage: cm.discover_action(P, ZZ, operator.imul)

Right scalar multiplication by Integer Ring on Univariate Polynomial Ring in x over Integer Ring

If op is division, look for action on right by inverse::

sage: cm.discover_action(P, ZZ, operator.truediv)

Right inverse action by Rational Field on Univariate Polynomial Ring in x over Integer Ring

with precomposition on right by Natural morphism:

From: Integer Ring

To: Rational Field

Check that :trac:`17740` is fixed::

sage: R = GF(5)['x']

sage: cm.discover_action(R, ZZ, operator.truediv)

Right inverse action by Finite Field of size 5 on Univariate Polynomial Ring in x over Finite Field of size 5

with precomposition on right by Natural morphism:

From: Integer Ring

To: Finite Field of size 5

sage: cm.bin_op(R.gen(), 7, operator.truediv).parent()

Univariate Polynomial Ring in x over Finite Field of size 5

Check that :trac:`18221` is fixed::

sage: F.<x> = FreeAlgebra(QQ)

sage: x / 2

1/2*x

sage: cm.discover_action(F, ZZ, operator.truediv)

Right inverse action by Rational Field on Free Algebra on 1 generators (x,) over Rational Field

with precomposition on right by Natural morphism:

From: Integer Ring

To: Rational Field

TESTS:

In Python 2, ``operator.div`` still works::

sage: from six import PY2

sage: div = getattr(operator, "div" if PY2 else "truediv")

sage: cm.discover_action(F, ZZ, div)

Right inverse action by Rational Field on Free Algebra on 1 generators (x,) over Rational Field

with precomposition on right by Natural morphism:

From: Integer Ring

To: Rational Field

"""

if op is div:

op = truediv

if isinstance(R, Parent):

action = (<Parent>R).get_action(S, op, True, r, s)

if action is not None:

return action

if isinstance(S, Parent):

action = (<Parent>S).get_action(R, op, False, s, r)

if action is not None:

return action

if type(R) is type:

sageR = py_scalar_parent(R)

if sageR is not None:

action = self.discover_action(sageR, S, op, s=s)

if action is not None:

return PrecomposedAction(action, sageR._internal_coerce_map_from(R), None)

if type(S) is type:

sageS = py_scalar_parent(S)

if sageS is not None:

action = self.discover_action(R, sageS, op, r=r)

if action is not None:

return PrecomposedAction(action, None, sageS._internal_coerce_map_from(S))

if op.__name__[0] == 'i':

try:

no_inplace_op = operator_dict[op.__name__[1:]]

a = self.discover_action(R, S, no_inplace_op, r, s)

if a is not None:

is_inverse = isinstance(a, InverseAction)

if is_inverse: a = ~a

if a is not None and isinstance(a, RightModuleAction):

# We want a new instance so that we don't alter the (potentially cached) original

a = RightModuleAction(S, R, s, r)

if is_inverse: a = ~a

return a

except KeyError:

self._record_exception()

if op is truediv:

# Division on right is the same acting on right by inverse, if it is so defined.

right_mul = None

try:

right_mul = self.get_action(R, S, mul)

except NotImplementedError:

self._record_exception()

if right_mul is not None and not right_mul.is_left():

try:

action = ~right_mul

if action.right_domain() != S:

action = PrecomposedAction(action, None,

action.right_domain()._internal_coerce_map_from(S))

return action

except TypeError: # action may not be invertible

self._record_exception()

# It's possible an action is defined on the fraction field itself.

try:

K = S._pseudo_fraction_field()

except AttributeError:

pass

else:

if K is not S:

try:

right_mul = self.get_action(R, K, mul)

except NotImplementedError:

self._record_exception()

if right_mul is not None and not right_mul.is_left():

try:

return PrecomposedAction(~right_mul, None, K.coerce_map_from(S))

except TypeError: # action may not be invertible

self._record_exception()

return None

cpdef richcmp(self, x, y, int op):

"""

Given two arbitrary objects ``x`` and ``y``, coerce them to

a common parent and compare them using rich comparison operator

``op``.

EXAMPLES::

sage: from sage.structure.element import get_coercion_model

sage: from sage.structure.richcmp import op_LT, op_LE, op_EQ, op_NE, op_GT, op_GE

sage: richcmp = get_coercion_model().richcmp

sage: richcmp(None, None, op_EQ)

True

sage: richcmp(None, 1, op_LT)

True

sage: richcmp("hello", None, op_LE)

False

sage: richcmp(-1, 1, op_GE)

False

sage: richcmp(int(1), float(2), op_GE)

False

If there is no coercion, only comparisons for equality make

sense::

sage: x = QQ.one(); y = GF(2).one()

sage: richcmp(x, y, op_EQ)

False

sage: richcmp(x, y, op_NE)

True

We support non-Sage types with the usual Python convention::

sage: class AlwaysEqual(object):

....: def __eq__(self, other):

....: return True

sage: x = AlwaysEqual()

sage: x == 1

True

sage: 1 == x

True

"""

# Some very special cases

if x is None or x is Ellipsis:

return rich_to_bool(op, 0 if x is y else -1)

if y is None or y is Ellipsis:

return rich_to_bool(op, 0 if x is y else 1)

cdef bint y_is_Element = isinstance(y, Element)

# Check for manual __richcmp__ override (only on y since

# x.__richcmp__ would already have been called)

if y_is_Element:

if (<Element>y)._parent.get_flag(Parent_richcmp_element_without_coercion):

return Py_TYPE(y).tp_richcompare(y, x, revop(op))

# Coerce to a common parent

try:

x, y = self.canonical_coercion(x, y)

except (TypeError, NotImplementedError):

pass

else:

# The common parent should not be one which explicitly

# asked to *not* use coercion for comparisons.

assert not (isinstance(x, Element) and

(<Element>x)._parent.get_flag(Parent_richcmp_element_without_coercion))

return PyObject_RichCompare(x, y, op)

# Comparing with coercion didn't work, try something else.

# Try y.__richcmp__(x, revop) where revop is the reversed

# operation (<= becomes >=).

# This only makes sense when y is not a Sage Element, otherwise

# we would end up trying the same coercion again.

if not y_is_Element and Py_TYPE(y).tp_richcompare:

res = Py_TYPE(y).tp_richcompare(y, x, revop(op))

if res is not NotImplemented:

return res

# Final attempt: compare by id()

if (<unsigned long><PyObject*>x) >= (<unsigned long><PyObject*>y):

# It cannot happen that x is y, since they don't

# have the same parent.

return rich_to_bool(op, 1)

else:

return rich_to_bool(op, -1)

def _coercion_error(self, x, x_map, x_elt, y, y_map, y_elt):

"""

This function is only called when someone has incorrectly implemented

a user-defined part of the coercion system (usually, a morphism).

EXAMPLES::

sage: cm = sage.structure.element.get_coercion_model()

sage: cm._coercion_error('a', 'f', 'f(a)', 'b', 'g', 'g(b)')

Traceback (most recent call last):

...

RuntimeError: There is a bug in the coercion code in Sage.

Both x (='f(a)') and y (='g(b)') are supposed to have identical parents but they don't.

In fact, x has parent '<type 'str'>'

whereas y has parent '<type 'str'>'

Original elements 'a' (parent <type 'str'>) and 'b' (parent <type 'str'>) and maps

<type 'str'> 'f'

<type 'str'> 'g'

"""

raise RuntimeError("""There is a bug in the coercion code in Sage.

Both x (=%r) and y (=%r) are supposed to have identical parents but they don't.

In fact, x has parent '%s'

whereas y has parent '%s'

Original elements %r (parent %s) and %r (parent %s) and maps

%s %r

%s %r""" % (x_elt, y_elt, parent(x_elt), parent(y_elt),

x, parent(x), y, parent(y),

type(x_map), x_map, type(y_map), y_map))

Coverage for local/lib/python2.7/site-packages/sage/structure/coerce.pyx : 81%

583 statements 471 run 112 missing 0 excluded