
    \h^                         S r SSKJr  SSKJrJrJr  SSKJr  SSK	J
r
  SSKJr  SSKJr  SSKJr  \ " S	 S
\
\\5      5       r\" 5       rg)z0Implementation of :class:`RationalField` class.     MPQ)SymPyRational	is_squaresqrtrem)CharacteristicZero)Field)SimpleDomain)CoercionFailed)publicc                       \ rS rSrSrSrSrS=rrSr	Sr
Sr\r\" S5      r\" S5      r\" \5      rS rS rS	 rS
 rS rS rSS.S jrS rS rS rS rS rS rS rS r S r!S r"S r#S r$S r%S r&S r'S r(S  r)S!r*g)"RationalField   a  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
QQTr      c                     g )N selfs    Y/var/www/auris/envauris/lib/python3.13/site-packages/sympy/polys/domains/rationalfield.py__init__RationalField.__init__-   s        c                 :    [        U[        5      (       a  g[        $ )z0Returns ``True`` if two domains are equivalent. T)
isinstancer   NotImplemented)r   others     r   __eq__RationalField.__eq__0   s    e]++!!r   c                     [        S5      $ )zReturns hash code of ``self``. r   )hashr   s    r   __hash__RationalField.__hash__7   s    Dzr   c                     SSK Jn  U$ )z'Returns ring associated with ``self``. r   )ZZ)sympy.polys.domainsr%   )r   r%   s     r   get_ringRationalField.get_ring;   s
    *	r   c                 f    [        [        UR                  5      [        UR                  5      5      $ )z!Convert ``a`` to a SymPy object. )r   int	numeratordenominatorr   as     r   to_sympyRationalField.to_sympy@   s!    S-s1==/ABBr   c                     UR                   (       a   [        UR                  UR                  5      $ UR                  (       a+  SSKJn  [        [        [        UR                  U5      5      6 $ [        SU-  5      e)z&Convert SymPy's Integer to ``dtype``. r   )RRz"expected `Rational` object, got %s)is_Rationalr   pqis_Floatr&   r2   mapr*   to_rationalr   )r   r.   r2   s      r   
from_sympyRationalField.from_sympyD   sS    ==qssACC= ZZ.C!2344 !E!IJJr   N)aliasc                &    SSK Jn  U" U /UQ7SU06$ )a  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)>
r   )AlgebraicFieldr;   )r&   r=   )r   r;   	extensionr=   s       r   algebraic_fieldRationalField.algebraic_fieldN   s    6 	7d<Y<e<<r   c                 z    UR                   (       a*  U R                  UR                  5       UR                  5      $ g)zRConvert a :py:class:`~.ANP` object to :ref:`QQ`.

See :py:meth:`~.Domain.convert`
N)	is_groundconvertLCdomK1r.   K0s      r   from_AlgebraicField!RationalField.from_AlgebraicFieldl   s+    
 ;;::addfbff-- r   c                     [        U5      $ z.Convert a Python ``int`` object to ``dtype``. r   rF   s      r   from_ZZRationalField.from_ZZt       1vr   c                     [        U5      $ rL   r   rF   s      r   from_ZZ_pythonRationalField.from_ZZ_pythonx   rO   r   c                 B    [        UR                  UR                  5      $ z3Convert a Python ``Fraction`` object to ``dtype``. r   r+   r,   rF   s      r   from_QQRationalField.from_QQ|       1;;..r   c                 B    [        UR                  UR                  5      $ rT   rU   rF   s      r   from_QQ_pythonRationalField.from_QQ_python   rX   r   c                     [        U5      $ )z,Convert a GMPY ``mpz`` object to ``dtype``. r   rF   s      r   from_ZZ_gmpyRationalField.from_ZZ_gmpy   rO   r   c                     U$ )z,Convert a GMPY ``mpq`` object to ``dtype``. r   rF   s      r   from_QQ_gmpyRationalField.from_QQ_gmpy   s    r   c                 N    UR                   S:X  a  [        UR                  5      $ g)z3Convert a ``GaussianElement`` object to ``dtype``. r   N)yr   xrF   s      r   from_GaussianRationalField(RationalField.from_GaussianRationalField   s    33!8qss8O r   c                 L    [        [        [        UR                  U5      5      6 $ )z.Convert a mpmath ``mpf`` object to ``dtype``. )r   r7   r*   r8   rF   s      r   from_RealFieldRationalField.from_RealField   s    CR^^A./00r   c                 0    [        U5      [        U5      -  $ )z=Exact quotient of ``a`` and ``b``, implies ``__truediv__``.  r   r   r.   bs      r   exquoRationalField.exquo       1vAr   c                 0    [        U5      [        U5      -  $ )z6Quotient of ``a`` and ``b``, implies ``__truediv__``. r   rk   s      r   quoRationalField.quo   ro   r   c                     U R                   $ )z0Remainder of ``a`` and ``b``, implies nothing.  )zerork   s      r   remRationalField.rem   s    yyr   c                 H    [        U5      [        U5      -  U R                  4$ )z6Division of ``a`` and ``b``, implies ``__truediv__``. )r   rt   rk   s      r   divRationalField.div   s    1vA		))r   c                     UR                   $ )zReturns numerator of ``a``. )r+   r-   s     r   numerRationalField.numer   s    {{r   c                     UR                   $ )zReturns denominator of ``a``. )r,   r-   s     r   denomRationalField.denom   s    }}r   c                 d    [        UR                  5      =(       a    [        UR                  5      $ )zReturn ``True`` if ``a`` is a square.

Explanation
===========
A rational number is a square if and only if there exists
a rational number ``b`` such that ``b * b == a``.
)r   r+   r,   r-   s     r   r   RationalField.is_square   s!     %B)AMM*BBr   c                     UR                   S:  a  g[        UR                   5      u  p#US:w  a  g[        UR                  5      u  pEUS:w  a  g[        X$5      $ )zUNon-negative square root of ``a`` if ``a`` is a square.

See also
========
is_square
r   N)r+   r   r,   r   )r   r.   p_sqrtp_remq_sqrtq_rems         r   exsqrtRationalField.exsqrt   sQ     ;;?,A:.A:6""r   r   )+__name__
__module____qualname____firstlineno____doc__repr;   is_RationalFieldis_QQis_Numericalhas_assoc_Ringhas_assoc_Fieldr   dtypert   onetypetpr   r   r"   r'   r/   r9   r?   rI   rM   rQ   rV   rZ   r]   r`   re   rh   rm   rq   ru   rx   r{   r~   r   r   __static_attributes__r   r   r   r   r      s     CE##uLNOE8D
(C	cB"
CK 15 =<.//
1*C#r   r   N)r   sympy.external.gmpyr   sympy.polys.domains.groundtypesr   r   r   &sympy.polys.domains.characteristiczeror   sympy.polys.domains.fieldr	    sympy.polys.domains.simpledomainr
   sympy.polys.polyerrorsr   sympy.utilitiesr   r   r   r   r   r   <module>r      sM    6 $ M M E + 9 1 "w#E-| w# w#r _r   