Spaces:
Running
Running
| """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'} | |