sympy/functions/elementary/trigonometric.py

   1
   2 from sympy.core.basic import Basic, S, cache_it, cache_it_immutable
   3 from sympy.core.function import DefinedFunction, Apply, Lambda, SingleValuedFunction
   4
   5 ###############################################################################
   6 ########################## TRIGONOMETRIC FUNCTIONS ############################
   7 ###############################################################################
   8
   9 class Sin(DefinedFunction):
  10
  11     nofargs = 1
  12
  13     def fdiff(self, argindex=1):
  14         if argindex == 1:
  15             return S.Cos
  16         else:
  17             raise ArgumentIndexError(self, argindex)
  18
  19     def inverse(self, argindex=1):
  20         return S.ASin
  21
  22     def _eval_apply(self, arg):
  23         arg = Basic.sympify(arg)
  24
  25         if isinstance(arg, Basic.Number):
  26             if isinstance(arg, Basic.NaN):
  27                 return S.NaN
  28             elif isinstance(arg, Basic.Zero):
  29                 return S.Zero
  30             elif arg.is_negative:
  31                 return -self(-arg)
  32         else:
  33             i_coeff = arg.as_coefficient(S.ImaginaryUnit)
  34
  35             if i_coeff is not None:
  36                 return S.ImaginaryUnit * S.Sinh(i_coeff)
  37             else:
  38                 pi_coeff = arg.as_coefficient(S.Pi)
  39
  40                 if pi_coeff is not None:
  41                     if pi_coeff.is_integer:
  42                         return S.Zero
  43                     elif isinstance(pi_coeff, Basic.Rational):
  44                         cst_table = {
  45                             2 : S.One,
  46                             3 : S.Half*S.Sqrt(3),
  47                             4 : S.Half*S.Sqrt(2),
  48                             6 : S.Half,
  49                         }
  50
  51                         try:
  52                             result = cst_table[pi_coeff.q]
  53
  54                             if (pi_coeff.p // pi_coeff.q) % 2 == 1:
  55                                 return -result
  56                             else:
  57                                 return result
  58                         except KeyError:
  59                             pass
  60
  61                 coeff, terms = arg.as_coeff_terms()
  62
  63                 if coeff.is_negative:
  64                     return -self(-arg)
  65
  66     def _eval_apply_evalf(self, arg):
  67         arg = arg.evalf()
  68
  69         if isinstance(arg, Basic.Number):
  70             return arg.sin()
  71
  72     @cache_it_immutable
  73     def taylor_term(self, n, x, *previous_terms):
  74         if n < 0 or n % 2 == 0:
  75             return S.Zero
  76         else:
  77             x = Basic.sympify(x)
  78
  79             if len(previous_terms) > 2:
  80                 p = previous_terms[-2]
  81                 return -p * x**2 / (n*(n-1))
  82             else:
  83                 return (-1)**(n//2) * x**(n)/S.Factorial(n)
  84
  85 class ApplySin(Apply):
  86
  87     def _eval_rewrite_as_exp(self, arg):
  88         exp, I = S.Exp, S.ImaginaryUnit
  89         return (exp(arg*I) - exp(-arg*I)) / (2*I)
  90
  91     def _eval_rewrite_as_cos(self, arg):
  92         return -S.Cos(arg + S.Pi/2)
  93
  94     def _eval_rewrite_as_tan(self, arg):
  95         tan_half = S.Tan(S.Half*arg)
  96         return 2*tan_half/(1 + tan_half**2)
  97
  98     def _eval_rewrite_as_cot(self, arg):
  99         cot_half = S.Cot(S.Half*arg)
 100         return 2*cot_half/(1 + cot_half**2)
 101
 102     def _eval_conjugate(self):
 103         return self.func(self[0].conjugate())
 104
 105     def _eval_expand_complex(self, *args):
 106         if self[0].is_real:
 107             return self
 108         re, im = self[0].as_real_imag()
 109         return S.Sin(re)*S.Cosh(im) + \
 110             S.ImaginaryUnit*S.Cos(re)*S.Sinh(im)
 111
 112     def _eval_expand_trig(self, *args):
 113         arg = self[0].expand()
 114         cos, sin = S.Cos, S.Sin
 115         x = None
 116         if isinstance(arg, Basic.Add):
 117             x = arg[0]
 118             y = Basic.Add(*arg[1:])
 119         else:
 120             coeff, terms = arg.as_coeff_terms()
 121             if not isinstance(coeff, Basic.One) and isinstance(coeff, Basic.Integer) and terms:
 122                 x = Basic.Mul(*terms)
 123                 y = (coeff-1)*x
 124         if x is not None:
 125             return (sin(x)*cos(y) + sin(y)*cos(x)).expand(trig=True)
 126         return sin(arg)
 127
 128     def _eval_as_leading_term(self, x):
 129         arg = self[0].as_leading_term(x)
 130
 131         if Basic.Order(1,x).contains(arg):
 132             return arg
 133         else:
 134             return self.func(arg)
 135
 136     def _eval_is_real(self):
 137         return self[0].is_real
 138
 139     def _eval_is_bounded(self):
 140         arg = self[0]
 141         if arg.is_real:
 142             return True
 143
 144 class Cos(DefinedFunction):
 145
 146     nofargs = 1
 147
 148     def fdiff(self, argindex=1):
 149         if argindex == 1:
 150             return -S.Sin
 151         else:
 152             raise ArgumentIndexError(self, argindex)
 153
 154     def inverse(self, argindex=1):
 155         return S.ACos
 156
 157     def _eval_apply(self, arg):
 158         arg = Basic.sympify(arg)
 159
 160         if isinstance(arg, Basic.Number):
 161             if isinstance(arg, Basic.NaN):
 162                 return S.NaN
 163             elif isinstance(arg, Basic.Zero):
 164                 return S.One
 165             elif arg.is_negative:
 166                 return self(-arg)
 167         else:
 168             i_coeff = arg.as_coefficient(S.ImaginaryUnit)
 169
 170             if i_coeff is not None:
 171                 return S.Cosh(i_coeff)
 172             else:
 173                 pi_coeff = arg.as_coefficient(S.Pi)
 174
 175                 if pi_coeff is not None:
 176                     if isinstance(pi_coeff, Basic.Rational):
 177                         cst_table = {
 178                             1 : S.One,
 179                             2 : S.Zero,
 180                             3 : S.Half,
 181                             4 : S.Half*S.Sqrt(2),
 182                             6 : S.Half*S.Sqrt(3),
 183                         }
 184
 185                         try:
 186                             result = cst_table[pi_coeff.q]
 187
 188                             if (2*pi_coeff.p // pi_coeff.q) % 4 in (1, 2):
 189                                 return -result
 190                             else:
 191                                 return result
 192                         except KeyError:
 193                             pass
 194
 195                 coeff, terms = arg.as_coeff_terms()
 196
 197                 if coeff.is_negative:
 198                     return self(-arg)
 199
 200     def _eval_apply_evalf(self, arg):
 201         arg = arg.evalf()
 202
 203         if isinstance(arg, Basic.Number):
 204             return arg.cos()
 205
 206     @cache_it_immutable
 207     def taylor_term(self, n, x, *previous_terms):
 208         if n < 0 or n % 2 == 1:
 209             return S.Zero
 210         else:
 211             x = Basic.sympify(x)
 212
 213             if len(previous_terms) > 2:
 214                 p = previous_terms[-2]
 215                 return -p * x**2 / (n*(n-1))
 216             else:
 217                 return (-1)**(n//2)*x**(n)/S.Factorial(n)
 218
 219 class ApplyCos(Apply):
 220
 221     def _eval_rewrite_as_exp(self, arg):
 222         exp, I = S.Exp, S.ImaginaryUnit
 223         return (exp(arg*I) + exp(-arg*I)) / 2
 224
 225     def _eval_rewrite_as_sin(self, arg):
 226         return S.Sin(arg + S.Pi/2)
 227
 228     def _eval_rewrite_as_tan(self, arg):
 229         tan_half = S.Tan(S.Half*arg)**2
 230         return (1-tan_half)/(1+tan_half)
 231
 232     def _eval_rewrite_as_cot(self, arg):
 233         cot_half = S.Cot(S.Half*arg)**2
 234         return (cot_half-1)/(cot_half+1)
 235
 236     def _eval_conjugate(self):
 237         return self.func(self[0].conjugate())
 238
 239     def _eval_expand_complex(self, *args):
 240         if self[0].is_real:
 241             return self
 242         re, im = self[0].as_real_imag()
 243         return S.Cos(re)*S.Cosh(im) - \
 244             S.ImaginaryUnit*S.Sin(re)*S.Sinh(im)
 245
 246     def _eval_expand_trig(self, *args):
 247         arg = self[0].expand()
 248         cos = S.Cos
 249         sin = S.Sin
 250         x = None
 251         if isinstance(arg, Basic.Add):
 252             x = arg[0]
 253             y = Basic.Add(*arg[1:])
 254             return (cos(x)*cos(y) - sin(y)*sin(x)).expand(trig=True)
 255         else:
 256             coeff, terms = arg.as_coeff_terms()
 257             if not isinstance(coeff, Basic.One) and isinstance(coeff, Basic.Integer) and terms:
 258                 x = Basic.Mul(*terms)
 259                 return Basic.ChebyshevT()(coeff, cos(x))
 260         return cos(arg)
 261
 262     def _eval_as_leading_term(self, x):
 263         arg = self[0].as_leading_term(x)
 264
 265         if Basic.Order(1,x).contains(arg):
 266             return S.One
 267         else:
 268             return self.func(arg)
 269
 270     def _eval_is_bounded(self):
 271         arg = self[0]
 272
 273         if arg.is_real:
 274             return True
 275
 276 class tan(SingleValuedFunction):
 277
 278     nofargs = 1
 279
 280     def fdiff(self, argindex=1):
 281         if argindex==1:
 282             return S.One + self**2
 283         else:
 284             raise ArgumentIndexError(self, argindex)
 285
 286     def inverse(self, argindex=1):
 287         return S.ATan
 288
 289     @classmethod
 290     def _eval_apply_subs(self, *args):
 291         return
 292
 293     @classmethod
 294     def _eval_apply(self, arg):
 295         arg = Basic.sympify(arg)
 296
 297         if isinstance(arg, Basic.Number):
 298             if isinstance(arg, Basic.NaN):
 299                 return S.NaN
 300             elif isinstance(arg, Basic.Zero):
 301                 return S.Zero
 302             elif arg.is_negative:
 303                 return -self(-arg)
 304         else:
 305             i_coeff = arg.as_coefficient(S.ImaginaryUnit)
 306
 307             if i_coeff is not None:
 308                 return S.ImaginaryUnit * S.Tanh(i_coeff)
 309             else:
 310                 pi_coeff = arg.as_coefficient(S.Pi)
 311
 312                 if pi_coeff is not None:
 313                     if pi_coeff.is_integer:
 314                         return S.Zero
 315                     elif isinstance(pi_coeff, Basic.Rational):
 316                         cst_table = {
 317                            #2 : S.ComplexInfinity,
 318                             3 : S.Sqrt(3),
 319                             4 : S.One,
 320                             6 : 1 / S.Sqrt(3),
 321                         }
 322
 323                         try:
 324                             result = cst_table[pi_coeff.q]
 325
 326                             if (2*pi_coeff.p // pi_coeff.q) % 4 in (1, 3):
 327                                 return -result
 328                             else:
 329                                 return result
 330                         except KeyError:
 331                             pass
 332
 333                 coeff, terms = arg.as_coeff_terms()
 334
 335                 if coeff.is_negative:
 336                     return -self(-arg)
 337
 338     def _eval_apply_evalf(self, arg):
 339         arg = arg.evalf()
 340
 341         if isinstance(arg, Basic.Number):
 342             return arg.tan()
 343
 344     #@cache_it_immutable
 345     @classmethod
 346     def taylor_term(self, n, x, *previous_terms):
 347         if n < 0 or n % 2 == 0:
 348             return S.Zero
 349         else:
 350             x = Basic.sympify(x)
 351
 352             a, b = ((n-1)//2), 2**(n+1)
 353
 354             B = S.Bernoulli(n+1)
 355             F = S.Factorial(n+1)
 356
 357             return (-1)**a * b*(b-1) * B/F * x**n
 358
 359     def _eval_conjugate(self):
 360         return self.func(self[0].conjugate())
 361
 362     def _eval_expand_complex(self, *args):
 363         if self[0].is_real:
 364             return self
 365         re, im = self[0].as_real_imag()
 366         denom = S.Cos(re)**2 + S.Sinh(im)**2
 367         return (S.Sin(re)*S.Cos(re) + \
 368             S.ImaginaryUnit*S.Sinh(im)*S.Cosh(im))/denom
 369
 370     def _eval_expand_trig(self, *args):
 371         return self
 372
 373     def _eval_rewrite_as_exp(self, arg):
 374         exp, I = S.Exp, S.ImaginaryUnit
 375         neg_exp, pos_exp = exp(-arg*I), exp(arg*I)
 376         return I*(neg_exp-pos_exp)/(neg_exp+pos_exp)
 377
 378     def _eval_rewrite_as_sin(self, arg):
 379         return 2*S.Sin(x)**2/S.Sin(2*x)
 380
 381     def _eval_rewrite_as_cos(self, arg):
 382         return -S.Cos(x + S.Pi/2)/S.Cos(x)
 383
 384     def _eval_rewrite_as_cot(self, arg):
 385         return 1/S.Cot(arg)
 386
 387     def _eval_as_leading_term(self, x):
 388         arg = self[0].as_leading_term(x)
 389
 390         if Basic.Order(1,x).contains(arg):
 391             return S.One
 392         else:
 393             return self.func(arg)
 394
 395     def _eval_is_bounded(self):
 396         arg = self[0]
 397
 398         if arg.is_imaginary:
 399             return True
 400
 401 class cot(SingleValuedFunction):
 402
 403     nofargs = 1
 404
 405     def fdiff(self, argindex=1):
 406         if argindex == 1:
 407             return -S.One - S.Cot**2
 408         else:
 409             raise ArgumentIndexError(self, argindex)
 410
 411     def inverse(self, argindex=1):
 412         return S.ACot
 413
 414     @classmethod
 415     def _eval_apply_subs(self, *args):
 416         return
 417
 418     @classmethod
 419     def _eval_apply(self, arg):
 420         arg = Basic.sympify(arg)
 421
 422         if isinstance(arg, Basic.Number):
 423             if isinstance(arg, Basic.NaN):
 424                 return S.NaN
 425             #elif isinstance(arg, Basic.Zero):
 426             #    return S.ComplexInfinity
 427             elif arg.is_negative:
 428                 return -self(-arg)
 429         else:
 430             i_coeff = arg.as_coefficient(S.ImaginaryUnit)
 431
 432             if i_coeff is not None:
 433                 return -S.ImaginaryUnit * S.Coth(i_coeff)
 434             else:
 435                 pi_coeff = arg.as_coefficient(S.Pi)
 436
 437                 if pi_coeff is not None:
 438                     #if pi_coeff.is_integer:
 439                     #    return S.ComplexInfinity
 440                     if isinstance(pi_coeff, Basic.Rational):
 441                         cst_table = {
 442                             2 : S.Zero,
 443                             3 : 1 / S.Sqrt(3),
 444                             4 : S.One,
 445                             6 : S.Sqrt(3)
 446                         }
 447
 448                         try:
 449                             result = cst_table[pi_coeff.q]
 450
 451                             if (2*pi_coeff.p // pi_coeff.q) % 4 in (1, 3):
 452                                 return -result
 453                             else:
 454                                 return result
 455                         except KeyError:
 456                             pass
 457
 458                 coeff, terms = arg.as_coeff_terms()
 459
 460                 if coeff.is_negative:
 461                     return -self(-arg)
 462
 463     def _eval_apply_evalf(self, arg):
 464         arg = arg.evalf()
 465
 466         if isinstance(arg, Basic.Number):
 467             return arg.cot()
 468
 469     @cache_it_immutable
 470     def taylor_term(self, n, x, *previous_terms):
 471         if n == 0:
 472             return 1 / Basic.sympify(x)
 473         elif n < 0 or n % 2 == 0:
 474             return S.Zero
 475         else:
 476             x = Basic.sympify(x)
 477
 478             B = S.Bernoulli(n+1)
 479             F = S.Factorial(n+1)
 480
 481             return (-1)**((n+1)//2) * 2**(n+1) * B/F * x**n
 482
 483     def _eval_conjugate(self):
 484         assert len(self) == 1
 485         return self.func(self[0].conjugate())
 486
 487     def _eval_expand_complex(self, *args):
 488         if self[0].is_real:
 489             return self
 490         re, im = self[0].as_real_imag()
 491         denom = S.Sin(re)**2 + S.Sinh(im)**2
 492         return (S.Sin(re)*S.Cos(re) - \
 493             S.ImaginaryUnit*S.Sinh(im)*S.Cosh(im))/denom
 494
 495     def _eval_rewrite_as_exp(self, arg):
 496         exp, I = S.Exp, S.ImaginaryUnit
 497         neg_exp, pos_exp = exp(-arg*I), exp(arg*I)
 498         return I*(pos_exp+neg_exp)/(pos_exp-neg_exp)
 499
 500     def _eval_rewrite_as_sin(self, arg):
 501         return 2*S.Sin(2*x)/S.Sin(x)**2
 502
 503     def _eval_rewrite_as_cos(self, arg):
 504         return -S.Cos(x)/S.Cos(x + S.Pi/2)
 505
 506     def _eval_rewrite_as_tan(self, arg):
 507         return 1/S.Tan(arg)
 508
 509     def _eval_as_leading_term(self, x):
 510         arg = self[0].as_leading_term(x)
 511
 512         if Basic.Order(1,x).contains(arg):
 513             return S.One
 514         else:
 515             return self.func(arg)
 516
 517 Basic.singleton['sin'] = Sin
 518 Basic.singleton['cos'] = Cos
 519
 520 ###############################################################################
 521 ########################### TRIGONOMETRIC INVERSES ############################
 522 ###############################################################################
 523
 524 class ASin(DefinedFunction):
 525
 526     nofargs = 1
 527
 528     def fdiff(self, argindex=1):
 529         if argindex == 1:
 530             s = Basic.Symbol('x', dummy=True)
 531             return Lambda((1 - s**2)**(-S.Half), s)
 532         else:
 533             raise ArgumentIndexError(self, argindex)
 534
 535     def _eval_apply(self, arg):
 536         arg = Basic.sympify(arg)
 537
 538         if isinstance(arg, Basic.Number):
 539             if isinstance(arg, Basic.NaN):
 540                 return S.NaN
 541             elif isinstance(arg, Basic.Infinity):
 542                 return S.NegativeInfinity * S.ImaginaryUnit
 543             elif isinstance(arg, Basic.NegativeInfinity):
 544                 return S.Infinity * S.ImaginaryUnit
 545             elif isinstance(arg, Basic.Zero):
 546                 return S.Zero
 547             elif isinstance(arg, Basic.One):
 548                 return S.Pi / 2
 549             elif isinstance(arg, Basic.NegativeOne):
 550                 return -S.Pi / 2
 551             else:
 552                 cst_table = {
 553                     S.Half       : 6,
 554                     -S.Half      : -6,
 555                     S.Sqrt(2)/2  : 4,
 556                     -S.Sqrt(2)/2 : -4,
 557                     1/S.Sqrt(2)  : 4,
 558                     -1/S.Sqrt(2) : -4,
 559                     S.Sqrt(3)/2  : 3,
 560                     -S.Sqrt(3)/2 : -3,
 561                 }
 562
 563                 if arg in cst_table:
 564                     return S.Pi / cst_table[arg]
 565                 elif arg.is_negative:
 566                     return -self(-arg)
 567         else:
 568             i_coeff = arg.as_coefficient(S.ImaginaryUnit)
 569
 570             if i_coeff is not None:
 571                 return S.ImaginaryUnit * S.ASinh(i_coeff)
 572             else:
 573                 coeff, terms = arg.as_coeff_terms()
 574
 575                 if coeff.is_negative:
 576                     return -self(-arg)
 577
 578     def _eval_apply_evalf(self, arg):
 579         arg = arg.evalf()
 580
 581         if isinstance(arg, Basic.Number):
 582             return arg.asin()
 583
 584     @cache_it_immutable
 585     def taylor_term(self, n, x, *previous_terms):
 586         if n < 0 or n % 2 == 0:
 587             return S.Zero
 588         else:
 589             x = Basic.sympify(x)
 590
 591             if len(previous_terms) > 2:
 592                 p = previous_terms[-2]
 593                 return p * (n-2)**2/(k*(k-1)) * x**2
 594             else:
 595                 k = (n - 1) // 2
 596
 597                 R = S.RisingFactorial(S.Half, k)
 598                 F = S.Factorial(k)
 599
 600                 return R / F * x**n / n
 601
 602 class ApplyASin(Apply):
 603
 604     def _eval_as_leading_term(self, x):
 605         arg = self[0].as_leading_term(x)
 606
 607         if Basic.Order(1,x).contains(arg):
 608             return arg
 609         else:
 610             return self.func(arg)
 611
 612 class ACos(DefinedFunction):
 613
 614     nofargs = 1
 615
 616     def fdiff(self, argindex=1):
 617         if argindex == 1:
 618             s = Basic.Symbol('x', dummy=True)
 619             return Lambda(-(1 - s**2)**(-S.Half), s)
 620         else:
 621             raise ArgumentIndexError(self, argindex)
 622
 623     def _eval_apply(self, arg):
 624         arg = Basic.sympify(arg)
 625
 626         if isinstance(arg, Basic.Number):
 627             if isinstance(arg, Basic.NaN):
 628                 return S.NaN
 629             elif isinstance(arg, Basic.Infinity):
 630                 return S.Infinity * S.ImaginaryUnit
 631             elif isinstance(arg, Basic.NegativeInfinity):
 632                 return S.NegativeInfinity * S.ImaginaryUnit
 633             elif isinstance(arg, Basic.Zero):
 634                 return S.Pi / 2
 635             elif isinstance(arg, Basic.One):
 636                 return S.Zero
 637             elif isinstance(arg, Basic.NegativeOne):
 638                 return S.Pi
 639             else:
 640                 cst_table = {
 641                     S.Half       : S.Pi/3,
 642                     -S.Half      : 2*S.Pi/3,
 643                     S.Sqrt(2)/2  : S.Pi/4,
 644                     -S.Sqrt(2)/2 : 3*S.Pi/4,
 645                     1/S.Sqrt(2)  : S.Pi/4,
 646                     -1/S.Sqrt(2) : 3*S.Pi/4,
 647                     S.Sqrt(3)/2  : S.Pi/6,
 648                     -S.Sqrt(3)/2 : 5*S.Pi/6,
 649                 }
 650
 651                 if arg in cst_table:
 652                     return cst_table[arg]
 653
 654     def _eval_apply_evalf(self, arg):
 655         arg = arg.evalf()
 656
 657         if isinstance(arg, Basic.Number):
 658             return arg.acos()
 659
 660     @cache_it_immutable
 661     def taylor_term(self, n, x, *previous_terms):
 662         if n == 0:
 663             return S.Pi / 2
 664         elif n < 0 or n % 2 == 0:
 665             return S.Zero
 666         else:
 667             x = Basic.sympify(x)
 668
 669             if len(previous_terms) > 2:
 670                 p = previous_terms[-2]
 671                 return p * (n-2)**2/(k*(k-1)) * x**2
 672             else:
 673                 k = (n - 1) // 2
 674
 675                 R = S.RisingFactorial(S.Half, k)
 676                 F = S.Factorial(k)
 677
 678                 return -R / F * x**n / n
 679
 680 class ApplyACos(Apply):
 681
 682     def _eval_as_leading_term(self, x):
 683         arg = self[0].as_leading_term(x)
 684
 685         if Basic.Order(1,x).contains(arg):
 686             return arg
 687         else:
 688             return self.func(arg)
 689
 690 class ATan(DefinedFunction):
 691
 692     nofargs = 1
 693
 694     def fdiff(self, argindex=1):
 695         if argindex == 1:
 696             s = Basic.Symbol('x', dummy=True)
 697             return Lambda(1 / (1 + s**2), s)
 698         else:
 699             raise ArgumentIndexError(self, argindex)
 700
 701     def _eval_apply(self, arg):
 702         arg = Basic.sympify(arg)
 703
 704         if isinstance(arg, Basic.Number):
 705             if isinstance(arg, Basic.NaN):
 706                 return S.NaN
 707             elif isinstance(arg, Basic.Infinity):
 708                 return S.Pi / 2
 709             elif isinstance(arg, Basic.NegativeInfinity):
 710                 return -S.Pi / 2
 711             elif isinstance(arg, Basic.Zero):
 712                 return S.Zero
 713             elif isinstance(arg, Basic.One):
 714                 return S.Pi / 4
 715             elif isinstance(arg, Basic.NegativeOne):
 716                 return -S.Pi / 4
 717             else:
 718                 cst_table = {
 719                     S.Sqrt(3)/3  : 6,
 720                     -S.Sqrt(3)/3 : -6,
 721                     1/S.Sqrt(3)  : 6,
 722                     -1/S.Sqrt(3) : -6,
 723                     S.Sqrt(3)    : 3,
 724                     -S.Sqrt(3)   : -3,
 725                 }
 726
 727                 if arg in cst_table:
 728                     return S.Pi / cst_table[arg]
 729                 elif arg.is_negative:
 730                     return -self(-arg)
 731         else:
 732             i_coeff = arg.as_coefficient(S.ImaginaryUnit)
 733
 734             if i_coeff is not None:
 735                 return S.ImaginaryUnit * S.ATanh(i_coeff)
 736             else:
 737                 coeff, terms = arg.as_coeff_terms()
 738
 739                 if coeff.is_negative:
 740                     return -self(-arg)
 741
 742     def _eval_apply_evalf(self, arg):
 743         arg = arg.evalf()
 744
 745         if isinstance(arg, Basic.Number):
 746             return arg.atan()
 747
 748     @cache_it_immutable
 749     def taylor_term(self, n, x, *previous_terms):
 750         if n < 0 or n % 2 == 0:
 751             return S.Zero
 752         else:
 753             x = Basic.sympify(x)
 754             return (-1)**((n-1)//2) * x**n / n
 755
 756 class ApplyATan(Apply):
 757
 758     def _eval_as_leading_term(self, x):
 759         arg = self[0].as_leading_term(x)
 760
 761         if Basic.Order(1,x).contains(arg):
 762             return arg
 763         else:
 764             return self.func(arg)
 765
 766 class acot(SingleValuedFunction):
 767
 768     nofargs = 1
 769
 770     def fdiff(self, argindex=1):
 771         if argindex == 1:
 772             s = Basic.Symbol('x', dummy=True)
 773             return Lambda(-1 / (1 + s**2), s)
 774         else:
 775             raise ArgumentIndexError(self, argindex)
 776
 777     def _eval_apply(self, arg):
 778         arg = Basic.sympify(arg)
 779
 780         if isinstance(arg, Basic.Number):
 781             if isinstance(arg, Basic.NaN):
 782                 return S.NaN
 783             elif isinstance(arg, Basic.Infinity):
 784                 return S.Zero
 785             elif isinstance(arg, Basic.NegativeInfinity):
 786                 return S.Zero
 787             elif isinstance(arg, Basic.Zero):
 788                 return S.Pi/ 2
 789             elif isinstance(arg, Basic.One):
 790                 return S.Pi / 4
 791             elif isinstance(arg, Basic.NegativeOne):
 792                 return -S.Pi / 4
 793             else:
 794                 cst_table = {
 795                     S.Sqrt(3)/3  : 3,
 796                     -S.Sqrt(3)/3 : -3,
 797                     1/S.Sqrt(3)  : 3,
 798                     -1/S.Sqrt(3) : -3,
 799                     S.Sqrt(3)    : 6,
 800                     -S.Sqrt(3)   : -6,
 801                 }
 802
 803                 if arg in cst_table:
 804                     return S.Pi / cst_table[arg]
 805                 elif arg.is_negative:
 806                     return -self(-arg)
 807         else:
 808             i_coeff = arg.as_coefficient(S.ImaginaryUnit)
 809
 810             if i_coeff is not None:
 811                 return -S.ImaginaryUnit * S.ACoth(i_coeff)
 812             else:
 813                 coeff, terms = arg.as_coeff_terms()
 814
 815                 if coeff.is_negative:
 816                     return -self(-arg)
 817
 818     def _eval_apply_evalf(self, arg):
 819         arg = arg.evalf()
 820
 821         if isinstance(arg, Basic.Number):
 822             return arg.acot()
 823
 824     @cache_it_immutable
 825     def taylor_term(self, n, x, *previous_terms):
 826         if n == 0:
 827             return S.Pi / 2 # FIX THIS
 828         elif n < 0 or n % 2 == 0:
 829             return S.Zero
 830         else:
 831             x = Basic.sympify(x)
 832             return (-1)**((n+1)//2) * x**n / n
 833
 834     def _eval_as_leading_term(self, x):
 835         arg = self[0].as_leading_term(x)
 836
 837         if Basic.Order(1,x).contains(arg):
 838             return arg
 839         else:
 840             return self.func(arg)
 841
 842 Basic.singleton['asin'] = ASin
 843 Basic.singleton['acos'] = ACos
 844 Basic.singleton['atan'] = ATan