Spaces:
Running
Running
File size: 3,236 Bytes
6a86ad5 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 |
"""Implementation of :class:`Ring` class. """
from sympy.polys.domains.domain import Domain
from sympy.polys.polyerrors import ExactQuotientFailed, NotInvertible, NotReversible
from sympy.utilities import public
@public
class Ring(Domain):
"""Represents a ring domain. """
is_Ring = True
def get_ring(self):
"""Returns a ring associated with ``self``. """
return self
def exquo(self, a, b):
"""Exact quotient of ``a`` and ``b``, implies ``__floordiv__``. """
if a % b:
raise ExactQuotientFailed(a, b, self)
else:
return a // b
def quo(self, a, b):
"""Quotient of ``a`` and ``b``, implies ``__floordiv__``. """
return a // b
def rem(self, a, b):
"""Remainder of ``a`` and ``b``, implies ``__mod__``. """
return a % b
def div(self, a, b):
"""Division of ``a`` and ``b``, implies ``__divmod__``. """
return divmod(a, b)
def invert(self, a, b):
"""Returns inversion of ``a mod b``. """
s, t, h = self.gcdex(a, b)
if self.is_one(h):
return s % b
else:
raise NotInvertible("zero divisor")
def revert(self, a):
"""Returns ``a**(-1)`` if possible. """
if self.is_one(a) or self.is_one(-a):
return a
else:
raise NotReversible('only units are reversible in a ring')
def is_unit(self, a):
try:
self.revert(a)
return True
except NotReversible:
return False
def numer(self, a):
"""Returns numerator of ``a``. """
return a
def denom(self, a):
"""Returns denominator of `a`. """
return self.one
def free_module(self, rank):
"""
Generate a free module of rank ``rank`` over self.
>>> from sympy.abc import x
>>> from sympy import QQ
>>> QQ.old_poly_ring(x).free_module(2)
QQ[x]**2
"""
raise NotImplementedError
def ideal(self, *gens):
"""
Generate an ideal of ``self``.
>>> from sympy.abc import x
>>> from sympy import QQ
>>> QQ.old_poly_ring(x).ideal(x**2)
<x**2>
"""
from sympy.polys.agca.ideals import ModuleImplementedIdeal
return ModuleImplementedIdeal(self, self.free_module(1).submodule(
*[[x] for x in gens]))
def quotient_ring(self, e):
"""
Form a quotient ring of ``self``.
Here ``e`` can be an ideal or an iterable.
>>> from sympy.abc import x
>>> from sympy import QQ
>>> QQ.old_poly_ring(x).quotient_ring(QQ.old_poly_ring(x).ideal(x**2))
QQ[x]/<x**2>
>>> QQ.old_poly_ring(x).quotient_ring([x**2])
QQ[x]/<x**2>
The division operator has been overloaded for this:
>>> QQ.old_poly_ring(x)/[x**2]
QQ[x]/<x**2>
"""
from sympy.polys.agca.ideals import Ideal
from sympy.polys.domains.quotientring import QuotientRing
if not isinstance(e, Ideal):
e = self.ideal(*e)
return QuotientRing(self, e)
def __truediv__(self, e):
return self.quotient_ring(e)
|