(exprs, opt)
return polys, tuple(gens)
Transform expressions into a multinomial form and figure out generators.
Transform expressions into a multinomial form and figure out generators.
Transform expressions into a multinomial form and figure out generators .
def _parallel_dict_from_expr_no_gens(exprs, opt):
    """Transform expressions into a multinomial form and figure out generators. """
    if opt.domain is not None:
        def _is_coeff(factor):
            return factor in opt.domain
    elif opt.extension is True:
        def _is_coeff(factor):
            return ask(Q.algebraic(factor))
    elif opt.greedy is not False:
        def _is_coeff(factor):
            return False
    else:
        def _is_coeff(factor):
            return factor.is_number

    gens, reprs = set([]), []

    for expr in exprs:
        terms = []

        if expr.is_Equality:
            expr = expr.lhs - expr.rhs

        for term in Add.make_args(expr):
            coeff, elements = [], {}

            for factor in Mul.make_args(term):
                if not _not_a_coeff(factor) and (factor.is_Number or _is_coeff(factor)):
                    coeff.append(factor)
                else:
                    base, exp = decompose_power(factor)

                    if exp < 0:
                        exp, base = -exp, Pow(base, -S.One)

                    elements[base] = exp
                    gens.add(base)

            terms.append((coeff, elements))

        reprs.append(terms)

    if not gens:
        if len(exprs) == 1:
            arg = exprs[0]
        else:
            arg = (exprs,)

        raise GeneratorsNeeded("specify generators to give %s a meaning" % arg)

    gens = _sort_gens(gens, opt=opt)
    k, indices = len(gens), {}

    for i, g in enumerate(gens):
        indices[g] = i

    polys = []

    for terms in reprs:
        poly = {}

        for coeff, term in terms:
            monom = [0]*k

            for base, exp in term.items():
                monom[indices[base]] = exp

            monom = tuple(monom)

            if monom in poly:
                poly[monom] += Mul(*coeff)
            else:
                poly[monom] = Mul(*coeff)

        polys.append(poly)

    return polys, tuple(gens)
def _parallel_dict_from_expr_no_gens ( exprs , opt ) : if opt . domain is not None : def _is_coeff ( factor ) : return factor in opt . domain elif opt . extension is True : def _is_coeff ( factor ) : return ask ( Q . algebraic ( factor ) ) elif opt . greedy is not False : def _is_coeff ( factor ) : return False else : def _is_coeff ( factor ) : return factor . is_number gens , reprs = set ( [ ] ) , [ ] for expr in exprs : terms = [ ] if expr . is_Equality : expr = expr . lhs - expr . rhs for term in Add . make_args ( expr ) : coeff , elements = [ ] , { } for factor in Mul . make_args ( term ) : if not _not_a_coeff ( factor ) and ( factor . is_Number or _is_coeff ( factor ) ) : coeff . append ( factor ) else : base , exp = decompose_power ( factor ) if exp < 0 : exp , base = - exp , Pow ( base , - S . One ) elements [ base ] = exp gens . add ( base ) terms . append ( ( coeff , elements ) ) reprs . append ( terms ) if not gens : if len ( exprs ) == 1 : arg = exprs [ 0 ] else : arg = ( exprs , ) raise GeneratorsNeeded ( "specify generators to give %s a meaning" % arg ) gens = _sort_gens ( gens , opt = opt ) k , indices = len ( gens ) , { } for i , g in enumerate ( gens ) : indices [ g ] = i polys = [ ] for terms in reprs : poly = { } for coeff , term in terms : monom = [ 0 ] * k for base , exp in term . items ( ) : monom [ indices [ base ] ] = exp monom = tuple ( monom ) if monom in poly : poly [ monom ] += Mul ( * coeff ) else : poly [ monom ] = Mul ( * coeff ) polys . append ( poly ) return polys , tuple ( gens )