sympy/core/add.py

   1
   2 from basic import Basic, S, C
   3 from operations import AssocOp
   4 from cache import cacheit
   5
   6 from symbol import Symbol, Wild, Temporary
   7 # from numbers import Number    /cyclic/
   8 # from mul import Mul    /cyclic/
   9 # from function import FunctionClass    /cyclic/
  10
  11 class Add(AssocOp):
  12
  13     __slots__ = []
  14
  15     is_Add = True
  16
  17     @classmethod
  18     def flatten(cls, seq):
  19         """
  20         Takes the sequence "seq" of nested Adds and returns a flatten list.
  21
  22         Returns: (commutative_part, noncommutative_part, order_symbols)
  23
  24         Applies associativity, all terms are commutable with respect to
  25         addition.
  26         """
  27         terms = {}      # term -> coeff
  28                         # e.g. x**2 -> 5   for ... + 5*x**2 + ...
  29
  30         coeff = S.Zero  # standalone term
  31                         # e.g. 3 + ...
  32         order_factors = []
  33
  34         for o in seq:
  35
  36             # O(x)
  37             if o.is_Order:
  38                 for o1 in order_factors:
  39                     if o1.contains(o):
  40                         o = None
  41                         break
  42                 if o is None:
  43                     continue
  44                 order_factors = [o]+[o1 for o1 in order_factors if not o.contains(o1)]
  45                 continue
  46
  47             # 3
  48             elif o.is_Number:
  49                 coeff += o
  50                 continue
  51
  52             # Add([...])
  53             elif o.is_Add:
  54                 # NB: here we assume Add is always commutative
  55                 seq.extend(o.args)  # TODO zerocopy?
  56                 continue
  57
  58             # Mul([...])
  59             elif o.is_Mul:
  60                 c = o.args[0]
  61
  62                 # 3*...
  63                 if c.is_Number:
  64                     if c is S.One:
  65                         s = o
  66                     else:
  67                         s = o.as_two_terms()[1]
  68
  69                 else:
  70                     c = S.One
  71                     s = o
  72
  73             # everything else
  74             else:
  75                 c = S.One
  76                 s = o
  77
  78
  79             # now we have:
  80             # o = c*s, where
  81             #
  82             # c is a Number
  83             # s is an expression with number factor extracted
  84
  85             # let's collect terms with the same s, so e.g.
  86             # 2*x**2 + 3*x**2  ->  5*x**2
  87             if s in terms:
  88                 terms[s] += c
  89             else:
  90                 terms[s] = c
  91
  92
  93         # now let's construct new args:
  94         # [2*x**2, x**3, 7*x**4, pi, ...]
  95         newseq = []
  96         noncommutative = False
  97         for s,c in terms.items():
  98             # 0*s
  99             if c is S.Zero:
 100                 continue
 101             # 1*s
 102             elif c is S.One:
 103                 newseq.append(s)
 104             # c*s
 105             else:
 106                 if s.is_Mul:
 107                     # Mul, already keeps it's arguments in perfect order.
 108                     # so we can simply put c in slot0 and go the fast way.
 109                     cs = s._new_rawargs(*((c,) + s.args))
 110                     newseq.append(cs)
 111
 112                 else:
 113                     # alternatively we have to call all Mul's machinery (slow)
 114                     newseq.append(Mul(c,s))
 115
 116             noncommutative = noncommutative or not s.is_commutative
 117
 118         # nan
 119         if coeff is S.NaN:
 120             # we know for sure the result will be nan
 121             return [S.NaN], [], None
 122
 123         # oo, -oo
 124         elif (coeff is S.Infinity) or (coeff is S.NegativeInfinity):
 125             newseq = [f for f in newseq if not f.is_real]
 126
 127
 128         # process O(x)
 129         if order_factors:
 130             newseq2 = []
 131             for t in newseq:
 132                 for o in order_factors:
 133                     if o.contains(t):
 134                         t = None
 135                         break
 136                 if t is not None:
 137                     newseq2.append(t)
 138             newseq = newseq2 + order_factors
 139
 140         # order args canonically
 141         # Currently we sort things using hashes, as it is quite fast. A better
 142         # solution is not to sort things at all - but this needs some more
 143         # fixing.
 144         newseq.sort(key=hash)
 145
 146         # current code expects coeff to be always in slot-0
 147         if coeff is not S.Zero:
 148             newseq.insert(0, coeff)
 149
 150         # we are done
 151         if noncommutative:
 152             return [], newseq, None
 153         else:
 154             return newseq, [], None
 155
 156
 157     @cacheit
 158     def as_coeff_factors(self, x=None):
 159         if x is not None:
 160             l1 = []
 161             l2 = []
 162             for f in self.args:
 163                 if f.has(x):
 164                     l2.append(f)
 165                 else:
 166                     l1.append(f)
 167             return Add(*l1), tuple(l2)
 168         coeff = self.args[0]
 169         if coeff.is_Number:
 170             return coeff, self.args[1:]
 171         return S.Zero, self.args
 172
 173     def _eval_derivative(self, s):
 174         return Add(*[f.diff(s) for f in self.args])
 175
 176     def nseries(self, x, x0, n):
 177         terms = [t.nseries(x, x0, n) for t in self.args]
 178         return Add(*terms)
 179
 180     def _matches_simple(pattern, expr, repl_dict):
 181         # handle (w+3).matches('x+5') -> {w: x+2}
 182         coeff, factors = pattern.as_coeff_factors()
 183         if len(factors)==1:
 184             return factors[0].matches(expr - coeff, repl_dict)
 185         return
 186
 187     matches = AssocOp._matches_commutative
 188
 189     @staticmethod
 190     def _combine_inverse(lhs, rhs):
 191         return lhs - rhs
 192
 193     @cacheit
 194     def as_two_terms(self):
 195         if len(self.args) == 1:
 196             return S.Zero, self
 197         return self.args[0], Add(*self.args[1:])
 198
 199     def as_numer_denom(self):
 200         numers, denoms = [],[]
 201         for n,d in [f.as_numer_denom() for f in self.args]:
 202             numers.append(n)
 203             denoms.append(d)
 204         r = xrange(len(numers))
 205         return Add(*[Mul(*(denoms[:i]+[numers[i]]+denoms[i+1:])) for i in r]),Mul(*denoms)
 206
 207     def count_ops(self, symbolic=True):
 208         if symbolic:
 209             return Add(*[t.count_ops(symbolic) for t in self[:]]) + Symbol('ADD') * (len(self[:])-1)
 210         return Add(*[t.count_ops(symbolic) for t in self.args[:]]) + (len(self.args[:])-1)
 211
 212     def _eval_is_polynomial(self, syms):
 213         for term in self.args:
 214             if not term._eval_is_polynomial(syms):
 215                 return False
 216         return True
 217
 218     # assumption methods
 219     _eval_is_real = lambda self: self._eval_template_is_attr('is_real')
 220     _eval_is_bounded = lambda self: self._eval_template_is_attr('is_bounded')
 221     _eval_is_commutative = lambda self: self._eval_template_is_attr('is_commutative')
 222     _eval_is_integer = lambda self: self._eval_template_is_attr('is_integer')
 223     _eval_is_comparable = lambda self: self._eval_template_is_attr('is_comparable')
 224
 225     def _eval_is_odd(self):
 226         l = [f for f in self.args if not (f.is_even==True)]
 227         if not l:
 228             return False
 229         if l[0].is_odd:
 230             return Add(*l[1:]).is_even
 231
 232     def _eval_is_irrational(self):
 233         for t in self.args:
 234             a = t.is_irrational
 235             if a: return True
 236             if a is None: return
 237         return False
 238
 239     def _eval_is_positive(self):
 240         c = self.args[0]
 241         r = Add(*self.args[1:])
 242         if c.is_positive and r.is_positive:
 243             return True
 244         if c.is_unbounded:
 245             if r.is_unbounded:
 246                 # either c or r is negative
 247                 return
 248             else:
 249                 return c.is_positive
 250         elif r.is_unbounded:
 251             return r.is_positive
 252         if c.is_nonnegative and r.is_positive:
 253             return True
 254         if r.is_nonnegative and c.is_positive:
 255             return True
 256         if c.is_nonpositive and r.is_nonpositive:
 257             return False
 258
 259     def _eval_is_negative(self):
 260         c = self.args[0]
 261         r = Add(*self.args[1:])
 262         if c.is_negative and r.is_negative:
 263             return True
 264         if c.is_unbounded:
 265             if r.is_unbounded:
 266                 # either c or r is positive
 267                 return
 268             else:
 269                 return c.is_negative
 270         elif r.is_unbounded:
 271             return r.is_negative
 272         if c.is_nonpositive and r.is_negative:
 273             return True
 274         if r.is_nonpositive and c.is_negative:
 275             return True
 276         if c.is_nonnegative and r.is_nonnegative:
 277             return False
 278
 279     def as_coeff_terms(self, x=None):
 280         # -2 + 2 * a -> -1, 2-2*a
 281         if self.args[0].is_Number and self.args[0].is_negative:
 282             return -S.One,(-self,)
 283         return S.One,(self,)
 284
 285     def _eval_subs(self, old, new):
 286         if self==old: return new
 287         if isinstance(old, FunctionClass):
 288             return self.__class__(*[s.subs(old, new) for s in self.args ])
 289         coeff1,factors1 = self.as_coeff_factors()
 290         coeff2,factors2 = old.as_coeff_factors()
 291         if factors1==factors2: # (2+a).subs(3+a,y) -> 2-3+y
 292             return new + coeff1 - coeff2
 293         if old.is_Add:
 294             l1,l2 = len(factors1),len(factors2)
 295             if l2<l1: # (a+b+c+d).subs(b+c,x) -> a+x+d
 296                 for i in xrange(l1-l2+1):
 297                     if factors2==factors1[i:i+l2]:
 298                         factors1 = list(factors1)
 299                         factors2 = list(factors2)
 300                         return Add(*([coeff1-coeff2]+factors1[:i]+[new]+factors1[i+l2:]))
 301         return self.__class__(*[s.subs(old, new) for s in self.args])
 302
 303     def _eval_oseries(self, order):
 304         return Add(*[f.oseries(order) for f in self.args])
 305
 306     @cacheit
 307     def extract_leading_order(self, *symbols):
 308         lst = []
 309         seq = [(f, C.Order(f, *symbols)) for f in self.args]
 310         for ef,of in seq:
 311             for e,o in lst:
 312                 if o.contains(of):
 313                     of = None
 314                     break
 315             if of is None:
 316                 continue
 317             new_lst = [(ef,of)]
 318             for e,o in lst:
 319                 if of.contains(o):
 320                     continue
 321                 new_lst.append((e,o))
 322             lst = new_lst
 323         return tuple(lst)
 324
 325     def _eval_as_leading_term(self, x):
 326         coeff, factors = self.as_coeff_factors(x)
 327         has_unbounded = bool([f for f in self.args if f.is_unbounded])
 328         if has_unbounded:
 329             if isinstance(factors, Basic):
 330                 factors = factors.args
 331             factors = [f for f in factors if not f.is_bounded]
 332         if coeff is not S.Zero:
 333             o = C.Order(x)
 334         else:
 335             o = C.Order(factors[0]*x,x)
 336         s = self.oseries(o)
 337         while s is S.Zero:
 338             o *= x
 339             s = self.oseries(o)
 340         if s.is_Add:
 341             lst = s.extract_leading_order(x)
 342             return Add(*[e for (e,f) in lst])
 343         return s.as_leading_term(x)
 344
 345     def _eval_conjugate(self):
 346         return Add(*[t.conjugate() for t in self.args])
 347
 348     def __neg__(self):
 349         return Add(*[-t for t in self.args])
 350
 351     def _sage_(self):
 352         s = 0
 353         for x in self.args:
 354             s += x._sage_()
 355         return s
 356
 357
 358 # /cyclic/
 359 import basic as _
 360 _.Add       = Add
 361 del _
 362
 363 import mul as _
 364 _.Add       = Add
 365 del _
 366
 367 import power as _
 368 _.Add       = Add
 369 del _
 370
 371 import operations as _
 372 _.Add       = Add
 373 del _