Ejemplo n.º 1
0
def test_sdp_pow():
    f = sdp_from_dict({(1,): 2, (0,): 3}, grlex)

    assert sdp_pow(f, 0, 0, grlex, ZZ) == sdp_one(0, ZZ)
    assert sdp_pow(f, 1, 0, grlex, ZZ) == f

    assert sdp_pow(f, 2, 0, grlex, ZZ) == \
        sdp_from_dict({(2,): 4, (1,): 12, (0,): 9}, grlex)
    assert sdp_pow(f, 3, 0, grlex, ZZ) == \
        sdp_from_dict({(3,): 8, (2,): 36, (1,): 54, (0,): 27}, grlex)
    assert sdp_pow(f, 4, 0, grlex, ZZ) == \
        sdp_from_dict(
            {(4,): 16, (3,): 96, (2,): 216, (1,): 216, (0,): 81}, grlex)
    assert sdp_pow(f, 5, 0, grlex, ZZ) == \
        sdp_from_dict({(5,): 32, (
            4,): 240, (3,): 720, (2,): 1080, (1,): 810, (0,): 243}, grlex)

    f = sdp_from_dict(
        {(3, 1, 0): 1, (1, 2, 0): -2, (0, 0, 1): -3, (0, 0, 0): 1}, grlex)
    g = sdp_from_dict(
        {(
            6, 2, 0): 1, (
                4, 3, 0): -4, (2, 4, 0): 4, (3, 1, 1): -6, (3, 1, 0): 2,
         (1, 2, 1): 12, (1, 2, 0): -4, (0, 0, 2): 9, (0, 0, 1): -6, (0, 0, 0): 1}, grlex)

    assert sdp_pow(f, 2, 2, grlex, ZZ) == g

    raises(ValueError, lambda: sdp_pow(f, -2, 2, grlex, ZZ))
Ejemplo n.º 2
0
def sdm_from_dict(d, O):
    """
    Create an sdm from a dictionary.

    Here ``O`` is the monomial order to use.

    >>> from sympy.polys.distributedmodules import sdm_from_dict
    >>> from sympy.polys import QQ, lex
    >>> dic = {(1, 1, 0): QQ(1), (1, 0, 0): QQ(2), (0, 1, 0): QQ(0)}
    >>> sdm_from_dict(dic, lex)
    [((1, 1, 0), 1/1), ((1, 0, 0), 2/1)]
    """
    return sdp_strip(sdp_from_dict(d, O))
Ejemplo n.º 3
0
def test_sdp_rem():
    f = sdp_from_dict(
        {(2, 1): 4, (1, 1): -2, (1, 0): 4, (0, 1): -2, (0, 0): 8}, grlex)

    assert sdp_rem(f, [sdp_from_dict({(0, 0): 2}, grlex)], 1, grlex, ZZ) == []
    assert sdp_rem(f, [sdp_from_dict({(0, 1): 2}, grlex)], 1, grlex, ZZ) == \
        sdp_from_dict({(1, 0): 4, (0, 0): 8}, grlex)

    f = sdp_from_dict({(1, 0): 1, (0, 0): -1}, grlex)
    g = sdp_from_dict({(0, 1): 1, (0, 0): -1}, grlex)

    assert sdp_rem(f, [g], 1, grlex, ZZ) == f

    f = sdp_from_dict({(3,): 1, (2,): -12, (0,): -42}, grlex)
    g = sdp_from_dict({(1,): 1, (0,): -3}, grlex)

    r = sdp_from_dict({(0,): -123}, grlex)

    assert sdp_rem(f, [g], 0, grlex, ZZ) == r

    f = sdp_from_dict({(1, 2): 1, (0, 0): 1}, grlex)
    G = [sdp_from_dict({(1, 1): 1, (0, 0): 1}, grlex),
         sdp_from_dict({(0, 1): 1, (0, 0): 1}, grlex)]

    r = sdp_from_dict({(0, 0): 2}, grlex)

    assert sdp_rem(f, G, 1, grlex, ZZ) == r

    f = sdp_from_dict({(2, 1): 1, (1, 2): 1, (0, 2): 1}, grlex)

    G = [sdp_from_dict({(1, 1): 1, (0, 0): -1}, grlex),
         sdp_from_dict({(0, 2): 1, (0, 0): -1}, grlex)]

    r = sdp_from_dict({(1, 0): 1, (0, 1): 1, (0, 0): 1}, grlex)

    assert sdp_rem(f, G, 1, grlex, ZZ) == r

    G = [sdp_from_dict({(0, 2): 1, (0, 0): -1}, grlex),
         sdp_from_dict({(1, 1): 1, (0, 0): -1}, grlex)]

    r = sdp_from_dict({(1, 0): 2, (0, 0): 1}, grlex)

    assert sdp_rem(f, G, 1, grlex, ZZ) == r
Ejemplo n.º 4
0
def test_sdp_div():
    f = sdp_from_dict(
        {(2, 1): 4, (1, 1): -2, (1, 0): 4, (0, 1): -2, (0, 0): 8}, grlex)

    assert sdp_div(f, [sdp_from_dict({(0, 0): 2}, grlex)], 1, grlex, ZZ) == \
        ([sdp_from_dict({(2, 1): 2, (1, 1): -1, (1, 0): 2, (0, 1):
         -1, (0, 0): 4}, grlex)], [])

    assert sdp_div(f, [sdp_from_dict({(0, 1): 2}, grlex)], 1, grlex, ZZ) == \
        ([sdp_from_dict({(2, 0): 2, (1, 0): -1, (0, 0): -1}, grlex)],
         sdp_from_dict({(1, 0): 4, (0, 0): 8}, grlex))

    f = sdp_from_dict({(1, 0): 1, (0, 0): -1}, grlex)
    g = sdp_from_dict({(0, 1): 1, (0, 0): -1}, grlex)

    assert sdp_div(f, [g], 1, grlex, ZZ) == ([[]], f)

    f = sdp_from_dict({(3,): 1, (2,): -12, (0,): -42}, grlex)
    g = sdp_from_dict({(1,): 1, (0,): -3}, grlex)

    q = sdp_from_dict({(2,): 1, (1,): -9, (0,): -27}, grlex)
    r = sdp_from_dict({(0,): -123}, grlex)

    assert sdp_div(f, [g], 0, grlex, ZZ) == ([q], r)

    f = sdp_from_dict({(2,): QQ(1), (1,): QQ(2), (0,): QQ(2)}, grlex)

    g = sdp_from_dict({(0,): QQ(1)}, grlex)
    h = sdp_from_dict({(0,): QQ(2)}, grlex)

    q = sdp_from_dict({(2,): QQ(1, 2), (1,): QQ(1), (0,): QQ(1)}, grlex)

    assert sdp_div(f, [g], 0, grlex, QQ) == ([f], [])
    assert sdp_div(f, [h], 0, grlex, QQ) == ([q], [])

    f = sdp_from_dict({(1, 2): 1, (0, 0): 1}, grlex)
    G = [sdp_from_dict({(1, 1): 1, (0, 0): 1}, grlex),
         sdp_from_dict({(0, 1): 1, (0, 0): 1}, grlex)]

    Q = [sdp_from_dict({(0, 1): 1}, grlex),
         sdp_from_dict({(0, 0): -1}, grlex)]
    r = sdp_from_dict({(0, 0): 2}, grlex)

    assert sdp_div(f, G, 1, grlex, ZZ) == (Q, r)

    f = sdp_from_dict({(2, 1): 1, (1, 2): 1, (0, 2): 1}, grlex)

    G = [sdp_from_dict({(1, 1): 1, (0, 0): -1}, grlex),
         sdp_from_dict({(0, 2): 1, (0, 0): -1}, grlex)]

    Q = [sdp_from_dict({(1, 0): 1, (0, 1): 1}, grlex),
         sdp_from_dict({(0, 0): 1}, grlex)]
    r = sdp_from_dict({(1, 0): 1, (0, 1): 1, (0, 0): 1}, grlex)

    assert sdp_div(f, G, 1, grlex, ZZ) == (Q, r)

    G = [sdp_from_dict({(0, 2): 1, (0, 0): -1}, grlex),
         sdp_from_dict({(1, 1): 1, (0, 0): -1}, grlex)]

    Q = [sdp_from_dict({(1, 0): 1, (0, 0): 1}, grlex),
         sdp_from_dict({(1, 0): 1}, grlex)]
    r = sdp_from_dict({(1, 0): 2, (0, 0): 1}, grlex)

    assert sdp_div(f, G, 1, grlex, ZZ) == (Q, r)
Ejemplo n.º 5
0
def helper_test_sdp_groebner():
    f = sdp_from_dict({(1,2): QQ(2,), (2,0): QQ(1)}, lex)
    g = sdp_from_dict({(0,3): QQ(2), (1,1): QQ(1), (0,0): QQ(-1)},  lex)

    a = sdp_from_dict({(1,0): QQ(1,1)}, lex)
    b = sdp_from_dict({(0,3): QQ(1,1), (0,0): QQ(-1,2)}, lex)

    assert sdp_groebner((f, g), 1, lex, QQ) == [a, b]

    f = sdp_from_dict({(2,1): QQ(2,), (0,2): QQ(1)}, lex)
    g = sdp_from_dict({(3,0): QQ(2), (1,1): QQ(1), (0,0): QQ(-1)},  lex)

    a = sdp_from_dict({(0,1): QQ(1,1)}, lex)
    b = sdp_from_dict({(3,0): QQ(1,1), (0,0): QQ(-1,2)}, lex)

    assert sdp_groebner((f, g), 1, lex, QQ) == [b, a]

    f = sdp_from_dict({(0,0,2): QQ(-1), (1,0,0): QQ(1)}, lex)
    g = sdp_from_dict({(0,0,3): QQ(-1), (0,1,0): QQ(1)}, lex)

    assert sdp_groebner((f, g), 1, lex, QQ) == [f, g]

    f = sdp_from_dict({(3,0): QQ(1), (1,1): QQ(-2)}, grlex)
    g = sdp_from_dict({(2,1): QQ(1), (0,2): QQ(-2), (1,0): QQ(1)}, grlex)

    a = sdp_from_dict({(2,0): QQ(1)}, grlex)
    b = sdp_from_dict({(1,1): QQ(1)}, grlex)
    c = sdp_from_dict({(0,2): QQ(1), (1, 0): QQ(-1,2)}, grlex)

    assert sdp_groebner((f, g), 1, grlex, QQ) == [a, b, c]

    f = sdp_from_dict({(2,0,0): -QQ(1), (0,1,0): QQ(1)}, lex)
    g = sdp_from_dict({(3,0,0): -QQ(1), (0,0,1): QQ(1)}, lex)

    assert sdp_groebner((f, g), 2, lex, QQ) == [
        sdp_from_dict({(2,0,0): QQ(1), (0,1,0): -QQ(1)}, lex),
        sdp_from_dict({(1,1,0): QQ(1), (0,0,1): -QQ(1)}, lex),
        sdp_from_dict({(1,0,1): QQ(1), (0,2,0): -QQ(1)}, lex),
        sdp_from_dict({(0,3,0): QQ(1), (0,0,2): -QQ(1)}, lex),
    ]

    f = sdp_from_dict({(2,0,0): -QQ(1), (0,1,0): QQ(1)}, grlex)
    g = sdp_from_dict({(3,0,0): -QQ(1), (0,0,1): QQ(1)}, grlex)

    assert sdp_groebner((f, g), 2, grlex, QQ) == [
        sdp_from_dict({(0,3,0): QQ(1), (0,0,2): -QQ(1)}, grlex),
        sdp_from_dict({(2,0,0): QQ(1), (0,1,0): -QQ(1)}, grlex),
        sdp_from_dict({(1,1,0): QQ(1), (0,0,1): -QQ(1)}, grlex),
        sdp_from_dict({(1,0,1): QQ(1), (0,2,0): -QQ(1)}, grlex),
    ]

    f = sdp_from_dict({(2,0,0): -QQ(1), (0,0,1): QQ(1)}, lex)
    g = sdp_from_dict({(3,0,0): -QQ(1), (0,1,0): QQ(1)}, lex)

    assert sdp_groebner((f, g), 2, lex, QQ) == [
        sdp_from_dict({(2,0,0): QQ(1), (0,0,1): -QQ(1)}, lex),
        sdp_from_dict({(1,1,0): QQ(1), (0,0,2): -QQ(1)}, lex),
        sdp_from_dict({(1,0,1): QQ(1), (0,1,0): -QQ(1)}, lex),
        sdp_from_dict({(0,2,0): QQ(1), (0,0,3): -QQ(1)}, lex),
    ]

    f = sdp_from_dict({(2,0,0): -QQ(1), (0,0,1): QQ(1)}, grlex)
    g = sdp_from_dict({(3,0,0): -QQ(1), (0,1,0): QQ(1)}, grlex)

    assert sdp_groebner((f, g), 2, grlex, QQ) == [
        sdp_from_dict({(0,0,3): QQ(1), (0,2,0): -QQ(1)}, grlex),
        sdp_from_dict({(2,0,0): QQ(1), (0,0,1): -QQ(1)}, grlex),
        sdp_from_dict({(1,1,0): QQ(1), (0,0,2): -QQ(1)}, grlex),
        sdp_from_dict({(1,0,1): QQ(1), (0,1,0): -QQ(1)}, grlex),
    ]

    f = sdp_from_dict({(0,2,0): -QQ(1), (1,0,0): QQ(1)}, lex)
    g = sdp_from_dict({(0,3,0): -QQ(1), (0,0,1): QQ(1)}, lex)

    assert sdp_groebner((f, g), 2, lex, QQ) == [
        sdp_from_dict({(1,0,0): QQ(1), (0,2,0): -QQ(1)}, lex),
        sdp_from_dict({(0,3,0): QQ(1), (0,0,1): -QQ(1)}, lex),
    ]

    f = sdp_from_dict({(0,2,0): -QQ(1), (1,0,0): QQ(1)}, grlex)
    g = sdp_from_dict({(0,3,0): -QQ(1), (0,0,1): QQ(1)}, grlex)

    assert sdp_groebner((f, g), 2, grlex, QQ) == [
        sdp_from_dict({(2,0,0): QQ(1), (0,1,1): -QQ(1)}, grlex),
        sdp_from_dict({(1,1,0): QQ(1), (0,0,1): -QQ(1)}, grlex),
        sdp_from_dict({(0,2,0): QQ(1), (1,0,0): -QQ(1)}, grlex),
    ]

    f = sdp_from_dict({(0,0,2): -QQ(1), (1,0,0): QQ(1)}, lex)
    g = sdp_from_dict({(0,0,3): -QQ(1), (0,1,0): QQ(1)}, lex)

    assert sdp_groebner((f, g), 2, lex, QQ) == [
        sdp_from_dict({(1,0,0): QQ(1), (0,0,2): -QQ(1)}, lex),
        sdp_from_dict({(0,1,0): QQ(1), (0,0,3): -QQ(1)}, lex),
    ]

    f = sdp_from_dict({(0,0,2): -QQ(1), (1,0,0): QQ(1)}, grlex)
    g = sdp_from_dict({(0,0,3): -QQ(1), (0,1,0): QQ(1)}, grlex)

    assert sdp_groebner((f, g), 2, grlex, QQ) == [
        sdp_from_dict({(2,0,0): QQ(1), (0,1,1): -QQ(1)}, grlex),
        sdp_from_dict({(1,0,1): QQ(1), (0,1,0): -QQ(1)}, grlex),
        sdp_from_dict({(0,0,2): QQ(1), (1,0,0): -QQ(1)}, grlex),
    ]

    f = sdp_from_dict({(0,2,0): -QQ(1), (0,0,1): QQ(1)}, lex)
    g = sdp_from_dict({(0,3,0): -QQ(1), (1,0,0): QQ(1)}, lex)

    assert sdp_groebner((f, g), 2, lex, QQ) == [
        sdp_from_dict({(1,0,0): QQ(1), (0,1,1): -QQ(1)}, lex),
        sdp_from_dict({(0,2,0): QQ(1), (0,0,1): -QQ(1)}, lex),
    ]

    f = sdp_from_dict({(0,2,0): -QQ(1), (0,0,1): QQ(1)}, grlex)
    g = sdp_from_dict({(0,3,0): -QQ(1), (1,0,0): QQ(1)}, grlex)

    assert sdp_groebner((f, g), 2, grlex, QQ) == [
        sdp_from_dict({(0,0,3): QQ(1), (2,0,0): -QQ(1)}, grlex),
        sdp_from_dict({(1,1,0): QQ(1), (0,0,2): -QQ(1)}, grlex),
        sdp_from_dict({(0,2,0): QQ(1), (0,0,1): -QQ(1)}, grlex),
        sdp_from_dict({(0,1,1): QQ(1), (1,0,0): -QQ(1)}, grlex),
    ]

    f = sdp_from_dict({(0,0,2): -QQ(1), (0,1,0): QQ(1)}, lex)
    g = sdp_from_dict({(0,0,3): -QQ(1), (1,0,0): QQ(1)}, lex)

    assert sdp_groebner((f, g), 2, lex, QQ) == [
        sdp_from_dict({(1,0,0): QQ(1), (0,0,3): -QQ(1)}, lex),
        sdp_from_dict({(0,1,0): QQ(1), (0,0,2): -QQ(1)}, lex),
    ]

    f = sdp_from_dict({(0,0,2): -QQ(1), (0,1,0): QQ(1)}, grlex)
    g = sdp_from_dict({(0,0,3): -QQ(1), (1,0,0): QQ(1)}, grlex)

    assert sdp_groebner((f, g), 2, grlex, QQ) == [
        sdp_from_dict({(0,3,0): QQ(1), (2,0,0): -QQ(1)}, grlex),
        sdp_from_dict({(1,0,1): QQ(1), (0,2,0): -QQ(1)}, grlex),
        sdp_from_dict({(0,1,1): QQ(1), (1,0,0): -QQ(1)}, grlex),
        sdp_from_dict({(0,0,2): QQ(1), (0,1,0): -QQ(1)}, grlex),
    ]

    f = sdp_from_dict({(2,2): QQ(4), (1,1): QQ(4), (0,0): QQ(1)}, lex)
    g = sdp_from_dict({(2,0): QQ(1), (0,2): QQ(1), (0,0):-QQ(1)}, lex)

    assert sdp_groebner((f, g), 1, lex, QQ) == [
        sdp_from_dict({(1,0): QQ(1,1), (0,7): QQ(-4,1), (0,5): QQ(8,1), (0,3): QQ(-7,1), (0,1): QQ(3,1)}, lex),
        sdp_from_dict({(0,8): QQ(1,1), (0,6): QQ(-2,1), (0,4): QQ(3,2), (0,2): QQ(-1,2), (0,0): QQ(1,16)}, lex),
    ]

    raises(DomainError, lambda: sdp_groebner([], 1, lex, ZZ))