ai-content-maker/.venv/Lib/site-packages/sympy/polys/domains/rationalfield.py

164 lines
4.8 KiB
Python
Raw Normal View History

2024-05-03 04:18:51 +03:00
"""Implementation of :class:`RationalField` class. """
from sympy.external.gmpy import MPQ
from sympy.polys.domains.groundtypes import SymPyRational
from sympy.polys.domains.characteristiczero import CharacteristicZero
from sympy.polys.domains.field import Field
from sympy.polys.domains.simpledomain import SimpleDomain
from sympy.polys.polyerrors import CoercionFailed
from sympy.utilities import public
@public
class RationalField(Field, CharacteristicZero, SimpleDomain):
r"""Abstract base class for the domain :ref:`QQ`.
The :py:class:`RationalField` class represents the field of rational
numbers $\mathbb{Q}$ as a :py:class:`~.Domain` in the domain system.
:py:class:`RationalField` is a superclass of
:py:class:`PythonRationalField` and :py:class:`GMPYRationalField` one of
which will be the implementation for :ref:`QQ` depending on whether either
of ``gmpy`` or ``gmpy2`` is installed or not.
See also
========
Domain
"""
rep = 'QQ'
alias = 'QQ'
is_RationalField = is_QQ = True
is_Numerical = True
has_assoc_Ring = True
has_assoc_Field = True
dtype = MPQ
zero = dtype(0)
one = dtype(1)
tp = type(one)
def __init__(self):
pass
def get_ring(self):
"""Returns ring associated with ``self``. """
from sympy.polys.domains import ZZ
return ZZ
def to_sympy(self, a):
"""Convert ``a`` to a SymPy object. """
return SymPyRational(int(a.numerator), int(a.denominator))
def from_sympy(self, a):
"""Convert SymPy's Integer to ``dtype``. """
if a.is_Rational:
return MPQ(a.p, a.q)
elif a.is_Float:
from sympy.polys.domains import RR
return MPQ(*map(int, RR.to_rational(a)))
else:
raise CoercionFailed("expected `Rational` object, got %s" % a)
def algebraic_field(self, *extension, alias=None):
r"""Returns an algebraic field, i.e. `\mathbb{Q}(\alpha, \ldots)`.
Parameters
==========
*extension : One or more :py:class:`~.Expr`
Generators of the extension. These should be expressions that are
algebraic over `\mathbb{Q}`.
alias : str, :py:class:`~.Symbol`, None, optional (default=None)
If provided, this will be used as the alias symbol for the
primitive element of the returned :py:class:`~.AlgebraicField`.
Returns
=======
:py:class:`~.AlgebraicField`
A :py:class:`~.Domain` representing the algebraic field extension.
Examples
========
>>> from sympy import QQ, sqrt
>>> QQ.algebraic_field(sqrt(2))
QQ<sqrt(2)>
"""
from sympy.polys.domains import AlgebraicField
return AlgebraicField(self, *extension, alias=alias)
def from_AlgebraicField(K1, a, K0):
"""Convert a :py:class:`~.ANP` object to :ref:`QQ`.
See :py:meth:`~.Domain.convert`
"""
if a.is_ground:
return K1.convert(a.LC(), K0.dom)
def from_ZZ(K1, a, K0):
"""Convert a Python ``int`` object to ``dtype``. """
return MPQ(a)
def from_ZZ_python(K1, a, K0):
"""Convert a Python ``int`` object to ``dtype``. """
return MPQ(a)
def from_QQ(K1, a, K0):
"""Convert a Python ``Fraction`` object to ``dtype``. """
return MPQ(a.numerator, a.denominator)
def from_QQ_python(K1, a, K0):
"""Convert a Python ``Fraction`` object to ``dtype``. """
return MPQ(a.numerator, a.denominator)
def from_ZZ_gmpy(K1, a, K0):
"""Convert a GMPY ``mpz`` object to ``dtype``. """
return MPQ(a)
def from_QQ_gmpy(K1, a, K0):
"""Convert a GMPY ``mpq`` object to ``dtype``. """
return a
def from_GaussianRationalField(K1, a, K0):
"""Convert a ``GaussianElement`` object to ``dtype``. """
if a.y == 0:
return MPQ(a.x)
def from_RealField(K1, a, K0):
"""Convert a mpmath ``mpf`` object to ``dtype``. """
return MPQ(*map(int, K0.to_rational(a)))
def exquo(self, a, b):
"""Exact quotient of ``a`` and ``b``, implies ``__truediv__``. """
return MPQ(a) / MPQ(b)
def quo(self, a, b):
"""Quotient of ``a`` and ``b``, implies ``__truediv__``. """
return MPQ(a) / MPQ(b)
def rem(self, a, b):
"""Remainder of ``a`` and ``b``, implies nothing. """
return self.zero
def div(self, a, b):
"""Division of ``a`` and ``b``, implies ``__truediv__``. """
return MPQ(a) / MPQ(b), self.zero
def numer(self, a):
"""Returns numerator of ``a``. """
return a.numerator
def denom(self, a):
"""Returns denominator of ``a``. """
return a.denominator
QQ = RationalField()