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()
