486 lines
12 KiB
Python
486 lines
12 KiB
Python
"""Tests for options manager for :class:`Poly` and public API functions. """
|
|
|
|
from sympy.polys.polyoptions import (
|
|
Options, Expand, Gens, Wrt, Sort, Order, Field, Greedy, Domain,
|
|
Split, Gaussian, Extension, Modulus, Symmetric, Strict, Auto,
|
|
Frac, Formal, Polys, Include, All, Gen, Symbols, Method)
|
|
|
|
from sympy.polys.orderings import lex
|
|
from sympy.polys.domains import FF, GF, ZZ, QQ, QQ_I, RR, CC, EX
|
|
|
|
from sympy.polys.polyerrors import OptionError, GeneratorsError
|
|
|
|
from sympy.core.numbers import (I, Integer)
|
|
from sympy.core.symbol import Symbol
|
|
from sympy.functions.elementary.miscellaneous import sqrt
|
|
from sympy.testing.pytest import raises
|
|
from sympy.abc import x, y, z
|
|
|
|
|
|
def test_Options_clone():
|
|
opt = Options((x, y, z), {'domain': 'ZZ'})
|
|
|
|
assert opt.gens == (x, y, z)
|
|
assert opt.domain == ZZ
|
|
assert ('order' in opt) is False
|
|
|
|
new_opt = opt.clone({'gens': (x, y), 'order': 'lex'})
|
|
|
|
assert opt.gens == (x, y, z)
|
|
assert opt.domain == ZZ
|
|
assert ('order' in opt) is False
|
|
|
|
assert new_opt.gens == (x, y)
|
|
assert new_opt.domain == ZZ
|
|
assert ('order' in new_opt) is True
|
|
|
|
|
|
def test_Expand_preprocess():
|
|
assert Expand.preprocess(False) is False
|
|
assert Expand.preprocess(True) is True
|
|
|
|
assert Expand.preprocess(0) is False
|
|
assert Expand.preprocess(1) is True
|
|
|
|
raises(OptionError, lambda: Expand.preprocess(x))
|
|
|
|
|
|
def test_Expand_postprocess():
|
|
opt = {'expand': True}
|
|
Expand.postprocess(opt)
|
|
|
|
assert opt == {'expand': True}
|
|
|
|
|
|
def test_Gens_preprocess():
|
|
assert Gens.preprocess((None,)) == ()
|
|
assert Gens.preprocess((x, y, z)) == (x, y, z)
|
|
assert Gens.preprocess(((x, y, z),)) == (x, y, z)
|
|
|
|
a = Symbol('a', commutative=False)
|
|
|
|
raises(GeneratorsError, lambda: Gens.preprocess((x, x, y)))
|
|
raises(GeneratorsError, lambda: Gens.preprocess((x, y, a)))
|
|
|
|
|
|
def test_Gens_postprocess():
|
|
opt = {'gens': (x, y)}
|
|
Gens.postprocess(opt)
|
|
|
|
assert opt == {'gens': (x, y)}
|
|
|
|
|
|
def test_Wrt_preprocess():
|
|
assert Wrt.preprocess(x) == ['x']
|
|
assert Wrt.preprocess('') == []
|
|
assert Wrt.preprocess(' ') == []
|
|
assert Wrt.preprocess('x,y') == ['x', 'y']
|
|
assert Wrt.preprocess('x y') == ['x', 'y']
|
|
assert Wrt.preprocess('x, y') == ['x', 'y']
|
|
assert Wrt.preprocess('x , y') == ['x', 'y']
|
|
assert Wrt.preprocess(' x, y') == ['x', 'y']
|
|
assert Wrt.preprocess(' x, y') == ['x', 'y']
|
|
assert Wrt.preprocess([x, y]) == ['x', 'y']
|
|
|
|
raises(OptionError, lambda: Wrt.preprocess(','))
|
|
raises(OptionError, lambda: Wrt.preprocess(0))
|
|
|
|
|
|
def test_Wrt_postprocess():
|
|
opt = {'wrt': ['x']}
|
|
Wrt.postprocess(opt)
|
|
|
|
assert opt == {'wrt': ['x']}
|
|
|
|
|
|
def test_Sort_preprocess():
|
|
assert Sort.preprocess([x, y, z]) == ['x', 'y', 'z']
|
|
assert Sort.preprocess((x, y, z)) == ['x', 'y', 'z']
|
|
|
|
assert Sort.preprocess('x > y > z') == ['x', 'y', 'z']
|
|
assert Sort.preprocess('x>y>z') == ['x', 'y', 'z']
|
|
|
|
raises(OptionError, lambda: Sort.preprocess(0))
|
|
raises(OptionError, lambda: Sort.preprocess({x, y, z}))
|
|
|
|
|
|
def test_Sort_postprocess():
|
|
opt = {'sort': 'x > y'}
|
|
Sort.postprocess(opt)
|
|
|
|
assert opt == {'sort': 'x > y'}
|
|
|
|
|
|
def test_Order_preprocess():
|
|
assert Order.preprocess('lex') == lex
|
|
|
|
|
|
def test_Order_postprocess():
|
|
opt = {'order': True}
|
|
Order.postprocess(opt)
|
|
|
|
assert opt == {'order': True}
|
|
|
|
|
|
def test_Field_preprocess():
|
|
assert Field.preprocess(False) is False
|
|
assert Field.preprocess(True) is True
|
|
|
|
assert Field.preprocess(0) is False
|
|
assert Field.preprocess(1) is True
|
|
|
|
raises(OptionError, lambda: Field.preprocess(x))
|
|
|
|
|
|
def test_Field_postprocess():
|
|
opt = {'field': True}
|
|
Field.postprocess(opt)
|
|
|
|
assert opt == {'field': True}
|
|
|
|
|
|
def test_Greedy_preprocess():
|
|
assert Greedy.preprocess(False) is False
|
|
assert Greedy.preprocess(True) is True
|
|
|
|
assert Greedy.preprocess(0) is False
|
|
assert Greedy.preprocess(1) is True
|
|
|
|
raises(OptionError, lambda: Greedy.preprocess(x))
|
|
|
|
|
|
def test_Greedy_postprocess():
|
|
opt = {'greedy': True}
|
|
Greedy.postprocess(opt)
|
|
|
|
assert opt == {'greedy': True}
|
|
|
|
|
|
def test_Domain_preprocess():
|
|
assert Domain.preprocess(ZZ) == ZZ
|
|
assert Domain.preprocess(QQ) == QQ
|
|
assert Domain.preprocess(EX) == EX
|
|
assert Domain.preprocess(FF(2)) == FF(2)
|
|
assert Domain.preprocess(ZZ[x, y]) == ZZ[x, y]
|
|
|
|
assert Domain.preprocess('Z') == ZZ
|
|
assert Domain.preprocess('Q') == QQ
|
|
|
|
assert Domain.preprocess('ZZ') == ZZ
|
|
assert Domain.preprocess('QQ') == QQ
|
|
|
|
assert Domain.preprocess('EX') == EX
|
|
|
|
assert Domain.preprocess('FF(23)') == FF(23)
|
|
assert Domain.preprocess('GF(23)') == GF(23)
|
|
|
|
raises(OptionError, lambda: Domain.preprocess('Z[]'))
|
|
|
|
assert Domain.preprocess('Z[x]') == ZZ[x]
|
|
assert Domain.preprocess('Q[x]') == QQ[x]
|
|
assert Domain.preprocess('R[x]') == RR[x]
|
|
assert Domain.preprocess('C[x]') == CC[x]
|
|
|
|
assert Domain.preprocess('ZZ[x]') == ZZ[x]
|
|
assert Domain.preprocess('QQ[x]') == QQ[x]
|
|
assert Domain.preprocess('RR[x]') == RR[x]
|
|
assert Domain.preprocess('CC[x]') == CC[x]
|
|
|
|
assert Domain.preprocess('Z[x,y]') == ZZ[x, y]
|
|
assert Domain.preprocess('Q[x,y]') == QQ[x, y]
|
|
assert Domain.preprocess('R[x,y]') == RR[x, y]
|
|
assert Domain.preprocess('C[x,y]') == CC[x, y]
|
|
|
|
assert Domain.preprocess('ZZ[x,y]') == ZZ[x, y]
|
|
assert Domain.preprocess('QQ[x,y]') == QQ[x, y]
|
|
assert Domain.preprocess('RR[x,y]') == RR[x, y]
|
|
assert Domain.preprocess('CC[x,y]') == CC[x, y]
|
|
|
|
raises(OptionError, lambda: Domain.preprocess('Z()'))
|
|
|
|
assert Domain.preprocess('Z(x)') == ZZ.frac_field(x)
|
|
assert Domain.preprocess('Q(x)') == QQ.frac_field(x)
|
|
|
|
assert Domain.preprocess('ZZ(x)') == ZZ.frac_field(x)
|
|
assert Domain.preprocess('QQ(x)') == QQ.frac_field(x)
|
|
|
|
assert Domain.preprocess('Z(x,y)') == ZZ.frac_field(x, y)
|
|
assert Domain.preprocess('Q(x,y)') == QQ.frac_field(x, y)
|
|
|
|
assert Domain.preprocess('ZZ(x,y)') == ZZ.frac_field(x, y)
|
|
assert Domain.preprocess('QQ(x,y)') == QQ.frac_field(x, y)
|
|
|
|
assert Domain.preprocess('Q<I>') == QQ.algebraic_field(I)
|
|
assert Domain.preprocess('QQ<I>') == QQ.algebraic_field(I)
|
|
|
|
assert Domain.preprocess('Q<sqrt(2), I>') == QQ.algebraic_field(sqrt(2), I)
|
|
assert Domain.preprocess(
|
|
'QQ<sqrt(2), I>') == QQ.algebraic_field(sqrt(2), I)
|
|
|
|
raises(OptionError, lambda: Domain.preprocess('abc'))
|
|
|
|
|
|
def test_Domain_postprocess():
|
|
raises(GeneratorsError, lambda: Domain.postprocess({'gens': (x, y),
|
|
'domain': ZZ[y, z]}))
|
|
|
|
raises(GeneratorsError, lambda: Domain.postprocess({'gens': (),
|
|
'domain': EX}))
|
|
raises(GeneratorsError, lambda: Domain.postprocess({'domain': EX}))
|
|
|
|
|
|
def test_Split_preprocess():
|
|
assert Split.preprocess(False) is False
|
|
assert Split.preprocess(True) is True
|
|
|
|
assert Split.preprocess(0) is False
|
|
assert Split.preprocess(1) is True
|
|
|
|
raises(OptionError, lambda: Split.preprocess(x))
|
|
|
|
|
|
def test_Split_postprocess():
|
|
raises(NotImplementedError, lambda: Split.postprocess({'split': True}))
|
|
|
|
|
|
def test_Gaussian_preprocess():
|
|
assert Gaussian.preprocess(False) is False
|
|
assert Gaussian.preprocess(True) is True
|
|
|
|
assert Gaussian.preprocess(0) is False
|
|
assert Gaussian.preprocess(1) is True
|
|
|
|
raises(OptionError, lambda: Gaussian.preprocess(x))
|
|
|
|
|
|
def test_Gaussian_postprocess():
|
|
opt = {'gaussian': True}
|
|
Gaussian.postprocess(opt)
|
|
|
|
assert opt == {
|
|
'gaussian': True,
|
|
'domain': QQ_I,
|
|
}
|
|
|
|
|
|
def test_Extension_preprocess():
|
|
assert Extension.preprocess(True) is True
|
|
assert Extension.preprocess(1) is True
|
|
|
|
assert Extension.preprocess([]) is None
|
|
|
|
assert Extension.preprocess(sqrt(2)) == {sqrt(2)}
|
|
assert Extension.preprocess([sqrt(2)]) == {sqrt(2)}
|
|
|
|
assert Extension.preprocess([sqrt(2), I]) == {sqrt(2), I}
|
|
|
|
raises(OptionError, lambda: Extension.preprocess(False))
|
|
raises(OptionError, lambda: Extension.preprocess(0))
|
|
|
|
|
|
def test_Extension_postprocess():
|
|
opt = {'extension': {sqrt(2)}}
|
|
Extension.postprocess(opt)
|
|
|
|
assert opt == {
|
|
'extension': {sqrt(2)},
|
|
'domain': QQ.algebraic_field(sqrt(2)),
|
|
}
|
|
|
|
opt = {'extension': True}
|
|
Extension.postprocess(opt)
|
|
|
|
assert opt == {'extension': True}
|
|
|
|
|
|
def test_Modulus_preprocess():
|
|
assert Modulus.preprocess(23) == 23
|
|
assert Modulus.preprocess(Integer(23)) == 23
|
|
|
|
raises(OptionError, lambda: Modulus.preprocess(0))
|
|
raises(OptionError, lambda: Modulus.preprocess(x))
|
|
|
|
|
|
def test_Modulus_postprocess():
|
|
opt = {'modulus': 5}
|
|
Modulus.postprocess(opt)
|
|
|
|
assert opt == {
|
|
'modulus': 5,
|
|
'domain': FF(5),
|
|
}
|
|
|
|
opt = {'modulus': 5, 'symmetric': False}
|
|
Modulus.postprocess(opt)
|
|
|
|
assert opt == {
|
|
'modulus': 5,
|
|
'domain': FF(5, False),
|
|
'symmetric': False,
|
|
}
|
|
|
|
|
|
def test_Symmetric_preprocess():
|
|
assert Symmetric.preprocess(False) is False
|
|
assert Symmetric.preprocess(True) is True
|
|
|
|
assert Symmetric.preprocess(0) is False
|
|
assert Symmetric.preprocess(1) is True
|
|
|
|
raises(OptionError, lambda: Symmetric.preprocess(x))
|
|
|
|
|
|
def test_Symmetric_postprocess():
|
|
opt = {'symmetric': True}
|
|
Symmetric.postprocess(opt)
|
|
|
|
assert opt == {'symmetric': True}
|
|
|
|
|
|
def test_Strict_preprocess():
|
|
assert Strict.preprocess(False) is False
|
|
assert Strict.preprocess(True) is True
|
|
|
|
assert Strict.preprocess(0) is False
|
|
assert Strict.preprocess(1) is True
|
|
|
|
raises(OptionError, lambda: Strict.preprocess(x))
|
|
|
|
|
|
def test_Strict_postprocess():
|
|
opt = {'strict': True}
|
|
Strict.postprocess(opt)
|
|
|
|
assert opt == {'strict': True}
|
|
|
|
|
|
def test_Auto_preprocess():
|
|
assert Auto.preprocess(False) is False
|
|
assert Auto.preprocess(True) is True
|
|
|
|
assert Auto.preprocess(0) is False
|
|
assert Auto.preprocess(1) is True
|
|
|
|
raises(OptionError, lambda: Auto.preprocess(x))
|
|
|
|
|
|
def test_Auto_postprocess():
|
|
opt = {'auto': True}
|
|
Auto.postprocess(opt)
|
|
|
|
assert opt == {'auto': True}
|
|
|
|
|
|
def test_Frac_preprocess():
|
|
assert Frac.preprocess(False) is False
|
|
assert Frac.preprocess(True) is True
|
|
|
|
assert Frac.preprocess(0) is False
|
|
assert Frac.preprocess(1) is True
|
|
|
|
raises(OptionError, lambda: Frac.preprocess(x))
|
|
|
|
|
|
def test_Frac_postprocess():
|
|
opt = {'frac': True}
|
|
Frac.postprocess(opt)
|
|
|
|
assert opt == {'frac': True}
|
|
|
|
|
|
def test_Formal_preprocess():
|
|
assert Formal.preprocess(False) is False
|
|
assert Formal.preprocess(True) is True
|
|
|
|
assert Formal.preprocess(0) is False
|
|
assert Formal.preprocess(1) is True
|
|
|
|
raises(OptionError, lambda: Formal.preprocess(x))
|
|
|
|
|
|
def test_Formal_postprocess():
|
|
opt = {'formal': True}
|
|
Formal.postprocess(opt)
|
|
|
|
assert opt == {'formal': True}
|
|
|
|
|
|
def test_Polys_preprocess():
|
|
assert Polys.preprocess(False) is False
|
|
assert Polys.preprocess(True) is True
|
|
|
|
assert Polys.preprocess(0) is False
|
|
assert Polys.preprocess(1) is True
|
|
|
|
raises(OptionError, lambda: Polys.preprocess(x))
|
|
|
|
|
|
def test_Polys_postprocess():
|
|
opt = {'polys': True}
|
|
Polys.postprocess(opt)
|
|
|
|
assert opt == {'polys': True}
|
|
|
|
|
|
def test_Include_preprocess():
|
|
assert Include.preprocess(False) is False
|
|
assert Include.preprocess(True) is True
|
|
|
|
assert Include.preprocess(0) is False
|
|
assert Include.preprocess(1) is True
|
|
|
|
raises(OptionError, lambda: Include.preprocess(x))
|
|
|
|
|
|
def test_Include_postprocess():
|
|
opt = {'include': True}
|
|
Include.postprocess(opt)
|
|
|
|
assert opt == {'include': True}
|
|
|
|
|
|
def test_All_preprocess():
|
|
assert All.preprocess(False) is False
|
|
assert All.preprocess(True) is True
|
|
|
|
assert All.preprocess(0) is False
|
|
assert All.preprocess(1) is True
|
|
|
|
raises(OptionError, lambda: All.preprocess(x))
|
|
|
|
|
|
def test_All_postprocess():
|
|
opt = {'all': True}
|
|
All.postprocess(opt)
|
|
|
|
assert opt == {'all': True}
|
|
|
|
|
|
def test_Gen_postprocess():
|
|
opt = {'gen': x}
|
|
Gen.postprocess(opt)
|
|
|
|
assert opt == {'gen': x}
|
|
|
|
|
|
def test_Symbols_preprocess():
|
|
raises(OptionError, lambda: Symbols.preprocess(x))
|
|
|
|
|
|
def test_Symbols_postprocess():
|
|
opt = {'symbols': [x, y, z]}
|
|
Symbols.postprocess(opt)
|
|
|
|
assert opt == {'symbols': [x, y, z]}
|
|
|
|
|
|
def test_Method_preprocess():
|
|
raises(OptionError, lambda: Method.preprocess(10))
|
|
|
|
|
|
def test_Method_postprocess():
|
|
opt = {'method': 'f5b'}
|
|
Method.postprocess(opt)
|
|
|
|
assert opt == {'method': 'f5b'}
|