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_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 convert(self, element, base=None): """Convert ``element`` to ``self.dtype``. """ if _not_a_coeff(element): raise CoercionFailed('%s is not in any domain' % element) if base is not None: return self.convert_from(element, base) if self.of_type(element): return element from sympy.polys.domains import ZZ, QQ, RealField, ComplexField if ZZ.of_type(element): return self.convert_from(element, ZZ) if isinstance(element, int): return self.convert_from(ZZ(element), ZZ) if HAS_GMPY: integers = ZZ if isinstance(element, integers.tp): return self.convert_from(element, integers) rationals = QQ if isinstance(element, rationals.tp): return self.convert_from(element, rationals) if isinstance(element, float): parent = RealField(tol=False) return self.convert_from(parent(element), parent) if isinstance(element, complex): parent = ComplexField(tol=False) return self.convert_from(parent(element), parent) if isinstance(element, DomainElement): return self.convert_from(element, element.parent()) # TODO: implement this in from_ methods if self.is_Numerical and getattr(element, 'is_ground', False): return self.convert(element.LC()) if isinstance(element, Basic): try: return self.from_sympy(element) except (TypeError, ValueError): pass else: # TODO: remove this branch if not is_sequence(element): try: element = sympify(element, strict=True) if isinstance(element, Basic): return self.from_sympy(element) except (TypeError, ValueError): pass raise CoercionFailed("can't convert %s of type %s to %s" % (element, type(element), self))
def __truediv__(A, lamda): """ Method for Scalar Divison""" if isinstance(lamda, int) or ZZ.of_type(lamda): lamda = DomainScalar(ZZ(lamda), ZZ) if not isinstance(lamda, DomainScalar): return NotImplemented A, lamda = A.to_field().unify(lamda) if lamda.element == lamda.domain.zero: raise ZeroDivisionError if lamda.element == lamda.domain.one: return A.to_field() return A.mul(1 / lamda.element)
def _hermite_normal_form_modulo_D(A, D): r""" Perform the mod *D* Hermite Normal Form reduction algorithm on :py:class:`~.DomainMatrix` *A*. Explanation =========== If *A* is an $m \times n$ matrix of rank $m$, having Hermite Normal Form $W$, and if *D* is any positive integer known in advance to be a multiple of $\det(W)$, then the HNF of *A* can be computed by an algorithm that works mod *D* in order to prevent coefficient explosion. Parameters ========== A : :py:class:`~.DomainMatrix` over :ref:`ZZ` $m \times n$ matrix, having rank $m$. D : :ref:`ZZ` Positive integer, known to be a multiple of the determinant of the HNF of *A*. Returns ======= :py:class:`~.DomainMatrix` The HNF of matrix *A*. Raises ====== DMDomainError If the domain of the matrix is not :ref:`ZZ`, or if *D* is given but is not in :ref:`ZZ`. DMShapeError If the matrix has more rows than columns. References ========== .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.* (See Algorithm 2.4.8.) """ if not A.domain.is_ZZ: raise DMDomainError('Matrix must be over domain ZZ.') if not ZZ.of_type(D) or D < 1: raise DMDomainError('Modulus D must be positive element of domain ZZ.') def add_columns_mod_R(m, R, i, j, a, b, c, d): # replace m[:, i] by (a*m[:, i] + b*m[:, j]) % R # and m[:, j] by (c*m[:, i] + d*m[:, j]) % R for k in range(len(m)): e = m[k][i] m[k][i] = symmetric_residue((a * e + b * m[k][j]) % R, R) m[k][j] = symmetric_residue((c * e + d * m[k][j]) % R, R) W = defaultdict(dict) m, n = A.shape if n < m: raise DMShapeError( 'Matrix must have at least as many columns as rows.') A = A.to_dense().rep.copy() k = n R = D for i in range(m - 1, -1, -1): k -= 1 for j in range(k - 1, -1, -1): if A[i][j] != 0: u, v, d = _gcdex(A[i][k], A[i][j]) r, s = A[i][k] // d, A[i][j] // d add_columns_mod_R(A, R, k, j, u, v, -s, r) b = A[i][k] if b == 0: A[i][k] = b = R u, v, d = _gcdex(b, R) for ii in range(m): W[ii][i] = u * A[ii][k] % R if W[i][i] == 0: W[i][i] = R for j in range(i + 1, m): q = W[i][j] // W[i][i] add_columns(W, j, i, 1, -q, 0, 1) R //= d return DomainMatrix(W, (m, m), ZZ).to_dense()