Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/sympy/algebras/__init__.py

@@ -0,0 +1,3 @@
+from .quaternion import Quaternion
+
+__all__ = ["Quaternion",]

env-llmeval/lib/python3.10/site-packages/sympy/algebras/quaternion.py

@@ -0,0 +1,1673 @@
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.relational import is_eq
+from sympy.functions.elementary.complexes import (conjugate, im, re, sign)
+from sympy.functions.elementary.exponential import (exp, log as ln)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, asin, atan2)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.simplify.trigsimp import trigsimp
+from sympy.integrals.integrals import integrate
+from sympy.matrices.dense import MutableDenseMatrix as Matrix
+from sympy.core.sympify import sympify, _sympify
+from sympy.core.expr import Expr
+from sympy.core.logic import fuzzy_not, fuzzy_or
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+def _check_norm(elements, norm):
+    """validate if input norm is consistent"""
+    if norm is not None and norm.is_number:
+        if norm.is_positive is False:
+            raise ValueError("Input norm must be positive.")
+
+        numerical = all(i.is_number and i.is_real is True for i in elements)
+        if numerical and is_eq(norm**2, sum(i**2 for i in elements)) is False:
+            raise ValueError("Incompatible value for norm.")
+
+
+def _is_extrinsic(seq):
+    """validate seq and return True if seq is lowercase and False if uppercase"""
+    if type(seq) != str:
+        raise ValueError('Expected seq to be a string.')
+    if len(seq) != 3:
+        raise ValueError("Expected 3 axes, got `{}`.".format(seq))
+
+    intrinsic = seq.isupper()
+    extrinsic = seq.islower()
+    if not (intrinsic or extrinsic):
+        raise ValueError("seq must either be fully uppercase (for extrinsic "
+                         "rotations), or fully lowercase, for intrinsic "
+                         "rotations).")
+
+    i, j, k = seq.lower()
+    if (i == j) or (j == k):
+        raise ValueError("Consecutive axes must be different")
+
+    bad = set(seq) - set('xyzXYZ')
+    if bad:
+        raise ValueError("Expected axes from `seq` to be from "
+                         "['x', 'y', 'z'] or ['X', 'Y', 'Z'], "
+                         "got {}".format(''.join(bad)))
+
+    return extrinsic
+
+
+class Quaternion(Expr):
+    """Provides basic quaternion operations.
+    Quaternion objects can be instantiated as Quaternion(a, b, c, d)
+    as in (a + b*i + c*j + d*k).
+
+    Parameters
+    ==========
+
+    norm : None or number
+        Pre-defined quaternion norm. If a value is given, Quaternion.norm
+        returns this pre-defined value instead of calculating the norm
+
+    Examples
+    ========
+
+    >>> from sympy import Quaternion
+    >>> q = Quaternion(1, 2, 3, 4)
+    >>> q
+    1 + 2*i + 3*j + 4*k
+
+    Quaternions over complex fields can be defined as :
+
+    >>> from sympy import Quaternion
+    >>> from sympy import symbols, I
+    >>> x = symbols('x')
+    >>> q1 = Quaternion(x, x**3, x, x**2, real_field = False)
+    >>> q2 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+    >>> q1
+    x + x**3*i + x*j + x**2*k
+    >>> q2
+    (3 + 4*I) + (2 + 5*I)*i + 0*j + (7 + 8*I)*k
+
+    Defining symbolic unit quaternions:
+    >>> from sympy import Quaternion
+    >>> from sympy.abc import w, x, y, z
+    >>> q = Quaternion(w, x, y, z, norm=1)
+    >>> q
+    w + x*i + y*j + z*k
+    >>> q.norm()
+    1
+
+    References
+    ==========
+
+    .. [1] https://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/
+    .. [2] https://en.wikipedia.org/wiki/Quaternion
+
+    """
+    _op_priority = 11.0
+
+    is_commutative = False
+
+    def __new__(cls, a=0, b=0, c=0, d=0, real_field=True, norm=None):
+        a, b, c, d = map(sympify, (a, b, c, d))
+
+        if any(i.is_commutative is False for i in [a, b, c, d]):
+            raise ValueError("arguments have to be commutative")
+        else:
+            obj = Expr.__new__(cls, a, b, c, d)
+            obj._a = a
+            obj._b = b
+            obj._c = c
+            obj._d = d
+            obj._real_field = real_field
+            obj.set_norm(norm)
+            return obj
+
+    def set_norm(self, norm):
+        """Sets norm of an already instantiated quaternion.
+
+        Parameters
+        ==========
+
+        norm : None or number
+            Pre-defined quaternion norm. If a value is given, Quaternion.norm
+            returns this pre-defined value instead of calculating the norm
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q = Quaternion(a, b, c, d)
+        >>> q.norm()
+        sqrt(a**2 + b**2 + c**2 + d**2)
+
+        Setting the norm:
+
+        >>> q.set_norm(1)
+        >>> q.norm()
+        1
+
+        Removing set norm:
+
+        >>> q.set_norm(None)
+        >>> q.norm()
+        sqrt(a**2 + b**2 + c**2 + d**2)
+
+        """
+        norm = sympify(norm)
+        _check_norm(self.args, norm)
+        self._norm = norm
+
+    @property
+    def a(self):
+        return self._a
+
+    @property
+    def b(self):
+        return self._b
+
+    @property
+    def c(self):
+        return self._c
+
+    @property
+    def d(self):
+        return self._d
+
+    @property
+    def real_field(self):
+        return self._real_field
+
+    @property
+    def product_matrix_left(self):
+        r"""Returns 4 x 4 Matrix equivalent to a Hamilton product from the
+        left. This can be useful when treating quaternion elements as column
+        vectors. Given a quaternion $q = a + bi + cj + dk$ where a, b, c and d
+        are real numbers, the product matrix from the left is:
+
+        .. math::
+
+            M  =  \begin{bmatrix} a  &-b  &-c  &-d \\
+                                  b  & a  &-d  & c \\
+                                  c  & d  & a  &-b \\
+                                  d  &-c  & b  & a \end{bmatrix}
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q1 = Quaternion(1, 0, 0, 1)
+        >>> q2 = Quaternion(a, b, c, d)
+        >>> q1.product_matrix_left
+        Matrix([
+        [1, 0,  0, -1],
+        [0, 1, -1,  0],
+        [0, 1,  1,  0],
+        [1, 0,  0,  1]])
+
+        >>> q1.product_matrix_left * q2.to_Matrix()
+        Matrix([
+        [a - d],
+        [b - c],
+        [b + c],
+        [a + d]])
+
+        This is equivalent to:
+
+        >>> (q1 * q2).to_Matrix()
+        Matrix([
+        [a - d],
+        [b - c],
+        [b + c],
+        [a + d]])
+        """
+        return Matrix([
+                [self.a, -self.b, -self.c, -self.d],
+                [self.b, self.a, -self.d, self.c],
+                [self.c, self.d, self.a, -self.b],
+                [self.d, -self.c, self.b, self.a]])
+
+    @property
+    def product_matrix_right(self):
+        r"""Returns 4 x 4 Matrix equivalent to a Hamilton product from the
+        right. This can be useful when treating quaternion elements as column
+        vectors. Given a quaternion $q = a + bi + cj + dk$ where a, b, c and d
+        are real numbers, the product matrix from the left is:
+
+        .. math::
+
+            M  =  \begin{bmatrix} a  &-b  &-c  &-d \\
+                                  b  & a  & d  &-c \\
+                                  c  &-d  & a  & b \\
+                                  d  & c  &-b  & a \end{bmatrix}
+
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q1 = Quaternion(a, b, c, d)
+        >>> q2 = Quaternion(1, 0, 0, 1)
+        >>> q2.product_matrix_right
+        Matrix([
+        [1, 0, 0, -1],
+        [0, 1, 1, 0],
+        [0, -1, 1, 0],
+        [1, 0, 0, 1]])
+
+        Note the switched arguments: the matrix represents the quaternion on
+        the right, but is still considered as a matrix multiplication from the
+        left.
+
+        >>> q2.product_matrix_right * q1.to_Matrix()
+        Matrix([
+        [ a - d],
+        [ b + c],
+        [-b + c],
+        [ a + d]])
+
+        This is equivalent to:
+
+        >>> (q1 * q2).to_Matrix()
+        Matrix([
+        [ a - d],
+        [ b + c],
+        [-b + c],
+        [ a + d]])
+        """
+        return Matrix([
+                [self.a, -self.b, -self.c, -self.d],
+                [self.b, self.a, self.d, -self.c],
+                [self.c, -self.d, self.a, self.b],
+                [self.d, self.c, -self.b, self.a]])
+
+    def to_Matrix(self, vector_only=False):
+        """Returns elements of quaternion as a column vector.
+        By default, a Matrix of length 4 is returned, with the real part as the
+        first element.
+        If vector_only is True, returns only imaginary part as a Matrix of
+        length 3.
+
+        Parameters
+        ==========
+
+        vector_only : bool
+            If True, only imaginary part is returned.
+            Default value: False
+
+        Returns
+        =======
+
+        Matrix
+            A column vector constructed by the elements of the quaternion.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q = Quaternion(a, b, c, d)
+        >>> q
+        a + b*i + c*j + d*k
+
+        >>> q.to_Matrix()
+        Matrix([
+        [a],
+        [b],
+        [c],
+        [d]])
+
+
+        >>> q.to_Matrix(vector_only=True)
+        Matrix([
+        [b],
+        [c],
+        [d]])
+
+        """
+        if vector_only:
+            return Matrix(self.args[1:])
+        else:
+            return Matrix(self.args)
+
+    @classmethod
+    def from_Matrix(cls, elements):
+        """Returns quaternion from elements of a column vector`.
+        If vector_only is True, returns only imaginary part as a Matrix of
+        length 3.
+
+        Parameters
+        ==========
+
+        elements : Matrix, list or tuple of length 3 or 4. If length is 3,
+            assume real part is zero.
+            Default value: False
+
+        Returns
+        =======
+
+        Quaternion
+            A quaternion created from the input elements.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q = Quaternion.from_Matrix([a, b, c, d])
+        >>> q
+        a + b*i + c*j + d*k
+
+        >>> q = Quaternion.from_Matrix([b, c, d])
+        >>> q
+        0 + b*i + c*j + d*k
+
+        """
+        length = len(elements)
+        if length != 3 and length != 4:
+            raise ValueError("Input elements must have length 3 or 4, got {} "
+                             "elements".format(length))
+
+        if length == 3:
+            return Quaternion(0, *elements)
+        else:
+            return Quaternion(*elements)
+
+    @classmethod
+    def from_euler(cls, angles, seq):
+        """Returns quaternion equivalent to rotation represented by the Euler
+        angles, in the sequence defined by ``seq``.
+
+        Parameters
+        ==========
+
+        angles : list, tuple or Matrix of 3 numbers
+            The Euler angles (in radians).
+        seq : string of length 3
+            Represents the sequence of rotations.
+            For intrinsic rotations, seq must be all lowercase and its elements
+            must be from the set ``{'x', 'y', 'z'}``
+            For extrinsic rotations, seq must be all uppercase and its elements
+            must be from the set ``{'X', 'Y', 'Z'}``
+
+        Returns
+        =======
+
+        Quaternion
+            The normalized rotation quaternion calculated from the Euler angles
+            in the given sequence.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import pi
+        >>> q = Quaternion.from_euler([pi/2, 0, 0], 'xyz')
+        >>> q
+        sqrt(2)/2 + sqrt(2)/2*i + 0*j + 0*k
+
+        >>> q = Quaternion.from_euler([0, pi/2, pi] , 'zyz')
+        >>> q
+        0 + (-sqrt(2)/2)*i + 0*j + sqrt(2)/2*k
+
+        >>> q = Quaternion.from_euler([0, pi/2, pi] , 'ZYZ')
+        >>> q
+        0 + sqrt(2)/2*i + 0*j + sqrt(2)/2*k
+
+        """
+
+        if len(angles) != 3:
+            raise ValueError("3 angles must be given.")
+
+        extrinsic = _is_extrinsic(seq)
+        i, j, k = seq.lower()
+
+        # get elementary basis vectors
+        ei = [1 if n == i else 0 for n in 'xyz']
+        ej = [1 if n == j else 0 for n in 'xyz']
+        ek = [1 if n == k else 0 for n in 'xyz']
+
+        # calculate distinct quaternions
+        qi = cls.from_axis_angle(ei, angles[0])
+        qj = cls.from_axis_angle(ej, angles[1])
+        qk = cls.from_axis_angle(ek, angles[2])
+
+        if extrinsic:
+            return trigsimp(qk * qj * qi)
+        else:
+            return trigsimp(qi * qj * qk)
+
+    def to_euler(self, seq, angle_addition=True, avoid_square_root=False):
+        r"""Returns Euler angles representing same rotation as the quaternion,
+        in the sequence given by ``seq``. This implements the method described
+        in [1]_.
+
+        For degenerate cases (gymbal lock cases), the third angle is
+        set to zero.
+
+        Parameters
+        ==========
+
+        seq : string of length 3
+            Represents the sequence of rotations.
+            For intrinsic rotations, seq must be all lowercase and its elements
+            must be from the set ``{'x', 'y', 'z'}``
+            For extrinsic rotations, seq must be all uppercase and its elements
+            must be from the set ``{'X', 'Y', 'Z'}``
+
+        angle_addition : bool
+            When True, first and third angles are given as an addition and
+            subtraction of two simpler ``atan2`` expressions. When False, the
+            first and third angles are each given by a single more complicated
+            ``atan2`` expression. This equivalent expression is given by:
+
+            .. math::
+
+                \operatorname{atan_2} (b,a) \pm \operatorname{atan_2} (d,c) =
+                \operatorname{atan_2} (bc\pm ad, ac\mp bd)
+
+            Default value: True
+
+        avoid_square_root : bool
+            When True, the second angle is calculated with an expression based
+            on ``acos``, which is slightly more complicated but avoids a square
+            root. When False, second angle is calculated with ``atan2``, which
+            is simpler and can be better for numerical reasons (some
+            numerical implementations of ``acos`` have problems near zero).
+            Default value: False
+
+
+        Returns
+        =======
+
+        Tuple
+            The Euler angles calculated from the quaternion
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> euler = Quaternion(a, b, c, d).to_euler('zyz')
+        >>> euler
+        (-atan2(-b, c) + atan2(d, a),
+         2*atan2(sqrt(b**2 + c**2), sqrt(a**2 + d**2)),
+         atan2(-b, c) + atan2(d, a))
+
+
+        References
+        ==========
+
+        .. [1] https://doi.org/10.1371/journal.pone.0276302
+
+        """
+        if self.is_zero_quaternion():
+            raise ValueError('Cannot convert a quaternion with norm 0.')
+
+        angles = [0, 0, 0]
+
+        extrinsic = _is_extrinsic(seq)
+        i, j, k = seq.lower()
+
+        # get index corresponding to elementary basis vectors
+        i = 'xyz'.index(i) + 1
+        j = 'xyz'.index(j) + 1
+        k = 'xyz'.index(k) + 1
+
+        if not extrinsic:
+            i, k = k, i
+
+        # check if sequence is symmetric
+        symmetric = i == k
+        if symmetric:
+            k = 6 - i - j
+
+        # parity of the permutation
+        sign = (i - j) * (j - k) * (k - i) // 2
+
+        # permutate elements
+        elements = [self.a, self.b, self.c, self.d]
+        a = elements[0]
+        b = elements[i]
+        c = elements[j]
+        d = elements[k] * sign
+
+        if not symmetric:
+            a, b, c, d = a - c, b + d, c + a, d - b
+
+        if avoid_square_root:
+            if symmetric:
+                n2 = self.norm()**2
+                angles[1] = acos((a * a + b * b - c * c - d * d) / n2)
+            else:
+                n2 = 2 * self.norm()**2
+                angles[1] = asin((c * c + d * d - a * a - b * b) / n2)
+        else:
+            angles[1] = 2 * atan2(sqrt(c * c + d * d), sqrt(a * a + b * b))
+            if not symmetric:
+                angles[1] -= S.Pi / 2
+
+        # Check for singularities in numerical cases
+        case = 0
+        if is_eq(c, S.Zero) and is_eq(d, S.Zero):
+            case = 1
+        if is_eq(a, S.Zero) and is_eq(b, S.Zero):
+            case = 2
+
+        if case == 0:
+            if angle_addition:
+                angles[0] = atan2(b, a) + atan2(d, c)
+                angles[2] = atan2(b, a) - atan2(d, c)
+            else:
+                angles[0] = atan2(b*c + a*d, a*c - b*d)
+                angles[2] = atan2(b*c - a*d, a*c + b*d)
+
+        else:  # any degenerate case
+            angles[2 * (not extrinsic)] = S.Zero
+            if case == 1:
+                angles[2 * extrinsic] = 2 * atan2(b, a)
+            else:
+                angles[2 * extrinsic] = 2 * atan2(d, c)
+                angles[2 * extrinsic] *= (-1 if extrinsic else 1)
+
+        # for Tait-Bryan angles
+        if not symmetric:
+            angles[0] *= sign
+
+        if extrinsic:
+            return tuple(angles[::-1])
+        else:
+            return tuple(angles)
+
+    @classmethod
+    def from_axis_angle(cls, vector, angle):
+        """Returns a rotation quaternion given the axis and the angle of rotation.
+
+        Parameters
+        ==========
+
+        vector : tuple of three numbers
+            The vector representation of the given axis.
+        angle : number
+            The angle by which axis is rotated (in radians).
+
+        Returns
+        =======
+
+        Quaternion
+            The normalized rotation quaternion calculated from the given axis and the angle of rotation.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import pi, sqrt
+        >>> q = Quaternion.from_axis_angle((sqrt(3)/3, sqrt(3)/3, sqrt(3)/3), 2*pi/3)
+        >>> q
+        1/2 + 1/2*i + 1/2*j + 1/2*k
+
+        """
+        (x, y, z) = vector
+        norm = sqrt(x**2 + y**2 + z**2)
+        (x, y, z) = (x / norm, y / norm, z / norm)
+        s = sin(angle * S.Half)
+        a = cos(angle * S.Half)
+        b = x * s
+        c = y * s
+        d = z * s
+
+        # note that this quaternion is already normalized by construction:
+        # c^2 + (s*x)^2 + (s*y)^2 + (s*z)^2 = c^2 + s^2*(x^2 + y^2 + z^2) = c^2 + s^2 * 1 = c^2 + s^2 = 1
+        # so, what we return is a normalized quaternion
+
+        return cls(a, b, c, d)
+
+    @classmethod
+    def from_rotation_matrix(cls, M):
+        """Returns the equivalent quaternion of a matrix. The quaternion will be normalized
+        only if the matrix is special orthogonal (orthogonal and det(M) = 1).
+
+        Parameters
+        ==========
+
+        M : Matrix
+            Input matrix to be converted to equivalent quaternion. M must be special
+            orthogonal (orthogonal and det(M) = 1) for the quaternion to be normalized.
+
+        Returns
+        =======
+
+        Quaternion
+            The quaternion equivalent to given matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import Matrix, symbols, cos, sin, trigsimp
+        >>> x = symbols('x')
+        >>> M = Matrix([[cos(x), -sin(x), 0], [sin(x), cos(x), 0], [0, 0, 1]])
+        >>> q = trigsimp(Quaternion.from_rotation_matrix(M))
+        >>> q
+        sqrt(2)*sqrt(cos(x) + 1)/2 + 0*i + 0*j + sqrt(2 - 2*cos(x))*sign(sin(x))/2*k
+
+        """
+
+        absQ = M.det()**Rational(1, 3)
+
+        a = sqrt(absQ + M[0, 0] + M[1, 1] + M[2, 2]) / 2
+        b = sqrt(absQ + M[0, 0] - M[1, 1] - M[2, 2]) / 2
+        c = sqrt(absQ - M[0, 0] + M[1, 1] - M[2, 2]) / 2
+        d = sqrt(absQ - M[0, 0] - M[1, 1] + M[2, 2]) / 2
+
+        b = b * sign(M[2, 1] - M[1, 2])
+        c = c * sign(M[0, 2] - M[2, 0])
+        d = d * sign(M[1, 0] - M[0, 1])
+
+        return Quaternion(a, b, c, d)
+
+    def __add__(self, other):
+        return self.add(other)
+
+    def __radd__(self, other):
+        return self.add(other)
+
+    def __sub__(self, other):
+        return self.add(other*-1)
+
+    def __mul__(self, other):
+        return self._generic_mul(self, _sympify(other))
+
+    def __rmul__(self, other):
+        return self._generic_mul(_sympify(other), self)
+
+    def __pow__(self, p):
+        return self.pow(p)
+
+    def __neg__(self):
+        return Quaternion(-self._a, -self._b, -self._c, -self.d)
+
+    def __truediv__(self, other):
+        return self * sympify(other)**-1
+
+    def __rtruediv__(self, other):
+        return sympify(other) * self**-1
+
+    def _eval_Integral(self, *args):
+        return self.integrate(*args)
+
+    def diff(self, *symbols, **kwargs):
+        kwargs.setdefault('evaluate', True)
+        return self.func(*[a.diff(*symbols, **kwargs) for a  in self.args])
+
+    def add(self, other):
+        """Adds quaternions.
+
+        Parameters
+        ==========
+
+        other : Quaternion
+            The quaternion to add to current (self) quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            The resultant quaternion after adding self to other
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import symbols
+        >>> q1 = Quaternion(1, 2, 3, 4)
+        >>> q2 = Quaternion(5, 6, 7, 8)
+        >>> q1.add(q2)
+        6 + 8*i + 10*j + 12*k
+        >>> q1 + 5
+        6 + 2*i + 3*j + 4*k
+        >>> x = symbols('x', real = True)
+        >>> q1.add(x)
+        (x + 1) + 2*i + 3*j + 4*k
+
+        Quaternions over complex fields :
+
+        >>> from sympy import Quaternion
+        >>> from sympy import I
+        >>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+        >>> q3.add(2 + 3*I)
+        (5 + 7*I) + (2 + 5*I)*i + 0*j + (7 + 8*I)*k
+
+        """
+        q1 = self
+        q2 = sympify(other)
+
+        # If q2 is a number or a SymPy expression instead of a quaternion
+        if not isinstance(q2, Quaternion):
+            if q1.real_field and q2.is_complex:
+                return Quaternion(re(q2) + q1.a, im(q2) + q1.b, q1.c, q1.d)
+            elif q2.is_commutative:
+                return Quaternion(q1.a + q2, q1.b, q1.c, q1.d)
+            else:
+                raise ValueError("Only commutative expressions can be added with a Quaternion.")
+
+        return Quaternion(q1.a + q2.a, q1.b + q2.b, q1.c + q2.c, q1.d
+                          + q2.d)
+
+    def mul(self, other):
+        """Multiplies quaternions.
+
+        Parameters
+        ==========
+
+        other : Quaternion or symbol
+            The quaternion to multiply to current (self) quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            The resultant quaternion after multiplying self with other
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import symbols
+        >>> q1 = Quaternion(1, 2, 3, 4)
+        >>> q2 = Quaternion(5, 6, 7, 8)
+        >>> q1.mul(q2)
+        (-60) + 12*i + 30*j + 24*k
+        >>> q1.mul(2)
+        2 + 4*i + 6*j + 8*k
+        >>> x = symbols('x', real = True)
+        >>> q1.mul(x)
+        x + 2*x*i + 3*x*j + 4*x*k
+
+        Quaternions over complex fields :
+
+        >>> from sympy import Quaternion
+        >>> from sympy import I
+        >>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+        >>> q3.mul(2 + 3*I)
+        (2 + 3*I)*(3 + 4*I) + (2 + 3*I)*(2 + 5*I)*i + 0*j + (2 + 3*I)*(7 + 8*I)*k
+
+        """
+        return self._generic_mul(self, _sympify(other))
+
+    @staticmethod
+    def _generic_mul(q1, q2):
+        """Generic multiplication.
+
+        Parameters
+        ==========
+
+        q1 : Quaternion or symbol
+        q2 : Quaternion or symbol
+
+        It is important to note that if neither q1 nor q2 is a Quaternion,
+        this function simply returns q1 * q2.
+
+        Returns
+        =======
+
+        Quaternion
+            The resultant quaternion after multiplying q1 and q2
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import Symbol, S
+        >>> q1 = Quaternion(1, 2, 3, 4)
+        >>> q2 = Quaternion(5, 6, 7, 8)
+        >>> Quaternion._generic_mul(q1, q2)
+        (-60) + 12*i + 30*j + 24*k
+        >>> Quaternion._generic_mul(q1, S(2))
+        2 + 4*i + 6*j + 8*k
+        >>> x = Symbol('x', real = True)
+        >>> Quaternion._generic_mul(q1, x)
+        x + 2*x*i + 3*x*j + 4*x*k
+
+        Quaternions over complex fields :
+
+        >>> from sympy import I
+        >>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+        >>> Quaternion._generic_mul(q3, 2 + 3*I)
+        (2 + 3*I)*(3 + 4*I) + (2 + 3*I)*(2 + 5*I)*i + 0*j + (2 + 3*I)*(7 + 8*I)*k
+
+        """
+        # None is a Quaternion:
+        if not isinstance(q1, Quaternion) and not isinstance(q2, Quaternion):
+            return q1 * q2
+
+        # If q1 is a number or a SymPy expression instead of a quaternion
+        if not isinstance(q1, Quaternion):
+            if q2.real_field and q1.is_complex:
+                return Quaternion(re(q1), im(q1), 0, 0) * q2
+            elif q1.is_commutative:
+                return Quaternion(q1 * q2.a, q1 * q2.b, q1 * q2.c, q1 * q2.d)
+            else:
+                raise ValueError("Only commutative expressions can be multiplied with a Quaternion.")
+
+        # If q2 is a number or a SymPy expression instead of a quaternion
+        if not isinstance(q2, Quaternion):
+            if q1.real_field and q2.is_complex:
+                return q1 * Quaternion(re(q2), im(q2), 0, 0)
+            elif q2.is_commutative:
+                return Quaternion(q2 * q1.a, q2 * q1.b, q2 * q1.c, q2 * q1.d)
+            else:
+                raise ValueError("Only commutative expressions can be multiplied with a Quaternion.")
+
+        # If any of the quaternions has a fixed norm, pre-compute norm
+        if q1._norm is None and q2._norm is None:
+            norm = None
+        else:
+            norm = q1.norm() * q2.norm()
+
+        return Quaternion(-q1.b*q2.b - q1.c*q2.c - q1.d*q2.d + q1.a*q2.a,
+                          q1.b*q2.a + q1.c*q2.d - q1.d*q2.c + q1.a*q2.b,
+                          -q1.b*q2.d + q1.c*q2.a + q1.d*q2.b + q1.a*q2.c,
+                          q1.b*q2.c - q1.c*q2.b + q1.d*q2.a + q1.a * q2.d,
+                          norm=norm)
+
+    def _eval_conjugate(self):
+        """Returns the conjugate of the quaternion."""
+        q = self
+        return Quaternion(q.a, -q.b, -q.c, -q.d, norm=q._norm)
+
+    def norm(self):
+        """Returns the norm of the quaternion."""
+        if self._norm is None:  # check if norm is pre-defined
+            q = self
+            # trigsimp is used to simplify sin(x)^2 + cos(x)^2 (these terms
+            # arise when from_axis_angle is used).
+            self._norm = sqrt(trigsimp(q.a**2 + q.b**2 + q.c**2 + q.d**2))
+
+        return self._norm
+
+    def normalize(self):
+        """Returns the normalized form of the quaternion."""
+        q = self
+        return q * (1/q.norm())
+
+    def inverse(self):
+        """Returns the inverse of the quaternion."""
+        q = self
+        if not q.norm():
+            raise ValueError("Cannot compute inverse for a quaternion with zero norm")
+        return conjugate(q) * (1/q.norm()**2)
+
+    def pow(self, p):
+        """Finds the pth power of the quaternion.
+
+        Parameters
+        ==========
+
+        p : int
+            Power to be applied on quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            Returns the p-th power of the current quaternion.
+            Returns the inverse if p = -1.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.pow(4)
+        668 + (-224)*i + (-336)*j + (-448)*k
+
+        """
+        p = sympify(p)
+        q = self
+        if p == -1:
+            return q.inverse()
+        res = 1
+
+        if not p.is_Integer:
+            return NotImplemented
+
+        if p < 0:
+            q, p = q.inverse(), -p
+
+        while p > 0:
+            if p % 2 == 1:
+                res = q * res
+
+            p = p//2
+            q = q * q
+
+        return res
+
+    def exp(self):
+        """Returns the exponential of q (e^q).
+
+        Returns
+        =======
+
+        Quaternion
+            Exponential of q (e^q).
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.exp()
+        E*cos(sqrt(29))
+        + 2*sqrt(29)*E*sin(sqrt(29))/29*i
+        + 3*sqrt(29)*E*sin(sqrt(29))/29*j
+        + 4*sqrt(29)*E*sin(sqrt(29))/29*k
+
+        """
+        # exp(q) = e^a(cos||v|| + v/||v||*sin||v||)
+        q = self
+        vector_norm = sqrt(q.b**2 + q.c**2 + q.d**2)
+        a = exp(q.a) * cos(vector_norm)
+        b = exp(q.a) * sin(vector_norm) * q.b / vector_norm
+        c = exp(q.a) * sin(vector_norm) * q.c / vector_norm
+        d = exp(q.a) * sin(vector_norm) * q.d / vector_norm
+
+        return Quaternion(a, b, c, d)
+
+    def _ln(self):
+        """Returns the natural logarithm of the quaternion (_ln(q)).
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q._ln()
+        log(sqrt(30))
+        + 2*sqrt(29)*acos(sqrt(30)/30)/29*i
+        + 3*sqrt(29)*acos(sqrt(30)/30)/29*j
+        + 4*sqrt(29)*acos(sqrt(30)/30)/29*k
+
+        """
+        # _ln(q) = _ln||q|| + v/||v||*arccos(a/||q||)
+        q = self
+        vector_norm = sqrt(q.b**2 + q.c**2 + q.d**2)
+        q_norm = q.norm()
+        a = ln(q_norm)
+        b = q.b * acos(q.a / q_norm) / vector_norm
+        c = q.c * acos(q.a / q_norm) / vector_norm
+        d = q.d * acos(q.a / q_norm) / vector_norm
+
+        return Quaternion(a, b, c, d)
+
+    def _eval_subs(self, *args):
+        elements = [i.subs(*args) for i in self.args]
+        norm = self._norm
+        try:
+            norm = norm.subs(*args)
+        except AttributeError:
+            pass
+        _check_norm(elements, norm)
+        return Quaternion(*elements, norm=norm)
+
+    def _eval_evalf(self, prec):
+        """Returns the floating point approximations (decimal numbers) of the quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            Floating point approximations of quaternion(self)
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import sqrt
+        >>> q = Quaternion(1/sqrt(1), 1/sqrt(2), 1/sqrt(3), 1/sqrt(4))
+        >>> q.evalf()
+        1.00000000000000
+        + 0.707106781186547*i
+        + 0.577350269189626*j
+        + 0.500000000000000*k
+
+        """
+        nprec = prec_to_dps(prec)
+        return Quaternion(*[arg.evalf(n=nprec) for arg in self.args])
+
+    def pow_cos_sin(self, p):
+        """Computes the pth power in the cos-sin form.
+
+        Parameters
+        ==========
+
+        p : int
+            Power to be applied on quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            The p-th power in the cos-sin form.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.pow_cos_sin(4)
+        900*cos(4*acos(sqrt(30)/30))
+        + 1800*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*i
+        + 2700*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*j
+        + 3600*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*k
+
+        """
+        # q = ||q||*(cos(a) + u*sin(a))
+        # q^p = ||q||^p * (cos(p*a) + u*sin(p*a))
+
+        q = self
+        (v, angle) = q.to_axis_angle()
+        q2 = Quaternion.from_axis_angle(v, p * angle)
+        return q2 * (q.norm()**p)
+
+    def integrate(self, *args):
+        """Computes integration of quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            Integration of the quaternion(self) with the given variable.
+
+        Examples
+        ========
+
+        Indefinite Integral of quaternion :
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import x
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.integrate(x)
+        x + 2*x*i + 3*x*j + 4*x*k
+
+        Definite integral of quaternion :
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import x
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.integrate((x, 1, 5))
+        4 + 8*i + 12*j + 16*k
+
+        """
+        # TODO: is this expression correct?
+        return Quaternion(integrate(self.a, *args), integrate(self.b, *args),
+                          integrate(self.c, *args), integrate(self.d, *args))
+
+    @staticmethod
+    def rotate_point(pin, r):
+        """Returns the coordinates of the point pin(a 3 tuple) after rotation.
+
+        Parameters
+        ==========
+
+        pin : tuple
+            A 3-element tuple of coordinates of a point which needs to be
+            rotated.
+        r : Quaternion or tuple
+            Axis and angle of rotation.
+
+            It's important to note that when r is a tuple, it must be of the form
+            (axis, angle)
+
+        Returns
+        =======
+
+        tuple
+            The coordinates of the point after rotation.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import symbols, trigsimp, cos, sin
+        >>> x = symbols('x')
+        >>> q = Quaternion(cos(x/2), 0, 0, sin(x/2))
+        >>> trigsimp(Quaternion.rotate_point((1, 1, 1), q))
+        (sqrt(2)*cos(x + pi/4), sqrt(2)*sin(x + pi/4), 1)
+        >>> (axis, angle) = q.to_axis_angle()
+        >>> trigsimp(Quaternion.rotate_point((1, 1, 1), (axis, angle)))
+        (sqrt(2)*cos(x + pi/4), sqrt(2)*sin(x + pi/4), 1)
+
+        """
+        if isinstance(r, tuple):
+            # if r is of the form (vector, angle)
+            q = Quaternion.from_axis_angle(r[0], r[1])
+        else:
+            # if r is a quaternion
+            q = r.normalize()
+        pout = q * Quaternion(0, pin[0], pin[1], pin[2]) * conjugate(q)
+        return (pout.b, pout.c, pout.d)
+
+    def to_axis_angle(self):
+        """Returns the axis and angle of rotation of a quaternion.
+
+        Returns
+        =======
+
+        tuple
+            Tuple of (axis, angle)
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 1, 1, 1)
+        >>> (axis, angle) = q.to_axis_angle()
+        >>> axis
+        (sqrt(3)/3, sqrt(3)/3, sqrt(3)/3)
+        >>> angle
+        2*pi/3
+
+        """
+        q = self
+        if q.a.is_negative:
+            q = q * -1
+
+        q = q.normalize()
+        angle = trigsimp(2 * acos(q.a))
+
+        # Since quaternion is normalised, q.a is less than 1.
+        s = sqrt(1 - q.a*q.a)
+
+        x = trigsimp(q.b / s)
+        y = trigsimp(q.c / s)
+        z = trigsimp(q.d / s)
+
+        v = (x, y, z)
+        t = (v, angle)
+
+        return t
+
+    def to_rotation_matrix(self, v=None, homogeneous=True):
+        """Returns the equivalent rotation transformation matrix of the quaternion
+        which represents rotation about the origin if v is not passed.
+
+        Parameters
+        ==========
+
+        v : tuple or None
+            Default value: None
+        homogeneous : bool
+            When True, gives an expression that may be more efficient for
+            symbolic calculations but less so for direct evaluation. Both
+            formulas are mathematically equivalent.
+            Default value: True
+
+        Returns
+        =======
+
+        tuple
+            Returns the equivalent rotation transformation matrix of the quaternion
+            which represents rotation about the origin if v is not passed.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import symbols, trigsimp, cos, sin
+        >>> x = symbols('x')
+        >>> q = Quaternion(cos(x/2), 0, 0, sin(x/2))
+        >>> trigsimp(q.to_rotation_matrix())
+        Matrix([
+        [cos(x), -sin(x), 0],
+        [sin(x),  cos(x), 0],
+        [     0,       0, 1]])
+
+        Generates a 4x4 transformation matrix (used for rotation about a point
+        other than the origin) if the point(v) is passed as an argument.
+        """
+
+        q = self
+        s = q.norm()**-2
+
+        # diagonal elements are different according to parameter normal
+        if homogeneous:
+            m00 = s*(q.a**2 + q.b**2 - q.c**2 - q.d**2)
+            m11 = s*(q.a**2 - q.b**2 + q.c**2 - q.d**2)
+            m22 = s*(q.a**2 - q.b**2 - q.c**2 + q.d**2)
+        else:
+            m00 = 1 - 2*s*(q.c**2 + q.d**2)
+            m11 = 1 - 2*s*(q.b**2 + q.d**2)
+            m22 = 1 - 2*s*(q.b**2 + q.c**2)
+
+        m01 = 2*s*(q.b*q.c - q.d*q.a)
+        m02 = 2*s*(q.b*q.d + q.c*q.a)
+
+        m10 = 2*s*(q.b*q.c + q.d*q.a)
+        m12 = 2*s*(q.c*q.d - q.b*q.a)
+
+        m20 = 2*s*(q.b*q.d - q.c*q.a)
+        m21 = 2*s*(q.c*q.d + q.b*q.a)
+
+        if not v:
+            return Matrix([[m00, m01, m02], [m10, m11, m12], [m20, m21, m22]])
+
+        else:
+            (x, y, z) = v
+
+            m03 = x - x*m00 - y*m01 - z*m02
+            m13 = y - x*m10 - y*m11 - z*m12
+            m23 = z - x*m20 - y*m21 - z*m22
+            m30 = m31 = m32 = 0
+            m33 = 1
+
+            return Matrix([[m00, m01, m02, m03], [m10, m11, m12, m13],
+                          [m20, m21, m22, m23], [m30, m31, m32, m33]])
+
+    def scalar_part(self):
+        r"""Returns scalar part($\mathbf{S}(q)$) of the quaternion q.
+
+        Explanation
+        ===========
+
+        Given a quaternion $q = a + bi + cj + dk$, returns $\mathbf{S}(q) = a$.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(4, 8, 13, 12)
+        >>> q.scalar_part()
+        4
+
+        """
+
+        return self.a
+
+    def vector_part(self):
+        r"""
+        Returns vector part($\mathbf{V}(q)$) of the quaternion q.
+
+        Explanation
+        ===========
+
+        Given a quaternion $q = a + bi + cj + dk$, returns $\mathbf{V}(q) = bi + cj + dk$.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(1, 1, 1, 1)
+        >>> q.vector_part()
+        0 + 1*i + 1*j + 1*k
+
+        >>> q = Quaternion(4, 8, 13, 12)
+        >>> q.vector_part()
+        0 + 8*i + 13*j + 12*k
+
+        """
+
+        return Quaternion(0, self.b, self.c, self.d)
+
+    def axis(self):
+        r"""
+        Returns the axis($\mathbf{Ax}(q)$) of the quaternion.
+
+        Explanation
+        ===========
+
+        Given a quaternion $q = a + bi + cj + dk$, returns $\mathbf{Ax}(q)$  i.e., the versor of the vector part of that quaternion
+        equal to $\mathbf{U}[\mathbf{V}(q)]$.
+        The axis is always an imaginary unit with square equal to $-1 + 0i + 0j + 0k$.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(1, 1, 1, 1)
+        >>> q.axis()
+        0 + sqrt(3)/3*i + sqrt(3)/3*j + sqrt(3)/3*k
+
+        See Also
+        ========
+
+        vector_part
+
+        """
+        axis = self.vector_part().normalize()
+
+        return Quaternion(0, axis.b, axis.c, axis.d)
+
+    def is_pure(self):
+        """
+        Returns true if the quaternion is pure, false if the quaternion is not pure
+        or returns none if it is unknown.
+
+        Explanation
+        ===========
+
+        A pure quaternion (also a vector quaternion) is a quaternion with scalar
+        part equal to 0.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(0, 8, 13, 12)
+        >>> q.is_pure()
+        True
+
+        See Also
+        ========
+        scalar_part
+
+        """
+
+        return self.a.is_zero
+
+    def is_zero_quaternion(self):
+        """
+        Returns true if the quaternion is a zero quaternion or false if it is not a zero quaternion
+        and None if the value is unknown.
+
+        Explanation
+        ===========
+
+        A zero quaternion is a quaternion with both scalar part and
+        vector part equal to 0.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(1, 0, 0, 0)
+        >>> q.is_zero_quaternion()
+        False
+
+        >>> q = Quaternion(0, 0, 0, 0)
+        >>> q.is_zero_quaternion()
+        True
+
+        See Also
+        ========
+        scalar_part
+        vector_part
+
+        """
+
+        return self.norm().is_zero
+
+    def angle(self):
+        r"""
+        Returns the angle of the quaternion measured in the real-axis plane.
+
+        Explanation
+        ===========
+
+        Given a quaternion $q = a + bi + cj + dk$ where a, b, c and d
+        are real numbers, returns the angle of the quaternion given by
+
+        .. math::
+            angle := atan2(\sqrt{b^2 + c^2 + d^2}, {a})
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(1, 4, 4, 4)
+        >>> q.angle()
+        atan(4*sqrt(3))
+
+        """
+
+        return atan2(self.vector_part().norm(), self.scalar_part())
+
+
+    def arc_coplanar(self, other):
+        """
+        Returns True if the transformation arcs represented by the input quaternions happen in the same plane.
+
+        Explanation
+        ===========
+
+        Two quaternions are said to be coplanar (in this arc sense) when their axes are parallel.
+        The plane of a quaternion is the one normal to its axis.
+
+        Parameters
+        ==========
+
+        other : a Quaternion
+
+        Returns
+        =======
+
+        True : if the planes of the two quaternions are the same, apart from its orientation/sign.
+        False : if the planes of the two quaternions are not the same, apart from its orientation/sign.
+        None : if plane of either of the quaternion is unknown.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q1 = Quaternion(1, 4, 4, 4)
+        >>> q2 = Quaternion(3, 8, 8, 8)
+        >>> Quaternion.arc_coplanar(q1, q2)
+        True
+
+        >>> q1 = Quaternion(2, 8, 13, 12)
+        >>> Quaternion.arc_coplanar(q1, q2)
+        False
+
+        See Also
+        ========
+
+        vector_coplanar
+        is_pure
+
+        """
+        if (self.is_zero_quaternion()) or (other.is_zero_quaternion()):
+            raise ValueError('Neither of the given quaternions can be 0')
+
+        return fuzzy_or([(self.axis() - other.axis()).is_zero_quaternion(), (self.axis() + other.axis()).is_zero_quaternion()])
+
+    @classmethod
+    def vector_coplanar(cls, q1, q2, q3):
+        r"""
+        Returns True if the axis of the pure quaternions seen as 3D vectors
+        q1, q2, and q3 are coplanar.
+
+        Explanation
+        ===========
+
+        Three pure quaternions are vector coplanar if the quaternions seen as 3D vectors are coplanar.
+
+        Parameters
+        ==========
+
+        q1
+            A pure Quaternion.
+        q2
+            A pure Quaternion.
+        q3
+            A pure Quaternion.
+
+        Returns
+        =======
+
+        True : if the axis of the pure quaternions seen as 3D vectors
+        q1, q2, and q3 are coplanar.
+        False : if the axis of the pure quaternions seen as 3D vectors
+        q1, q2, and q3 are not coplanar.
+        None : if the axis of the pure quaternions seen as 3D vectors
+        q1, q2, and q3 are coplanar is unknown.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q1 = Quaternion(0, 4, 4, 4)
+        >>> q2 = Quaternion(0, 8, 8, 8)
+        >>> q3 = Quaternion(0, 24, 24, 24)
+        >>> Quaternion.vector_coplanar(q1, q2, q3)
+        True
+
+        >>> q1 = Quaternion(0, 8, 16, 8)
+        >>> q2 = Quaternion(0, 8, 3, 12)
+        >>> Quaternion.vector_coplanar(q1, q2, q3)
+        False
+
+        See Also
+        ========
+
+        axis
+        is_pure
+
+        """
+
+        if fuzzy_not(q1.is_pure()) or fuzzy_not(q2.is_pure()) or fuzzy_not(q3.is_pure()):
+            raise ValueError('The given quaternions must be pure')
+
+        M = Matrix([[q1.b, q1.c, q1.d], [q2.b, q2.c, q2.d], [q3.b, q3.c, q3.d]]).det()
+        return M.is_zero
+
+    def parallel(self, other):
+        """
+        Returns True if the two pure quaternions seen as 3D vectors are parallel.
+
+        Explanation
+        ===========
+
+        Two pure quaternions are called parallel when their vector product is commutative which
+        implies that the quaternions seen as 3D vectors have same direction.
+
+        Parameters
+        ==========
+
+        other : a Quaternion
+
+        Returns
+        =======
+
+        True : if the two pure quaternions seen as 3D vectors are parallel.
+        False : if the two pure quaternions seen as 3D vectors are not parallel.
+        None : if the two pure quaternions seen as 3D vectors are parallel is unknown.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(0, 4, 4, 4)
+        >>> q1 = Quaternion(0, 8, 8, 8)
+        >>> q.parallel(q1)
+        True
+
+        >>> q1 = Quaternion(0, 8, 13, 12)
+        >>> q.parallel(q1)
+        False
+
+        """
+
+        if fuzzy_not(self.is_pure()) or fuzzy_not(other.is_pure()):
+            raise ValueError('The provided quaternions must be pure')
+
+        return (self*other - other*self).is_zero_quaternion()
+
+    def orthogonal(self, other):
+        """
+        Returns the orthogonality of two quaternions.
+
+        Explanation
+        ===========
+
+        Two pure quaternions are called orthogonal when their product is anti-commutative.
+
+        Parameters
+        ==========
+
+        other : a Quaternion
+
+        Returns
+        =======
+
+        True : if the two pure quaternions seen as 3D vectors are orthogonal.
+        False : if the two pure quaternions seen as 3D vectors are not orthogonal.
+        None : if the two pure quaternions seen as 3D vectors are orthogonal is unknown.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(0, 4, 4, 4)
+        >>> q1 = Quaternion(0, 8, 8, 8)
+        >>> q.orthogonal(q1)
+        False
+
+        >>> q1 = Quaternion(0, 2, 2, 0)
+        >>> q = Quaternion(0, 2, -2, 0)
+        >>> q.orthogonal(q1)
+        True
+
+        """
+
+        if fuzzy_not(self.is_pure()) or fuzzy_not(other.is_pure()):
+            raise ValueError('The given quaternions must be pure')
+
+        return (self*other + other*self).is_zero_quaternion()
+
+    def index_vector(self):
+        r"""
+        Returns the index vector of the quaternion.
+
+        Explanation
+        ===========
+
+        Index vector is given by $\mathbf{T}(q)$ multiplied by $\mathbf{Ax}(q)$ where $\mathbf{Ax}(q)$ is the axis of the quaternion q,
+        and mod(q) is the $\mathbf{T}(q)$ (magnitude) of the quaternion.
+
+        Returns
+        =======
+
+        Quaternion: representing index vector of the provided quaternion.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(2, 4, 2, 4)
+        >>> q.index_vector()
+        0 + 4*sqrt(10)/3*i + 2*sqrt(10)/3*j + 4*sqrt(10)/3*k
+
+        See Also
+        ========
+
+        axis
+        norm
+
+        """
+
+        return self.norm() * self.axis()
+
+    def mensor(self):
+        """
+        Returns the natural logarithm of the norm(magnitude) of the quaternion.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(2, 4, 2, 4)
+        >>> q.mensor()
+        log(2*sqrt(10))
+        >>> q.norm()
+        2*sqrt(10)
+
+        See Also
+        ========
+
+        norm
+
+        """
+
+        return ln(self.norm())

env-llmeval/lib/python3.10/site-packages/sympy/algebras/tests/test_quaternion.py

@@ -0,0 +1,409 @@
+from sympy.core.function import diff
+from sympy.core.function import expand
+from sympy.core.numbers import (E, I, Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (Abs, conjugate, im, re, sign)
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, asin, cos, sin, atan2, atan)
+from sympy.integrals.integrals import integrate
+from sympy.matrices.dense import Matrix
+from sympy.simplify import simplify
+from sympy.simplify.trigsimp import trigsimp
+from sympy.algebras.quaternion import Quaternion
+from sympy.testing.pytest import raises
+from itertools import permutations, product
+
+w, x, y, z = symbols('w:z')
+phi = symbols('phi')
+
+def test_quaternion_construction():
+    q = Quaternion(w, x, y, z)
+    assert q + q == Quaternion(2*w, 2*x, 2*y, 2*z)
+
+    q2 = Quaternion.from_axis_angle((sqrt(3)/3, sqrt(3)/3, sqrt(3)/3),
+                                    pi*Rational(2, 3))
+    assert q2 == Quaternion(S.Half, S.Half,
+                            S.Half, S.Half)
+
+    M = Matrix([[cos(phi), -sin(phi), 0], [sin(phi), cos(phi), 0], [0, 0, 1]])
+    q3 = trigsimp(Quaternion.from_rotation_matrix(M))
+    assert q3 == Quaternion(
+        sqrt(2)*sqrt(cos(phi) + 1)/2, 0, 0, sqrt(2 - 2*cos(phi))*sign(sin(phi))/2)
+
+    nc = Symbol('nc', commutative=False)
+    raises(ValueError, lambda: Quaternion(w, x, nc, z))
+
+
+def test_quaternion_construction_norm():
+    q1 = Quaternion(*symbols('a:d'))
+
+    q2 = Quaternion(w, x, y, z)
+    assert expand((q1*q2).norm()**2 - (q1.norm()**2 * q2.norm()**2)) == 0
+
+    q3 = Quaternion(w, x, y, z, norm=1)
+    assert (q1 * q3).norm() == q1.norm()
+
+
+def test_to_and_from_Matrix():
+    q = Quaternion(w, x, y, z)
+    q_full = Quaternion.from_Matrix(q.to_Matrix())
+    q_vect = Quaternion.from_Matrix(q.to_Matrix(True))
+    assert (q - q_full).is_zero_quaternion()
+    assert (q.vector_part() - q_vect).is_zero_quaternion()
+
+
+def test_product_matrices():
+    q1 = Quaternion(w, x, y, z)
+    q2 = Quaternion(*(symbols("a:d")))
+    assert (q1 * q2).to_Matrix() == q1.product_matrix_left * q2.to_Matrix()
+    assert (q1 * q2).to_Matrix() == q2.product_matrix_right * q1.to_Matrix()
+
+    R1 = (q1.product_matrix_left * q1.product_matrix_right.T)[1:, 1:]
+    R2 = simplify(q1.to_rotation_matrix()*q1.norm()**2)
+    assert R1 == R2
+
+
+def test_quaternion_axis_angle():
+
+    test_data = [ # axis, angle, expected_quaternion
+        ((1, 0, 0), 0, (1, 0, 0, 0)),
+        ((1, 0, 0), pi/2, (sqrt(2)/2, sqrt(2)/2, 0, 0)),
+        ((0, 1, 0), pi/2, (sqrt(2)/2, 0, sqrt(2)/2, 0)),
+        ((0, 0, 1), pi/2, (sqrt(2)/2, 0, 0, sqrt(2)/2)),
+        ((1, 0, 0), pi, (0, 1, 0, 0)),
+        ((0, 1, 0), pi, (0, 0, 1, 0)),
+        ((0, 0, 1), pi, (0, 0, 0, 1)),
+        ((1, 1, 1), pi, (0, 1/sqrt(3),1/sqrt(3),1/sqrt(3))),
+        ((sqrt(3)/3, sqrt(3)/3, sqrt(3)/3), pi*2/3, (S.Half, S.Half, S.Half, S.Half))
+    ]
+
+    for axis, angle, expected in test_data:
+        assert Quaternion.from_axis_angle(axis, angle) == Quaternion(*expected)
+
+
+def test_quaternion_axis_angle_simplification():
+    result = Quaternion.from_axis_angle((1, 2, 3), asin(4))
+    assert result.a == cos(asin(4)/2)
+    assert result.b == sqrt(14)*sin(asin(4)/2)/14
+    assert result.c == sqrt(14)*sin(asin(4)/2)/7
+    assert result.d == 3*sqrt(14)*sin(asin(4)/2)/14
+
+def test_quaternion_complex_real_addition():
+    a = symbols("a", complex=True)
+    b = symbols("b", real=True)
+    # This symbol is not complex:
+    c = symbols("c", commutative=False)
+
+    q = Quaternion(w, x, y, z)
+    assert a + q == Quaternion(w + re(a), x + im(a), y, z)
+    assert 1 + q == Quaternion(1 + w, x, y, z)
+    assert I + q == Quaternion(w, 1 + x, y, z)
+    assert b + q == Quaternion(w + b, x, y, z)
+    raises(ValueError, lambda: c + q)
+    raises(ValueError, lambda: q * c)
+    raises(ValueError, lambda: c * q)
+
+    assert -q == Quaternion(-w, -x, -y, -z)
+
+    q1 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+    q2 = Quaternion(1, 4, 7, 8)
+
+    assert q1 + (2 + 3*I) == Quaternion(5 + 7*I, 2 + 5*I, 0, 7 + 8*I)
+    assert q2 + (2 + 3*I) == Quaternion(3, 7, 7, 8)
+    assert q1 * (2 + 3*I) == \
+    Quaternion((2 + 3*I)*(3 + 4*I), (2 + 3*I)*(2 + 5*I), 0, (2 + 3*I)*(7 + 8*I))
+    assert q2 * (2 + 3*I) == Quaternion(-10, 11, 38, -5)
+
+    q1 = Quaternion(1, 2, 3, 4)
+    q0 = Quaternion(0, 0, 0, 0)
+    assert q1 + q0 == q1
+    assert q1 - q0 == q1
+    assert q1 - q1 == q0
+
+
+def test_quaternion_evalf():
+    assert (Quaternion(sqrt(2), 0, 0, sqrt(3)).evalf() ==
+            Quaternion(sqrt(2).evalf(), 0, 0, sqrt(3).evalf()))
+    assert (Quaternion(1/sqrt(2), 0, 0, 1/sqrt(2)).evalf() ==
+            Quaternion((1/sqrt(2)).evalf(), 0, 0, (1/sqrt(2)).evalf()))
+
+
+def test_quaternion_functions():
+    q = Quaternion(w, x, y, z)
+    q1 = Quaternion(1, 2, 3, 4)
+    q0 = Quaternion(0, 0, 0, 0)
+
+    assert conjugate(q) == Quaternion(w, -x, -y, -z)
+    assert q.norm() == sqrt(w**2 + x**2 + y**2 + z**2)
+    assert q.normalize() == Quaternion(w, x, y, z) / sqrt(w**2 + x**2 + y**2 + z**2)
+    assert q.inverse() == Quaternion(w, -x, -y, -z) / (w**2 + x**2 + y**2 + z**2)
+    assert q.inverse() == q.pow(-1)
+    raises(ValueError, lambda: q0.inverse())
+    assert q.pow(2) == Quaternion(w**2 - x**2 - y**2 - z**2, 2*w*x, 2*w*y, 2*w*z)
+    assert q**(2) == Quaternion(w**2 - x**2 - y**2 - z**2, 2*w*x, 2*w*y, 2*w*z)
+    assert q1.pow(-2) == Quaternion(
+        Rational(-7, 225), Rational(-1, 225), Rational(-1, 150), Rational(-2, 225))
+    assert q1**(-2) == Quaternion(
+        Rational(-7, 225), Rational(-1, 225), Rational(-1, 150), Rational(-2, 225))
+    assert q1.pow(-0.5) == NotImplemented
+    raises(TypeError, lambda: q1**(-0.5))
+
+    assert q1.exp() == \
+    Quaternion(E * cos(sqrt(29)),
+               2 * sqrt(29) * E * sin(sqrt(29)) / 29,
+               3 * sqrt(29) * E * sin(sqrt(29)) / 29,
+               4 * sqrt(29) * E * sin(sqrt(29)) / 29)
+    assert q1._ln() == \
+    Quaternion(log(sqrt(30)),
+               2 * sqrt(29) * acos(sqrt(30)/30) / 29,
+               3 * sqrt(29) * acos(sqrt(30)/30) / 29,
+               4 * sqrt(29) * acos(sqrt(30)/30) / 29)
+
+    assert q1.pow_cos_sin(2) == \
+    Quaternion(30 * cos(2 * acos(sqrt(30)/30)),
+               60 * sqrt(29) * sin(2 * acos(sqrt(30)/30)) / 29,
+               90 * sqrt(29) * sin(2 * acos(sqrt(30)/30)) / 29,
+               120 * sqrt(29) * sin(2 * acos(sqrt(30)/30)) / 29)
+
+    assert diff(Quaternion(x, x, x, x), x) == Quaternion(1, 1, 1, 1)
+
+    assert integrate(Quaternion(x, x, x, x), x) == \
+    Quaternion(x**2 / 2, x**2 / 2, x**2 / 2, x**2 / 2)
+
+    assert Quaternion.rotate_point((1, 1, 1), q1) == (S.One / 5, 1, S(7) / 5)
+    n = Symbol('n')
+    raises(TypeError, lambda: q1**n)
+    n = Symbol('n', integer=True)
+    raises(TypeError, lambda: q1**n)
+
+    assert Quaternion(22, 23, 55, 8).scalar_part() == 22
+    assert Quaternion(w, x, y, z).scalar_part() == w
+
+    assert Quaternion(22, 23, 55, 8).vector_part() == Quaternion(0, 23, 55, 8)
+    assert Quaternion(w, x, y, z).vector_part() == Quaternion(0, x, y, z)
+
+    assert q1.axis() == Quaternion(0, 2*sqrt(29)/29, 3*sqrt(29)/29, 4*sqrt(29)/29)
+    assert q1.axis().pow(2) == Quaternion(-1, 0, 0, 0)
+    assert q0.axis().scalar_part() == 0
+    assert (q.axis() == Quaternion(0,
+                                   x/sqrt(x**2 + y**2 + z**2),
+                                   y/sqrt(x**2 + y**2 + z**2),
+                                   z/sqrt(x**2 + y**2 + z**2)))
+
+    assert q0.is_pure() is True
+    assert q1.is_pure() is False
+    assert Quaternion(0, 0, 0, 3).is_pure() is True
+    assert Quaternion(0, 2, 10, 3).is_pure() is True
+    assert Quaternion(w, 2, 10, 3).is_pure() is None
+
+    assert q1.angle() == atan(sqrt(29))
+    assert q.angle() == atan2(sqrt(x**2 + y**2 + z**2), w)
+
+    assert Quaternion.arc_coplanar(q1, Quaternion(2, 4, 6, 8)) is True
+    assert Quaternion.arc_coplanar(q1, Quaternion(1, -2, -3, -4)) is True
+    assert Quaternion.arc_coplanar(q1, Quaternion(1, 8, 12, 16)) is True
+    assert Quaternion.arc_coplanar(q1, Quaternion(1, 2, 3, 4)) is True
+    assert Quaternion.arc_coplanar(q1, Quaternion(w, 4, 6, 8)) is True
+    assert Quaternion.arc_coplanar(q1, Quaternion(2, 7, 4, 1)) is False
+    assert Quaternion.arc_coplanar(q1, Quaternion(w, x, y, z)) is None
+    raises(ValueError, lambda: Quaternion.arc_coplanar(q1, q0))
+
+    assert Quaternion.vector_coplanar(
+        Quaternion(0, 8, 12, 16),
+        Quaternion(0, 4, 6, 8),
+        Quaternion(0, 2, 3, 4)) is True
+    assert Quaternion.vector_coplanar(
+        Quaternion(0, 0, 0, 0), Quaternion(0, 4, 6, 8), Quaternion(0, 2, 3, 4)) is True
+    assert Quaternion.vector_coplanar(
+        Quaternion(0, 8, 2, 6), Quaternion(0, 1, 6, 6), Quaternion(0, 0, 3, 4)) is False
+    assert Quaternion.vector_coplanar(
+        Quaternion(0, 1, 3, 4),
+        Quaternion(0, 4, w, 6),
+        Quaternion(0, 6, 8, 1)) is None
+    raises(ValueError, lambda:
+        Quaternion.vector_coplanar(q0, Quaternion(0, 4, 6, 8), q1))
+
+    assert Quaternion(0, 1, 2, 3).parallel(Quaternion(0, 2, 4, 6)) is True
+    assert Quaternion(0, 1, 2, 3).parallel(Quaternion(0, 2, 2, 6)) is False
+    assert Quaternion(0, 1, 2, 3).parallel(Quaternion(w, x, y, 6)) is None
+    raises(ValueError, lambda: q0.parallel(q1))
+
+    assert Quaternion(0, 1, 2, 3).orthogonal(Quaternion(0, -2, 1, 0)) is True
+    assert Quaternion(0, 2, 4, 7).orthogonal(Quaternion(0, 2, 2, 6)) is False
+    assert Quaternion(0, 2, 4, 7).orthogonal(Quaternion(w, x, y, 6)) is None
+    raises(ValueError, lambda: q0.orthogonal(q1))
+
+    assert q1.index_vector() == Quaternion(
+        0, 2*sqrt(870)/29,
+        3*sqrt(870)/29,
+        4*sqrt(870)/29)
+    assert Quaternion(0, 3, 9, 4).index_vector() == Quaternion(0, 3, 9, 4)
+
+    assert Quaternion(4, 3, 9, 4).mensor() == log(sqrt(122))
+    assert Quaternion(3, 3, 0, 2).mensor() == log(sqrt(22))
+
+    assert q0.is_zero_quaternion() is True
+    assert q1.is_zero_quaternion() is False
+    assert Quaternion(w, 0, 0, 0).is_zero_quaternion() is None
+
+def test_quaternion_conversions():
+    q1 = Quaternion(1, 2, 3, 4)
+
+    assert q1.to_axis_angle() == ((2 * sqrt(29)/29,
+                                   3 * sqrt(29)/29,
+                                   4 * sqrt(29)/29),
+                                   2 * acos(sqrt(30)/30))
+
+    assert (q1.to_rotation_matrix() ==
+            Matrix([[Rational(-2, 3), Rational(2, 15), Rational(11, 15)],
+                    [Rational(2, 3), Rational(-1, 3), Rational(2, 3)],
+                    [Rational(1, 3), Rational(14, 15), Rational(2, 15)]]))
+
+    assert (q1.to_rotation_matrix((1, 1, 1)) ==
+            Matrix([
+                [Rational(-2, 3), Rational(2, 15), Rational(11, 15), Rational(4, 5)],
+                [Rational(2, 3), Rational(-1, 3), Rational(2, 3), S.Zero],
+                [Rational(1, 3), Rational(14, 15), Rational(2, 15), Rational(-2, 5)],
+                [S.Zero, S.Zero, S.Zero, S.One]]))
+
+    theta = symbols("theta", real=True)
+    q2 = Quaternion(cos(theta/2), 0, 0, sin(theta/2))
+
+    assert trigsimp(q2.to_rotation_matrix()) == Matrix([
+                                               [cos(theta), -sin(theta), 0],
+                                               [sin(theta),  cos(theta), 0],
+                                               [0,           0,          1]])
+
+    assert q2.to_axis_angle() == ((0, 0, sin(theta/2)/Abs(sin(theta/2))),
+                                   2*acos(cos(theta/2)))
+
+    assert trigsimp(q2.to_rotation_matrix((1, 1, 1))) == Matrix([
+               [cos(theta), -sin(theta), 0, sin(theta) - cos(theta) + 1],
+               [sin(theta),  cos(theta), 0, -sin(theta) - cos(theta) + 1],
+               [0,           0,          1,  0],
+               [0,           0,          0,  1]])
+
+
+def test_rotation_matrix_homogeneous():
+    q = Quaternion(w, x, y, z)
+    R1 = q.to_rotation_matrix(homogeneous=True) * q.norm()**2
+    R2 = simplify(q.to_rotation_matrix(homogeneous=False) * q.norm()**2)
+    assert R1 == R2
+
+
+def test_quaternion_rotation_iss1593():
+    """
+    There was a sign mistake in the definition,
+    of the rotation matrix. This tests that particular sign mistake.
+    See issue 1593 for reference.
+    See wikipedia
+    https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#Quaternion-derived_rotation_matrix
+    for the correct definition
+    """
+    q = Quaternion(cos(phi/2), sin(phi/2), 0, 0)
+    assert(trigsimp(q.to_rotation_matrix()) == Matrix([
+                [1,        0,         0],
+                [0, cos(phi), -sin(phi)],
+                [0, sin(phi),  cos(phi)]]))
+
+
+def test_quaternion_multiplication():
+    q1 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+    q2 = Quaternion(1, 2, 3, 5)
+    q3 = Quaternion(1, 1, 1, y)
+
+    assert Quaternion._generic_mul(S(4), S.One) == 4
+    assert (Quaternion._generic_mul(S(4), q1) ==
+            Quaternion(12 + 16*I, 8 + 20*I, 0, 28 + 32*I))
+    assert q2.mul(2) == Quaternion(2, 4, 6, 10)
+    assert q2.mul(q3) == Quaternion(-5*y - 4, 3*y - 2, 9 - 2*y, y + 4)
+    assert q2.mul(q3) == q2*q3
+
+    z = symbols('z', complex=True)
+    z_quat = Quaternion(re(z), im(z), 0, 0)
+    q = Quaternion(*symbols('q:4', real=True))
+
+    assert z * q == z_quat * q
+    assert q * z == q * z_quat
+
+
+def test_issue_16318():
+    #for rtruediv
+    q0 = Quaternion(0, 0, 0, 0)
+    raises(ValueError, lambda: 1/q0)
+    #for rotate_point
+    q = Quaternion(1, 2, 3, 4)
+    (axis, angle) = q.to_axis_angle()
+    assert Quaternion.rotate_point((1, 1, 1), (axis, angle)) == (S.One / 5, 1, S(7) / 5)
+    #test for to_axis_angle
+    q = Quaternion(-1, 1, 1, 1)
+    axis = (-sqrt(3)/3, -sqrt(3)/3, -sqrt(3)/3)
+    angle = 2*pi/3
+    assert (axis, angle) == q.to_axis_angle()
+
+
+def test_to_euler():
+    q = Quaternion(w, x, y, z)
+    q_normalized = q.normalize()
+
+    seqs = ['zxy', 'zyx', 'zyz', 'zxz']
+    seqs += [seq.upper() for seq in seqs]
+
+    for seq in seqs:
+        euler_from_q = q.to_euler(seq)
+        q_back = simplify(Quaternion.from_euler(euler_from_q, seq))
+        assert q_back == q_normalized
+
+
+def test_to_euler_iss24504():
+    """
+    There was a mistake in the degenerate case testing
+    See issue 24504 for reference.
+    """
+    q = Quaternion.from_euler((phi, 0, 0), 'zyz')
+    assert trigsimp(q.to_euler('zyz'), inverse=True) == (phi, 0, 0)
+
+
+def test_to_euler_numerical_singilarities():
+
+    def test_one_case(angles, seq):
+        q = Quaternion.from_euler(angles, seq)
+        assert q.to_euler(seq) == angles
+
+    # symmetric
+    test_one_case((pi/2,  0, 0), 'zyz')
+    test_one_case((pi/2,  0, 0), 'ZYZ')
+    test_one_case((pi/2,  pi, 0), 'zyz')
+    test_one_case((pi/2,  pi, 0), 'ZYZ')
+
+    # asymmetric
+    test_one_case((pi/2,  pi/2, 0), 'zyx')
+    test_one_case((pi/2,  -pi/2, 0), 'zyx')
+    test_one_case((pi/2,  pi/2, 0), 'ZYX')
+    test_one_case((pi/2,  -pi/2, 0), 'ZYX')
+
+
+def test_to_euler_options():
+    def test_one_case(q):
+        angles1 = Matrix(q.to_euler(seq, True, True))
+        angles2 = Matrix(q.to_euler(seq, False, False))
+        angle_errors = simplify(angles1-angles2).evalf()
+        for angle_error in angle_errors:
+            # forcing angles to set {-pi, pi}
+            angle_error = (angle_error + pi) % (2 * pi) - pi
+            assert angle_error < 10e-7
+
+    for xyz in ('xyz', 'XYZ'):
+        for seq_tuple in permutations(xyz):
+            for symmetric in (True, False):
+                if symmetric:
+                    seq = ''.join([seq_tuple[0], seq_tuple[1], seq_tuple[0]])
+                else:
+                    seq = ''.join(seq_tuple)
+
+                for elements in product([-1, 0, 1], repeat=4):
+                    q = Quaternion(*elements)
+                    if not q.is_zero_quaternion():
+                        test_one_case(q)

env-llmeval/lib/python3.10/site-packages/sympy/polys/domains/__init__.py

@@ -0,0 +1,57 @@
+"""Implementation of mathematical domains. """
+
+__all__ = [
+    'Domain', 'FiniteField', 'IntegerRing', 'RationalField', 'RealField',
+    'ComplexField', 'AlgebraicField', 'PolynomialRing', 'FractionField',
+    'ExpressionDomain', 'PythonRational',
+
+    'GF', 'FF', 'ZZ', 'QQ', 'ZZ_I', 'QQ_I', 'RR', 'CC', 'EX', 'EXRAW',
+]
+
+from .domain import Domain
+from .finitefield import FiniteField, FF, GF
+from .integerring import IntegerRing, ZZ
+from .rationalfield import RationalField, QQ
+from .algebraicfield import AlgebraicField
+from .gaussiandomains import ZZ_I, QQ_I
+from .realfield import RealField, RR
+from .complexfield import ComplexField, CC
+from .polynomialring import PolynomialRing
+from .fractionfield import FractionField
+from .expressiondomain import ExpressionDomain, EX
+from .expressionrawdomain import EXRAW
+from .pythonrational import PythonRational
+
+
+# This is imported purely for backwards compatibility because some parts of
+# the codebase used to import this from here and it's possible that downstream
+# does as well:
+from sympy.external.gmpy import GROUND_TYPES  # noqa: F401
+
+#
+# The rest of these are obsolete and provided only for backwards
+# compatibility:
+#
+
+from .pythonfinitefield import PythonFiniteField
+from .gmpyfinitefield import GMPYFiniteField
+from .pythonintegerring import PythonIntegerRing
+from .gmpyintegerring import GMPYIntegerRing
+from .pythonrationalfield import PythonRationalField
+from .gmpyrationalfield import GMPYRationalField
+
+FF_python = PythonFiniteField
+FF_gmpy = GMPYFiniteField
+
+ZZ_python = PythonIntegerRing
+ZZ_gmpy = GMPYIntegerRing
+
+QQ_python = PythonRationalField
+QQ_gmpy = GMPYRationalField
+
+__all__.extend((
+    'PythonFiniteField', 'GMPYFiniteField', 'PythonIntegerRing',
+    'GMPYIntegerRing', 'PythonRational', 'GMPYRationalField',
+
+    'FF_python', 'FF_gmpy', 'ZZ_python', 'ZZ_gmpy', 'QQ_python', 'QQ_gmpy',
+))

env-llmeval/lib/python3.10/site-packages/sympy/polys/domains/field.py

@@ -0,0 +1,104 @@
+"""Implementation of :class:`Field` class. """
+
+
+from sympy.polys.domains.ring import Ring
+from sympy.polys.polyerrors import NotReversible, DomainError
+from sympy.utilities import public
+
+@public
+class Field(Ring):
+    """Represents a field domain. """
+
+    is_Field = True
+    is_PID = True
+
+    def get_ring(self):
+        """Returns a ring associated with ``self``. """
+        raise DomainError('there is no ring associated with %s' % self)
+
+    def get_field(self):
+        """Returns a field associated with ``self``. """
+        return self
+
+    def exquo(self, a, b):
+        """Exact quotient of ``a`` and ``b``, implies ``__truediv__``.  """
+        return a / b
+
+    def quo(self, a, b):
+        """Quotient of ``a`` and ``b``, implies ``__truediv__``. """
+        return a / 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 a / b, self.zero
+
+    def gcd(self, a, b):
+        """
+        Returns GCD of ``a`` and ``b``.
+
+        This definition of GCD over fields allows to clear denominators
+        in `primitive()`.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.domains import QQ
+        >>> from sympy import S, gcd, primitive
+        >>> from sympy.abc import x
+
+        >>> QQ.gcd(QQ(2, 3), QQ(4, 9))
+        2/9
+        >>> gcd(S(2)/3, S(4)/9)
+        2/9
+        >>> primitive(2*x/3 + S(4)/9)
+        (2/9, 3*x + 2)
+
+        """
+        try:
+            ring = self.get_ring()
+        except DomainError:
+            return self.one
+
+        p = ring.gcd(self.numer(a), self.numer(b))
+        q = ring.lcm(self.denom(a), self.denom(b))
+
+        return self.convert(p, ring)/q
+
+    def lcm(self, a, b):
+        """
+        Returns LCM of ``a`` and ``b``.
+
+        >>> from sympy.polys.domains import QQ
+        >>> from sympy import S, lcm
+
+        >>> QQ.lcm(QQ(2, 3), QQ(4, 9))
+        4/3
+        >>> lcm(S(2)/3, S(4)/9)
+        4/3
+
+        """
+
+        try:
+            ring = self.get_ring()
+        except DomainError:
+            return a*b
+
+        p = ring.lcm(self.numer(a), self.numer(b))
+        q = ring.gcd(self.denom(a), self.denom(b))
+
+        return self.convert(p, ring)/q
+
+    def revert(self, a):
+        """Returns ``a**(-1)`` if possible. """
+        if a:
+            return 1/a
+        else:
+            raise NotReversible('zero is not reversible')
+
+    def is_unit(self, a):
+        """Return true if ``a`` is a invertible"""
+        return bool(a)

env-llmeval/lib/python3.10/site-packages/sympy/polys/domains/groundtypes.py

@@ -0,0 +1,73 @@
+"""Ground types for various mathematical domains in SymPy. """
+
+import builtins
+from sympy.external.gmpy import HAS_GMPY, factorial, sqrt
+
+PythonInteger = builtins.int
+PythonReal = builtins.float
+PythonComplex = builtins.complex
+
+from .pythonrational import PythonRational
+
+from sympy.core.numbers import (
+    igcdex as python_gcdex,
+    igcd2 as python_gcd,
+    ilcm as python_lcm,
+)
+
+from sympy.core.numbers import (Float as SymPyReal, Integer as SymPyInteger, Rational as SymPyRational)
+
+
+if HAS_GMPY == 2:
+    from gmpy2 import (
+        mpz as GMPYInteger,
+        mpq as GMPYRational,
+        numer as gmpy_numer,
+        denom as gmpy_denom,
+        gcdext as gmpy_gcdex,
+        gcd as gmpy_gcd,
+        lcm as gmpy_lcm,
+        qdiv as gmpy_qdiv,
+    )
+    gcdex = gmpy_gcdex
+    gcd = gmpy_gcd
+    lcm = gmpy_lcm
+else:
+    class _GMPYInteger:
+        def __init__(self, obj):
+            pass
+
+    class _GMPYRational:
+        def __init__(self, obj):
+            pass
+
+    GMPYInteger = _GMPYInteger
+    GMPYRational = _GMPYRational
+    gmpy_numer = None
+    gmpy_denom = None
+    gmpy_gcdex = None
+    gmpy_gcd = None
+    gmpy_lcm = None
+    gmpy_qdiv = None
+    gcdex = python_gcdex
+    gcd = python_gcd
+    lcm = python_lcm
+
+
+__all__ = [
+    'PythonInteger', 'PythonReal', 'PythonComplex',
+
+    'PythonRational',
+
+    'python_gcdex', 'python_gcd', 'python_lcm',
+
+    'SymPyReal', 'SymPyInteger', 'SymPyRational',
+
+    'GMPYInteger', 'GMPYRational', 'gmpy_numer',
+    'gmpy_denom', 'gmpy_gcdex', 'gmpy_gcd', 'gmpy_lcm',
+    'gmpy_qdiv',
+
+    'factorial', 'sqrt',
+
+    'GMPYInteger', 'GMPYRational',
+]

env-llmeval/lib/python3.10/site-packages/sympy/polys/domains/pythonfinitefield.py

@@ -0,0 +1,16 @@
+"""Implementation of :class:`PythonFiniteField` class. """
+
+
+from sympy.polys.domains.finitefield import FiniteField
+from sympy.polys.domains.pythonintegerring import PythonIntegerRing
+
+from sympy.utilities import public
+
+@public
+class PythonFiniteField(FiniteField):
+    """Finite field based on Python's integers. """
+
+    alias = 'FF_python'
+
+    def __init__(self, mod, symmetric=True):
+        return super().__init__(mod, PythonIntegerRing(), symmetric)

env-llmeval/lib/python3.10/site-packages/sympy/polys/domains/pythonrational.py

@@ -0,0 +1,22 @@
+"""
+Rational number type based on Python integers.
+
+The PythonRational class from here has been moved to
+sympy.external.pythonmpq
+
+This module is just left here for backwards compatibility.
+"""
+
+
+from sympy.core.numbers import Rational
+from sympy.core.sympify import _sympy_converter
+from sympy.utilities import public
+from sympy.external.pythonmpq import PythonMPQ
+
+
+PythonRational = public(PythonMPQ)
+
+
+def sympify_pythonrational(arg):
+    return Rational(arg.numerator, arg.denominator)
+_sympy_converter[PythonRational] = sympify_pythonrational

env-llmeval/lib/python3.10/site-packages/sympy/polys/domains/rationalfield.py

@@ -0,0 +1,163 @@
+"""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()

env-llmeval/lib/python3.10/site-packages/sympy/polys/domains/simpledomain.py

@@ -0,0 +1,15 @@
+"""Implementation of :class:`SimpleDomain` class. """
+
+
+from sympy.polys.domains.domain import Domain
+from sympy.utilities import public
+
+@public
+class SimpleDomain(Domain):
+    """Base class for simple domains, e.g. ZZ, QQ. """
+
+    is_Simple = True
+
+    def inject(self, *gens):
+        """Inject generators into this domain. """
+        return self.poly_ring(*gens)

env-llmeval/lib/python3.10/site-packages/sympy/polys/domains/tests/test_domains.py

@@ -0,0 +1,1270 @@
+"""Tests for classes defining properties of ground domains, e.g. ZZ, QQ, ZZ[x] ... """
+
+from sympy.core.numbers import (AlgebraicNumber, E, Float, I, Integer,
+    Rational, oo, pi, _illegal)
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.polys.polytools import Poly
+from sympy.abc import x, y, z
+
+from sympy.external.gmpy import HAS_GMPY
+
+from sympy.polys.domains import (ZZ, QQ, RR, CC, FF, GF, EX, EXRAW, ZZ_gmpy,
+    ZZ_python, QQ_gmpy, QQ_python)
+from sympy.polys.domains.algebraicfield import AlgebraicField
+from sympy.polys.domains.gaussiandomains import ZZ_I, QQ_I
+from sympy.polys.domains.polynomialring import PolynomialRing
+from sympy.polys.domains.realfield import RealField
+
+from sympy.polys.numberfields.subfield import field_isomorphism
+from sympy.polys.rings import ring
+from sympy.polys.specialpolys import cyclotomic_poly
+from sympy.polys.fields import field
+
+from sympy.polys.agca.extensions import FiniteExtension
+
+from sympy.polys.polyerrors import (
+    UnificationFailed,
+    GeneratorsError,
+    CoercionFailed,
+    NotInvertible,
+    DomainError)
+
+from sympy.testing.pytest import raises
+
+from itertools import product
+
+ALG = QQ.algebraic_field(sqrt(2), sqrt(3))
+
+def unify(K0, K1):
+    return K0.unify(K1)
+
+def test_Domain_unify():
+    F3 = GF(3)
+
+    assert unify(F3, F3) == F3
+    assert unify(F3, ZZ) == ZZ
+    assert unify(F3, QQ) == QQ
+    assert unify(F3, ALG) == ALG
+    assert unify(F3, RR) == RR
+    assert unify(F3, CC) == CC
+    assert unify(F3, ZZ[x]) == ZZ[x]
+    assert unify(F3, ZZ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(F3, EX) == EX
+
+    assert unify(ZZ, F3) == ZZ
+    assert unify(ZZ, ZZ) == ZZ
+    assert unify(ZZ, QQ) == QQ
+    assert unify(ZZ, ALG) == ALG
+    assert unify(ZZ, RR) == RR
+    assert unify(ZZ, CC) == CC
+    assert unify(ZZ, ZZ[x]) == ZZ[x]
+    assert unify(ZZ, ZZ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(ZZ, EX) == EX
+
+    assert unify(QQ, F3) == QQ
+    assert unify(QQ, ZZ) == QQ
+    assert unify(QQ, QQ) == QQ
+    assert unify(QQ, ALG) == ALG
+    assert unify(QQ, RR) == RR
+    assert unify(QQ, CC) == CC
+    assert unify(QQ, ZZ[x]) == QQ[x]
+    assert unify(QQ, ZZ.frac_field(x)) == QQ.frac_field(x)
+    assert unify(QQ, EX) == EX
+
+    assert unify(ZZ_I, F3) == ZZ_I
+    assert unify(ZZ_I, ZZ) == ZZ_I
+    assert unify(ZZ_I, ZZ_I) == ZZ_I
+    assert unify(ZZ_I, QQ) == QQ_I
+    assert unify(ZZ_I, ALG) == QQ.algebraic_field(I, sqrt(2), sqrt(3))
+    assert unify(ZZ_I, RR) == CC
+    assert unify(ZZ_I, CC) == CC
+    assert unify(ZZ_I, ZZ[x]) == ZZ_I[x]
+    assert unify(ZZ_I, ZZ_I[x]) == ZZ_I[x]
+    assert unify(ZZ_I, ZZ.frac_field(x)) == ZZ_I.frac_field(x)
+    assert unify(ZZ_I, ZZ_I.frac_field(x)) == ZZ_I.frac_field(x)
+    assert unify(ZZ_I, EX) == EX
+
+    assert unify(QQ_I, F3) == QQ_I
+    assert unify(QQ_I, ZZ) == QQ_I
+    assert unify(QQ_I, ZZ_I) == QQ_I
+    assert unify(QQ_I, QQ) == QQ_I
+    assert unify(QQ_I, ALG) == QQ.algebraic_field(I, sqrt(2), sqrt(3))
+    assert unify(QQ_I, RR) == CC
+    assert unify(QQ_I, CC) == CC
+    assert unify(QQ_I, ZZ[x]) == QQ_I[x]
+    assert unify(QQ_I, ZZ_I[x]) == QQ_I[x]
+    assert unify(QQ_I, QQ[x]) == QQ_I[x]
+    assert unify(QQ_I, QQ_I[x]) == QQ_I[x]
+    assert unify(QQ_I, ZZ.frac_field(x)) == QQ_I.frac_field(x)
+    assert unify(QQ_I, ZZ_I.frac_field(x)) == QQ_I.frac_field(x)
+    assert unify(QQ_I, QQ.frac_field(x)) == QQ_I.frac_field(x)
+    assert unify(QQ_I, QQ_I.frac_field(x)) == QQ_I.frac_field(x)
+    assert unify(QQ_I, EX) == EX
+
+    assert unify(RR, F3) == RR
+    assert unify(RR, ZZ) == RR
+    assert unify(RR, QQ) == RR
+    assert unify(RR, ALG) == RR
+    assert unify(RR, RR) == RR
+    assert unify(RR, CC) == CC
+    assert unify(RR, ZZ[x]) == RR[x]
+    assert unify(RR, ZZ.frac_field(x)) == RR.frac_field(x)
+    assert unify(RR, EX) == EX
+    assert RR[x].unify(ZZ.frac_field(y)) == RR.frac_field(x, y)
+
+    assert unify(CC, F3) == CC
+    assert unify(CC, ZZ) == CC
+    assert unify(CC, QQ) == CC
+    assert unify(CC, ALG) == CC
+    assert unify(CC, RR) == CC
+    assert unify(CC, CC) == CC
+    assert unify(CC, ZZ[x]) == CC[x]
+    assert unify(CC, ZZ.frac_field(x)) == CC.frac_field(x)
+    assert unify(CC, EX) == EX
+
+    assert unify(ZZ[x], F3) == ZZ[x]
+    assert unify(ZZ[x], ZZ) == ZZ[x]
+    assert unify(ZZ[x], QQ) == QQ[x]
+    assert unify(ZZ[x], ALG) == ALG[x]
+    assert unify(ZZ[x], RR) == RR[x]
+    assert unify(ZZ[x], CC) == CC[x]
+    assert unify(ZZ[x], ZZ[x]) == ZZ[x]
+    assert unify(ZZ[x], ZZ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(ZZ[x], EX) == EX
+
+    assert unify(ZZ.frac_field(x), F3) == ZZ.frac_field(x)
+    assert unify(ZZ.frac_field(x), ZZ) == ZZ.frac_field(x)
+    assert unify(ZZ.frac_field(x), QQ) == QQ.frac_field(x)
+    assert unify(ZZ.frac_field(x), ALG) == ALG.frac_field(x)
+    assert unify(ZZ.frac_field(x), RR) == RR.frac_field(x)
+    assert unify(ZZ.frac_field(x), CC) == CC.frac_field(x)
+    assert unify(ZZ.frac_field(x), ZZ[x]) == ZZ.frac_field(x)
+    assert unify(ZZ.frac_field(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(ZZ.frac_field(x), EX) == EX
+
+    assert unify(EX, F3) == EX
+    assert unify(EX, ZZ) == EX
+    assert unify(EX, QQ) == EX
+    assert unify(EX, ALG) == EX
+    assert unify(EX, RR) == EX
+    assert unify(EX, CC) == EX
+    assert unify(EX, ZZ[x]) == EX
+    assert unify(EX, ZZ.frac_field(x)) == EX
+    assert unify(EX, EX) == EX
+
+def test_Domain_unify_composite():
+    assert unify(ZZ.poly_ring(x), ZZ) == ZZ.poly_ring(x)
+    assert unify(ZZ.poly_ring(x), QQ) == QQ.poly_ring(x)
+    assert unify(QQ.poly_ring(x), ZZ) == QQ.poly_ring(x)
+    assert unify(QQ.poly_ring(x), QQ) == QQ.poly_ring(x)
+
+    assert unify(ZZ, ZZ.poly_ring(x)) == ZZ.poly_ring(x)
+    assert unify(QQ, ZZ.poly_ring(x)) == QQ.poly_ring(x)
+    assert unify(ZZ, QQ.poly_ring(x)) == QQ.poly_ring(x)
+    assert unify(QQ, QQ.poly_ring(x)) == QQ.poly_ring(x)
+
+    assert unify(ZZ.poly_ring(x, y), ZZ) == ZZ.poly_ring(x, y)
+    assert unify(ZZ.poly_ring(x, y), QQ) == QQ.poly_ring(x, y)
+    assert unify(QQ.poly_ring(x, y), ZZ) == QQ.poly_ring(x, y)
+    assert unify(QQ.poly_ring(x, y), QQ) == QQ.poly_ring(x, y)
+
+    assert unify(ZZ, ZZ.poly_ring(x, y)) == ZZ.poly_ring(x, y)
+    assert unify(QQ, ZZ.poly_ring(x, y)) == QQ.poly_ring(x, y)
+    assert unify(ZZ, QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
+    assert unify(QQ, QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
+
+    assert unify(ZZ.frac_field(x), ZZ) == ZZ.frac_field(x)
+    assert unify(ZZ.frac_field(x), QQ) == QQ.frac_field(x)
+    assert unify(QQ.frac_field(x), ZZ) == QQ.frac_field(x)
+    assert unify(QQ.frac_field(x), QQ) == QQ.frac_field(x)
+
+    assert unify(ZZ, ZZ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(QQ, ZZ.frac_field(x)) == QQ.frac_field(x)
+    assert unify(ZZ, QQ.frac_field(x)) == QQ.frac_field(x)
+    assert unify(QQ, QQ.frac_field(x)) == QQ.frac_field(x)
+
+    assert unify(ZZ.frac_field(x, y), ZZ) == ZZ.frac_field(x, y)
+    assert unify(ZZ.frac_field(x, y), QQ) == QQ.frac_field(x, y)
+    assert unify(QQ.frac_field(x, y), ZZ) == QQ.frac_field(x, y)
+    assert unify(QQ.frac_field(x, y), QQ) == QQ.frac_field(x, y)
+
+    assert unify(ZZ, ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
+    assert unify(QQ, ZZ.frac_field(x, y)) == QQ.frac_field(x, y)
+    assert unify(ZZ, QQ.frac_field(x, y)) == QQ.frac_field(x, y)
+    assert unify(QQ, QQ.frac_field(x, y)) == QQ.frac_field(x, y)
+
+    assert unify(ZZ.poly_ring(x), ZZ.poly_ring(x)) == ZZ.poly_ring(x)
+    assert unify(ZZ.poly_ring(x), QQ.poly_ring(x)) == QQ.poly_ring(x)
+    assert unify(QQ.poly_ring(x), ZZ.poly_ring(x)) == QQ.poly_ring(x)
+    assert unify(QQ.poly_ring(x), QQ.poly_ring(x)) == QQ.poly_ring(x)
+
+    assert unify(ZZ.poly_ring(x, y), ZZ.poly_ring(x)) == ZZ.poly_ring(x, y)
+    assert unify(ZZ.poly_ring(x, y), QQ.poly_ring(x)) == QQ.poly_ring(x, y)
+    assert unify(QQ.poly_ring(x, y), ZZ.poly_ring(x)) == QQ.poly_ring(x, y)
+    assert unify(QQ.poly_ring(x, y), QQ.poly_ring(x)) == QQ.poly_ring(x, y)
+
+    assert unify(ZZ.poly_ring(x), ZZ.poly_ring(x, y)) == ZZ.poly_ring(x, y)
+    assert unify(ZZ.poly_ring(x), QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
+    assert unify(QQ.poly_ring(x), ZZ.poly_ring(x, y)) == QQ.poly_ring(x, y)
+    assert unify(QQ.poly_ring(x), QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
+
+    assert unify(ZZ.poly_ring(x, y), ZZ.poly_ring(x, z)) == ZZ.poly_ring(x, y, z)
+    assert unify(ZZ.poly_ring(x, y), QQ.poly_ring(x, z)) == QQ.poly_ring(x, y, z)
+    assert unify(QQ.poly_ring(x, y), ZZ.poly_ring(x, z)) == QQ.poly_ring(x, y, z)
+    assert unify(QQ.poly_ring(x, y), QQ.poly_ring(x, z)) == QQ.poly_ring(x, y, z)
+
+    assert unify(ZZ.frac_field(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(ZZ.frac_field(x), QQ.frac_field(x)) == QQ.frac_field(x)
+    assert unify(QQ.frac_field(x), ZZ.frac_field(x)) == QQ.frac_field(x)
+    assert unify(QQ.frac_field(x), QQ.frac_field(x)) == QQ.frac_field(x)
+
+    assert unify(ZZ.frac_field(x, y), ZZ.frac_field(x)) == ZZ.frac_field(x, y)
+    assert unify(ZZ.frac_field(x, y), QQ.frac_field(x)) == QQ.frac_field(x, y)
+    assert unify(QQ.frac_field(x, y), ZZ.frac_field(x)) == QQ.frac_field(x, y)
+    assert unify(QQ.frac_field(x, y), QQ.frac_field(x)) == QQ.frac_field(x, y)
+
+    assert unify(ZZ.frac_field(x), ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
+    assert unify(ZZ.frac_field(x), QQ.frac_field(x, y)) == QQ.frac_field(x, y)
+    assert unify(QQ.frac_field(x), ZZ.frac_field(x, y)) == QQ.frac_field(x, y)
+    assert unify(QQ.frac_field(x), QQ.frac_field(x, y)) == QQ.frac_field(x, y)
+
+    assert unify(ZZ.frac_field(x, y), ZZ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
+    assert unify(ZZ.frac_field(x, y), QQ.frac_field(x, z)) == QQ.frac_field(x, y, z)
+    assert unify(QQ.frac_field(x, y), ZZ.frac_field(x, z)) == QQ.frac_field(x, y, z)
+    assert unify(QQ.frac_field(x, y), QQ.frac_field(x, z)) == QQ.frac_field(x, y, z)
+
+    assert unify(ZZ.poly_ring(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(ZZ.poly_ring(x), QQ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(QQ.poly_ring(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
+    assert unify(QQ.poly_ring(x), QQ.frac_field(x)) == QQ.frac_field(x)
+
+    assert unify(ZZ.poly_ring(x, y), ZZ.frac_field(x)) == ZZ.frac_field(x, y)
+    assert unify(ZZ.poly_ring(x, y), QQ.frac_field(x)) == ZZ.frac_field(x, y)
+    assert unify(QQ.poly_ring(x, y), ZZ.frac_field(x)) == ZZ.frac_field(x, y)
+    assert unify(QQ.poly_ring(x, y), QQ.frac_field(x)) == QQ.frac_field(x, y)
+
+    assert unify(ZZ.poly_ring(x), ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
+    assert unify(ZZ.poly_ring(x), QQ.frac_field(x, y)) == ZZ.frac_field(x, y)
+    assert unify(QQ.poly_ring(x), ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
+    assert unify(QQ.poly_ring(x), QQ.frac_field(x, y)) == QQ.frac_field(x, y)
+
+    assert unify(ZZ.poly_ring(x, y), ZZ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
+    assert unify(ZZ.poly_ring(x, y), QQ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
+    assert unify(QQ.poly_ring(x, y), ZZ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
+    assert unify(QQ.poly_ring(x, y), QQ.frac_field(x, z)) == QQ.frac_field(x, y, z)
+
+    assert unify(ZZ.frac_field(x), ZZ.poly_ring(x)) == ZZ.frac_field(x)
+    assert unify(ZZ.frac_field(x), QQ.poly_ring(x)) == ZZ.frac_field(x)
+    assert unify(QQ.frac_field(x), ZZ.poly_ring(x)) == ZZ.frac_field(x)
+    assert unify(QQ.frac_field(x), QQ.poly_ring(x)) == QQ.frac_field(x)
+
+    assert unify(ZZ.frac_field(x, y), ZZ.poly_ring(x)) == ZZ.frac_field(x, y)
+    assert unify(ZZ.frac_field(x, y), QQ.poly_ring(x)) == ZZ.frac_field(x, y)
+    assert unify(QQ.frac_field(x, y), ZZ.poly_ring(x)) == ZZ.frac_field(x, y)
+    assert unify(QQ.frac_field(x, y), QQ.poly_ring(x)) == QQ.frac_field(x, y)
+
+    assert unify(ZZ.frac_field(x), ZZ.poly_ring(x, y)) == ZZ.frac_field(x, y)
+    assert unify(ZZ.frac_field(x), QQ.poly_ring(x, y)) == ZZ.frac_field(x, y)
+    assert unify(QQ.frac_field(x), ZZ.poly_ring(x, y)) == ZZ.frac_field(x, y)
+    assert unify(QQ.frac_field(x), QQ.poly_ring(x, y)) == QQ.frac_field(x, y)
+
+    assert unify(ZZ.frac_field(x, y), ZZ.poly_ring(x, z)) == ZZ.frac_field(x, y, z)
+    assert unify(ZZ.frac_field(x, y), QQ.poly_ring(x, z)) == ZZ.frac_field(x, y, z)
+    assert unify(QQ.frac_field(x, y), ZZ.poly_ring(x, z)) == ZZ.frac_field(x, y, z)
+    assert unify(QQ.frac_field(x, y), QQ.poly_ring(x, z)) == QQ.frac_field(x, y, z)
+
+def test_Domain_unify_algebraic():
+    sqrt5 = QQ.algebraic_field(sqrt(5))
+    sqrt7 = QQ.algebraic_field(sqrt(7))
+    sqrt57 = QQ.algebraic_field(sqrt(5), sqrt(7))
+
+    assert sqrt5.unify(sqrt7) == sqrt57
+
+    assert sqrt5.unify(sqrt5[x, y]) == sqrt5[x, y]
+    assert sqrt5[x, y].unify(sqrt5) == sqrt5[x, y]
+
+    assert sqrt5.unify(sqrt5.frac_field(x, y)) == sqrt5.frac_field(x, y)
+    assert sqrt5.frac_field(x, y).unify(sqrt5) == sqrt5.frac_field(x, y)
+
+    assert sqrt5.unify(sqrt7[x, y]) == sqrt57[x, y]
+    assert sqrt5[x, y].unify(sqrt7) == sqrt57[x, y]
+
+    assert sqrt5.unify(sqrt7.frac_field(x, y)) == sqrt57.frac_field(x, y)
+    assert sqrt5.frac_field(x, y).unify(sqrt7) == sqrt57.frac_field(x, y)
+
+def test_Domain_unify_FiniteExtension():
+    KxZZ = FiniteExtension(Poly(x**2 - 2, x, domain=ZZ))
+    KxQQ = FiniteExtension(Poly(x**2 - 2, x, domain=QQ))
+    KxZZy = FiniteExtension(Poly(x**2 - 2, x, domain=ZZ[y]))
+    KxQQy = FiniteExtension(Poly(x**2 - 2, x, domain=QQ[y]))
+
+    assert KxZZ.unify(KxZZ) == KxZZ
+    assert KxQQ.unify(KxQQ) == KxQQ
+    assert KxZZy.unify(KxZZy) == KxZZy
+    assert KxQQy.unify(KxQQy) == KxQQy
+
+    assert KxZZ.unify(ZZ) == KxZZ
+    assert KxZZ.unify(QQ) == KxQQ
+    assert KxQQ.unify(ZZ) == KxQQ
+    assert KxQQ.unify(QQ) == KxQQ
+
+    assert KxZZ.unify(ZZ[y]) == KxZZy
+    assert KxZZ.unify(QQ[y]) == KxQQy
+    assert KxQQ.unify(ZZ[y]) == KxQQy
+    assert KxQQ.unify(QQ[y]) == KxQQy
+
+    assert KxZZy.unify(ZZ) == KxZZy
+    assert KxZZy.unify(QQ) == KxQQy
+    assert KxQQy.unify(ZZ) == KxQQy
+    assert KxQQy.unify(QQ) == KxQQy
+
+    assert KxZZy.unify(ZZ[y]) == KxZZy
+    assert KxZZy.unify(QQ[y]) == KxQQy
+    assert KxQQy.unify(ZZ[y]) == KxQQy
+    assert KxQQy.unify(QQ[y]) == KxQQy
+
+    K = FiniteExtension(Poly(x**2 - 2, x, domain=ZZ[y]))
+    assert K.unify(ZZ) == K
+    assert K.unify(ZZ[x]) == K
+    assert K.unify(ZZ[y]) == K
+    assert K.unify(ZZ[x, y]) == K
+
+    Kz = FiniteExtension(Poly(x**2 - 2, x, domain=ZZ[y, z]))
+    assert K.unify(ZZ[z]) == Kz
+    assert K.unify(ZZ[x, z]) == Kz
+    assert K.unify(ZZ[y, z]) == Kz
+    assert K.unify(ZZ[x, y, z]) == Kz
+
+    Kx = FiniteExtension(Poly(x**2 - 2, x, domain=ZZ))
+    Ky = FiniteExtension(Poly(y**2 - 2, y, domain=ZZ))
+    Kxy = FiniteExtension(Poly(y**2 - 2, y, domain=Kx))
+    assert Kx.unify(Kx) == Kx
+    assert Ky.unify(Ky) == Ky
+    assert Kx.unify(Ky) == Kxy
+    assert Ky.unify(Kx) == Kxy
+
+def test_Domain_unify_with_symbols():
+    raises(UnificationFailed, lambda: ZZ[x, y].unify_with_symbols(ZZ, (y, z)))
+    raises(UnificationFailed, lambda: ZZ.unify_with_symbols(ZZ[x, y], (y, z)))
+
+def test_Domain__contains__():
+    assert (0 in EX) is True
+    assert (0 in ZZ) is True
+    assert (0 in QQ) is True
+    assert (0 in RR) is True
+    assert (0 in CC) is True
+    assert (0 in ALG) is True
+    assert (0 in ZZ[x, y]) is True
+    assert (0 in QQ[x, y]) is True
+    assert (0 in RR[x, y]) is True
+
+    assert (-7 in EX) is True
+    assert (-7 in ZZ) is True
+    assert (-7 in QQ) is True
+    assert (-7 in RR) is True
+    assert (-7 in CC) is True
+    assert (-7 in ALG) is True
+    assert (-7 in ZZ[x, y]) is True
+    assert (-7 in QQ[x, y]) is True
+    assert (-7 in RR[x, y]) is True
+
+    assert (17 in EX) is True
+    assert (17 in ZZ) is True
+    assert (17 in QQ) is True
+    assert (17 in RR) is True
+    assert (17 in CC) is True
+    assert (17 in ALG) is True
+    assert (17 in ZZ[x, y]) is True
+    assert (17 in QQ[x, y]) is True
+    assert (17 in RR[x, y]) is True
+
+    assert (Rational(-1, 7) in EX) is True
+    assert (Rational(-1, 7) in ZZ) is False
+    assert (Rational(-1, 7) in QQ) is True
+    assert (Rational(-1, 7) in RR) is True
+    assert (Rational(-1, 7) in CC) is True
+    assert (Rational(-1, 7) in ALG) is True
+    assert (Rational(-1, 7) in ZZ[x, y]) is False
+    assert (Rational(-1, 7) in QQ[x, y]) is True
+    assert (Rational(-1, 7) in RR[x, y]) is True
+
+    assert (Rational(3, 5) in EX) is True
+    assert (Rational(3, 5) in ZZ) is False
+    assert (Rational(3, 5) in QQ) is True
+    assert (Rational(3, 5) in RR) is True
+    assert (Rational(3, 5) in CC) is True
+    assert (Rational(3, 5) in ALG) is True
+    assert (Rational(3, 5) in ZZ[x, y]) is False
+    assert (Rational(3, 5) in QQ[x, y]) is True
+    assert (Rational(3, 5) in RR[x, y]) is True
+
+    assert (3.0 in EX) is True
+    assert (3.0 in ZZ) is True
+    assert (3.0 in QQ) is True
+    assert (3.0 in RR) is True
+    assert (3.0 in CC) is True
+    assert (3.0 in ALG) is True
+    assert (3.0 in ZZ[x, y]) is True
+    assert (3.0 in QQ[x, y]) is True
+    assert (3.0 in RR[x, y]) is True
+
+    assert (3.14 in EX) is True
+    assert (3.14 in ZZ) is False
+    assert (3.14 in QQ) is True
+    assert (3.14 in RR) is True
+    assert (3.14 in CC) is True
+    assert (3.14 in ALG) is True
+    assert (3.14 in ZZ[x, y]) is False
+    assert (3.14 in QQ[x, y]) is True
+    assert (3.14 in RR[x, y]) is True
+
+    assert (oo in ALG) is False
+    assert (oo in ZZ[x, y]) is False
+    assert (oo in QQ[x, y]) is False
+
+    assert (-oo in ZZ) is False
+    assert (-oo in QQ) is False
+    assert (-oo in ALG) is False
+    assert (-oo in ZZ[x, y]) is False
+    assert (-oo in QQ[x, y]) is False
+
+    assert (sqrt(7) in EX) is True
+    assert (sqrt(7) in ZZ) is False
+    assert (sqrt(7) in QQ) is False
+    assert (sqrt(7) in RR) is True
+    assert (sqrt(7) in CC) is True
+    assert (sqrt(7) in ALG) is False
+    assert (sqrt(7) in ZZ[x, y]) is False
+    assert (sqrt(7) in QQ[x, y]) is False
+    assert (sqrt(7) in RR[x, y]) is True
+
+    assert (2*sqrt(3) + 1 in EX) is True
+    assert (2*sqrt(3) + 1 in ZZ) is False
+    assert (2*sqrt(3) + 1 in QQ) is False
+    assert (2*sqrt(3) + 1 in RR) is True
+    assert (2*sqrt(3) + 1 in CC) is True
+    assert (2*sqrt(3) + 1 in ALG) is True
+    assert (2*sqrt(3) + 1 in ZZ[x, y]) is False
+    assert (2*sqrt(3) + 1 in QQ[x, y]) is False
+    assert (2*sqrt(3) + 1 in RR[x, y]) is True
+
+    assert (sin(1) in EX) is True
+    assert (sin(1) in ZZ) is False
+    assert (sin(1) in QQ) is False
+    assert (sin(1) in RR) is True
+    assert (sin(1) in CC) is True
+    assert (sin(1) in ALG) is False
+    assert (sin(1) in ZZ[x, y]) is False
+    assert (sin(1) in QQ[x, y]) is False
+    assert (sin(1) in RR[x, y]) is True
+
+    assert (x**2 + 1 in EX) is True
+    assert (x**2 + 1 in ZZ) is False
+    assert (x**2 + 1 in QQ) is False
+    assert (x**2 + 1 in RR) is False
+    assert (x**2 + 1 in CC) is False
+    assert (x**2 + 1 in ALG) is False
+    assert (x**2 + 1 in ZZ[x]) is True
+    assert (x**2 + 1 in QQ[x]) is True
+    assert (x**2 + 1 in RR[x]) is True
+    assert (x**2 + 1 in ZZ[x, y]) is True
+    assert (x**2 + 1 in QQ[x, y]) is True
+    assert (x**2 + 1 in RR[x, y]) is True
+
+    assert (x**2 + y**2 in EX) is True
+    assert (x**2 + y**2 in ZZ) is False
+    assert (x**2 + y**2 in QQ) is False
+    assert (x**2 + y**2 in RR) is False
+    assert (x**2 + y**2 in CC) is False
+    assert (x**2 + y**2 in ALG) is False
+    assert (x**2 + y**2 in ZZ[x]) is False
+    assert (x**2 + y**2 in QQ[x]) is False
+    assert (x**2 + y**2 in RR[x]) is False
+    assert (x**2 + y**2 in ZZ[x, y]) is True
+    assert (x**2 + y**2 in QQ[x, y]) is True
+    assert (x**2 + y**2 in RR[x, y]) is True
+
+    assert (Rational(3, 2)*x/(y + 1) - z in QQ[x, y, z]) is False
+
+
+def test_issue_14433():
+    assert (Rational(2, 3)*x in QQ.frac_field(1/x)) is True
+    assert (1/x in QQ.frac_field(x)) is True
+    assert ((x**2 + y**2) in QQ.frac_field(1/x, 1/y)) is True
+    assert ((x + y) in QQ.frac_field(1/x, y)) is True
+    assert ((x - y) in QQ.frac_field(x, 1/y)) is True
+
+
+def test_Domain_get_ring():
+    assert ZZ.has_assoc_Ring is True
+    assert QQ.has_assoc_Ring is True
+    assert ZZ[x].has_assoc_Ring is True
+    assert QQ[x].has_assoc_Ring is True
+    assert ZZ[x, y].has_assoc_Ring is True
+    assert QQ[x, y].has_assoc_Ring is True
+    assert ZZ.frac_field(x).has_assoc_Ring is True
+    assert QQ.frac_field(x).has_assoc_Ring is True
+    assert ZZ.frac_field(x, y).has_assoc_Ring is True
+    assert QQ.frac_field(x, y).has_assoc_Ring is True
+
+    assert EX.has_assoc_Ring is False
+    assert RR.has_assoc_Ring is False
+    assert ALG.has_assoc_Ring is False
+
+    assert ZZ.get_ring() == ZZ
+    assert QQ.get_ring() == ZZ
+    assert ZZ[x].get_ring() == ZZ[x]
+    assert QQ[x].get_ring() == QQ[x]
+    assert ZZ[x, y].get_ring() == ZZ[x, y]
+    assert QQ[x, y].get_ring() == QQ[x, y]
+    assert ZZ.frac_field(x).get_ring() == ZZ[x]
+    assert QQ.frac_field(x).get_ring() == QQ[x]
+    assert ZZ.frac_field(x, y).get_ring() == ZZ[x, y]
+    assert QQ.frac_field(x, y).get_ring() == QQ[x, y]
+
+    assert EX.get_ring() == EX
+
+    assert RR.get_ring() == RR
+    # XXX: This should also be like RR
+    raises(DomainError, lambda: ALG.get_ring())
+
+
+def test_Domain_get_field():
+    assert EX.has_assoc_Field is True
+    assert ZZ.has_assoc_Field is True
+    assert QQ.has_assoc_Field is True
+    assert RR.has_assoc_Field is True
+    assert ALG.has_assoc_Field is True
+    assert ZZ[x].has_assoc_Field is True
+    assert QQ[x].has_assoc_Field is True
+    assert ZZ[x, y].has_assoc_Field is True
+    assert QQ[x, y].has_assoc_Field is True
+
+    assert EX.get_field() == EX
+    assert ZZ.get_field() == QQ
+    assert QQ.get_field() == QQ
+    assert RR.get_field() == RR
+    assert ALG.get_field() == ALG
+    assert ZZ[x].get_field() == ZZ.frac_field(x)
+    assert QQ[x].get_field() == QQ.frac_field(x)
+    assert ZZ[x, y].get_field() == ZZ.frac_field(x, y)
+    assert QQ[x, y].get_field() == QQ.frac_field(x, y)
+
+
+def test_Domain_get_exact():
+    assert EX.get_exact() == EX
+    assert ZZ.get_exact() == ZZ
+    assert QQ.get_exact() == QQ
+    assert RR.get_exact() == QQ
+    assert ALG.get_exact() == ALG
+    assert ZZ[x].get_exact() == ZZ[x]
+    assert QQ[x].get_exact() == QQ[x]
+    assert ZZ[x, y].get_exact() == ZZ[x, y]
+    assert QQ[x, y].get_exact() == QQ[x, y]
+    assert ZZ.frac_field(x).get_exact() == ZZ.frac_field(x)
+    assert QQ.frac_field(x).get_exact() == QQ.frac_field(x)
+    assert ZZ.frac_field(x, y).get_exact() == ZZ.frac_field(x, y)
+    assert QQ.frac_field(x, y).get_exact() == QQ.frac_field(x, y)
+
+
+def test_Domain_is_unit():
+    nums = [-2, -1, 0, 1, 2]
+    invring = [False, True, False, True, False]
+    invfield = [True, True, False, True, True]
+    ZZx, QQx, QQxf = ZZ[x], QQ[x], QQ.frac_field(x)
+    assert [ZZ.is_unit(ZZ(n)) for n in nums] == invring
+    assert [QQ.is_unit(QQ(n)) for n in nums] == invfield
+    assert [ZZx.is_unit(ZZx(n)) for n in nums] == invring
+    assert [QQx.is_unit(QQx(n)) for n in nums] == invfield
+    assert [QQxf.is_unit(QQxf(n)) for n in nums] == invfield
+    assert ZZx.is_unit(ZZx(x)) is False
+    assert QQx.is_unit(QQx(x)) is False
+    assert QQxf.is_unit(QQxf(x)) is True
+
+
+def test_Domain_convert():
+
+    def check_element(e1, e2, K1, K2, K3):
+        assert type(e1) is type(e2), '%s, %s: %s %s -> %s' % (e1, e2, K1, K2, K3)
+        assert e1 == e2, '%s, %s: %s %s -> %s' % (e1, e2, K1, K2, K3)
+
+    def check_domains(K1, K2):
+        K3 = K1.unify(K2)
+        check_element(K3.convert_from( K1.one, K1),  K3.one, K1, K2, K3)
+        check_element(K3.convert_from( K2.one, K2),  K3.one, K1, K2, K3)
+        check_element(K3.convert_from(K1.zero, K1), K3.zero, K1, K2, K3)
+        check_element(K3.convert_from(K2.zero, K2), K3.zero, K1, K2, K3)
+
+    def composite_domains(K):
+        domains = [
+            K,
+            K[y], K[z], K[y, z],
+            K.frac_field(y), K.frac_field(z), K.frac_field(y, z),
+            # XXX: These should be tested and made to work...
+            # K.old_poly_ring(y), K.old_frac_field(y),
+        ]
+        return domains
+
+    QQ2 = QQ.algebraic_field(sqrt(2))
+    QQ3 = QQ.algebraic_field(sqrt(3))
+    doms = [ZZ, QQ, QQ2, QQ3, QQ_I, ZZ_I, RR, CC]
+
+    for i, K1 in enumerate(doms):
+        for K2 in doms[i:]:
+            for K3 in composite_domains(K1):
+                for K4 in composite_domains(K2):
+                    check_domains(K3, K4)
+
+    assert QQ.convert(10e-52) == QQ(1684996666696915, 1684996666696914987166688442938726917102321526408785780068975640576)
+
+    R, xr = ring("x", ZZ)
+    assert ZZ.convert(xr - xr) == 0
+    assert ZZ.convert(xr - xr, R.to_domain()) == 0
+
+    assert CC.convert(ZZ_I(1, 2)) == CC(1, 2)
+    assert CC.convert(QQ_I(1, 2)) == CC(1, 2)
+
+    K1 = QQ.frac_field(x)
+    K2 = ZZ.frac_field(x)
+    K3 = QQ[x]
+    K4 = ZZ[x]
+    Ks = [K1, K2, K3, K4]
+    for Ka, Kb in product(Ks, Ks):
+        assert Ka.convert_from(Kb.from_sympy(x), Kb) == Ka.from_sympy(x)
+
+    assert K2.convert_from(QQ(1, 2), QQ) == K2(QQ(1, 2))
+
+
+def test_GlobalPolynomialRing_convert():
+    K1 = QQ.old_poly_ring(x)
+    K2 = QQ[x]
+    assert K1.convert(x) == K1.convert(K2.convert(x), K2)
+    assert K2.convert(x) == K2.convert(K1.convert(x), K1)
+
+    K1 = QQ.old_poly_ring(x, y)
+    K2 = QQ[x]
+    assert K1.convert(x) == K1.convert(K2.convert(x), K2)
+    #assert K2.convert(x) == K2.convert(K1.convert(x), K1)
+
+    K1 = ZZ.old_poly_ring(x, y)
+    K2 = QQ[x]
+    assert K1.convert(x) == K1.convert(K2.convert(x), K2)
+    #assert K2.convert(x) == K2.convert(K1.convert(x), K1)
+
+
+def test_PolynomialRing__init():
+    R, = ring("", ZZ)
+    assert ZZ.poly_ring() == R.to_domain()
+
+
+def test_FractionField__init():
+    F, = field("", ZZ)
+    assert ZZ.frac_field() == F.to_domain()
+
+
+def test_FractionField_convert():
+    K = QQ.frac_field(x)
+    assert K.convert(QQ(2, 3), QQ) == K.from_sympy(Rational(2, 3))
+    K = QQ.frac_field(x)
+    assert K.convert(ZZ(2), ZZ) == K.from_sympy(Integer(2))
+
+
+def test_inject():
+    assert ZZ.inject(x, y, z) == ZZ[x, y, z]
+    assert ZZ[x].inject(y, z) == ZZ[x, y, z]
+    assert ZZ.frac_field(x).inject(y, z) == ZZ.frac_field(x, y, z)
+    raises(GeneratorsError, lambda: ZZ[x].inject(x))
+
+
+def test_drop():
+    assert ZZ.drop(x) == ZZ
+    assert ZZ[x].drop(x) == ZZ
+    assert ZZ[x, y].drop(x) == ZZ[y]
+    assert ZZ.frac_field(x).drop(x) == ZZ
+    assert ZZ.frac_field(x, y).drop(x) == ZZ.frac_field(y)
+    assert ZZ[x][y].drop(y) == ZZ[x]
+    assert ZZ[x][y].drop(x) == ZZ[y]
+    assert ZZ.frac_field(x)[y].drop(x) == ZZ[y]
+    assert ZZ.frac_field(x)[y].drop(y) == ZZ.frac_field(x)
+    Ky = FiniteExtension(Poly(x**2-1, x, domain=ZZ[y]))
+    K = FiniteExtension(Poly(x**2-1, x, domain=ZZ))
+    assert Ky.drop(y) == K
+    raises(GeneratorsError, lambda: Ky.drop(x))
+
+
+def test_Domain_map():
+    seq = ZZ.map([1, 2, 3, 4])
+
+    assert all(ZZ.of_type(elt) for elt in seq)
+
+    seq = ZZ.map([[1, 2, 3, 4]])
+
+    assert all(ZZ.of_type(elt) for elt in seq[0]) and len(seq) == 1
+
+
+def test_Domain___eq__():
+    assert (ZZ[x, y] == ZZ[x, y]) is True
+    assert (QQ[x, y] == QQ[x, y]) is True
+
+    assert (ZZ[x, y] == QQ[x, y]) is False
+    assert (QQ[x, y] == ZZ[x, y]) is False
+
+    assert (ZZ.frac_field(x, y) == ZZ.frac_field(x, y)) is True
+    assert (QQ.frac_field(x, y) == QQ.frac_field(x, y)) is True
+
+    assert (ZZ.frac_field(x, y) == QQ.frac_field(x, y)) is False
+    assert (QQ.frac_field(x, y) == ZZ.frac_field(x, y)) is False
+
+    assert RealField()[x] == RR[x]
+
+
+def test_Domain__algebraic_field():
+    alg = ZZ.algebraic_field(sqrt(2))
+    assert alg.ext.minpoly == Poly(x**2 - 2)
+    assert alg.dom == QQ
+
+    alg = QQ.algebraic_field(sqrt(2))
+    assert alg.ext.minpoly == Poly(x**2 - 2)
+    assert alg.dom == QQ
+
+    alg = alg.algebraic_field(sqrt(3))
+    assert alg.ext.minpoly == Poly(x**4 - 10*x**2 + 1)
+    assert alg.dom == QQ
+
+
+def test_Domain_alg_field_from_poly():
+    f = Poly(x**2 - 2)
+    g = Poly(x**2 - 3)
+    h = Poly(x**4 - 10*x**2 + 1)
+
+    alg = ZZ.alg_field_from_poly(f)
+    assert alg.ext.minpoly == f
+    assert alg.dom == QQ
+
+    alg = QQ.alg_field_from_poly(f)
+    assert alg.ext.minpoly == f
+    assert alg.dom == QQ
+
+    alg = alg.alg_field_from_poly(g)
+    assert alg.ext.minpoly == h
+    assert alg.dom == QQ
+
+
+def test_Domain_cyclotomic_field():
+    K = ZZ.cyclotomic_field(12)
+    assert K.ext.minpoly == Poly(cyclotomic_poly(12))
+    assert K.dom == QQ
+
+    F = QQ.cyclotomic_field(3)
+    assert F.ext.minpoly == Poly(cyclotomic_poly(3))
+    assert F.dom == QQ
+
+    E = F.cyclotomic_field(4)
+    assert field_isomorphism(E.ext, K.ext) is not None
+    assert E.dom == QQ
+
+
+def test_PolynomialRing_from_FractionField():
+    F, x,y = field("x,y", ZZ)
+    R, X,Y = ring("x,y", ZZ)
+
+    f = (x**2 + y**2)/(x + 1)
+    g = (x**2 + y**2)/4
+    h =  x**2 + y**2
+
+    assert R.to_domain().from_FractionField(f, F.to_domain()) is None
+    assert R.to_domain().from_FractionField(g, F.to_domain()) == X**2/4 + Y**2/4
+    assert R.to_domain().from_FractionField(h, F.to_domain()) == X**2 + Y**2
+
+    F, x,y = field("x,y", QQ)
+    R, X,Y = ring("x,y", QQ)
+
+    f = (x**2 + y**2)/(x + 1)
+    g = (x**2 + y**2)/4
+    h =  x**2 + y**2
+
+    assert R.to_domain().from_FractionField(f, F.to_domain()) is None
+    assert R.to_domain().from_FractionField(g, F.to_domain()) == X**2/4 + Y**2/4
+    assert R.to_domain().from_FractionField(h, F.to_domain()) == X**2 + Y**2
+
+def test_FractionField_from_PolynomialRing():
+    R, x,y = ring("x,y", QQ)
+    F, X,Y = field("x,y", ZZ)
+
+    f = 3*x**2 + 5*y**2
+    g = x**2/3 + y**2/5
+
+    assert F.to_domain().from_PolynomialRing(f, R.to_domain()) == 3*X**2 + 5*Y**2
+    assert F.to_domain().from_PolynomialRing(g, R.to_domain()) == (5*X**2 + 3*Y**2)/15
+
+def test_FF_of_type():
+    assert FF(3).of_type(FF(3)(1)) is True
+    assert FF(5).of_type(FF(5)(3)) is True
+    assert FF(5).of_type(FF(7)(3)) is False
+
+
+def test___eq__():
+    assert not QQ[x] == ZZ[x]
+    assert not QQ.frac_field(x) == ZZ.frac_field(x)
+
+
+def test_RealField_from_sympy():
+    assert RR.convert(S.Zero) == RR.dtype(0)
+    assert RR.convert(S(0.0)) == RR.dtype(0.0)
+    assert RR.convert(S.One) == RR.dtype(1)
+    assert RR.convert(S(1.0)) == RR.dtype(1.0)
+    assert RR.convert(sin(1)) == RR.dtype(sin(1).evalf())
+
+
+def test_not_in_any_domain():
+    check = list(_illegal) + [x] + [
+        float(i) for i in _illegal[:3]]
+    for dom in (ZZ, QQ, RR, CC, EX):
+        for i in check:
+            if i == x and dom == EX:
+                continue
+            assert i not in dom, (i, dom)
+            raises(CoercionFailed, lambda: dom.convert(i))
+
+
+def test_ModularInteger():
+    F3 = FF(3)
+
+    a = F3(0)
+    assert isinstance(a, F3.dtype) and a == 0
+    a = F3(1)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2)
+    assert isinstance(a, F3.dtype) and a == 2
+    a = F3(3)
+    assert isinstance(a, F3.dtype) and a == 0
+    a = F3(4)
+    assert isinstance(a, F3.dtype) and a == 1
+
+    a = F3(F3(0))
+    assert isinstance(a, F3.dtype) and a == 0
+    a = F3(F3(1))
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(F3(2))
+    assert isinstance(a, F3.dtype) and a == 2
+    a = F3(F3(3))
+    assert isinstance(a, F3.dtype) and a == 0
+    a = F3(F3(4))
+    assert isinstance(a, F3.dtype) and a == 1
+
+    a = -F3(1)
+    assert isinstance(a, F3.dtype) and a == 2
+    a = -F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+
+    a = 2 + F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2) + 2
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2) + F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2) + F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+
+    a = 3 - F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(3) - 2
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(3) - F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(3) - F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+
+    a = 2*F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2)*2
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2)*F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2)*F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+
+    a = 2/F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2)/2
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2)/F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2)/F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+
+    a = 1 % F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(1) % 2
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(1) % F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(1) % F3(2)
+    assert isinstance(a, F3.dtype) and a == 1
+
+    a = F3(2)**0
+    assert isinstance(a, F3.dtype) and a == 1
+    a = F3(2)**1
+    assert isinstance(a, F3.dtype) and a == 2
+    a = F3(2)**2
+    assert isinstance(a, F3.dtype) and a == 1
+
+    F7 = FF(7)
+
+    a = F7(3)**100000000000
+    assert isinstance(a, F7.dtype) and a == 4
+    a = F7(3)**-100000000000
+    assert isinstance(a, F7.dtype) and a == 2
+    a = F7(3)**S(2)
+    assert isinstance(a, F7.dtype) and a == 2
+
+    assert bool(F3(3)) is False
+    assert bool(F3(4)) is True
+
+    F5 = FF(5)
+
+    a = F5(1)**(-1)
+    assert isinstance(a, F5.dtype) and a == 1
+    a = F5(2)**(-1)
+    assert isinstance(a, F5.dtype) and a == 3
+    a = F5(3)**(-1)
+    assert isinstance(a, F5.dtype) and a == 2
+    a = F5(4)**(-1)
+    assert isinstance(a, F5.dtype) and a == 4
+
+    assert (F5(1) < F5(2)) is True
+    assert (F5(1) <= F5(2)) is True
+    assert (F5(1) > F5(2)) is False
+    assert (F5(1) >= F5(2)) is False
+
+    assert (F5(3) < F5(2)) is False
+    assert (F5(3) <= F5(2)) is False
+    assert (F5(3) > F5(2)) is True
+    assert (F5(3) >= F5(2)) is True
+
+    assert (F5(1) < F5(7)) is True
+    assert (F5(1) <= F5(7)) is True
+    assert (F5(1) > F5(7)) is False
+    assert (F5(1) >= F5(7)) is False
+
+    assert (F5(3) < F5(7)) is False
+    assert (F5(3) <= F5(7)) is False
+    assert (F5(3) > F5(7)) is True
+    assert (F5(3) >= F5(7)) is True
+
+    assert (F5(1) < 2) is True
+    assert (F5(1) <= 2) is True
+    assert (F5(1) > 2) is False
+    assert (F5(1) >= 2) is False
+
+    assert (F5(3) < 2) is False
+    assert (F5(3) <= 2) is False
+    assert (F5(3) > 2) is True
+    assert (F5(3) >= 2) is True
+
+    assert (F5(1) < 7) is True
+    assert (F5(1) <= 7) is True
+    assert (F5(1) > 7) is False
+    assert (F5(1) >= 7) is False
+
+    assert (F5(3) < 7) is False
+    assert (F5(3) <= 7) is False
+    assert (F5(3) > 7) is True
+    assert (F5(3) >= 7) is True
+
+    raises(NotInvertible, lambda: F5(0)**(-1))
+    raises(NotInvertible, lambda: F5(5)**(-1))
+
+    raises(ValueError, lambda: FF(0))
+    raises(ValueError, lambda: FF(2.1))
+
+def test_QQ_int():
+    assert int(QQ(2**2000, 3**1250)) == 455431
+    assert int(QQ(2**100, 3)) == 422550200076076467165567735125
+
+def test_RR_double():
+    assert RR(3.14) > 1e-50
+    assert RR(1e-13) > 1e-50
+    assert RR(1e-14) > 1e-50
+    assert RR(1e-15) > 1e-50
+    assert RR(1e-20) > 1e-50
+    assert RR(1e-40) > 1e-50
+
+def test_RR_Float():
+    f1 = Float("1.01")
+    f2 = Float("1.0000000000000000000001")
+    assert f1._prec == 53
+    assert f2._prec == 80
+    assert RR(f1)-1 > 1e-50
+    assert RR(f2)-1 < 1e-50 # RR's precision is lower than f2's
+
+    RR2 = RealField(prec=f2._prec)
+    assert RR2(f1)-1 > 1e-50
+    assert RR2(f2)-1 > 1e-50 # RR's precision is equal to f2's
+
+
+def test_CC_double():
+    assert CC(3.14).real > 1e-50
+    assert CC(1e-13).real > 1e-50
+    assert CC(1e-14).real > 1e-50
+    assert CC(1e-15).real > 1e-50
+    assert CC(1e-20).real > 1e-50
+    assert CC(1e-40).real > 1e-50
+
+    assert CC(3.14j).imag > 1e-50
+    assert CC(1e-13j).imag > 1e-50
+    assert CC(1e-14j).imag > 1e-50
+    assert CC(1e-15j).imag > 1e-50
+    assert CC(1e-20j).imag > 1e-50
+    assert CC(1e-40j).imag > 1e-50
+
+
+def test_gaussian_domains():
+    I = S.ImaginaryUnit
+    a, b, c, d = [ZZ_I.convert(x) for x in (5, 2 + I, 3 - I, 5 - 5*I)]
+    assert ZZ_I.gcd(a, b) == b
+    assert ZZ_I.gcd(a, c) == b
+    assert ZZ_I.lcm(a, b) == a
+    assert ZZ_I.lcm(a, c) == d
+    assert ZZ_I(3, 4) != QQ_I(3, 4)  # XXX is this right or should QQ->ZZ if possible?
+    assert ZZ_I(3, 0) != 3           # and should this go to Integer?
+    assert QQ_I(S(3)/4, 0) != S(3)/4 # and this to Rational?
+    assert ZZ_I(0, 0).quadrant() == 0
+    assert ZZ_I(-1, 0).quadrant() == 2
+
+    assert QQ_I.convert(QQ(3, 2)) == QQ_I(QQ(3, 2), QQ(0))
+    assert QQ_I.convert(QQ(3, 2), QQ) == QQ_I(QQ(3, 2), QQ(0))
+
+    for G in (QQ_I, ZZ_I):
+
+        q = G(3, 4)
+        assert str(q) == '3 + 4*I'
+        assert q.parent() == G
+        assert q._get_xy(pi) == (None, None)
+        assert q._get_xy(2) == (2, 0)
+        assert q._get_xy(2*I) == (0, 2)
+
+        assert hash(q) == hash((3, 4))
+        assert G(1, 2) == G(1, 2)
+        assert G(1, 2) != G(1, 3)
+        assert G(3, 0) == G(3)
+
+        assert q + q == G(6, 8)
+        assert q - q == G(0, 0)
+        assert 3 - q  == -q + 3 == G(0, -4)
+        assert 3 + q == q + 3 == G(6, 4)
+        assert q * q == G(-7, 24)
+        assert 3 * q == q * 3 == G(9, 12)
+        assert q ** 0 == G(1, 0)
+        assert q ** 1 == q
+        assert q ** 2 == q * q == G(-7, 24)
+        assert q ** 3 == q * q * q == G(-117, 44)
+        assert 1 / q == q ** -1 == QQ_I(S(3)/25, - S(4)/25)
+        assert q / 1 == QQ_I(3, 4)
+        assert q / 2 == QQ_I(S(3)/2, 2)
+        assert q/3 == QQ_I(1, S(4)/3)
+        assert 3/q == QQ_I(S(9)/25, -S(12)/25)
+        i, r = divmod(q, 2)
+        assert 2*i + r == q
+        i, r = divmod(2, q)
+        assert q*i + r == G(2, 0)
+
+        raises(ZeroDivisionError, lambda: q % 0)
+        raises(ZeroDivisionError, lambda: q / 0)
+        raises(ZeroDivisionError, lambda: q // 0)
+        raises(ZeroDivisionError, lambda: divmod(q, 0))
+        raises(ZeroDivisionError, lambda: divmod(q, 0))
+        raises(TypeError, lambda: q + x)
+        raises(TypeError, lambda: q - x)
+        raises(TypeError, lambda: x + q)
+        raises(TypeError, lambda: x - q)
+        raises(TypeError, lambda: q * x)
+        raises(TypeError, lambda: x * q)
+        raises(TypeError, lambda: q / x)
+        raises(TypeError, lambda: x / q)
+        raises(TypeError, lambda: q // x)
+        raises(TypeError, lambda: x // q)
+
+        assert G.from_sympy(S(2)) == G(2, 0)
+        assert G.to_sympy(G(2, 0)) == S(2)
+        raises(CoercionFailed, lambda: G.from_sympy(pi))
+
+        PR = G.inject(x)
+        assert isinstance(PR, PolynomialRing)
+        assert PR.domain == G
+        assert len(PR.gens) == 1 and PR.gens[0].as_expr() == x
+
+        if G is QQ_I:
+            AF = G.as_AlgebraicField()
+            assert isinstance(AF, AlgebraicField)
+            assert AF.domain == QQ
+            assert AF.ext.args[0] == I
+
+        for qi in [G(-1, 0), G(1, 0), G(0, -1), G(0, 1)]:
+            assert G.is_negative(qi) is False
+            assert G.is_positive(qi) is False
+            assert G.is_nonnegative(qi) is False
+            assert G.is_nonpositive(qi) is False
+
+        domains = [ZZ_python(), QQ_python(), AlgebraicField(QQ, I)]
+        if HAS_GMPY:
+            domains += [ZZ_gmpy(), QQ_gmpy()]
+
+        for K in domains:
+            assert G.convert(K(2)) == G(2, 0)
+            assert G.convert(K(2), K) == G(2, 0)
+
+        for K in ZZ_I, QQ_I:
+            assert G.convert(K(1, 1)) == G(1, 1)
+            assert G.convert(K(1, 1), K) == G(1, 1)
+
+        if G == ZZ_I:
+            assert repr(q) == 'ZZ_I(3, 4)'
+            assert q//3 == G(1, 1)
+            assert 12//q == G(1, -2)
+            assert 12 % q == G(1, 2)
+            assert q % 2 == G(-1, 0)
+            assert i == G(0, 0)
+            assert r == G(2, 0)
+            assert G.get_ring() == G
+            assert G.get_field() == QQ_I
+        else:
+            assert repr(q) == 'QQ_I(3, 4)'
+            assert G.get_ring() == ZZ_I
+            assert G.get_field() == G
+            assert q//3 == G(1, S(4)/3)
+            assert 12//q == G(S(36)/25, -S(48)/25)
+            assert 12 % q == G(0, 0)
+            assert q % 2 == G(0, 0)
+            assert i == G(S(6)/25, -S(8)/25), (G,i)
+            assert r == G(0, 0)
+            q2 = G(S(3)/2, S(5)/3)
+            assert G.numer(q2) == ZZ_I(9, 10)
+            assert G.denom(q2) == ZZ_I(6)
+
+
+def test_EX_EXRAW():
+    assert EXRAW.zero is S.Zero
+    assert EXRAW.one is S.One
+
+    assert EX(1) == EX.Expression(1)
+    assert EX(1).ex is S.One
+    assert EXRAW(1) is S.One
+
+    # EX has cancelling but EXRAW does not
+    assert 2*EX((x + y*x)/x) == EX(2 + 2*y) != 2*((x + y*x)/x)
+    assert 2*EXRAW((x + y*x)/x) == 2*((x + y*x)/x) != (1 + y)
+
+    assert EXRAW.convert_from(EX(1), EX) is EXRAW.one
+    assert EX.convert_from(EXRAW(1), EXRAW) == EX.one
+
+    assert EXRAW.from_sympy(S.One) is S.One
+    assert EXRAW.to_sympy(EXRAW.one) is S.One
+    raises(CoercionFailed, lambda: EXRAW.from_sympy([]))
+
+    assert EXRAW.get_field() == EXRAW
+
+    assert EXRAW.unify(EX) == EXRAW
+    assert EX.unify(EXRAW) == EXRAW
+
+
+def test_canonical_unit():
+
+    for K in [ZZ, QQ, RR]: # CC?
+        assert K.canonical_unit(K(2)) == K(1)
+        assert K.canonical_unit(K(-2)) == K(-1)
+
+    for K in [ZZ_I, QQ_I]:
+        i = K.from_sympy(I)
+        assert K.canonical_unit(K(2)) == K(1)
+        assert K.canonical_unit(K(2)*i) == -i
+        assert K.canonical_unit(-K(2)) == K(-1)
+        assert K.canonical_unit(-K(2)*i) == i
+
+    K = ZZ[x]
+    assert K.canonical_unit(K(x + 1)) == K(1)
+    assert K.canonical_unit(K(-x + 1)) == K(-1)
+
+    K = ZZ_I[x]
+    assert K.canonical_unit(K.from_sympy(I*x)) == ZZ_I(0, -1)
+
+    K = ZZ_I.frac_field(x, y)
+    i = K.from_sympy(I)
+    assert i / i == K.one
+    assert (K.one + i)/(i - K.one) == -i
+
+
+def test_issue_18278():
+    assert str(RR(2).parent()) == 'RR'
+    assert str(CC(2).parent()) == 'CC'
+
+
+def test_Domain_is_negative():
+    I = S.ImaginaryUnit
+    a, b = [CC.convert(x) for x in (2 + I, 5)]
+    assert CC.is_negative(a) == False
+    assert CC.is_negative(b) == False
+
+
+def test_Domain_is_positive():
+    I = S.ImaginaryUnit
+    a, b = [CC.convert(x) for x in (2 + I, 5)]
+    assert CC.is_positive(a) == False
+    assert CC.is_positive(b) == False
+
+
+def test_Domain_is_nonnegative():
+    I = S.ImaginaryUnit
+    a, b = [CC.convert(x) for x in (2 + I, 5)]
+    assert CC.is_nonnegative(a) == False
+    assert CC.is_nonnegative(b) == False
+
+
+def test_Domain_is_nonpositive():
+    I = S.ImaginaryUnit
+    a, b = [CC.convert(x) for x in (2 + I, 5)]
+    assert CC.is_nonpositive(a) == False
+    assert CC.is_nonpositive(b) == False
+
+
+def test_exponential_domain():
+    K = ZZ[E]
+    eK = K.from_sympy(E)
+    assert K.from_sympy(exp(3)) == eK ** 3
+    assert K.convert(exp(3)) == eK ** 3
+
+
+def test_AlgebraicField_alias():
+    # No default alias:
+    k = QQ.algebraic_field(sqrt(2))
+    assert k.ext.alias is None
+
+    # For a single extension, its alias is used:
+    alpha = AlgebraicNumber(sqrt(2), alias='alpha')
+    k = QQ.algebraic_field(alpha)
+    assert k.ext.alias.name == 'alpha'
+
+    # Can override the alias of a single extension:
+    k = QQ.algebraic_field(alpha, alias='theta')
+    assert k.ext.alias.name == 'theta'
+
+    # With multiple extensions, no default alias:
+    k = QQ.algebraic_field(sqrt(2), sqrt(3))
+    assert k.ext.alias is None
+
+    # With multiple extensions, no default alias, even if one of
+    # the extensions has one:
+    k = QQ.algebraic_field(alpha, sqrt(3))
+    assert k.ext.alias is None
+
+    # With multiple extensions, may set an alias:
+    k = QQ.algebraic_field(sqrt(2), sqrt(3), alias='theta')
+    assert k.ext.alias.name == 'theta'
+
+    # Alias is passed to constructed field elements:
+    k = QQ.algebraic_field(alpha)
+    beta = k.to_alg_num(k([1, 2, 3]))
+    assert beta.alias is alpha.alias

env-llmeval/lib/python3.10/site-packages/sympy/polys/domains/tests/test_polynomialring.py

@@ -0,0 +1,102 @@
+"""Tests for the PolynomialRing classes. """
+
+from sympy.polys.domains import QQ, ZZ
+from sympy.polys.polyerrors import ExactQuotientFailed, CoercionFailed, NotReversible
+
+from sympy.abc import x, y
+
+from sympy.testing.pytest import raises
+
+
+def test_build_order():
+    R = QQ.old_poly_ring(x, y, order=(("lex", x), ("ilex", y)))
+    assert R.order((1, 5)) == ((1,), (-5,))
+
+
+def test_globalring():
+    Qxy = QQ.old_frac_field(x, y)
+    R = QQ.old_poly_ring(x, y)
+    X = R.convert(x)
+    Y = R.convert(y)
+
+    assert x in R
+    assert 1/x not in R
+    assert 1/(1 + x) not in R
+    assert Y in R
+    assert X.ring == R
+    assert X * (Y**2 + 1) == R.convert(x * (y**2 + 1))
+    assert X * y == X * Y == R.convert(x * y) == x * Y
+    assert X + y == X + Y == R.convert(x + y) == x + Y
+    assert X - y == X - Y == R.convert(x - y) == x - Y
+    assert X + 1 == R.convert(x + 1)
+    raises(ExactQuotientFailed, lambda: X/Y)
+    raises(ExactQuotientFailed, lambda: x/Y)
+    raises(ExactQuotientFailed, lambda: X/y)
+    assert X**2 / X == X
+
+    assert R.from_GlobalPolynomialRing(ZZ.old_poly_ring(x, y).convert(x), ZZ.old_poly_ring(x, y)) == X
+    assert R.from_FractionField(Qxy.convert(x), Qxy) == X
+    assert R.from_FractionField(Qxy.convert(x)/y, Qxy) is None
+
+    assert R._sdm_to_vector(R._vector_to_sdm([X, Y], R.order), 2) == [X, Y]
+
+
+def test_localring():
+    Qxy = QQ.old_frac_field(x, y)
+    R = QQ.old_poly_ring(x, y, order="ilex")
+    X = R.convert(x)
+    Y = R.convert(y)
+
+    assert x in R
+    assert 1/x not in R
+    assert 1/(1 + x) in R
+    assert Y in R
+    assert X.ring == R
+    assert X*(Y**2 + 1)/(1 + X) == R.convert(x*(y**2 + 1)/(1 + x))
+    assert X*y == X*Y
+    raises(ExactQuotientFailed, lambda: X/Y)
+    raises(ExactQuotientFailed, lambda: x/Y)
+    raises(ExactQuotientFailed, lambda: X/y)
+    assert X + y == X + Y == R.convert(x + y) == x + Y
+    assert X - y == X - Y == R.convert(x - y) == x - Y
+    assert X + 1 == R.convert(x + 1)
+    assert X**2 / X == X
+
+    assert R.from_GlobalPolynomialRing(ZZ.old_poly_ring(x, y).convert(x), ZZ.old_poly_ring(x, y)) == X
+    assert R.from_FractionField(Qxy.convert(x), Qxy) == X
+    raises(CoercionFailed, lambda: R.from_FractionField(Qxy.convert(x)/y, Qxy))
+    raises(ExactQuotientFailed, lambda: X/Y)
+    raises(NotReversible, lambda: X.invert())
+
+    assert R._sdm_to_vector(
+        R._vector_to_sdm([X/(X + 1), Y/(1 + X*Y)], R.order), 2) == \
+        [X*(1 + X*Y), Y*(1 + X)]
+
+
+def test_conversion():
+    L = QQ.old_poly_ring(x, y, order="ilex")
+    G = QQ.old_poly_ring(x, y)
+
+    assert L.convert(x) == L.convert(G.convert(x), G)
+    assert G.convert(x) == G.convert(L.convert(x), L)
+    raises(CoercionFailed, lambda: G.convert(L.convert(1/(1 + x)), L))
+
+
+def test_units():
+    R = QQ.old_poly_ring(x)
+    assert R.is_unit(R.convert(1))
+    assert R.is_unit(R.convert(2))
+    assert not R.is_unit(R.convert(x))
+    assert not R.is_unit(R.convert(1 + x))
+
+    R = QQ.old_poly_ring(x, order='ilex')
+    assert R.is_unit(R.convert(1))
+    assert R.is_unit(R.convert(2))
+    assert not R.is_unit(R.convert(x))
+    assert R.is_unit(R.convert(1 + x))
+
+    R = ZZ.old_poly_ring(x)
+    assert R.is_unit(R.convert(1))
+    assert not R.is_unit(R.convert(2))
+    assert not R.is_unit(R.convert(x))
+    assert not R.is_unit(R.convert(1 + x))

env-llmeval/lib/python3.10/site-packages/sympy/polys/domains/tests/test_quotientring.py

@@ -0,0 +1,52 @@
+"""Tests for quotient rings."""
+
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.domains.rationalfield import QQ
+from sympy.abc import x, y
+
+from sympy.polys.polyerrors import NotReversible
+
+from sympy.testing.pytest import raises
+
+
+def test_QuotientRingElement():
+    R = QQ.old_poly_ring(x)/[x**10]
+    X = R.convert(x)
+
+    assert X*(X + 1) == R.convert(x**2 + x)
+    assert X*x == R.convert(x**2)
+    assert x*X == R.convert(x**2)
+    assert X + x == R.convert(2*x)
+    assert x + X == 2*X
+    assert X**2 == R.convert(x**2)
+    assert 1/(1 - X) == R.convert(sum(x**i for i in range(10)))
+    assert X**10 == R.zero
+    assert X != x
+
+    raises(NotReversible, lambda: 1/X)
+
+
+def test_QuotientRing():
+    I = QQ.old_poly_ring(x).ideal(x**2 + 1)
+    R = QQ.old_poly_ring(x)/I
+
+    assert R == QQ.old_poly_ring(x)/[x**2 + 1]
+    assert R == QQ.old_poly_ring(x)/QQ.old_poly_ring(x).ideal(x**2 + 1)
+    assert R != QQ.old_poly_ring(x)
+
+    assert R.convert(1)/x == -x + I
+    assert -1 + I == x**2 + I
+    assert R.convert(ZZ(1), ZZ) == 1 + I
+    assert R.convert(R.convert(x), R) == R.convert(x)
+
+    X = R.convert(x)
+    Y = QQ.old_poly_ring(x).convert(x)
+    assert -1 + I == X**2 + I
+    assert -1 + I == Y**2 + I
+    assert R.to_sympy(X) == x
+
+    raises(ValueError, lambda: QQ.old_poly_ring(x)/QQ.old_poly_ring(x, y).ideal(x))
+
+    R = QQ.old_poly_ring(x, order="ilex")
+    I = R.ideal(x)
+    assert R.convert(1) + I == (R/I).convert(1)

env-llmeval/lib/python3.10/site-packages/sympy/polys/numberfields/__init__.py

@@ -0,0 +1,27 @@
+"""Computational algebraic field theory. """
+
+__all__ = [
+    'minpoly', 'minimal_polynomial',
+
+    'field_isomorphism', 'primitive_element', 'to_number_field',
+
+    'isolate',
+
+    'round_two',
+
+    'prime_decomp', 'prime_valuation',
+
+    'galois_group',
+]
+
+from .minpoly import minpoly, minimal_polynomial
+
+from .subfield import field_isomorphism, primitive_element, to_number_field
+
+from .utilities import isolate
+
+from .basis import round_two
+
+from .primes import prime_decomp, prime_valuation
+
+from .galoisgroups import galois_group

env-llmeval/lib/python3.10/site-packages/sympy/polys/numberfields/basis.py

@@ -0,0 +1,246 @@
+"""Computing integral bases for number fields. """
+
+from sympy.polys.polytools import Poly
+from sympy.polys.domains.algebraicfield import AlgebraicField
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.domains.rationalfield import QQ
+from sympy.utilities.decorator import public
+from .modules import ModuleEndomorphism, ModuleHomomorphism, PowerBasis
+from .utilities import extract_fundamental_discriminant
+
+
+def _apply_Dedekind_criterion(T, p):
+    r"""
+    Apply the "Dedekind criterion" to test whether the order needs to be
+    enlarged relative to a given prime *p*.
+    """
+    x = T.gen
+    T_bar = Poly(T, modulus=p)
+    lc, fl = T_bar.factor_list()
+    assert lc == 1
+    g_bar = Poly(1, x, modulus=p)
+    for ti_bar, _ in fl:
+        g_bar *= ti_bar
+    h_bar = T_bar // g_bar
+    g = Poly(g_bar, domain=ZZ)
+    h = Poly(h_bar, domain=ZZ)
+    f = (g * h - T) // p
+    f_bar = Poly(f, modulus=p)
+    Z_bar = f_bar
+    for b in [g_bar, h_bar]:
+        Z_bar = Z_bar.gcd(b)
+    U_bar = T_bar // Z_bar
+    m = Z_bar.degree()
+    return U_bar, m
+
+
+def nilradical_mod_p(H, p, q=None):
+    r"""
+    Compute the nilradical mod *p* for a given order *H*, and prime *p*.
+
+    Explanation
+    ===========
+
+    This is the ideal $I$ in $H/pH$ consisting of all elements some positive
+    power of which is zero in this quotient ring, i.e. is a multiple of *p*.
+
+    Parameters
+    ==========
+
+    H : :py:class:`~.Submodule`
+        The given order.
+    p : int
+        The rational prime.
+    q : int, optional
+        If known, the smallest power of *p* that is $>=$ the dimension of *H*.
+        If not provided, we compute it here.
+
+    Returns
+    =======
+
+    :py:class:`~.Module` representing the nilradical mod *p* in *H*.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory*.
+    (See Lemma 6.1.6.)
+
+    """
+    n = H.n
+    if q is None:
+        q = p
+        while q < n:
+            q *= p
+    phi = ModuleEndomorphism(H, lambda x: x**q)
+    return phi.kernel(modulus=p)
+
+
+def _second_enlargement(H, p, q):
+    r"""
+    Perform the second enlargement in the Round Two algorithm.
+    """
+    Ip = nilradical_mod_p(H, p, q=q)
+    B = H.parent.submodule_from_matrix(H.matrix * Ip.matrix, denom=H.denom)
+    C = B + p*H
+    E = C.endomorphism_ring()
+    phi = ModuleHomomorphism(H, E, lambda x: E.inner_endomorphism(x))
+    gamma = phi.kernel(modulus=p)
+    G = H.parent.submodule_from_matrix(H.matrix * gamma.matrix, denom=H.denom * p)
+    H1 = G + H
+    return H1, Ip
+
+
+@public
+def round_two(T, radicals=None):
+    r"""
+    Zassenhaus's "Round 2" algorithm.
+
+    Explanation
+    ===========
+
+    Carry out Zassenhaus's "Round 2" algorithm on an irreducible polynomial
+    *T* over :ref:`ZZ` or :ref:`QQ`. This computes an integral basis and the
+    discriminant for the field $K = \mathbb{Q}[x]/(T(x))$.
+
+    Alternatively, you may pass an :py:class:`~.AlgebraicField` instance, in
+    place of the polynomial *T*, in which case the algorithm is applied to the
+    minimal polynomial for the field's primitive element.
+
+    Ordinarily this function need not be called directly, as one can instead
+    access the :py:meth:`~.AlgebraicField.maximal_order`,
+    :py:meth:`~.AlgebraicField.integral_basis`, and
+    :py:meth:`~.AlgebraicField.discriminant` methods of an
+    :py:class:`~.AlgebraicField`.
+
+    Examples
+    ========
+
+    Working through an AlgebraicField:
+
+    >>> from sympy import Poly, QQ
+    >>> from sympy.abc import x
+    >>> T = Poly(x ** 3 + x ** 2 - 2 * x + 8)
+    >>> K = QQ.alg_field_from_poly(T, "theta")
+    >>> print(K.maximal_order())
+    Submodule[[2, 0, 0], [0, 2, 0], [0, 1, 1]]/2
+    >>> print(K.discriminant())
+    -503
+    >>> print(K.integral_basis(fmt='sympy'))
+    [1, theta, theta/2 + theta**2/2]
+
+    Calling directly:
+
+    >>> from sympy import Poly
+    >>> from sympy.abc import x
+    >>> from sympy.polys.numberfields.basis import round_two
+    >>> T = Poly(x ** 3 + x ** 2 - 2 * x + 8)
+    >>> print(round_two(T))
+    (Submodule[[2, 0, 0], [0, 2, 0], [0, 1, 1]]/2, -503)
+
+    The nilradicals mod $p$ that are sometimes computed during the Round Two
+    algorithm may be useful in further calculations. Pass a dictionary under
+    `radicals` to receive these:
+
+    >>> T = Poly(x**3 + 3*x**2 + 5)
+    >>> rad = {}
+    >>> ZK, dK = round_two(T, radicals=rad)
+    >>> print(rad)
+    {3: Submodule[[-1, 1, 0], [-1, 0, 1]]}
+
+    Parameters
+    ==========
+
+    T : :py:class:`~.Poly`, :py:class:`~.AlgebraicField`
+        Either (1) the irreducible polynomial over :ref:`ZZ` or :ref:`QQ`
+        defining the number field, or (2) an :py:class:`~.AlgebraicField`
+        representing the number field itself.
+
+    radicals : dict, optional
+        This is a way for any $p$-radicals (if computed) to be returned by
+        reference. If desired, pass an empty dictionary. If the algorithm
+        reaches the point where it computes the nilradical mod $p$ of the ring
+        of integers $Z_K$, then an $\mathbb{F}_p$-basis for this ideal will be
+        stored in this dictionary under the key ``p``. This can be useful for
+        other algorithms, such as prime decomposition.
+
+    Returns
+    =======
+
+    Pair ``(ZK, dK)``, where:
+
+        ``ZK`` is a :py:class:`~sympy.polys.numberfields.modules.Submodule`
+        representing the maximal order.
+
+        ``dK`` is the discriminant of the field $K = \mathbb{Q}[x]/(T(x))$.
+
+    See Also
+    ========
+
+    .AlgebraicField.maximal_order
+    .AlgebraicField.integral_basis
+    .AlgebraicField.discriminant
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+
+    """
+    K = None
+    if isinstance(T, AlgebraicField):
+        K, T = T, T.ext.minpoly_of_element()
+    if (   not T.is_univariate
+        or not T.is_irreducible
+        or T.domain not in [ZZ, QQ]):
+        raise ValueError('Round 2 requires an irreducible univariate polynomial over ZZ or QQ.')
+    T, _ = T.make_monic_over_integers_by_scaling_roots()
+    n = T.degree()
+    D = T.discriminant()
+    D_modulus = ZZ.from_sympy(abs(D))
+    # D must be 0 or 1 mod 4 (see Cohen Sec 4.4), which ensures we can write
+    # it in the form D = D_0 * F**2, where D_0 is 1 or a fundamental discriminant.
+    _, F = extract_fundamental_discriminant(D)
+    Ztheta = PowerBasis(K or T)
+    H = Ztheta.whole_submodule()
+    nilrad = None
+    while F:
+        # Next prime:
+        p, e = F.popitem()
+        U_bar, m = _apply_Dedekind_criterion(T, p)
+        if m == 0:
+            continue
+        # For a given prime p, the first enlargement of the order spanned by
+        # the current basis can be done in a simple way:
+        U = Ztheta.element_from_poly(Poly(U_bar, domain=ZZ))
+        # TODO:
+        #  Theory says only first m columns of the U//p*H term below are needed.
+        #  Could be slightly more efficient to use only those. Maybe `Submodule`
+        #  class should support a slice operator?
+        H = H.add(U // p * H, hnf_modulus=D_modulus)
+        if e <= m:
+            continue
+        # A second, and possibly more, enlargements for p will be needed.
+        # These enlargements require a more involved procedure.
+        q = p
+        while q < n:
+            q *= p
+        H1, nilrad = _second_enlargement(H, p, q)
+        while H1 != H:
+            H = H1
+            H1, nilrad = _second_enlargement(H, p, q)
+    # Note: We do not store all nilradicals mod p, only the very last. This is
+    # because, unless computed against the entire integral basis, it might not
+    # be accurate. (In other words, if H was not already equal to ZK when we
+    # passed it to `_second_enlargement`, then we can't trust the nilradical
+    # so computed.) Example: if T(x) = x ** 3 + 15 * x ** 2 - 9 * x + 13, then
+    # F is divisible by 2, 3, and 7, and the nilradical mod 2 as computed above
+    # will not be accurate for the full, maximal order ZK.
+    if nilrad is not None and isinstance(radicals, dict):
+        radicals[p] = nilrad
+    ZK = H
+    # Pre-set expensive boolean properties which we already know to be true:
+    ZK._starts_with_unity = True
+    ZK._is_sq_maxrank_HNF = True
+    dK = (D * ZK.matrix.det() ** 2) // ZK.denom ** (2 * n)
+    return ZK, dK

env-llmeval/lib/python3.10/site-packages/sympy/polys/numberfields/exceptions.py

@@ -0,0 +1,53 @@
+"""Special exception classes for numberfields. """
+
+
+class ClosureFailure(Exception):
+    r"""
+    Signals that a :py:class:`ModuleElement` which we tried to represent in a
+    certain :py:class:`Module` cannot in fact be represented there.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import Poly, cyclotomic_poly, ZZ
+    >>> from sympy.polys.matrices import DomainMatrix
+    >>> from sympy.polys.numberfields.modules import PowerBasis, to_col, ClosureFailure
+    >>> from sympy.testing.pytest import raises
+    >>> T = Poly(cyclotomic_poly(5))
+    >>> A = PowerBasis(T)
+    >>> B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+
+    Because we are in a cyclotomic field, the power basis ``A`` is an integral
+    basis, and the submodule ``B`` is just the ideal $(2)$. Therefore ``B`` can
+    represent an element having all even coefficients over the power basis:
+
+    >>> a1 = A(to_col([2, 4, 6, 8]))
+    >>> print(B.represent(a1))
+    DomainMatrix([[1], [2], [3], [4]], (4, 1), ZZ)
+
+    but ``B`` cannot represent an element with an odd coefficient:
+
+    >>> a2 = A(to_col([1, 2, 2, 2]))
+    >>> print(raises(ClosureFailure, lambda: B.represent(a2)))
+    <ExceptionInfo ClosureFailure('Element in QQ-span but not ZZ-span of this basis.')>
+
+    """
+    pass
+
+
+class StructureError(Exception):
+    r"""
+    Represents cases in which an algebraic structure was expected to have a
+    certain property, or be of a certain type, but was not.
+    """
+    pass
+
+
+class MissingUnityError(StructureError):
+    r"""Structure should contain a unity element but does not."""
+    pass
+
+
+__all__ = [
+    'ClosureFailure', 'StructureError', 'MissingUnityError',
+]