switching to high quality piper tts and added label translations
This commit is contained in:
Matthias Hinrichs
@@ -0,0 +1,387 @@
|
||||
"""Tools for constructing domains for expressions. """
|
||||
from math import prod
|
||||
|
||||
from sympy.core import sympify
|
||||
from sympy.core.evalf import pure_complex
|
||||
from sympy.core.sorting import ordered
|
||||
from sympy.polys.domains import ZZ, QQ, ZZ_I, QQ_I, EX
|
||||
from sympy.polys.domains.complexfield import ComplexField
|
||||
from sympy.polys.domains.realfield import RealField
|
||||
from sympy.polys.polyoptions import build_options
|
||||
from sympy.polys.polyutils import parallel_dict_from_basic
|
||||
from sympy.utilities import public
|
||||
|
||||
|
||||
def _construct_simple(coeffs, opt):
|
||||
"""Handle simple domains, e.g.: ZZ, QQ, RR and algebraic domains. """
|
||||
rationals = floats = complexes = algebraics = False
|
||||
float_numbers = []
|
||||
|
||||
if opt.extension is True:
|
||||
is_algebraic = lambda coeff: coeff.is_number and coeff.is_algebraic
|
||||
else:
|
||||
is_algebraic = lambda coeff: False
|
||||
|
||||
for coeff in coeffs:
|
||||
if coeff.is_Rational:
|
||||
if not coeff.is_Integer:
|
||||
rationals = True
|
||||
elif coeff.is_Float:
|
||||
if algebraics:
|
||||
# there are both reals and algebraics -> EX
|
||||
return False
|
||||
else:
|
||||
floats = True
|
||||
float_numbers.append(coeff)
|
||||
else:
|
||||
is_complex = pure_complex(coeff)
|
||||
if is_complex:
|
||||
complexes = True
|
||||
x, y = is_complex
|
||||
if x.is_Rational and y.is_Rational:
|
||||
if not (x.is_Integer and y.is_Integer):
|
||||
rationals = True
|
||||
continue
|
||||
else:
|
||||
floats = True
|
||||
if x.is_Float:
|
||||
float_numbers.append(x)
|
||||
if y.is_Float:
|
||||
float_numbers.append(y)
|
||||
elif is_algebraic(coeff):
|
||||
if floats:
|
||||
# there are both algebraics and reals -> EX
|
||||
return False
|
||||
algebraics = True
|
||||
else:
|
||||
# this is a composite domain, e.g. ZZ[X], EX
|
||||
return None
|
||||
|
||||
# Use the maximum precision of all coefficients for the RR or CC
|
||||
# precision
|
||||
max_prec = max(c._prec for c in float_numbers) if float_numbers else 53
|
||||
|
||||
if algebraics:
|
||||
domain, result = _construct_algebraic(coeffs, opt)
|
||||
else:
|
||||
if floats and complexes:
|
||||
domain = ComplexField(prec=max_prec)
|
||||
elif floats:
|
||||
domain = RealField(prec=max_prec)
|
||||
elif rationals or opt.field:
|
||||
domain = QQ_I if complexes else QQ
|
||||
else:
|
||||
domain = ZZ_I if complexes else ZZ
|
||||
|
||||
result = [domain.from_sympy(coeff) for coeff in coeffs]
|
||||
|
||||
return domain, result
|
||||
|
||||
|
||||
def _construct_algebraic(coeffs, opt):
|
||||
"""We know that coefficients are algebraic so construct the extension. """
|
||||
from sympy.polys.numberfields import primitive_element
|
||||
|
||||
exts = set()
|
||||
|
||||
def build_trees(args):
|
||||
trees = []
|
||||
for a in args:
|
||||
if a.is_Rational:
|
||||
tree = ('Q', QQ.from_sympy(a))
|
||||
elif a.is_Add:
|
||||
tree = ('+', build_trees(a.args))
|
||||
elif a.is_Mul:
|
||||
tree = ('*', build_trees(a.args))
|
||||
else:
|
||||
tree = ('e', a)
|
||||
exts.add(a)
|
||||
trees.append(tree)
|
||||
return trees
|
||||
|
||||
trees = build_trees(coeffs)
|
||||
exts = list(ordered(exts))
|
||||
|
||||
g, span, H = primitive_element(exts, ex=True, polys=True)
|
||||
root = sum(s*ext for s, ext in zip(span, exts))
|
||||
|
||||
domain, g = QQ.algebraic_field((g, root)), g.rep.to_list()
|
||||
|
||||
exts_dom = [domain.dtype.from_list(h, g, QQ) for h in H]
|
||||
exts_map = dict(zip(exts, exts_dom))
|
||||
|
||||
def convert_tree(tree):
|
||||
op, args = tree
|
||||
if op == 'Q':
|
||||
return domain.dtype.from_list([args], g, QQ)
|
||||
elif op == '+':
|
||||
return sum((convert_tree(a) for a in args), domain.zero)
|
||||
elif op == '*':
|
||||
return prod(convert_tree(a) for a in args)
|
||||
elif op == 'e':
|
||||
return exts_map[args]
|
||||
else:
|
||||
raise RuntimeError
|
||||
|
||||
result = [convert_tree(tree) for tree in trees]
|
||||
|
||||
return domain, result
|
||||
|
||||
|
||||
def _construct_composite(coeffs, opt):
|
||||
"""Handle composite domains, e.g.: ZZ[X], QQ[X], ZZ(X), QQ(X). """
|
||||
numers, denoms = [], []
|
||||
|
||||
for coeff in coeffs:
|
||||
numer, denom = coeff.as_numer_denom()
|
||||
|
||||
numers.append(numer)
|
||||
denoms.append(denom)
|
||||
|
||||
polys, gens = parallel_dict_from_basic(numers + denoms) # XXX: sorting
|
||||
if not gens:
|
||||
return None
|
||||
|
||||
if opt.composite is None:
|
||||
if any(gen.is_number and gen.is_algebraic for gen in gens):
|
||||
return None # generators are number-like so lets better use EX
|
||||
|
||||
all_symbols = set()
|
||||
|
||||
for gen in gens:
|
||||
symbols = gen.free_symbols
|
||||
|
||||
if all_symbols & symbols:
|
||||
return None # there could be algebraic relations between generators
|
||||
else:
|
||||
all_symbols |= symbols
|
||||
|
||||
n = len(gens)
|
||||
k = len(polys)//2
|
||||
|
||||
numers = polys[:k]
|
||||
denoms = polys[k:]
|
||||
|
||||
if opt.field:
|
||||
fractions = True
|
||||
else:
|
||||
fractions, zeros = False, (0,)*n
|
||||
|
||||
for denom in denoms:
|
||||
if len(denom) > 1 or zeros not in denom:
|
||||
fractions = True
|
||||
break
|
||||
|
||||
coeffs = set()
|
||||
|
||||
if not fractions:
|
||||
for numer, denom in zip(numers, denoms):
|
||||
denom = denom[zeros]
|
||||
|
||||
for monom, coeff in numer.items():
|
||||
coeff /= denom
|
||||
coeffs.add(coeff)
|
||||
numer[monom] = coeff
|
||||
else:
|
||||
for numer, denom in zip(numers, denoms):
|
||||
coeffs.update(list(numer.values()))
|
||||
coeffs.update(list(denom.values()))
|
||||
|
||||
rationals = floats = complexes = False
|
||||
float_numbers = []
|
||||
|
||||
for coeff in coeffs:
|
||||
if coeff.is_Rational:
|
||||
if not coeff.is_Integer:
|
||||
rationals = True
|
||||
elif coeff.is_Float:
|
||||
floats = True
|
||||
float_numbers.append(coeff)
|
||||
else:
|
||||
is_complex = pure_complex(coeff)
|
||||
if is_complex is not None:
|
||||
complexes = True
|
||||
x, y = is_complex
|
||||
if x.is_Rational and y.is_Rational:
|
||||
if not (x.is_Integer and y.is_Integer):
|
||||
rationals = True
|
||||
else:
|
||||
floats = True
|
||||
if x.is_Float:
|
||||
float_numbers.append(x)
|
||||
if y.is_Float:
|
||||
float_numbers.append(y)
|
||||
|
||||
max_prec = max(c._prec for c in float_numbers) if float_numbers else 53
|
||||
|
||||
if floats and complexes:
|
||||
ground = ComplexField(prec=max_prec)
|
||||
elif floats:
|
||||
ground = RealField(prec=max_prec)
|
||||
elif complexes:
|
||||
if rationals:
|
||||
ground = QQ_I
|
||||
else:
|
||||
ground = ZZ_I
|
||||
elif rationals:
|
||||
ground = QQ
|
||||
else:
|
||||
ground = ZZ
|
||||
|
||||
result = []
|
||||
|
||||
if not fractions:
|
||||
domain = ground.poly_ring(*gens)
|
||||
|
||||
for numer in numers:
|
||||
for monom, coeff in numer.items():
|
||||
numer[monom] = ground.from_sympy(coeff)
|
||||
|
||||
result.append(domain(numer))
|
||||
else:
|
||||
domain = ground.frac_field(*gens)
|
||||
|
||||
for numer, denom in zip(numers, denoms):
|
||||
for monom, coeff in numer.items():
|
||||
numer[monom] = ground.from_sympy(coeff)
|
||||
|
||||
for monom, coeff in denom.items():
|
||||
denom[monom] = ground.from_sympy(coeff)
|
||||
|
||||
result.append(domain((numer, denom)))
|
||||
|
||||
return domain, result
|
||||
|
||||
|
||||
def _construct_expression(coeffs, opt):
|
||||
"""The last resort case, i.e. use the expression domain. """
|
||||
domain, result = EX, []
|
||||
|
||||
for coeff in coeffs:
|
||||
result.append(domain.from_sympy(coeff))
|
||||
|
||||
return domain, result
|
||||
|
||||
|
||||
@public
|
||||
def construct_domain(obj, **args):
|
||||
"""Construct a minimal domain for a list of expressions.
|
||||
|
||||
Explanation
|
||||
===========
|
||||
|
||||
Given a list of normal SymPy expressions (of type :py:class:`~.Expr`)
|
||||
``construct_domain`` will find a minimal :py:class:`~.Domain` that can
|
||||
represent those expressions. The expressions will be converted to elements
|
||||
of the domain and both the domain and the domain elements are returned.
|
||||
|
||||
Parameters
|
||||
==========
|
||||
|
||||
obj: list or dict
|
||||
The expressions to build a domain for.
|
||||
|
||||
**args: keyword arguments
|
||||
Options that affect the choice of domain.
|
||||
|
||||
Returns
|
||||
=======
|
||||
|
||||
(K, elements): Domain and list of domain elements
|
||||
The domain K that can represent the expressions and the list or dict
|
||||
of domain elements representing the same expressions as elements of K.
|
||||
|
||||
Examples
|
||||
========
|
||||
|
||||
Given a list of :py:class:`~.Integer` ``construct_domain`` will return the
|
||||
domain :ref:`ZZ` and a list of integers as elements of :ref:`ZZ`.
|
||||
|
||||
>>> from sympy import construct_domain, S
|
||||
>>> expressions = [S(2), S(3), S(4)]
|
||||
>>> K, elements = construct_domain(expressions)
|
||||
>>> K
|
||||
ZZ
|
||||
>>> elements
|
||||
[2, 3, 4]
|
||||
>>> type(elements[0]) # doctest: +SKIP
|
||||
<class 'int'>
|
||||
>>> type(expressions[0])
|
||||
<class 'sympy.core.numbers.Integer'>
|
||||
|
||||
If there are any :py:class:`~.Rational` then :ref:`QQ` is returned
|
||||
instead.
|
||||
|
||||
>>> construct_domain([S(1)/2, S(3)/4])
|
||||
(QQ, [1/2, 3/4])
|
||||
|
||||
If there are symbols then a polynomial ring :ref:`K[x]` is returned.
|
||||
|
||||
>>> from sympy import symbols
|
||||
>>> x, y = symbols('x, y')
|
||||
>>> construct_domain([2*x + 1, S(3)/4])
|
||||
(QQ[x], [2*x + 1, 3/4])
|
||||
>>> construct_domain([2*x + 1, y])
|
||||
(ZZ[x,y], [2*x + 1, y])
|
||||
|
||||
If any symbols appear with negative powers then a rational function field
|
||||
:ref:`K(x)` will be returned.
|
||||
|
||||
>>> construct_domain([y/x, x/(1 - y)])
|
||||
(ZZ(x,y), [y/x, -x/(y - 1)])
|
||||
|
||||
Irrational algebraic numbers will result in the :ref:`EX` domain by
|
||||
default. The keyword argument ``extension=True`` leads to the construction
|
||||
of an algebraic number field :ref:`QQ(a)`.
|
||||
|
||||
>>> from sympy import sqrt
|
||||
>>> construct_domain([sqrt(2)])
|
||||
(EX, [EX(sqrt(2))])
|
||||
>>> construct_domain([sqrt(2)], extension=True) # doctest: +SKIP
|
||||
(QQ<sqrt(2)>, [ANP([1, 0], [1, 0, -2], QQ)])
|
||||
|
||||
See also
|
||||
========
|
||||
|
||||
Domain
|
||||
Expr
|
||||
"""
|
||||
opt = build_options(args)
|
||||
|
||||
if hasattr(obj, '__iter__'):
|
||||
if isinstance(obj, dict):
|
||||
if not obj:
|
||||
monoms, coeffs = [], []
|
||||
else:
|
||||
monoms, coeffs = list(zip(*list(obj.items())))
|
||||
else:
|
||||
coeffs = obj
|
||||
else:
|
||||
coeffs = [obj]
|
||||
|
||||
coeffs = list(map(sympify, coeffs))
|
||||
result = _construct_simple(coeffs, opt)
|
||||
|
||||
if result is not None:
|
||||
if result is not False:
|
||||
domain, coeffs = result
|
||||
else:
|
||||
domain, coeffs = _construct_expression(coeffs, opt)
|
||||
else:
|
||||
if opt.composite is False:
|
||||
result = None
|
||||
else:
|
||||
result = _construct_composite(coeffs, opt)
|
||||
|
||||
if result is not None:
|
||||
domain, coeffs = result
|
||||
else:
|
||||
domain, coeffs = _construct_expression(coeffs, opt)
|
||||
|
||||
if hasattr(obj, '__iter__'):
|
||||
if isinstance(obj, dict):
|
||||
return domain, dict(list(zip(monoms, coeffs)))
|
||||
else:
|
||||
return domain, coeffs
|
||||
else:
|
||||
return domain, coeffs[0]
|
||||
Reference in New Issue
Block a user