Coverage for sympy/core/add.py : 74%

from __future__ import print_function, division 

from collections import defaultdict 

from functools import cmp_to_key 

from .basic import Basic 

from .compatibility import reduce, is_sequence, range 

from .logic import _fuzzy_group, fuzzy_or, fuzzy_not 

from .singleton import S 

from .operations import AssocOp 

from .cache import cacheit 

from .numbers import ilcm, igcd 

from .expr import Expr 

# Key for sorting commutative args in canonical order 

_args_sortkey = cmp_to_key(Basic.compare) 

def _addsort(args): 

# in-place sorting of args 

args.sort(key=_args_sortkey) 

def _unevaluated_Add(*args): 

"""Return a well-formed unevaluated Add: Numbers are collected and 

put in slot 0 and args are sorted. Use this when args have changed 

but you still want to return an unevaluated Add. 

Examples 

======== 

>>> from sympy.core.add import _unevaluated_Add as uAdd 

>>> from sympy import S, Add 

>>> from sympy.abc import x, y 

>>> a = uAdd(*[S(1.0), x, S(2)]) 

>>> a.args[0] 

3.00000000000000 

>>> a.args[1] 

x 

Beyond the Number being in slot 0, there is no other assurance of 

order for the arguments since they are hash sorted. So, for testing 

purposes, output produced by this in some other function can only 

be tested against the output of this function or as one of several 

options: 

>>> opts = (Add(x, y, evaluated=False), Add(y, x, evaluated=False)) 

>>> a = uAdd(x, y) 

>>> assert a in opts and a == uAdd(x, y) 

""" 

args = list(args) 

newargs = [] 

co = S.Zero 

while args: 

a = args.pop() 

if a.is_Add: 

# this will keep nesting from building up 

# so that x + (x + 1) -> x + x + 1 (3 args) 

args.extend(a.args) 

elif a.is_Number: 

co += a 

else: 

newargs.append(a) 

_addsort(newargs) 

if co: 

newargs.insert(0, co) 

return Add._from_args(newargs) 

class Add(Expr, AssocOp): 

__slots__ = [] 

is_Add = True 

@classmethod 

def flatten(cls, seq): 

""" 

Takes the sequence "seq" of nested Adds and returns a flatten list. 

Returns: (commutative_part, noncommutative_part, order_symbols) 

Applies associativity, all terms are commutable with respect to 

addition. 

NB: the removal of 0 is already handled by AssocOp.__new__ 

See also 

======== 

sympy.core.mul.Mul.flatten 

""" 

from sympy.calculus.util import AccumBounds 

rv = None 

if len(seq) == 2: 

a, b = seq 

if b.is_Rational: 

a, b = b, a 

if a.is_Rational: 

if b.is_Mul: 

rv = [a, b], [], None 

if rv: 

if all(s.is_commutative for s in rv[0]): 

return rv 

return [], rv[0], None 

terms = {} # term -> coeff 

# e.g. x**2 -> 5 for ... + 5*x**2 + ... 

coeff = S.Zero # coefficient (Number or zoo) to always be in slot 0 

# e.g. 3 + ... 

order_factors = [] 

for o in seq: 

# O(x) 

if o.is_Order: 

for o1 in order_factors: 

if o1.contains(o): 

o = None 

break 

if o is None: 

continue 

order_factors = [o] + [ 

o1 for o1 in order_factors if not o.contains(o1)] 

continue 

# 3 or NaN 

elif o.is_Number: 

if (o is S.NaN or coeff is S.ComplexInfinity and 

o.is_finite is False): 

# we know for sure the result will be nan 

return [S.NaN], [], None 

if coeff.is_Number: 

coeff += o 

if coeff is S.NaN: 

# we know for sure the result will be nan 

return [S.NaN], [], None 

continue 

elif isinstance(o, AccumBounds): 

coeff = o.__add__(coeff) 

continue 

elif o is S.ComplexInfinity: 

if coeff.is_finite is False: 

# we know for sure the result will be nan 

return [S.NaN], [], None 

coeff = S.ComplexInfinity 

continue 

# Add([...]) 

elif o.is_Add: 

# NB: here we assume Add is always commutative 

seq.extend(o.args) # TODO zerocopy? 

continue 

# Mul([...]) 

elif o.is_Mul: 

c, s = o.as_coeff_Mul() 

# check for unevaluated Pow, e.g. 2**3 or 2**(-1/2) 

elif o.is_Pow: 

b, e = o.as_base_exp() 

if b.is_Number and (e.is_Integer or 

(e.is_Rational and e.is_negative)): 

seq.append(b**e) 

continue 

c, s = S.One, o 

else: 

# everything else 

c = S.One 

s = o 

# now we have: 

# o = c*s, where 

# 

# c is a Number 

# s is an expression with number factor extracted 

# let's collect terms with the same s, so e.g. 

# 2*x**2 + 3*x**2 -> 5*x**2 

if s in terms: 

terms[s] += c 

if terms[s] is S.NaN: 

# we know for sure the result will be nan 

return [S.NaN], [], None 

else: 

terms[s] = c 

# now let's construct new args: 

# [2*x**2, x**3, 7*x**4, pi, ...] 

newseq = [] 

noncommutative = False 

for s, c in terms.items(): 

# 0*s 

if c is S.Zero: 

continue 

# 1*s 

elif c is S.One: 

newseq.append(s) 

# c*s 

else: 

if s.is_Mul: 

# Mul, already keeps its arguments in perfect order. 

# so we can simply put c in slot0 and go the fast way. 

cs = s._new_rawargs(*((c,) + s.args)) 

newseq.append(cs) 

elif s.is_Add: 

# we just re-create the unevaluated Mul 

newseq.append(Mul(c, s, evaluate=False)) 

else: 

# alternatively we have to call all Mul's machinery (slow) 

newseq.append(Mul(c, s)) 

noncommutative = noncommutative or not s.is_commutative 

# oo, -oo 

if coeff is S.Infinity: 

newseq = [f for f in newseq if not 

(f.is_nonnegative or f.is_real and f.is_finite)] 

elif coeff is S.NegativeInfinity: 

newseq = [f for f in newseq if not 

(f.is_nonpositive or f.is_real and f.is_finite)] 

if coeff is S.ComplexInfinity: 

# zoo might be 

# infinite_real + finite_im 

# finite_real + infinite_im 

# infinite_real + infinite_im 

# addition of a finite real or imaginary number won't be able to 

# change the zoo nature; adding an infinite qualtity would result 

# in a NaN condition if it had sign opposite of the infinite 

# portion of zoo, e.g., infinite_real - infinite_real. 

newseq = [c for c in newseq if not (c.is_finite and 

c.is_real is not None)] 

# process O(x) 

if order_factors: 

newseq2 = [] 

for t in newseq: 

for o in order_factors: 

# x + O(x) -> O(x) 

if o.contains(t): 

t = None 

break 

# x + O(x**2) -> x + O(x**2) 

if t is not None: 

newseq2.append(t) 

newseq = newseq2 + order_factors 

# 1 + O(1) -> O(1) 

for o in order_factors: 

if o.contains(coeff): 

coeff = S.Zero 

break 

# order args canonically 

_addsort(newseq) 

# current code expects coeff to be first 

if coeff is not S.Zero: 

newseq.insert(0, coeff) 

# we are done 

if noncommutative: 

return [], newseq, None 

else: 

return newseq, [], None 

@classmethod 

def class_key(cls): 

"""Nice order of classes""" 

return 3, 1, cls.__name__ 

def as_coefficients_dict(a): 

"""Return a dictionary mapping terms to their Rational coefficient. 

Since the dictionary is a defaultdict, inquiries about terms which 

were not present will return a coefficient of 0. If an expression is 

not an Add it is considered to have a single term. 

Examples 

======== 

>>> from sympy.abc import a, x 

>>> (3*x + a*x + 4).as_coefficients_dict() 

{1: 4, x: 3, a*x: 1} 

>>> _[a] 

0 

>>> (3*a*x).as_coefficients_dict() 

{a*x: 3} 

""" 

d = defaultdict(list) 

for ai in a.args: 

c, m = ai.as_coeff_Mul() 

d[m].append(c) 

for k, v in d.items(): 

if len(v) == 1: 

d[k] = v[0] 

else: 

d[k] = Add(*v) 

di = defaultdict(int) 

di.update(d) 

return di 

@cacheit 

def as_coeff_add(self, *deps): 

""" 

Returns a tuple (coeff, args) where self is treated as an Add and coeff 

is the Number term and args is a tuple of all other terms. 

Examples 

======== 

>>> from sympy.abc import x 

>>> (7 + 3*x).as_coeff_add() 

(7, (3*x,)) 

>>> (7*x).as_coeff_add() 

(0, (7*x,)) 

""" 

if deps: 

l1 = [] 

l2 = [] 

for f in self.args: 

if f.has(*deps): 

l2.append(f) 

else: 

l1.append(f) 

return self._new_rawargs(*l1), tuple(l2) 

coeff, notrat = self.args[0].as_coeff_add() 

if coeff is not S.Zero: 

return coeff, notrat + self.args[1:] 

return S.Zero, self.args 

def as_coeff_Add(self, rational=False): 

"""Efficiently extract the coefficient of a summation. """ 

coeff, args = self.args[0], self.args[1:] 

if coeff.is_Number and not rational or coeff.is_Rational: 

return coeff, self._new_rawargs(*args) 

return S.Zero, self 

# Note, we intentionally do not implement Add.as_coeff_mul(). Rather, we 

# let Expr.as_coeff_mul() just always return (S.One, self) for an Add. See 

# issue 5524. 

@cacheit 

def _eval_derivative(self, s): 

return self.func(*[a.diff(s) for a in self.args]) 

def _eval_nseries(self, x, n, logx): 

terms = [t.nseries(x, n=n, logx=logx) for t in self.args] 

return self.func(*terms) 

def _matches_simple(self, expr, repl_dict): 

# handle (w+3).matches('x+5') -> {w: x+2} 

coeff, terms = self.as_coeff_add() 

if len(terms) == 1: 

return terms[0].matches(expr - coeff, repl_dict) 

return 

def matches(self, expr, repl_dict={}, old=False): 

return AssocOp._matches_commutative(self, expr, repl_dict, old) 

@staticmethod 

def _combine_inverse(lhs, rhs): 

""" 

Returns lhs - rhs, but treats arguments like symbols, so things like 

oo - oo return 0, instead of a nan. 

""" 

from sympy import oo, I, expand_mul 

if lhs == oo and rhs == oo or lhs == oo*I and rhs == oo*I: 

return S.Zero 

return expand_mul(lhs - rhs) 

@cacheit 

def as_two_terms(self): 

"""Return head and tail of self. 

This is the most efficient way to get the head and tail of an 

expression. 

- if you want only the head, use self.args[0]; 

- if you want to process the arguments of the tail then use 

self.as_coef_add() which gives the head and a tuple containing 

the arguments of the tail when treated as an Add. 

- if you want the coefficient when self is treated as a Mul 

then use self.as_coeff_mul()[0] 

>>> from sympy.abc import x, y 

>>> (3*x*y).as_two_terms() 

(3, x*y) 

""" 

if len(self.args) == 1: 

return S.Zero, self 

return self.args[0], self._new_rawargs(*self.args[1:]) 

def as_numer_denom(self): 

# clear rational denominator 

content, expr = self.primitive() 

ncon, dcon = content.as_numer_denom() 

# collect numerators and denominators of the terms 

nd = defaultdict(list) 

for f in expr.args: 

ni, di = f.as_numer_denom() 

nd[di].append(ni) 

# put infinity in the numerator 

if S.Zero in nd: 

n = nd.pop(S.Zero) 

assert len(n) == 1 

n = n[0] 

nd[S.One].append(n/S.Zero) 

# check for quick exit 

if len(nd) == 1: 

d, n = nd.popitem() 

return self.func( 

*[_keep_coeff(ncon, ni) for ni in n]), _keep_coeff(dcon, d) 

# sum up the terms having a common denominator 

for d, n in nd.items(): 

if len(n) == 1: 

nd[d] = n[0] 

else: 

nd[d] = self.func(*n) 

# assemble single numerator and denominator 

denoms, numers = [list(i) for i in zip(*iter(nd.items()))] 

n, d = self.func(*[Mul(*(denoms[:i] + [numers[i]] + denoms[i + 1:])) 

for i in range(len(numers))]), Mul(*denoms) 

return _keep_coeff(ncon, n), _keep_coeff(dcon, d) 

def _eval_is_polynomial(self, syms): 

return all(term._eval_is_polynomial(syms) for term in self.args) 

def _eval_is_rational_function(self, syms): 

return all(term._eval_is_rational_function(syms) for term in self.args) 

def _eval_is_algebraic_expr(self, syms): 

return all(term._eval_is_algebraic_expr(syms) for term in self.args) 

# assumption methods 

_eval_is_real = lambda self: _fuzzy_group( 

(a.is_real for a in self.args), quick_exit=True) 

_eval_is_complex = lambda self: _fuzzy_group( 

(a.is_complex for a in self.args), quick_exit=True) 

_eval_is_antihermitian = lambda self: _fuzzy_group( 

(a.is_antihermitian for a in self.args), quick_exit=True) 

_eval_is_finite = lambda self: _fuzzy_group( 

(a.is_finite for a in self.args), quick_exit=True) 

_eval_is_hermitian = lambda self: _fuzzy_group( 

(a.is_hermitian for a in self.args), quick_exit=True) 

_eval_is_integer = lambda self: _fuzzy_group( 

(a.is_integer for a in self.args), quick_exit=True) 

_eval_is_rational = lambda self: _fuzzy_group( 

(a.is_rational for a in self.args), quick_exit=True) 

_eval_is_algebraic = lambda self: _fuzzy_group( 

(a.is_algebraic for a in self.args), quick_exit=True) 

_eval_is_commutative = lambda self: _fuzzy_group( 

a.is_commutative for a in self.args) 

def _eval_is_imaginary(self): 

nz = [] 

im_I = [] 

for a in self.args: 

if a.is_real: 

if a.is_zero: 

pass 

elif a.is_zero is False: 

nz.append(a) 

else: 

return 

elif a.is_imaginary: 

im_I.append(a*S.ImaginaryUnit) 

elif (S.ImaginaryUnit*a).is_real: 

im_I.append(a*S.ImaginaryUnit) 

else: 

return 

if self.func(*nz).is_zero: 

return fuzzy_not(self.func(*im_I).is_zero) 

elif self.func(*nz).is_zero is False: 

return False 

def _eval_is_zero(self): 

if self.is_commutative is False: 

# issue 10528: there is no way to know if a nc symbol 

# is zero or not 

return 

nz = [] 

z = 0 

im_or_z = False 

im = False 

for a in self.args: 

if a.is_real: 

if a.is_zero: 

z += 1 

elif a.is_zero is False: 

nz.append(a) 

else: 

return 

elif a.is_imaginary: 

im = True 

elif (S.ImaginaryUnit*a).is_real: 

im_or_z = True 

else: 

return 

if z == len(self.args): 

return True 

if self.func(*nz).is_zero: 

if not im_or_z and not im: 

return True 

if im and not im_or_z: 

return False 

if self.func(*nz).is_zero is False: 

return False 

def _eval_is_odd(self): 

l = [f for f in self.args if not (f.is_even is True)] 

if not l: 

return False 

if l[0].is_odd: 

return self._new_rawargs(*l[1:]).is_even 

def _eval_is_irrational(self): 

for t in self.args: 

a = t.is_irrational 

if a: 

others = list(self.args) 

others.remove(t) 

if all(x.is_rational is True for x in others): 

return True 

return None 

if a is None: 

return 

return False 

def _eval_is_positive(self): 

from sympy.core.exprtools import _monotonic_sign 

if self.is_number: 

return super(Add, self)._eval_is_positive() 

c, a = self.as_coeff_Add() 

if not c.is_zero: 

v = _monotonic_sign(a) 

if v is not None: 

s = v + c 

if s.is_positive and a.is_nonnegative: 

return True 

if len(self.free_symbols) == 1: 

v = _monotonic_sign(self) 

if v is not None and v.is_positive: 

return True 

pos = nonneg = nonpos = unknown_sign = False 

saw_INF = set() 

args = [a for a in self.args if not a.is_zero] 

if not args: 

return False 

for a in args: 

ispos = a.is_positive 

infinite = a.is_infinite 

if infinite: 

saw_INF.add(fuzzy_or((ispos, a.is_nonnegative))) 

if True in saw_INF and False in saw_INF: 

return 

if ispos: 

pos = True 

continue 

elif a.is_nonnegative: 

nonneg = True 

continue 

elif a.is_nonpositive: 

nonpos = True 

continue 

if infinite is None: 

return 

unknown_sign = True 

if saw_INF: 

if len(saw_INF) > 1: 

return 

return saw_INF.pop() 

elif unknown_sign: 

return 

elif not nonpos and not nonneg and pos: 

return True 

elif not nonpos and pos: 

return True 

elif not pos and not nonneg: 

return False 

def _eval_is_nonnegative(self): 

from sympy.core.exprtools import _monotonic_sign 

if not self.is_number: 

c, a = self.as_coeff_Add() 

if not c.is_zero and a.is_nonnegative: 

v = _monotonic_sign(a) 

if v is not None: 

s = v + c 

if s.is_nonnegative: 

return True 

if len(self.free_symbols) == 1: 

v = _monotonic_sign(self) 

if v is not None and v.is_nonnegative: 

return True 

def _eval_is_nonpositive(self): 

from sympy.core.exprtools import _monotonic_sign 

if not self.is_number: 

c, a = self.as_coeff_Add() 

if not c.is_zero and a.is_nonpositive: 

v = _monotonic_sign(a) 

if v is not None: 

s = v + c 

if s.is_nonpositive: 

return True 

if len(self.free_symbols) == 1: 

v = _monotonic_sign(self) 

if v is not None and v.is_nonpositive: 

return True 

def _eval_is_negative(self): 

from sympy.core.exprtools import _monotonic_sign 

if self.is_number: 

return super(Add, self)._eval_is_negative() 

c, a = self.as_coeff_Add() 

if not c.is_zero: 

v = _monotonic_sign(a) 

if v is not None: 

s = v + c 

if s.is_negative and a.is_nonpositive: 

return True 

if len(self.free_symbols) == 1: 

v = _monotonic_sign(self) 

if v is not None and v.is_negative: 

return True 

neg = nonpos = nonneg = unknown_sign = False 

saw_INF = set() 

args = [a for a in self.args if not a.is_zero] 

if not args: 

return False 

for a in args: 

isneg = a.is_negative 

infinite = a.is_infinite 

if infinite: 

saw_INF.add(fuzzy_or((isneg, a.is_nonpositive))) 

if True in saw_INF and False in saw_INF: 

return 

if isneg: 

neg = True 

continue 

elif a.is_nonpositive: 

nonpos = True 

continue 

elif a.is_nonnegative: 

nonneg = True 

continue 

if infinite is None: 

return 

unknown_sign = True 

if saw_INF: 

if len(saw_INF) > 1: 

return 

return saw_INF.pop() 

elif unknown_sign: 

return 

elif not nonneg and not nonpos and neg: 

return True 

elif not nonneg and neg: 

return True 

elif not neg and not nonpos: 

return False 

def _eval_subs(self, old, new): 

if not old.is_Add: 

return None 

coeff_self, terms_self = self.as_coeff_Add() 

coeff_old, terms_old = old.as_coeff_Add() 

if coeff_self.is_Rational and coeff_old.is_Rational: 

if terms_self == terms_old: # (2 + a).subs( 3 + a, y) -> -1 + y 

return self.func(new, coeff_self, -coeff_old) 

if terms_self == -terms_old: # (2 + a).subs(-3 - a, y) -> -1 - y 

return self.func(-new, coeff_self, coeff_old) 

if coeff_self.is_Rational and coeff_old.is_Rational \ 

or coeff_self == coeff_old: 

args_old, args_self = self.func.make_args( 

terms_old), self.func.make_args(terms_self) 

if len(args_old) < len(args_self): # (a+b+c).subs(b+c,x) -> a+x 

self_set = set(args_self) 

old_set = set(args_old) 

if old_set < self_set: 

ret_set = self_set - old_set 

return self.func(new, coeff_self, -coeff_old, 

*[s._subs(old, new) for s in ret_set]) 

args_old = self.func.make_args( 

-terms_old) # (a+b+c+d).subs(-b-c,x) -> a-x+d 

old_set = set(args_old) 

if old_set < self_set: 

ret_set = self_set - old_set 

return self.func(-new, coeff_self, coeff_old, 

*[s._subs(old, new) for s in ret_set]) 

def removeO(self): 

args = [a for a in self.args if not a.is_Order] 

return self._new_rawargs(*args) 

def getO(self): 

args = [a for a in self.args if a.is_Order] 

if args: 

return self._new_rawargs(*args) 

@cacheit 

def extract_leading_order(self, symbols, point=None): 

""" 

Returns the leading term and its order. 

Examples 

======== 

>>> from sympy.abc import x 

>>> (x + 1 + 1/x**5).extract_leading_order(x) 

((x**(-5), O(x**(-5))),) 

>>> (1 + x).extract_leading_order(x) 

((1, O(1)),) 

>>> (x + x**2).extract_leading_order(x) 

((x, O(x)),) 

""" 

from sympy import Order 

lst = [] 

symbols = list(symbols if is_sequence(symbols) else [symbols]) 

if not point: 

point = [0]*len(symbols) 

seq = [(f, Order(f, *zip(symbols, point))) for f in self.args] 

for ef, of in seq: 

for e, o in lst: 

if o.contains(of) and o != of: 

of = None 

break 

if of is None: 

continue 

new_lst = [(ef, of)] 

for e, o in lst: 

if of.contains(o) and o != of: 

continue 

new_lst.append((e, o)) 

lst = new_lst 

return tuple(lst) 

def as_real_imag(self, deep=True, **hints): 

""" 

returns a tuple representing a complex number 

Examples 

======== 

>>> from sympy import I 

>>> (7 + 9*I).as_real_imag() 

(7, 9) 

>>> ((1 + I)/(1 - I)).as_real_imag() 

(0, 1) 

>>> ((1 + 2*I)*(1 + 3*I)).as_real_imag() 

(-5, 5) 

""" 

sargs, terms = self.args, [] 

re_part, im_part = [], [] 

for term in sargs: 

re, im = term.as_real_imag(deep=deep) 

re_part.append(re) 

im_part.append(im) 

return (self.func(*re_part), self.func(*im_part)) 

def _eval_as_leading_term(self, x): 

from sympy import expand_mul, factor_terms 

old = self 

expr = expand_mul(self) 

if not expr.is_Add: 

return expr.as_leading_term(x) 

infinite = [t for t in expr.args if t.is_infinite] 

expr = expr.func(*[t.as_leading_term(x) for t in expr.args]).removeO() 

if not expr: 

# simple leading term analysis gave us 0 but we have to send 

# back a term, so compute the leading term (via series) 

return old.compute_leading_term(x) 

elif expr is S.NaN: 

return old.func._from_args(infinite) 

elif not expr.is_Add: 

return expr 

else: 

plain = expr.func(*[s for s, _ in expr.extract_leading_order(x)]) 

rv = factor_terms(plain, fraction=False) 

rv_simplify = rv.simplify() 

# if it simplifies to an x-free expression, return that; 

# tests don't fail if we don't but it seems nicer to do this 

if x not in rv_simplify.free_symbols: 

if rv_simplify.is_zero and plain.is_zero is not True: 

return (expr - plain)._eval_as_leading_term(x) 

return rv_simplify 

return rv 

def _eval_adjoint(self): 

return self.func(*[t.adjoint() for t in self.args]) 

def _eval_conjugate(self): 

return self.func(*[t.conjugate() for t in self.args]) 

def _eval_transpose(self): 

return self.func(*[t.transpose() for t in self.args]) 

def __neg__(self): 

return self.func(*[-t for t in self.args]) 

def _sage_(self): 

s = 0 

for x in self.args: 

s += x._sage_() 

return s 

def primitive(self): 

""" 

Return ``(R, self/R)`` where ``R``` is the Rational GCD of ``self```. 

``R`` is collected only from the leading coefficient of each term. 

Examples 

======== 

>>> from sympy.abc import x, y 

>>> (2*x + 4*y).primitive() 

(2, x + 2*y) 

>>> (2*x/3 + 4*y/9).primitive() 

(2/9, 3*x + 2*y) 

>>> (2*x/3 + 4.2*y).primitive() 

(1/3, 2*x + 12.6*y) 

No subprocessing of term factors is performed: 

>>> ((2 + 2*x)*x + 2).primitive() 

(1, x*(2*x + 2) + 2) 

Recursive subprocessing can be done with the as_content_primitive() 

method: 

>>> ((2 + 2*x)*x + 2).as_content_primitive() 

(2, x*(x + 1) + 1) 

See also: primitive() function in polytools.py 

""" 

terms = [] 

inf = False 

for a in self.args: 

c, m = a.as_coeff_Mul() 

if not c.is_Rational: 

c = S.One 

m = a 

inf = inf or m is S.ComplexInfinity 

terms.append((c.p, c.q, m)) 

if not inf: 

ngcd = reduce(igcd, [t[0] for t in terms], 0) 

dlcm = reduce(ilcm, [t[1] for t in terms], 1) 

else: 

ngcd = reduce(igcd, [t[0] for t in terms if t[1]], 0)