sympy/functions/elementary/complexes.py

   1
   2 from sympy.core.basic import Basic, S, C, sympify
   3 from sympy.core.function import Function
   4 from sympy.functions.elementary.miscellaneous import sqrt
   5
   6 ###############################################################################
   7 ######################### REAL and IMAGINARY PARTS ############################
   8 ###############################################################################
   9
  10 class re(Function):
  11     """Returns real part of expression. This function performs only
  12        elementary analysis and so it will fail to decompose properly
  13        more complicated expressions. If completely simplified result
  14        is needed then use Basic.as_real_imag() or perform complex
  15        expansion on instance of this function.
  16
  17        >>> from sympy import *
  18
  19        >>> x, y = symbols('x', 'y')
  20
  21        >>> re(2*E)
  22        2*E
  23
  24        >>> re(2*I + 17)
  25        17
  26
  27        >>> re(2*I)
  28        0
  29
  30        >>> re(im(x) + x*I + 2)
  31        2
  32
  33     """
  34
  35     nargs = 1
  36
  37     is_real = True
  38
  39     @classmethod
  40     def _eval_apply_subs(self, *args):
  41         return
  42
  43     @classmethod
  44     def canonize(cls, arg):
  45         if arg is S.NaN:
  46             return S.NaN
  47         elif arg.is_real:
  48             return arg
  49         else:
  50             if not arg.is_Add:
  51                 arg = [arg]
  52
  53             included, reverted, excluded = [], [], []
  54
  55             if isinstance(arg, Basic):
  56                 arg = arg.args
  57             for term in arg:
  58                 coeff = term.as_coefficient(S.ImaginaryUnit)
  59
  60                 if coeff is not None:
  61                     if not coeff.is_real:
  62                         reverted.append(coeff)
  63                 elif not term.has(S.ImaginaryUnit) and term.is_real:
  64                     excluded.append(term)
  65                 else:
  66                     included.append(term)
  67
  68             if len(arg[:]) != len(included):
  69                 a, b, c = map(lambda xs: C.Add(*xs),
  70                     [included, reverted, excluded])
  71
  72                 return cls(a) - im(b) + c
  73
  74     def _eval_conjugate(self):
  75         return self
  76
  77     def _eval_expand_complex(self, *args):
  78         return self.args[0].as_real_imag()[0]
  79
  80 class im(Function):
  81     """Returns imaginary part of expression. This function performs
  82        only elementary analysis and so it will fail to decompose
  83        properly more complicated expressions. If completely simplified
  84        result is needed then use Basic.as_real_imag() or perform complex
  85        expansion on instance of this function.
  86
  87        >>> from sympy import *
  88
  89        >>> x, y = symbols('x', 'y')
  90
  91        >>> im(2*E)
  92        0
  93
  94        >>> re(2*I + 17)
  95        17
  96
  97        >>> im(x*I)
  98        re(x)
  99
 100        >>> im(re(x) + y)
 101        im(y)
 102
 103     """
 104
 105     nargs = 1
 106
 107     is_real = True
 108
 109     @classmethod
 110     def _eval_apply_subs(self, *args):
 111         return
 112
 113     @classmethod
 114     def canonize(cls, arg):
 115         if arg is S.NaN:
 116             return S.NaN
 117         elif arg.is_real:
 118             return S.Zero
 119         else:
 120             if not arg.is_Add:
 121                 arg = [arg]
 122
 123             included, reverted, excluded = [], [], []
 124
 125             if isinstance(arg, Basic):
 126                 arg = arg.args
 127             for term in arg:
 128                 coeff = term.as_coefficient(S.ImaginaryUnit)
 129
 130                 if coeff is not None:
 131                     if not coeff.is_real:
 132                         reverted.append(coeff)
 133                     else:
 134                         excluded.append(coeff)
 135                 elif term.has(S.ImaginaryUnit) or not term.is_real:
 136                     included.append(term)
 137
 138             if len(arg[:]) != len(included):
 139                 a, b, c = map(lambda xs: C.Add(*xs),
 140                     [included, reverted, excluded])
 141
 142                 return cls(a) + re(b) + c
 143
 144     def _eval_conjugate(self):
 145         return self
 146
 147     def _eval_expand_complex(self, *args):
 148         return self.args[0].as_real_imag()[1]
 149
 150 ###############################################################################
 151 ############### SIGN, ABSOLUTE VALUE, ARGUMENT and CONJUGATION ################
 152 ###############################################################################
 153
 154 class sign(Function):
 155
 156     nargs = 1
 157
 158     @classmethod
 159     def canonize(cls, arg):
 160         if arg is S.NaN:
 161             return S.NaN
 162         if arg is S.Zero: return S.Zero
 163         if arg.is_positive: return S.One
 164         if arg.is_negative: return S.NegativeOne
 165         if arg.is_Mul:
 166             coeff, terms = arg.as_coeff_terms()
 167             if coeff is not S.One:
 168                 return cls(coeff) * cls(C.Mul(*terms))
 169
 170     is_bounded = True
 171
 172     def _eval_conjugate(self):
 173         return self
 174
 175     def _eval_is_zero(self):
 176         return (self[0] is S.Zero)
 177
 178 class abs(Function):
 179
 180     nargs = 1
 181
 182     is_real = True
 183     is_negative = False
 184
 185     def fdiff(self, argindex=1):
 186         if argindex == 1:
 187             return sign(self.args[0])
 188         else:
 189             raise ArgumentIndexError(self, argindex)
 190
 191     @classmethod
 192     def _eval_apply_subs(self, *args):
 193         return
 194
 195     @classmethod
 196     def canonize(cls, arg):
 197         if arg is S.NaN:
 198             return S.NaN
 199         if arg.is_zero:     return arg
 200         if arg.is_positive: return arg
 201         if arg.is_negative: return -arg
 202         coeff, terms = arg.as_coeff_terms()
 203         if coeff is not S.One:
 204             return cls(coeff) * cls(C.Mul(*terms))
 205         if arg.is_real is False:
 206             return sqrt( (arg * arg.conjugate()).expand() )
 207         if arg.is_Pow:
 208             base, exponent = arg.as_base_exp()
 209             if exponent.is_Number:
 210                 if exponent.is_even:
 211                     return arg
 212         return
 213
 214     @classmethod
 215     def _eval_apply_evalf(cls, arg):
 216         # XXX this is weird!!!
 217         # XXX remove me when 'abs -> abs_' is done
 218         arg = arg.evalf()
 219
 220         if arg.is_Number:
 221             import operator
 222             return operator.abs(float(arg))
 223
 224     def _eval_is_nonzero(self):
 225         return self._args[0].is_nonzero
 226
 227     def _eval_is_positive(self):
 228         return self.is_nonzero
 229
 230     def _eval_conjugate(self):
 231         return self
 232
 233     def _eval_power(self,other):
 234         if self.args[0].is_real and other.is_integer:
 235             if other.is_even:
 236                 return self.args[0]**other
 237         return
 238
 239     @staticmethod
 240     def taylor_term(n, x, *previous_terms):
 241         if n == 1:
 242             return x
 243         else:
 244             return S.Zero
 245
 246
 247     def _sage_(self):
 248         import sage.all as sage
 249         return sage.abs_symbolic(self.args[0]._sage_())
 250
 251 class arg(Function):
 252
 253     nargs = 1
 254
 255     is_real = True
 256     is_bounded = True
 257
 258     @classmethod
 259     def canonize(cls, arg):
 260         x, y = re(arg), im(arg)
 261         arg = C.atan2(y, x)
 262         if arg.is_number:
 263             return arg
 264
 265     def _eval_conjugate(self):
 266         return self
 267
 268 class conjugate(Function):
 269     """Changes the sign of the imaginary part of a complex number.
 270
 271         >>> from sympy import *
 272
 273         >>> conjugate(1 + I)
 274         1 - I
 275
 276     """
 277
 278     nargs = 1
 279
 280     @classmethod
 281     def canonize(cls, arg):
 282         obj = arg._eval_conjugate()
 283         if obj is not None:
 284             return obj
 285
 286     def _eval_conjugate(self):
 287         return self.args[0]
 288
 289
 290 # /cyclic/
 291 from sympy.core import basic as _
 292 _.abs_ = abs
 293 del _