Exemplo n.º 1
0
	def LM(self,poly):
		from sympy import S,Poly
		if poly==0:return poly
		poly = Poly(poly,self.variables)
		polyDict = poly.as_dict()
		exponents = polyDict.keys()
		largest = exponents[0]
		for i in xrange(len(polyDict)):
			if self.compare(exponents[i],largest): largest = exponents[i]
		return Poly({largest:S(1)},self.variables)
Exemplo n.º 2
0
def test_poly_internals():
    p = Poly(x**2*y*z + x*y*z**3 + x*y + y*z, x, y, z)

    assert p.as_dict() == \
        {(1, 1, 3): 1, (1, 1, 0): 1, (2, 1, 1): 1, (0, 1, 1): 1}

    assert Poly._permute(p, x) == \
        {(2,): y*z, (0,): y*z, (1,): y + y*z**3}

    assert Poly._permute(p, y) == \
        {(1,): x + z + x*z**3 + z*x**2}

    assert Poly._permute(p, z) == \
        {(0,): x*y, (3,): x*y, (1,): y + y*x**2}

    assert Poly._permute(p, x, y) == \
        {(0, 1): z, (1, 1): 1 + z**3, (2, 1): z}

    assert Poly._permute(p, y, x) == \
        {(1, 2): z, (1, 0): z, (1, 1): 1 + z**3}

    assert Poly._permute(p, x, z) == \
        {(0, 1): y, (1, 0): y, (1, 3): y, (2, 1): y}

    assert Poly._permute(p, z, x) == \
        {(1, 2): y, (0, 1): y, (1, 0): y, (3, 1): y}

    assert Poly._permute(p, y, z) == \
        {(1, 0): x, (1, 3): x, (1, 1): 1 + x**2}

    assert Poly._permute(p, z, y) == \
        {(0, 1): x, (3, 1): x, (1, 1): 1 + x**2}

    q = Poly(x**2*y*z + 2*x*y*z**3 + 3*x*y + 4*y*z, x, y, z)

    assert q.as_dict() == \
        {(1, 1, 3): 2, (1, 1, 0): 3, (2, 1, 1): 1, (0, 1, 1): 4}

    assert Poly._permute(q, z, y, x) == \
        {(0, 1, 1): 3, (1, 1, 0): 4, (3, 1, 1): 2, (1, 1, 2): 1}
Exemplo n.º 3
0
def test_poly_internals():
    p = Poly(x**2*y*z + x*y*z**3 + x*y + y*z, x, y, z)

    assert p.as_dict() == \
        {(1, 1, 3): 1, (1, 1, 0): 1, (2, 1, 1): 1, (0, 1, 1): 1}

    assert Poly._permute(p, x) == \
        {(2,): y*z, (0,): y*z, (1,): y + y*z**3}

    assert Poly._permute(p, y) == \
        {(1,): x + z + x*z**3 + z*x**2}

    assert Poly._permute(p, z) == \
        {(0,): x*y, (3,): x*y, (1,): y + y*x**2}

    assert Poly._permute(p, x, y) == \
        {(0, 1): z, (1, 1): 1 + z**3, (2, 1): z}

    assert Poly._permute(p, y, x) == \
        {(1, 2): z, (1, 0): z, (1, 1): 1 + z**3}

    assert Poly._permute(p, x, z) == \
        {(0, 1): y, (1, 0): y, (1, 3): y, (2, 1): y}

    assert Poly._permute(p, z, x) == \
        {(1, 2): y, (0, 1): y, (1, 0): y, (3, 1): y}

    assert Poly._permute(p, y, z) == \
        {(1, 0): x, (1, 3): x, (1, 1): 1 + x**2}

    assert Poly._permute(p, z, y) == \
        {(0, 1): x, (3, 1): x, (1, 1): 1 + x**2}

    q = Poly(x**2*y*z + 2*x*y*z**3 + 3*x*y + 4*y*z, x, y, z)

    assert q.as_dict() == \
        {(1, 1, 3): 2, (1, 1, 0): 3, (2, 1, 1): 1, (0, 1, 1): 4}

    assert Poly._permute(q, z, y, x) == \
        {(0, 1, 1): 3, (1, 1, 0): 4, (3, 1, 1): 2, (1, 1, 2): 1}
Exemplo n.º 4
0
def new_poly(V_s, fields, n_coeffs):
    """Make a new polynomial function that has the same powers as V_s function
       but with coefficients C1, C2..."""

    from sympy import Poly
    from sympy import diff, Symbol, var, simplify, sympify, S
    from sympy.core.sympify import SympifyError

    P = Poly(V_s, *fields)
    d = P.as_dict()
    e = {}

    for key in d.iterkeys():
        #print d[key], str(d[key])
        for i in xrange(1, n_coeffs + 1):
            if 'C' + str(i) in str(d[key]):
                e[key] = sympify('C' + str(i))

    P2 = Poly(e, *fields)
    return str(P2.as_basic())
Exemplo n.º 5
0
def new_poly(V_s, fields, n_coeffs):
    """Make a new polynomial function that has the same powers as V_s function
       but with coefficients C1, C2..."""
    
    from sympy import Poly
    from sympy import diff, Symbol, var, simplify, sympify, S
    from sympy.core.sympify import SympifyError
    
    P = Poly(V_s,*fields)
    d = P.as_dict()
    e = {}
    
    for key in d.iterkeys():
        #print d[key], str(d[key])
        for i in xrange(1, n_coeffs+1):
            if 'C' + str(i) in str(d[key]):
                e[key] = sympify('C'+str(i))

    P2 = Poly(e,*fields)
    return str(P2.as_basic())
Exemplo n.º 6
0
def _expansion_search(expr, rep_list, lib=None):
    """
    Search for and substitute terms that match a series expansion of
    fundamental math functions.

    e: expression

    rep_list: list containing dummy variables

    """
    if debug:
        print("_expansion_search: ", expr)

    try:
        if isinstance(expr, Mul):
            exprs = [expr]
        elif isinstance(expr, Add):
            exprs = expr.args
        else:
            return expr

        if lib is not None:
            fncs, series = lib
        else:
            fncs, series = _fncs, _series

        newargs = []
        for expr in exprs:
            # Try to simplify the expression
            if isinstance(expr, Mul):
                # Split the expression into a LIST of commutative and a LIST of non-commutative factor (i.e. operators).
                c, nc = expr.args_cnc()
                if nc and c:
                    # Construct an expression of commutative elements ONLY.
                    expr = Mul(*c).expand()
                    #out = find_expansion(expr, *rep_list)

                    eq = Poly(expr, *rep_list)
                    bdict = eq.as_dict()

                    if any([
                            n > 1 for n in
                        [sum([i != 0 for i in k]) for k in bdict.keys()]
                    ]):
                        raise ValueError(
                            "Expressions cross-products of symbols are not supported (yet?).."
                        )

                    # Construct the list of 'vectors'
                    vecl = []
                    fncl = []
                    for x in rep_list:
                        for n in range(3):  #range(eq.degree()-1):
                            X = pow(x, n)
                            vecl.extend([((X * p.subs(_s, x)).expand() +
                                          O(pow(x,
                                                eq.degree() + 1))).removeO()
                                         for p in series])
                            fncl.extend([X * f(x) for f in fncs])
                        vecl.extend(
                            [pow(x, n) for n in range(max(eq.degree(), 3))])
                        fncl.extend(
                            [pow(x, n) for n in range(max(eq.degree(), 3))])

                    # Create vector coefficients
                    q = symbols(f'q:{len(vecl)}')
                    # Take inner product of 'vector' list and vector coefficients
                    A = Add(*[x * y
                              for x, y in zip(q, vecl)]).as_poly(*rep_list)

                    terms = []
                    for k, eq in A.as_dict().items():
                        terms.append(eq - bdict.get(k, 0))
                    H = linsolve(terms, *q)
                    h = H.subs({k: 0 for k in q})

                    out = Add(*[c * fnc for fnc, c in zip(fncl, list(h)[0])])

                    newargs.append(out * Mul(*nc))
                else:
                    newargs.append(expr)
            else:
                newargs.append(expr)

        return Add(*newargs)

    except Exception as e:
        print("Failed to identify series expansions: " + str(e))
        return e