doc/info/Special.texi

   1 @menu
   2 * Introduction to Special Functions::
   3 * Bessel Functions::
   4 * Airy Functions::
   5 * Gamma and factorial Functions::
   6 * Exponential Integrals::
   7 * Error Function::
   8 * Struve Functions::
   9 * Hypergeometric Functions::
  10 * Parabolic Cylinder Functions::
  11 * Functions and Variables for Special Functions::
  12 @end menu
  13
  14 @c -----------------------------------------------------------------------------
  15 @node Introduction to Special Functions, Bessel Functions, Special Functions, Special Functions
  16 @section Introduction to Special Functions
  17 @c -----------------------------------------------------------------------------
  18
  19 Special function notation follows:
  20
  21 @example
  22 bessel_j (index, expr)         Bessel function, 1st kind
  23 bessel_y (index, expr)         Bessel function, 2nd kind
  24 bessel_i (index, expr)         Modified Bessel function, 1st kind
  25 bessel_k (index, expr)         Modified Bessel function, 2nd kind
  26
  27 hankel_1 (v,z)                 Hankel function of the 1st kind
  28 hankel_2 (v,z)                 Hankel function of the 2nd kind
  29 struve_h (v,z)                 Struve H function
  30 struve_l (v,z)                 Struve L function
  31
  32 assoc_legendre_p[v,u] (z)      Legendre function of degree v and order u
  33 assoc_legendre_q[v,u] (z)      Legendre function, 2nd kind
  34
  35 %f[p,q] ([], [], expr)         Generalized Hypergeometric function
  36 gamma (z)                      Gamma function
  37 gamma_incomplete_lower (a,z)   Lower incomplete gamma function
  38 gamma_incomplete (a,z)         Tail of incomplete gamma function
  39 hypergeometric (l1, l2, z)     Hypergeometric function
  40 @c IS slommel THE "LOMMEL" FUNCTION ?? NOT OTHERWISE MENTIONED IN TEXINFO FILES
  41 slommel
  42 %m[u,k] (z)                    Whittaker function, 1st kind
  43 %w[u,k] (z)                    Whittaker function, 2nd kind
  44 erfc (z)                       Complement of the erf function
  45
  46 expintegral_e (v,z)            Exponential integral E
  47 expintegral_e1 (z)             Exponential integral E1
  48 expintegral_ei (z)             Exponential integral Ei
  49 expintegral_li (z)             Logarithmic integral Li
  50 expintegral_si (z)             Exponential integral Si
  51 expintegral_ci (z)             Exponential integral Ci
  52 expintegral_shi (z)            Exponential integral Shi
  53 expintegral_chi (z)            Exponential integral Chi
  54
  55 kelliptic (z)                  Complete elliptic integral of the first
  56                                kind (K)
  57 parabolic_cylinder_d (v,z)     Parabolic cylinder D function
  58 @end example
  59
  60 @opencatbox{Categories:}
  61 @category{Bessel functions}
  62 @category{Airy functions}
  63 @category{Special functions}
  64 @closecatbox
  65
  66 @c -----------------------------------------------------------------------------
  67 @node Bessel Functions, Airy Functions, Introduction to Special Functions, Special Functions
  68 @section Bessel Functions
  69 @c -----------------------------------------------------------------------------
  70
  71 @c -----------------------------------------------------------------------------
  72 @anchor{bessel_j}
  73 @deffn {Function} bessel_j (@var{v}, @var{z})
  74
  75 The Bessel function of the first kind of order @math{v} and argument @math{z}.
  76
  77 @code{bessel_j} is defined as
  78
  79 @ifnottex
  80 @example
  81                 inf
  82                 ====       k  - v - 2 k  v + 2 k
  83                 \     (- 1)  2          z
  84                  >    --------------------------
  85                 /        k! gamma(v + k + 1)
  86                 ====
  87                 k = 0
  88 @end example
  89 @end ifnottex
  90
  91 @tex
  92 $$\sum_{k=0}^{\infty }{{{\left(-1\right)^{k}\,\left(z\over 2\right)^{v+2\,k}
  93  }\over{k!\,\Gamma\left(v+k+1\right)}}}$$
  94 @end tex
  95
  96 although the infinite series is not used for computations.
  97
  98 @opencatbox{Categories:}
  99 @category{Bessel functions}
 100 @category{Special functions}
 101 @closecatbox
 102 @end deffn
 103
 104 @c -----------------------------------------------------------------------------
 105 @anchor{bessel_y}
 106 @deffn {Function} bessel_y (@var{v}, @var{z})
 107
 108 The Bessel function of the second kind of order @math{v} and argument @math{z}.
 109
 110 @code{bessel_y} is defined as
 111 @ifnottex
 112 @example
 113               cos(%pi v) bessel_j(v, z) - bessel_j(-v, z)
 114               -------------------------------------------
 115                              sin(%pi v)
 116 @end example
 117 @end ifnottex
 118
 119 @tex
 120 $${{\cos \left(\pi\,v\right)\,J_{v}(z)-J_{-v}(z)}\over{
 121  \sin \left(\pi\,v\right)}}$$
 122 @end tex
 123
 124 when @math{v} is not an integer.  When @math{v} is an integer @math{n},
 125 the limit as @math{v} approaches @math{n} is taken.
 126
 127 @opencatbox{Categories:}
 128 @category{Bessel functions}
 129 @category{Special functions}
 130 @closecatbox
 131 @end deffn
 132
 133 @c -----------------------------------------------------------------------------
 134 @anchor{bessel_i}
 135 @deffn {Function} bessel_i (@var{v}, @var{z})
 136
 137 The modified Bessel function of the first kind of order @math{v} and argument
 138 @math{z}.
 139
 140 @code{bessel_i} is defined as
 141 @ifnottex
 142 @example
 143                     inf
 144                     ====   - v - 2 k  v + 2 k
 145                     \     2          z
 146                      >    -------------------
 147                     /     k! gamma(v + k + 1)
 148                     ====
 149                     k = 0
 150 @end example
 151 @end ifnottex
 152
 153 @tex
 154 $$\sum_{k=0}^{\infty } {{1\over{k!\,\Gamma
 155  \left(v+k+1\right)}} {\left(z\over 2\right)^{v+2\,k}}}$$
 156 @end tex
 157
 158 although the infinite series is not used for computations.
 159
 160 @opencatbox{Categories:}
 161 @category{Bessel functions}
 162 @category{Special functions}
 163 @closecatbox
 164 @end deffn
 165
 166 @c -----------------------------------------------------------------------------
 167 @anchor{bessel_k}
 168 @deffn {Function} bessel_k (@var{v}, @var{z})
 169
 170 The modified Bessel function of the second kind of order @math{v} and argument
 171 @math{z}.
 172
 173 @code{bessel_k} is defined as
 174 @ifnottex
 175 @example
 176            %pi csc(%pi v) (bessel_i(-v, z) - bessel_i(v, z))
 177            -------------------------------------------------
 178                                   2
 179 @end example
 180 @end ifnottex
 181 @tex
 182 $${{\pi\,\csc \left(\pi\,v\right)\,\left(I_{-v}(z)-I_{v}(z)\right)}\over{2}}$$
 183 @end tex
 184
 185 when @math{v} is not an integer.  If @math{v} is an integer @math{n},
 186 then the limit as @math{v} approaches @math{n} is taken.
 187
 188 @opencatbox{Categories:}
 189 @category{Bessel functions}
 190 @category{Special functions}
 191 @closecatbox
 192 @end deffn
 193
 194 @c -----------------------------------------------------------------------------
 195 @anchor{hankel_1}
 196 @deffn {Function} hankel_1 (@var{v}, @var{z})
 197
 198 The Hankel function of the first kind of order @math{v} and argument @math{z}
 199 (A&S 9.1.3). @code{hankel_1} is defined as
 200
 201 @example
 202    bessel_j(v,z) + %i * bessel_y(v,z)
 203 @end example
 204
 205 Maxima evaluates @code{hankel_1} numerically for a complex order @math{v} and
 206 complex argument @math{z} in float precision. The numerical evaluation in
 207 bigfloat precision is not supported.
 208
 209 When @code{besselexpand} is @code{true}, @code{hankel_1} is expanded in terms
 210 of elementary functions when the order @math{v} is half of an odd integer.
 211 See @code{besselexpand}.
 212
 213 Maxima knows the derivative of @code{hankel_1} wrt the argument @math{z}.
 214
 215 Examples:
 216
 217 Numerical evaluation:
 218
 219 @c ===beg===
 220 @c hankel_1(1,0.5);
 221 @c hankel_1(1,0.5+%i);
 222 @c ===end===
 223 @example
 224 @group
 225 (%i1) hankel_1(1,0.5);
 226 (%o1)        0.24226845767487 - 1.471472392670243 %i
 227 @end group
 228 @group
 229 (%i2) hankel_1(1,0.5+%i);
 230 (%o2)       - 0.25582879948621 %i - 0.23957560188301
 231 @end group
 232 @end example
 233
 234 Expansion of @code{hankel_1} when @code{besselexpand} is @code{true}:
 235
 236 @c ===beg===
 237 @c hankel_1(1/2,z),besselexpand:true;
 238 @c ===end===
 239 @example
 240 @group
 241 (%i1) hankel_1(1/2,z),besselexpand:true;
 242                sqrt(2) sin(z) - sqrt(2) %i cos(z)
 243 (%o1)          ----------------------------------
 244                        sqrt(%pi) sqrt(z)
 245 @end group
 246 @end example
 247
 248 Derivative of @code{hankel_1} wrt the argument @math{z}. The derivative wrt the
 249 order @math{v} is not supported. Maxima returns a noun form:
 250
 251 @c ===beg===
 252 @c diff(hankel_1(v,z),z);
 253 @c diff(hankel_1(v,z),v);
 254 @c ===end===
 255 @example
 256 @group
 257 (%i1) diff(hankel_1(v,z),z);
 258              hankel_1(v - 1, z) - hankel_1(v + 1, z)
 259 (%o1)        ---------------------------------------
 260                                 2
 261 @end group
 262 @group
 263 (%i2) diff(hankel_1(v,z),v);
 264                        d
 265 (%o2)                  -- (hankel_1(v, z))
 266                        dv
 267 @end group
 268 @end example
 269
 270 @opencatbox{Categories:}
 271 @category{Bessel functions}
 272 @category{Special functions}
 273 @closecatbox
 274 @end deffn
 275
 276 @c -----------------------------------------------------------------------------
 277 @anchor{hankel_2}
 278 @deffn {Function} hankel_2 (@var{v}, @var{z})
 279
 280 The Hankel function of the second kind of order @math{v} and argument @math{z}
 281 (A&S 9.1.4). @code{hankel_2} is defined as
 282
 283 @example
 284    bessel_j(v,z) - %i * bessel_y(v,z)
 285 @end example
 286
 287 Maxima evaluates @code{hankel_2} numerically for a complex order @math{v} and
 288 complex argument @math{z} in float precision. The numerical evaluation in
 289 bigfloat precision is not supported.
 290
 291 When @code{besselexpand} is @code{true}, @code{hankel_2} is expanded in terms
 292 of elementary functions when the order @math{v} is half of an odd integer.
 293 See @code{besselexpand}.
 294
 295 Maxima knows the derivative of @code{hankel_2} wrt the argument @math{z}.
 296
 297 For examples see @code{hankel_1}.
 298
 299 @opencatbox{Categories:}
 300 @category{Bessel functions}
 301 @category{Special functions}
 302 @closecatbox
 303 @end deffn
 304
 305 @c -----------------------------------------------------------------------------
 306 @anchor{besselexpand}
 307 @defvr {Option variable} besselexpand
 308 Default value: @code{false}
 309
 310 @c REPHRASE
 311 Controls expansion of the Bessel functions when the order is half of
 312 an odd integer.  In this case, the Bessel functions can be expanded
 313 in terms of other elementary functions.  When @code{besselexpand} is @code{true},
 314 the Bessel function is expanded.
 315
 316 @example
 317 (%i1) besselexpand: false$
 318 (%i2) bessel_j (3/2, z);
 319                                     3
 320 (%o2)                      bessel_j(-, z)
 321                                     2
 322 (%i3) besselexpand: true$
 323 (%i4) bessel_j (3/2, z);
 324                                         sin(z)   cos(z)
 325                        sqrt(2) sqrt(z) (------ - ------)
 326                                            2       z
 327                                           z
 328 (%o4)                  ---------------------------------
 329                                    sqrt(%pi)
 330 @end example
 331
 332 @opencatbox{Categories:}
 333 @category{Bessel functions}
 334 @category{Simplification flags and variables}
 335 @category{Special functions}
 336 @closecatbox
 337 @end defvr
 338
 339 @c -----------------------------------------------------------------------------
 340 @anchor{scaled_bessel_i}
 341 @deffn {Function} scaled_bessel_i (@var{v}, @var{z})
 342
 343 The scaled modified Bessel function of the first kind of order
 344 @math{v} and argument @math{z}.  That is, @math{scaled\_bessel_i(v,z) =
 345 exp(-abs(z))*bessel_i(v, z)}.  This function is particularly useful
 346 for calculating @math{bessel_i} for large @math{z}, which is large.
 347 However, maxima does not otherwise know much about this function.  For
 348 symbolic work, it is probably preferable to work with the expression
 349 @code{exp(-abs(z))*bessel_i(v, z)}.
 350
 351 @opencatbox{Categories:}
 352 @category{Bessel functions}
 353 @closecatbox
 354 @end deffn
 355
 356 @anchor{scaled_bessel_i0}
 357 @deffn {Function} scaled_bessel_i0 (@var{z})
 358
 359 Identical to @code{scaled_bessel_i(0,z)}.
 360
 361 @opencatbox{Categories:}
 362 @category{Bessel functions}
 363 @category{Special functions}
 364 @closecatbox
 365 @end deffn
 366
 367 @c -----------------------------------------------------------------------------
 368 @anchor{scaled_bessel_i1}
 369 @deffn {Function} scaled_bessel_i1 (@var{z})
 370
 371 Identical to @code{scaled_bessel_i(1,z)}.
 372 @opencatbox{Categories:}
 373 @category{Bessel functions}
 374 @category{Special functions}
 375 @closecatbox
 376 @end deffn
 377
 378 @c -----------------------------------------------------------------------------
 379 @deffn {Function} %s [@var{u},@var{v}] (@var{z})
 380 Lommel's little s[u,v](z) function.
 381 Probably Gradshteyn & Ryzhik 8.570.1.
 382 @opencatbox{Categories:}
 383 @category{Bessel functions}
 384 @category{Special functions}
 385 @closecatbox
 386 @end deffn
 387
 388 @c -----------------------------------------------------------------------------
 389 @node Airy Functions, Gamma and factorial Functions, Bessel Functions, Special Functions
 390 @section Airy Functions
 391 @c -----------------------------------------------------------------------------
 392
 393 The Airy functions Ai(x) and Bi(x) are defined in Abramowitz and Stegun,
 394 @i{Handbook of Mathematical Functions}, Section 10.4.
 395
 396 @code{y = Ai(x)} and @code{y = Bi(x)} are two linearly independent solutions
 397 of the Airy differential equation @code{diff (y(x), x, 2) - x y(x) = 0}.
 398
 399 If the argument @code{x} is a real or complex floating point
 400 number, the numerical value of the function is returned.
 401
 402 @anchor{airy_ai}
 403 @deffn {Function} airy_ai (@var{x})
 404 The Airy function Ai(x).  (A&S 10.4.2)
 405
 406 The derivative @code{diff (airy_ai(x), x)} is @code{airy_dai(x)}.
 407
 408 See also @mrefcomma{airy_bi} @mrefcomma{airy_dai} @mrefdot{airy_dbi}
 409
 410 @opencatbox{Categories:}
 411 @category{Airy functions}
 412 @category{Special functions}
 413 @closecatbox
 414 @end deffn
 415
 416 @c -----------------------------------------------------------------------------
 417 @anchor{airy_dai}
 418 @deffn {Function} airy_dai (@var{x})
 419 The derivative of the Airy function Ai @code{airy_ai(x)}.
 420
 421 See @code{airy_ai}.
 422
 423 @opencatbox{Categories:}
 424 @category{Airy functions}
 425 @category{Special functions}
 426 @closecatbox
 427 @end deffn
 428
 429 @c -----------------------------------------------------------------------------
 430 @anchor{airy_bi}
 431 @deffn {Function} airy_bi (@var{x})
 432 The Airy function Bi(x).  (A&S 10.4.3)
 433
 434 The derivative @code{diff (airy_bi(x), x)} is @code{airy_dbi(x)}.
 435
 436 See @code{airy_ai}, @code{airy_dbi}.
 437
 438 @opencatbox{Categories:}
 439 @category{Airy functions}
 440 @category{Special functions}
 441 @closecatbox
 442 @end deffn
 443
 444 @c -----------------------------------------------------------------------------
 445 @anchor{airy_dbi}
 446 @deffn {Function} airy_dbi (@var{x})
 447 The derivative of the Airy Bi function @code{airy_bi(x)}.
 448
 449 See @code{airy_ai} and @code{airy_bi}.
 450
 451 @opencatbox{Categories:}
 452 @category{Airy functions}
 453 @category{Special functions}
 454 @closecatbox
 455 @end deffn
 456
 457 @c -----------------------------------------------------------------------------
 458 @node Gamma and factorial Functions, Exponential Integrals, Airy Functions, Special Functions
 459 @section Gamma and factorial Functions
 460 @c -----------------------------------------------------------------------------
 461
 462 The gamma function and the related beta, psi and incomplete gamma
 463 functions are defined in Abramowitz and Stegun,
 464 @i{Handbook of Mathematical Functions}, Chapter 6.
 465
 466 @c FOLLOWING FUNCTIONS IN bffac.mac ARE NOT DESCRIBED IN .texi FILES: !!!
 467 @c obfac, azetb, vonschtoonk, divrlst, obzeta, bfhzeta, bfpsi0 !!!
 468 @c DON'T KNOW WHICH ONES ARE INTENDED FOR GENERAL USE !!!
 469
 470 @c FOLLOWING FUNCTIONS IN bffac.mac ARE DESCRIBED IN Number.texi: !!!
 471 @c burn, bzeta, bfzeta !!!
 472
 473 @c FOLLOWING FUNCTIONS IN bffac.mac ARE DESCRIBED HERE: !!!
 474 @c bfpsi, bffac, cbffac !!!
 475
 476 @c -----------------------------------------------------------------------------
 477 @anchor{bffac}
 478 @deffn {Function} bffac (@var{expr}, @var{n})
 479
 480 Bigfloat version of the factorial (shifted gamma)
 481 function.  The second argument is how many digits to retain and return,
 482 it's a good idea to request a couple of extra.
 483
 484 @opencatbox{Categories:}
 485 @category{Gamma and factorial functions}
 486 @category{Numerical evaluation}
 487 @closecatbox
 488 @end deffn
 489
 490 @c -----------------------------------------------------------------------------
 491 @anchor{bfpsi}
 492 @deffn  {Function} bfpsi (@var{n}, @var{z}, @var{fpprec})
 493 @deffnx {Function} bfpsi0 (@var{z}, @var{fpprec})
 494
 495 @code{bfpsi} is the polygamma function of real argument @var{z} and integer
 496 order @var{n}.  @code{bfpsi0} is the digamma function.
 497 @code{bfpsi0 (@var{z}, @var{fpprec})} is equivalent to
 498 @code{bfpsi (0, @var{z}, @var{fpprec})}.
 499
 500 These functions return bigfloat values.
 501 @var{fpprec} is the bigfloat precision of the return value.
 502
 503 @c psi0(1) = -%gamma IS AN INTERESTING PROPERTY BUT IN THE ABSENCE OF ANY OTHER
 504 @c DISCUSSION OF THE PROPERTIES OF THIS FUNCTION, THIS STATEMENT SEEMS OUT OF PLACE.
 505 @c Note @code{-bfpsi0 (1, fpprec)} provides @code{%gamma} (Euler's constant) as a bigfloat.
 506
 507 @opencatbox{Categories:}
 508 @category{Gamma and factorial functions}
 509 @category{Numerical evaluation}
 510 @closecatbox
 511 @end deffn
 512
 513 @c -----------------------------------------------------------------------------
 514 @anchor{cbffac}
 515 @deffn {Function} cbffac (@var{z}, @var{fpprec})
 516 Complex bigfloat factorial.
 517
 518 @code{load ("bffac")} loads this function.
 519
 520 @opencatbox{Categories:}
 521 @category{Gamma and factorial functions}
 522 @category{Complex variables}
 523 @category{Numerical evaluation}
 524 @closecatbox
 525 @end deffn
 526
 527 @c -----------------------------------------------------------------------------
 528 @anchor{gamma}
 529 @deffn {Function} gamma (@var{z})
 530
 531 The basic definition of the gamma function (A&S 6.1.1) is
 532
 533 @ifnottex
 534 @example
 535                          inf
 536                         /
 537                         [     z - 1   - t
 538              gamma(z) = I    t      %e    dt
 539                         ]
 540                         /
 541                          0
 542 @end example
 543 @end ifnottex
 544 @tex
 545 $$\Gamma\left(z\right)=\int_{0}^{\infty }{t^{z-1}\,e^ {- t }\;dt}$$
 546 @end tex
 547
 548 Maxima simplifies @code{gamma} for positive integer and positive and negative
 549 rational numbers. For half integral values the result is a rational number times
 550 @code{sqrt(%pi)}. The simplification for integer values is controlled by
 551 @code{factlim}. For integers greater than @code{factlim} the numerical result of
 552 the factorial function, which is used to calculate @code{gamma}, will overflow.
 553 The simplification for rational numbers is controlled by @code{gammalim} to
 554 avoid internal overflow. See @code{factlim} and @code{gammalim}.
 555
 556 For negative integers @code{gamma} is not defined.
 557
 558 Maxima can evaluate @code{gamma} numerically for real and complex values in float
 559 and bigfloat precision.
 560
 561 @code{gamma} has mirror symmetry.
 562
 563 When @code{gamma_expand} is @code{true}, Maxima expands @code{gamma} for
 564 arguments @code{z+n} and @code{z-n} where @code{n} is an integer.
 565
 566 Maxima knows the derivative of @code{gamma}.
 567
 568 Examples:
 569
 570 Simplification for integer, half integral, and rational numbers:
 571
 572 @example
 573 (%i1) map('gamma,[1,2,3,4,5,6,7,8,9]);
 574 (%o1)        [1, 1, 2, 6, 24, 120, 720, 5040, 40320]
 575 (%i2) map('gamma,[1/2,3/2,5/2,7/2]);
 576                     sqrt(%pi)  3 sqrt(%pi)  15 sqrt(%pi)
 577 (%o2)   [sqrt(%pi), ---------, -----------, ------------]
 578                         2           4            8
 579 (%i3) map('gamma,[2/3,5/3,7/3]);
 580                                   2           1
 581                           2 gamma(-)  4 gamma(-)
 582                       2           3           3
 583 (%o3)          [gamma(-), ----------, ----------]
 584                       3       3           9
 585 @end example
 586
 587 Numerical evaluation for real and complex values:
 588
 589 @example
 590 (%i4) map('gamma,[2.5,2.5b0]);
 591 (%o4)     [1.329340388179137, 1.3293403881791370205b0]
 592 (%i5) map('gamma,[1.0+%i,1.0b0+%i]);
 593 (%o5) [0.498015668118356 - .1549498283018107 %i,
 594           4.9801566811835604272b-1 - 1.5494982830181068513b-1 %i]
 595 @end example
 596
 597 @code{gamma} has mirror symmetry:
 598
 599 @example
 600 (%i6) declare(z,complex)$
 601 (%i7) conjugate(gamma(z));
 602 (%o7)                  gamma(conjugate(z))
 603 @end example
 604
 605 Maxima expands @code{gamma(z+n)} and @code{gamma(z-n)}, when @code{gamma_expand}
 606 is @code{true}:
 607
 608 @example
 609 (%i8) gamma_expand:true$
 610
 611 (%i9) [gamma(z+1),gamma(z-1),gamma(z+2)/gamma(z+1)];
 612                                gamma(z)
 613 (%o9)             [z gamma(z), --------, z + 1]
 614                                 z - 1
 615 @end example
 616
 617 The derivative of @code{gamma}:
 618
 619 @example
 620 (%i10) diff(gamma(z),z);
 621 (%o10)                  psi (z) gamma(z)
 622                            0
 623 @end example
 624
 625 See also @mrefdot{makegamma}
 626
 627 The Euler-Mascheroni constant is @code{%gamma}.
 628
 629 @opencatbox{Categories:}
 630 @category{Gamma and factorial functions}
 631 @category{Special functions}
 632 @closecatbox
 633 @end deffn
 634
 635 @c -----------------------------------------------------------------------------
 636 @deffn {Function} log_gamma (@var{z})
 637
 638 The natural logarithm of the gamma function.
 639
 640 @opencatbox{Categories:}
 641 @category{Gamma and factorial functions}
 642 @category{Special functions}
 643 @closecatbox
 644 @end deffn
 645
 646 @c -----------------------------------------------------------------------------
 647 @deffn {Function} gamma_incomplete_lower (@var{a}, @var{z})
 648
 649 The lower incomplete gamma function (A&S 6.5.2):
 650
 651 @ifnottex
 652 @example
 653                                     z
 654                                    /
 655                                    [  a - 1   - t
 656     gamma_incomplete_lower(a, z) = I t      %e    dt
 657                                    ]
 658                                    /
 659                                     0
 660 @end example
 661 @end ifnottex
 662 @tex
 663 $$\gamma\left(a , z\right)=\int_{0}^{z}{t^{a-1}\,e^ {- t }\;dt}$$
 664 @end tex
 665
 666 See also @mref{gamma_incomplete} (upper incomplete gamma function).
 667
 668 @opencatbox{Categories:}
 669 @category{Gamma and factorial functions}
 670 @category{Special functions}
 671 @closecatbox
 672 @end deffn
 673
 674 @c -----------------------------------------------------------------------------
 675 @anchor{gamma_incomplete}
 676 @deffn {Function} gamma_incomplete (@var{a}, @var{z})
 677
 678 The incomplete upper gamma function (A&S 6.5.3):
 679
 680 @ifnottex
 681 @example
 682                               inf
 683                              /
 684                              [     a - 1   - t
 685     gamma_incomplete(a, z) = I    t      %e    dt
 686                              ]
 687                              /
 688                               z
 689 @end example
 690 @end ifnottex
 691 @tex
 692 $$\Gamma\left(a , z\right)=\int_{z}^{\infty }{t^{a-1}\,e^ {- t }\;dt}$$
 693 @end tex
 694
 695 See also @mref{gamma_expand} for controlling how
 696 @code{gamma_incomplete} is expressed in terms of elementary functions
 697 and @code{erfc}.
 698
 699 Also see the related functions @code{gamma_incomplete_regularized} and
 700 @code{gamma_incomplete_generalized}.
 701
 702 @opencatbox{Categories:}
 703 @category{Gamma and factorial functions}
 704 @category{Special functions}
 705 @closecatbox
 706 @end deffn
 707
 708 @c -----------------------------------------------------------------------------
 709 @deffn {Function} gamma_incomplete_regularized (@var{a}, @var{z})
 710
 711 The regularized incomplete upper gamma function (A&S 6.5.1):
 712
 713 @ifnottex
 714 @example
 715 gamma_incomplete_regularized(a, z) =
 716                                         gamma_incomplete(a, z)
 717                                         ----------------------
 718                                                gamma(a)
 719 @end example
 720 @end ifnottex
 721 @tex
 722 $${\it Q}\left(a , z\right)={{\Gamma\left(a , z\right)}\over{\Gamma\left(a\right)}}$$
 723 @end tex
 724
 725 See also @mref{gamma_expand} for controlling how
 726 @code{gamma_incomplete} is expressed in terms of elementary functions
 727 and @mrefdot{erfc}
 728
 729 Also see @code{gamma_incomplete}.
 730
 731 @opencatbox{Categories:}
 732 @category{Gamma and factorial functions}
 733 @category{Special functions}
 734 @closecatbox
 735 @end deffn
 736
 737 @c -----------------------------------------------------------------------------
 738 @deffn {Function} gamma_incomplete_generalized (@var{a}, @var{z1}, @var{z1})
 739
 740 The generalized incomplete gamma function.
 741
 742 @ifnottex
 743 @example
 744 gamma_incomplete_generalized(a, z1, z2) =
 745                                                z2
 746                                               /
 747                                               [    a - 1   - t
 748                                               I   t      %e    dt
 749                                               ]
 750                                               /
 751                                                z1
 752 @end example
 753 @end ifnottex
 754 @tex
 755 $$\Gamma\left(a , z_{1}, z_{2}\right)=\int_{z_{1}}^{z_{2}}{t^{a-1}\,e^ {- t }\;dt}$$
 756 @end tex
 757
 758 Also see @code{gamma_incomplete} and @code{gamma_incomplete_regularized}.
 759
 760 @opencatbox{Categories:}
 761 @category{Gamma and factorial functions}
 762 @category{Special functions}
 763 @closecatbox
 764 @end deffn
 765
 766
 767 @c -----------------------------------------------------------------------------
 768 @anchor{gamma_expand}
 769 @defvr {Option variable} gamma_expand
 770 Default value: @code{false}
 771
 772 @code{gamma_expand} controls expansion of @code{gamma_incomplete}.
 773 When @code{gamma_expand} is @code{true}, @code{gamma_incomplete(v,z)}
 774 is expanded in terms of
 775 @code{z}, @code{exp(z)}, and @code{gamma_incomplete} or @code{erfc(z)} when possible.
 776
 777 @example
 778 (%i1) gamma_incomplete(2,z);
 779 (%o1)                       gamma_incomplete(2, z)
 780 (%i2) gamma_expand:true;
 781 (%o2)                                true
 782 (%i3) gamma_incomplete(2,z);
 783                                            - z
 784 (%o3)                            (z + 1) %e
 785 @group
 786 (%i4) gamma_incomplete(3/2,z);
 787                               - z   sqrt(%pi) erfc(sqrt(z))
 788 (%o4)               sqrt(z) %e    + -----------------------
 789                                                2
 790 @end group
 791 @group
 792 (%i5) gamma_incomplete(4/3,z);
 793                                                     1
 794                                    gamma_incomplete(-, z)
 795                        1/3   - z                    3
 796 (%o5)                 z    %e    + ----------------------
 797                                              3
 798 @end group
 799 @group
 800 (%i6) gamma_incomplete(a+2,z);
 801              a               - z
 802 (%o6)       z  (z + a + 1) %e    + a (a + 1) gamma_incomplete(a, z)
 803 (%i7) gamma_incomplete(a-2, z);
 804         gamma_incomplete(a, z)    a - 2         z            1      - z
 805 (%o7)   ---------------------- - z      (--------------- + -----) %e
 806            (1 - a) (2 - a)               (a - 2) (a - 1)   a - 2
 807
 808 @end group
 809 @end example
 810
 811 @opencatbox{Categories:}
 812 @category{Gamma and factorial functions}
 813 @category{Simplification flags and variables}
 814 @closecatbox
 815
 816 @end defvr
 817 @c -----------------------------------------------------------------------------
 818 @anchor{gammalim}
 819 @defvr {Option variable} gammalim
 820 Default value: 10000
 821
 822 @c REPHRASE
 823 @code{gammalim} controls simplification of the gamma
 824 function for integral and rational number arguments.  If the absolute
 825 value of the argument is not greater than @code{gammalim}, then
 826 simplification will occur.  Note that the @code{factlim} switch controls
 827 simplification of the result of @code{gamma} of an integer argument as well.
 828
 829 @opencatbox{Categories:}
 830 @category{Gamma and factorial functions}
 831 @category{Simplification flags and variables}
 832 @closecatbox
 833
 834 @end defvr
 835
 836 @c NEED CROSS REFS HERE
 837 @c NEED EXAMPLES HERE
 838
 839 @c -----------------------------------------------------------------------------
 840 @anchor{makegamma}
 841 @deffn {Function} makegamma (@var{expr})
 842 Transforms instances of binomial, factorial, and beta
 843 functions in @var{expr} into gamma functions.
 844
 845 See also @mrefdot{makefact}
 846
 847 @opencatbox{Categories:}
 848 @category{Gamma and factorial functions}
 849 @closecatbox
 850 @end deffn
 851
 852 @anchor{beta}
 853 @c -----------------------------------------------------------------------------
 854 @deffn {Function} beta (@var{a}, @var{b})
 855 The beta function is defined as @code{gamma(a) gamma(b)/gamma(a+b)}
 856 (A&S 6.2.1).
 857
 858 Maxima simplifies the beta function for positive integers and rational
 859 numbers, which sum to an integer. When @code{beta_args_sum_to_integer} is
 860 @code{true}, Maxima simplifies also general expressions which sum to an integer.
 861
 862 For @var{a} or @var{b} equal to zero the beta function is not defined.
 863
 864 In general the beta function is not defined for negative integers as an
 865 argument. The exception is for @var{a=-n}, @var{n} a positive integer
 866 and @var{b} a positive integer with @code{b<=n}, it is possible to define an
 867 analytic continuation. Maxima gives for this case a result.
 868
 869 When @code{beta_expand} is @code{true}, expressions like @code{beta(a+n,b)} and
 870 @code{beta(a-n,b)} or @code{beta(a,b+n)} and @code{beta(a,b-n)} with @code{n}
 871 an integer are simplified.
 872
 873 Maxima can evaluate the beta function for real and complex values in float and
 874 bigfloat precision. For numerical evaluation Maxima uses @code{log_gamma}:
 875
 876 @example
 877            - log_gamma(b + a) + log_gamma(b) + log_gamma(a)
 878          %e
 879 @end example
 880
 881 Maxima knows that the beta function is symmetric and has mirror symmetry.
 882
 883 Maxima knows the derivatives of the beta function with respect to @var{a} or
 884 @var{b}.
 885
 886 To express the beta function as a ratio of gamma functions see @code{makegamma}.
 887
 888 Examples:
 889
 890 Simplification, when one of the arguments is an integer:
 891
 892 @example
 893 (%i1) [beta(2,3),beta(2,1/3),beta(2,a)];
 894                                1   9      1
 895 (%o1)                         [--, -, ---------]
 896                                12  4  a (a + 1)
 897 @end example
 898
 899 Simplification for two rational numbers as arguments which sum to an integer:
 900
 901 @example
 902 (%i2) [beta(1/2,5/2),beta(1/3,2/3),beta(1/4,3/4)];
 903                           3 %pi   2 %pi
 904 (%o2)                    [-----, -------, sqrt(2) %pi]
 905                             8    sqrt(3)
 906 @end example
 907
 908 When setting @code{beta_args_sum_to_integer} to @code{true} more general
 909 expression are simplified, when the sum of the arguments is an integer:
 910
 911 @example
 912 (%i3) beta_args_sum_to_integer:true$
 913 (%i4) beta(a+1,-a+2);
 914                                 %pi (a - 1) a
 915 (%o4)                         ------------------
 916                               2 sin(%pi (2 - a))
 917 @end example
 918
 919 The possible results, when one of the arguments is a negative integer:
 920
 921 @example
 922 (%i5) [beta(-3,1),beta(-3,2),beta(-3,3)];
 923                                     1  1    1
 924 (%o5)                            [- -, -, - -]
 925                                     3  6    3
 926 @end example
 927
 928 @code{beta(a+n,b)} or @code{beta(a-n)} with @code{n} an integer simplifies when
 929 @code{beta_expand} is @code{true}:
 930
 931 @example
 932 (%i6) beta_expand:true$
 933 (%i7) [beta(a+1,b),beta(a-1,b),beta(a+1,b)/beta(a,b+1)];
 934                     a beta(a, b)  beta(a, b) (b + a - 1)  a
 935 (%o7)              [------------, ----------------------, -]
 936                        b + a              a - 1           b
 937
 938 @end example
 939
 940 Beta is not defined, when one of the arguments is zero:
 941
 942 @example
 943 (%i7) beta(0,b);
 944 beta: expected nonzero arguments; found 0, b
 945  -- an error.  To debug this try debugmode(true);
 946 @end example
 947
 948 Numerical evaluation for real and complex arguments in float or bigfloat
 949 precision:
 950
 951 @example
 952 (%i8) beta(2.5,2.3);
 953 (%o8) .08694748611299981
 954
 955 (%i9) beta(2.5,1.4+%i);
 956 (%o9) 0.0640144950796695 - .1502078053286415 %i
 957
 958 (%i10) beta(2.5b0,2.3b0);
 959 (%o10) 8.694748611299969b-2
 960
 961 (%i11) beta(2.5b0,1.4b0+%i);
 962 (%o11) 6.401449507966944b-2 - 1.502078053286415b-1 %i
 963 @end example
 964
 965 Beta is symmetric and has mirror symmetry:
 966
 967 @example
 968 (%i14) beta(a,b)-beta(b,a);
 969 (%o14)                                 0
 970 (%i15) declare(a,complex,b,complex)$
 971 (%i16) conjugate(beta(a,b));
 972 (%o16)                 beta(conjugate(a), conjugate(b))
 973 @end example
 974
 975 The derivative of the beta function wrt @code{a}:
 976
 977 @example
 978 (%i17) diff(beta(a,b),a);
 979 (%o17)               - beta(a, b) (psi (b + a) - psi (a))
 980                                       0             0
 981 @end example
 982
 983 @opencatbox{Categories:}
 984 @category{Gamma and factorial functions}
 985 @closecatbox
 986 @end deffn
 987
 988 @c -----------------------------------------------------------------------------
 989 @deffn {Function} beta_incomplete (@var{a}, @var{b}, @var{z})
 990
 991 The basic definition of the incomplete beta function (A&S 6.6.1) is
 992
 993 @example
 994 @group
 995         z
 996        /
 997        [         b - 1  a - 1
 998        I  (1 - t)      t      dt
 999        ]
1000        /
1001         0
1002 @end group
1003 @end example
1004
1005 This definition is possible for @math{realpart(a)>0} and @math{realpart(b)>0}
1006 and @math{abs(z)<1}. For other values the incomplete beta function can be
1007 defined through a generalized hypergeometric function:
1008
1009 @example
1010    gamma(a) hypergeometric_generalized([a, 1 - b], [a + 1], z) z
1011 @end example
1012
1013 (See @url{https://functions.wolfram.com} for a complete definition of the incomplete beta
1014 function.)
1015
1016 For negative integers @math{a = -n} and positive integers @math{b=m} with
1017 @math{m<=n} the incomplete beta function is defined through
1018
1019 @example
1020                             m - 1           k
1021                             ====  (1 - m)  z
1022                       n - 1 \            k
1023                      z       >    -----------
1024                             /     k! (n - k)
1025                             ====
1026                             k = 0
1027 @end example
1028
1029 Maxima uses this definition to simplify @code{beta_incomplete} for @var{a} a
1030 negative integer.
1031
1032 For @var{a} a positive integer, @code{beta_incomplete} simplifies for any
1033 argument @var{b} and @var{z} and for @var{b} a positive integer for any
1034 argument @var{a} and @var{z}, with the exception of @var{a} a negative integer.
1035
1036 For @math{z=0} and @math{realpart(a)>0}, @code{beta_incomplete} has the
1037 specific value zero. For @var{z=1} and @math{realpart(b)>0},
1038 @code{beta_incomplete} simplifies to the beta function @code{beta(a,b)}.
1039
1040 Maxima evaluates @code{beta_incomplete} numerically for real and complex values
1041 in float or bigfloat precision. For the numerical evaluation an expansion of the
1042 incomplete beta function in continued fractions is used.
1043
1044 When the option variable @code{beta_expand} is @code{true}, Maxima expands
1045 expressions like @code{beta_incomplete(a+n,b,z)} and
1046 @code{beta_incomplete(a-n,b,z)} where n is a positive integer.
1047
1048 Maxima knows the derivatives of @code{beta_incomplete} with respect to the
1049 variables @var{a}, @var{b} and @var{z} and the integral with respect to the
1050 variable @var{z}.
1051
1052 Examples:
1053
1054 Simplification for @var{a} a positive integer:
1055
1056 @example
1057 (%i1) beta_incomplete(2,b,z);
1058                                        b
1059                             1 - (1 - z)  (b z + 1)
1060 (%o1)                       ----------------------
1061                                   b (b + 1)
1062 @end example
1063
1064 Simplification for @var{b} a positive integer:
1065
1066 @example
1067 (%i2) beta_incomplete(a,2,z);
1068                                                a
1069                               (a (1 - z) + 1) z
1070 (%o2)                         ------------------
1071                                   a (a + 1)
1072 @end example
1073
1074 Simplification for @var{a} and @var{b} a positive integer:
1075
1076 @example
1077 (%i3) beta_incomplete(3,2,z);
1078 @group
1079                                                3
1080                               (3 (1 - z) + 1) z
1081 (%o3)                         ------------------
1082                                       12
1083 @end group
1084 @end example
1085
1086 @var{a} is a negative integer and @math{b<=(-a)}, Maxima simplifies:
1087
1088 @example
1089 (%i4) beta_incomplete(-3,1,z);
1090                                        1
1091 (%o4)                              - ----
1092                                         3
1093                                      3 z
1094 @end example
1095
1096 For the specific values @math{z=0} and @math{z=1}, Maxima simplifies:
1097
1098 @example
1099 (%i5) assume(a>0,b>0)$
1100 (%i6) beta_incomplete(a,b,0);
1101 (%o6)                                 0
1102 (%i7) beta_incomplete(a,b,1);
1103 (%o7)                            beta(a, b)
1104 @end example
1105
1106 Numerical evaluation in float or bigfloat precision:
1107
1108 @example
1109 (%i8) beta_incomplete(0.25,0.50,0.9);
1110 (%o8)                          4.594959440269333
1111 (%i9)  fpprec:25$
1112 (%i10) beta_incomplete(0.25,0.50,0.9b0);
1113 (%o10)                    4.594959440269324086971203b0
1114 @end example
1115
1116 For @math{abs(z)>1} @code{beta_incomplete} returns a complex result:
1117
1118 @example
1119 (%i11) beta_incomplete(0.25,0.50,1.7);
1120 (%o11)              5.244115108584249 - 1.45518047787844 %i
1121 @end example
1122
1123 Results for more general complex arguments:
1124
1125 @example
1126 (%i14) beta_incomplete(0.25+%i,1.0+%i,1.7+%i);
1127 (%o14)             2.726960675662536 - .3831175704269199 %i
1128 (%i15) beta_incomplete(1/2,5/4*%i,2.8+%i);
1129 (%o15)             13.04649635168716 %i - 5.802067956270001
1130 (%i16)
1131 @end example
1132
1133 Expansion, when @code{beta_expand} is @code{true}:
1134
1135 @example
1136 (%i23) beta_incomplete(a+1,b,z),beta_expand:true;
1137                                                        b  a
1138                    a beta_incomplete(a, b, z)   (1 - z)  z
1139 (%o23)             -------------------------- - -----------
1140                              b + a                 b + a
1141
1142 (%i24) beta_incomplete(a-1,b,z),beta_expand:true;
1143                                                        b  a - 1
1144        beta_incomplete(a, b, z) (- b - a + 1)   (1 - z)  z
1145 (%o24) -------------------------------------- - ---------------
1146                        1 - a                         1 - a
1147 @end example
1148
1149 Derivative and integral for @code{beta_incomplete}:
1150
1151 @example
1152 (%i34) diff(beta_incomplete(a, b, z), z);
1153 @group
1154                               b - 1  a - 1
1155 (%o34)                 (1 - z)      z
1156 @end group
1157 (%i35) integrate(beta_incomplete(a, b, z), z);
1158               b  a
1159        (1 - z)  z
1160 (%o35) ----------- + beta_incomplete(a, b, z) z
1161           b + a
1162                                        a beta_incomplete(a, b, z)
1163                                      - --------------------------
1164                                                  b + a
1165 (%i36) factor(diff(%, z));
1166 (%o36)              beta_incomplete(a, b, z)
1167 @end example
1168
1169 @opencatbox{Categories:}
1170 @category{Gamma and factorial functions}
1171 @closecatbox
1172 @end deffn
1173
1174 @c -----------------------------------------------------------------------------
1175 @deffn {Function} beta_incomplete_regularized (@var{a}, @var{b}, @var{z})
1176
1177 The regularized incomplete beta function (A&S 6.6.2), defined as
1178
1179 @example
1180 beta_incomplete_regularized(a, b, z) =
1181                                       beta_incomplete(a, b, z)
1182                                       ------------------------
1183                                              beta(a, b)
1184 @end example
1185
1186 As for @code{beta_incomplete} this definition is not complete. See
1187 @url{https://functions.wolfram.com} for a complete definition of
1188 @code{beta_incomplete_regularized}.
1189
1190 @code{beta_incomplete_regularized} simplifies @var{a} or @var{b} a positive
1191 integer.
1192
1193 For @math{z=0} and @math{realpart(a)>0}, @code{beta_incomplete_regularized} has
1194 the specific value 0. For @var{z=1} and @math{realpart(b)>0},
1195 @code{beta_incomplete_regularized} simplifies to 1.
1196
1197 Maxima can evaluate @code{beta_incomplete_regularized} for real and complex
1198 arguments in float and bigfloat precision.
1199
1200 When @code{beta_expand} is @code{true}, Maxima expands
1201 @code{beta_incomplete_regularized} for arguments @math{a+n} or @math{a-n},
1202 where n is an integer.
1203
1204 Maxima knows the derivatives of @code{beta_incomplete_regularized} with respect
1205 to the variables @var{a}, @var{b}, and @var{z} and the integral with respect to
1206 the variable @var{z}.
1207
1208 Examples:
1209
1210 Simplification for @var{a} or @var{b} a positive integer:
1211
1212 @example
1213 (%i1) beta_incomplete_regularized(2,b,z);
1214                                        b
1215 (%o1)                       1 - (1 - z)  (b z + 1)
1216
1217 (%i2) beta_incomplete_regularized(a,2,z);
1218                                                a
1219 (%o2)                         (a (1 - z) + 1) z
1220
1221 (%i3) beta_incomplete_regularized(3,2,z);
1222                                                3
1223 (%o3)                         (3 (1 - z) + 1) z
1224 @end example
1225
1226 For the specific values @math{z=0} and @math{z=1}, Maxima simplifies:
1227
1228 @example
1229 (%i4) assume(a>0,b>0)$
1230 (%i5) beta_incomplete_regularized(a,b,0);
1231 (%o5)                                 0
1232 (%i6) beta_incomplete_regularized(a,b,1);
1233 (%o6)                                 1
1234 @end example
1235
1236 Numerical evaluation for real and complex arguments in float and bigfloat
1237 precision:
1238
1239 @example
1240 (%i7) beta_incomplete_regularized(0.12,0.43,0.9);
1241 (%o7)                         .9114011367359802
1242 (%i8) fpprec:32$
1243 (%i9) beta_incomplete_regularized(0.12,0.43,0.9b0);
1244 (%o9)               9.1140113673598075519946998779975b-1
1245 (%i10) beta_incomplete_regularized(1+%i,3/3,1.5*%i);
1246 (%o10)             .2865367499935403 %i - 0.122995963334684
1247 (%i11) fpprec:20$
1248 (%i12) beta_incomplete_regularized(1+%i,3/3,1.5b0*%i);
1249 (%o12)      2.8653674999354036142b-1 %i - 1.2299596333468400163b-1
1250 @end example
1251
1252 Expansion, when @code{beta_expand} is @code{true}:
1253
1254 @example
1255 (%i13) beta_incomplete_regularized(a+1,b,z);
1256                                                      b  a
1257                                               (1 - z)  z
1258 (%o13) beta_incomplete_regularized(a, b, z) - ------------
1259                                               a beta(a, b)
1260 (%i14) beta_incomplete_regularized(a-1,b,z);
1261 (%o14) beta_incomplete_regularized(a, b, z)
1262                                                      b  a - 1
1263                                               (1 - z)  z
1264                                          - ----------------------
1265                                            beta(a, b) (b + a - 1)
1266 @end example
1267
1268 The derivative and the integral wrt @var{z}:
1269
1270 @example
1271 (%i15) diff(beta_incomplete_regularized(a,b,z),z);
1272                               b - 1  a - 1
1273                        (1 - z)      z
1274 (%o15)                 -------------------
1275                            beta(a, b)
1276 (%i16) integrate(beta_incomplete_regularized(a,b,z),z);
1277 (%o16) beta_incomplete_regularized(a, b, z) z
1278                                                            b  a
1279                                                     (1 - z)  z
1280           a (beta_incomplete_regularized(a, b, z) - ------------)
1281                                                     a beta(a, b)
1282         - -------------------------------------------------------
1283                                    b + a
1284 @end example
1285
1286 @opencatbox{Categories:}
1287 @category{Gamma and factorial functions}
1288 @closecatbox
1289 @end deffn
1290
1291 @c -----------------------------------------------------------------------------
1292 @deffn {Function} beta_incomplete_generalized (@var{a}, @var{b}, @var{z1}, @var{z2})
1293
1294 The basic definition of the generalized incomplete beta function is
1295
1296 @example
1297 @group
1298              z2
1299            /
1300            [          b - 1  a - 1
1301            I   (1 - t)      t      dt
1302            ]
1303            /
1304             z1
1305 @end group
1306 @end example
1307
1308 Maxima simplifies @code{beta_incomplete_regularized} for @var{a} and @var{b}
1309 a positive integer.
1310
1311 For @math{realpart(a)>0} and @math{z1=0} or @math{z2=0}, Maxima simplifies
1312 @code{beta_incomplete_generalized} to @code{beta_incomplete}. For
1313 @math{realpart(b)>0} and @math{z1=1} or @var{z2=1}, Maxima simplifies to an
1314 expression with @code{beta} and @code{beta_incomplete}.
1315
1316 Maxima evaluates @code{beta_incomplete_regularized} for real and complex values
1317 in float and bigfloat precision.
1318
1319 When @code{beta_expand} is @code{true}, Maxima expands
1320 @code{beta_incomplete_generalized} for @math{a+n} and @math{a-n}, @var{n} a
1321 positive integer.
1322
1323 Maxima knows the derivative of @code{beta_incomplete_generalized} with respect
1324 to the variables @var{a}, @var{b}, @var{z1}, and @var{z2} and the integrals with
1325 respect to the variables @var{z1} and @var{z2}.
1326
1327 Examples:
1328
1329 Maxima simplifies @code{beta_incomplete_generalized} for @var{a} and @var{b} a
1330 positive integer:
1331
1332 @example
1333 (%i1) beta_incomplete_generalized(2,b,z1,z2);
1334                    b                      b
1335            (1 - z1)  (b z1 + 1) - (1 - z2)  (b z2 + 1)
1336 (%o1)      -------------------------------------------
1337                             b (b + 1)
1338 (%i2) beta_incomplete_generalized(a,2,z1,z2);
1339 @group
1340                               a                      a
1341            (a (1 - z2) + 1) z2  - (a (1 - z1) + 1) z1
1342 (%o2)      -------------------------------------------
1343                             a (a + 1)
1344 @end group
1345 (%i3) beta_incomplete_generalized(3,2,z1,z2);
1346               2      2                       2      2
1347       (1 - z1)  (3 z1  + 2 z1 + 1) - (1 - z2)  (3 z2  + 2 z2 + 1)
1348 (%o3) -----------------------------------------------------------
1349                                   12
1350 @end example
1351
1352 Simplification for specific values @math{z1=0}, @math{z2=0}, @math{z1=1}, or
1353 @math{z2=1}:
1354
1355 @example
1356 (%i4) assume(a > 0, b > 0)$
1357 (%i5) beta_incomplete_generalized(a,b,z1,0);
1358 (%o5)                    - beta_incomplete(a, b, z1)
1359
1360 (%i6) beta_incomplete_generalized(a,b,0,z2);
1361 (%o6)                    - beta_incomplete(a, b, z2)
1362
1363 (%i7) beta_incomplete_generalized(a,b,z1,1);
1364 (%o7)              beta(a, b) - beta_incomplete(a, b, z1)
1365
1366 (%i8) beta_incomplete_generalized(a,b,1,z2);
1367 (%o8)              beta_incomplete(a, b, z2) - beta(a, b)
1368 @end example
1369
1370 Numerical evaluation for real arguments in float or bigfloat precision:
1371
1372 @example
1373 (%i9) beta_incomplete_generalized(1/2,3/2,0.25,0.31);
1374 (%o9)                        .09638178086368676
1375
1376 (%i10) fpprec:32$
1377 (%i10) beta_incomplete_generalized(1/2,3/2,0.25,0.31b0);
1378 (%o10)               9.6381780863686935309170054689964b-2
1379 @end example
1380
1381 Numerical evaluation for complex arguments in float or bigfloat precision:
1382
1383 @example
1384 (%i11) beta_incomplete_generalized(1/2+%i,3/2+%i,0.25,0.31);
1385 (%o11)           - .09625463003205376 %i - .003323847735353769
1386 (%i12) fpprec:20$
1387 (%i13) beta_incomplete_generalized(1/2+%i,3/2+%i,0.25,0.31b0);
1388 (%o13)     - 9.6254630032054178691b-2 %i - 3.3238477353543591914b-3
1389 @end example
1390
1391 Expansion for @math{a+n} or @math{a-n}, @var{n} a positive integer, when
1392 @code{beta_expand} is @code{true}:
1393
1394 @example
1395 (%i14) beta_expand:true$
1396
1397 (%i15) beta_incomplete_generalized(a+1,b,z1,z2);
1398
1399                b   a           b   a
1400        (1 - z1)  z1  - (1 - z2)  z2
1401 (%o15) -----------------------------
1402                    b + a
1403                       a beta_incomplete_generalized(a, b, z1, z2)
1404                     + -------------------------------------------
1405                                          b + a
1406 (%i16) beta_incomplete_generalized(a-1,b,z1,z2);
1407
1408        beta_incomplete_generalized(a, b, z1, z2) (- b - a + 1)
1409 (%o16) -------------------------------------------------------
1410                                 1 - a
1411                                     b   a - 1           b   a - 1
1412                             (1 - z2)  z2      - (1 - z1)  z1
1413                           - -------------------------------------
1414                                             1 - a
1415 @end example
1416
1417 Derivative wrt the variable @var{z1} and integrals wrt @var{z1} and @var{z2}:
1418
1419 @example
1420 (%i17) diff(beta_incomplete_generalized(a,b,z1,z2),z1);
1421                                b - 1   a - 1
1422 (%o17)               - (1 - z1)      z1
1423 (%i18) integrate(beta_incomplete_generalized(a,b,z1,z2),z1);
1424 (%o18) beta_incomplete_generalized(a, b, z1, z2) z1
1425                                   + beta_incomplete(a + 1, b, z1)
1426 (%i19) integrate(beta_incomplete_generalized(a,b,z1,z2),z2);
1427 (%o19) beta_incomplete_generalized(a, b, z1, z2) z2
1428                                   - beta_incomplete(a + 1, b, z2)
1429 @end example
1430
1431 @opencatbox{Categories:}
1432 @category{Gamma and factorial functions}
1433 @closecatbox
1434 @end deffn
1435
1436 @defvr {Option variable} beta_expand
1437 Default value: false
1438
1439 When @code{beta_expand} is @code{true}, @code{beta(a,b)} and related
1440 functions are expanded for arguments like @math{a+n} or @math{a-n},
1441 where @math{n} is an integer.
1442
1443 @opencatbox{Categories:}
1444 @category{Gamma and factorial functions}
1445 @category{Simplification flags and variables}
1446 @closecatbox
1447 @end defvr
1448
1449 @defvr {Option variable} beta_args_sum_to_integer
1450 Default value: false
1451
1452 When @code{beta_args_sum_to_integer} is @code{true}, Maxima simplifies
1453 @code{beta(a,b)}, when the arguments @var{a} and @var{b} sum to an integer.
1454
1455 @opencatbox{Categories:}
1456 @category{Gamma and factorial functions}
1457 @category{Simplification flags and variables}
1458 @closecatbox
1459 @end defvr
1460
1461
1462 @c NEED INFO HERE ABOUT THE SUBSCRIPTED FORM psi[n](x)
1463 @c I (rtoy) don't think there is a plain psi(x) function anymore.
1464 @c @deffn {Function} psi (@var{x})
1465 @c @deffnx {Function} psi [@var{n}](@var{x})
1466 @deffn {Function} psi [@var{n}](@var{x})
1467
1468 The derivative of @code{log (gamma (@var{x}))} of order @code{@var{n}+1}.
1469 Thus, @code{psi[0](@var{x})} is the first derivative,
1470 @code{psi[1](@var{x})} is the second derivative, etc.
1471
1472 Maxima does not know how, in general, to compute a numerical value of
1473 @code{psi}, but it can compute some exact values for rational args.
1474 Several variables control what range of rational args @code{psi} will
1475 return an exact value, if possible.  See @code{maxpsiposint},
1476 @code{maxpsinegint}, @code{maxpsifracnum}, and @code{maxpsifracdenom}.
1477 That is, @var{x} must lie between @code{maxpsinegint} and
1478 @code{maxpsiposint}.  If the absolute value of the fractional part of
1479 @var{x} is rational and has a numerator less than @code{maxpsifracnum}
1480 and has a denominator less than @code{maxpsifracdenom}, @code{psi}
1481 will return an exact value.
1482
1483 The function @code{bfpsi} in the @code{bffac} package can compute
1484 numerical values.
1485
1486 @opencatbox{Categories:}
1487 @category{Gamma and factorial functions}
1488 @closecatbox
1489 @end deffn
1490
1491 @defvr {Option variable} maxpsiposint
1492 Default value: 20
1493
1494 @code{maxpsiposint} is the largest positive value for which
1495 @code{psi[n](x)} will try to compute an exact value.
1496
1497 @opencatbox{Categories:}
1498 @category{Gamma and factorial functions}
1499 @closecatbox
1500
1501 @end defvr
1502
1503 @defvr {Option variable} maxpsinegint
1504 Default value: -10
1505
1506 @code{maxpsinegint} is the most negative value for which
1507 @code{psi[n](x)} will try to compute an exact value.  That is if
1508 @var{x} is less than @code{maxnegint}, @code{psi[n](@var{x})} will not
1509 return simplified answer, even if it could.
1510
1511 @opencatbox{Categories:}
1512 @category{Gamma and factorial functions}
1513 @closecatbox
1514
1515 @end defvr
1516
1517 @defvr {Option variable} maxpsifracnum
1518 Default value: 6
1519
1520 Let @var{x} be a rational number less than one of the form @code{p/q}.
1521 If @code{p} is greater than @code{maxpsifracnum}, then
1522 @code{psi[@var{n}](@var{x})} will not try to return a simplified
1523 value.
1524
1525 @opencatbox{Categories:}
1526 @category{Gamma and factorial functions}
1527 @closecatbox
1528
1529 @end defvr
1530
1531 @defvr {Option variable} maxpsifracdenom
1532 Default value: 6
1533
1534 Let @var{x} be a rational number less than one of the form @code{p/q}.
1535 If @code{q} is greater than @code{maxpsifracdenom}, then
1536 @code{psi[@var{n}](@var{x})} will not try to return a simplified
1537 value.
1538
1539 @opencatbox{Categories:}
1540 @category{Gamma and factorial functions}
1541 @closecatbox
1542
1543 @end defvr
1544
1545 @c NEED CROSS REFS HERE
1546 @c NEED EXAMPLES HERE
1547 @anchor{makefact}
1548 @deffn {Function} makefact (@var{expr})
1549 Transforms instances of binomial, gamma, and beta
1550 functions in @var{expr} into factorials.
1551
1552 See also @mrefdot{makegamma}
1553
1554 @opencatbox{Categories:}
1555 @category{Gamma and factorial functions}
1556 @closecatbox
1557 @end deffn
1558
1559
1560 @c AREN'T THERE OTHER FUNCTIONS THAT DO ESSENTIALLY THE SAME THING ??
1561 @deffn {Function} numfactor (@var{expr})
1562 Returns the numerical factor multiplying the expression
1563 @var{expr}, which should be a single term.
1564
1565 @c WHY IS content MENTIONED IN THIS CONTEXT ??
1566 @code{content} returns the greatest common divisor (gcd) of all terms in a sum.
1567
1568 @example
1569 (%i1) gamma (7/2);
1570                           15 sqrt(%pi)
1571 (%o1)                     ------------
1572                                8
1573 (%i2) numfactor (%);
1574                                15
1575 (%o2)                          --
1576                                8
1577 @end example
1578
1579 @opencatbox{Categories:}
1580 @category{Expressions}
1581 @closecatbox
1582 @end deffn
1583
1584
1585 @node Exponential Integrals, Error Function, Gamma and factorial Functions, Special Functions
1586 @section Exponential Integrals
1587
1588 The Exponential Integral and related functions are defined in
1589 Abramowitz and Stegun,
1590 @i{Handbook of Mathematical Functions}, Chapter 5
1591
1592 @deffn {Function} expintegral_e1 (@var{z})
1593 The Exponential Integral E1(z) (A&S 5.1.1) defined as
1594
1595 @ifnotinfo
1596 @tex
1597 $$E_1(z) = \int_z^\infty {e^{-t} \over t} dt$$
1598
1599 with $|\arg\ z| < \pi$.
1600 @end tex
1601 @end ifnotinfo
1602 @ifinfo
1603 @math{integrate(exp(-t)/t, t, z, inf)}
1604 with @math{abs(arg z) < %pi}.
1605 @end ifinfo
1606
1607 @opencatbox{Categories:}
1608 @category{Exponential Integrals}
1609 @category{Special functions}
1610 @closecatbox
1611 @end deffn
1612
1613 @deffn {Function} expintegral_ei (@var{z})
1614 The Exponential Integral Ei(z) (A&S 5.1.2)
1615
1616 @opencatbox{Categories:}
1617 @category{Exponential Integrals}
1618 @category{Special functions}
1619 @closecatbox
1620 @end deffn
1621
1622 @deffn {Function} expintegral_li (@var{z})
1623 The Exponential Integral Li(z)  (A&S 5.1.3)
1624
1625 @opencatbox{Categories:}
1626 @category{Exponential Integrals}
1627 @category{Special functions}
1628 @closecatbox
1629 @end deffn
1630
1631 @deffn {Function} expintegral_e (@var{n},@var{z})
1632 The Exponential Integral En(z)  (A&S 5.1.4) defined as
1633
1634 @ifnotinfo
1635 @tex
1636 $$E_n(z) = \int_1^\infty {e^{-zt} \over t^n} dt$$
1637 with ${\rm Re}\ z > 0$ and $n = 0, 1, 2, \ldots$.
1638 @end tex
1639 @end ifnotinfo
1640 @ifinfo
1641 @math{integrate(exp(-z*t)/t^n, t, 1, inf)}
1642 with @math{real(x) > 1} and @math{n} a non-negative integer.
1643 @end ifinfo
1644
1645 @opencatbox{Categories:}
1646 @category{Exponential Integrals}
1647 @category{Special functions}
1648 @closecatbox
1649 @end deffn
1650
1651 @deffn {Function} expintegral_si (@var{z})
1652 The Exponential Integral Si(z) (A&S 5.2.1) defined as
1653
1654 @ifnotinfo
1655 @tex
1656 $${\rm Si}(z) = \int_0^z {\sin t \over t} dt$$
1657 @end tex
1658 @end ifnotinfo
1659 @ifinfo
1660 @math{integrate(sin(t)/t, t, 0, z)}
1661 @end ifinfo
1662
1663 @opencatbox{Categories:}
1664 @category{Exponential Integrals}
1665 @category{Special functions}
1666 @closecatbox
1667 @end deffn
1668
1669 @deffn {Function} expintegral_ci (@var{z})
1670 The Exponential Integral Ci(z) (A&S 5.2.2) defined as
1671
1672 @ifnotinfo
1673 @tex
1674 $${\rm Ci}(z) = \gamma + \log z + \int_0^z {{\cos t - 1} \over t} dt$$
1675
1676 with $|\arg\ z| < \pi$.
1677 @end tex
1678 @end ifnotinfo
1679 @ifinfo
1680 @math{%gamma + log(z) + integrate((cos(t) - 1)/t, t, 0, z)}
1681
1682 with @math{abs(arg z) < %pi}
1683 @end ifinfo
1684
1685 @opencatbox{Categories:}
1686 @category{Exponential Integrals}
1687 @category{Special functions}
1688 @closecatbox
1689 @end deffn
1690
1691 @deffn {Function} expintegral_shi (@var{z})
1692 The Exponential Integral Shi(z) (A&S 5.2.3) defined as
1693
1694 @ifnotinfo
1695 @tex
1696 $${\rm Shi}(z) = \int_0^z {\sinh t \over t} dt$$
1697 @end tex
1698 @end ifnotinfo
1699 @ifinfo
1700 @math{integrate(sinh(t)/t, t, 0, z)}
1701 @end ifinfo
1702
1703
1704 @opencatbox{Categories:}
1705 @category{Exponential Integrals}
1706 @category{Special functions}
1707 @closecatbox
1708 @end deffn
1709
1710 @deffn {Function} expintegral_chi (@var{z})
1711 The Exponential Integral Chi(z) (A&S 5.2.4) defined as
1712
1713 @ifnotinfo
1714 @tex
1715 $${\rm Chi}(z) = \gamma + \log z + \int_0^z {{\cosh t - 1} \over t} dt$$
1716
1717 with $|\arg\ z| < \pi$.
1718 @end tex
1719 @end ifnotinfo
1720 @ifinfo
1721 @math{%gamma + log(z) + integrate((cosh(t) - 1)/t, t, 0, z)}
1722
1723 with @math{abs(arg z) < %pi}
1724 @end ifinfo
1725
1726 @opencatbox{Categories:}
1727 @category{Exponential Integrals}
1728 @category{Special functions}
1729 @closecatbox
1730 @end deffn
1731
1732 @defvr {Option variable} expintrep
1733 Default value: false
1734
1735 Change the representation of one of the exponential integrals,
1736 @var{expintegral_e(m, z)}, @var{expintegral_e1}, or
1737 @var{expintegral_ei} to an equivalent form if possible.
1738
1739 Possible values for @var{expintrep} are @var{false},
1740 @var{gamma_incomplete}, @var{expintegral_e1}, @var{expintegral_ei},
1741 @var{expintegral_li}, @var{expintegral_trig}, or
1742 @var{expintegral_hyp}.
1743
1744 @var{false} means that the representation is not changed.  Other
1745 values indicate the representation is to be changed to use the
1746 function specified where @var{expintegral_trig} means
1747 @var{expintegral_si}, @var{expintegral_ci}, and @var{expintegral_hyp}
1748 means @var{expintegral_shi} or @var{expintegral_chi}.
1749
1750 @opencatbox{Categories:}
1751 @category{Exponential Integrals}
1752 @closecatbox
1753 @end defvr
1754
1755 @defvr {Option variable} expintexpand
1756 Default value: false
1757
1758 Expand the Exponential Integral E[n](z)
1759 for half integral values in terms of Erfc or Erf and
1760 for positive integers in terms of Ei
1761 @opencatbox{Categories:}
1762 @category{Exponential Integrals}
1763 @closecatbox
1764 @end defvr
1765
1766 @node Error Function, Struve Functions, Exponential Integrals, Special Functions
1767 @section Error Function
1768
1769 The Error function and related functions are defined in
1770 Abramowitz and Stegun,
1771 @i{Handbook of Mathematical Functions}, Chapter 7
1772
1773 @c -----------------------------------------------------------------------------
1774 @anchor{erf}
1775 @deffn {Function} erf (@var{z})
1776
1777 The Error Function erf(z) (A&S 7.1.1)
1778
1779 See also flag @mrefdot{erfflag}
1780 @opencatbox{Categories:}
1781 @category{Special functions}
1782 @closecatbox
1783 @end deffn
1784
1785 @anchor{erfc}
1786 @deffn {Function} erfc (@var{z})
1787 The Complementary Error Function erfc(z) (A&S 7.1.2)
1788
1789 @code{erfc(z) = 1-erf(z)}
1790 @opencatbox{Categories:}
1791 @category{Special functions}
1792 @closecatbox
1793 @end deffn
1794
1795 @deffn {Function} erfi (@var{z})
1796 The Imaginary Error Function.
1797
1798 @code{erfi(z) = -%i*erf(%i*z)}
1799 @opencatbox{Categories:}
1800 @category{Special functions}
1801 @closecatbox
1802 @end deffn
1803
1804 @deffn {Function} erf_generalized (@var{z1},@var{z2})
1805 Generalized Error function Erf(z1,z2)
1806 @opencatbox{Categories:}
1807 @category{Special functions}
1808 @closecatbox
1809 @end deffn
1810
1811 @deffn {Function} fresnel_c (@var{z})
1812 The Fresnel Integral C(z) = integrate(cos((%pi/2)*t^2),t,0,z). (A&S 7.3.1)
1813
1814 The simplification fresnel_c(-x) = -fresnel_c(x) is applied when
1815 flag @code{trigsign} is true.
1816
1817 The simplification fresnel_c(%i*x) =  %i*fresnel_c(x) is applied when
1818 flag @code{%iargs} is true.
1819
1820 See flags @code{erf_representation} and @code{hypergeometric_representation}.
1821 @opencatbox{Categories:}
1822 @category{Special functions}
1823 @closecatbox
1824 @end deffn
1825
1826 @deffn {Function} fresnel_s (@var{z})
1827 The Fresnel Integral S(z) = integrate(sin((%pi/2)*t^2),t,0,z). (A&S 7.3.2)
1828
1829 The simplification fresnel_s(-x) = -fresnel_s(x) is applied when
1830 flag @code{trigsign} is true.
1831
1832 The simplification fresnel_s(%i*x) =  -%i*fresnel_s(x) is applied when
1833 flag @code{%iargs} is true.
1834
1835 See flags @code{erf_representation} and @code{hypergeometric_representation}.
1836 @opencatbox{Categories:}
1837 @category{Special functions}
1838 @closecatbox
1839 @end deffn
1840
1841 @defvr {Option variable} erf_representation
1842 Default value: false
1843
1844 When T erfc, erfi, erf_generalized, fresnel_s
1845 and fresnel_c are transformed to erf.
1846 @end defvr
1847
1848 @defvr {Option variable} hypergeometric_representation
1849 Default value: false
1850
1851 Enables transformation to a Hypergeometric
1852 representation for fresnel_s and fresnel_c
1853 @end defvr
1854
1855 @node Struve Functions, Hypergeometric Functions, Error Function, Special Functions
1856 @section Struve Functions
1857
1858 The Struve functions are defined in Abramowitz and Stegun,
1859 @i{Handbook of Mathematical Functions}, Chapter 12.
1860
1861 @c -----------------------------------------------------------------------------
1862 @deffn {Function} struve_h (@var{v}, @var{z})
1863 The Struve Function H of order v and argument z. (A&S 12.1.1)
1864
1865 @opencatbox{Categories:}
1866 @category{Special functions}
1867 @closecatbox
1868 @end deffn
1869
1870 @c -----------------------------------------------------------------------------
1871 @deffn {Function} struve_l (@var{v}, @var{z})
1872 The Modified Struve Function L of order v and argument z. (A&S 12.2.1)
1873
1874 @opencatbox{Categories:}
1875 @category{Special functions}
1876 @closecatbox
1877 @end deffn
1878
1879 @node Hypergeometric Functions, Parabolic Cylinder Functions, Struve Functions, Special Functions
1880 @section Hypergeometric Functions
1881
1882 The Hypergeometric Functions are defined in Abramowitz and Stegun,
1883 @i{Handbook of Mathematical Functions}, Chapters 13 and 15.
1884
1885 Maxima has very limited knowledge of these functions.  They
1886 can be returned from function @code{hgfred}.
1887
1888 @deffn {Function} %m [@var{k},@var{u}] (@var{z})
1889 Whittaker M function
1890 @code{M[k,u](z) = exp(-z/2)*z^(1/2+u)*M(1/2+u-k,1+2*u,z)}.
1891 (A&S 13.1.32)
1892 @opencatbox{Categories:}
1893 @category{Special functions}
1894 @closecatbox
1895 @end deffn
1896
1897 @deffn {Function} %w [@var{k},@var{u}] (@var{z})
1898 Whittaker W function.  (A&S 13.1.33)
1899 @opencatbox{Categories:}
1900 @category{Special functions}
1901 @closecatbox
1902 @end deffn
1903
1904
1905 @deffn {Function} %f [@var{p},@var{q}] (@var{[a],[b],z})
1906 The pFq(a1,a2,..ap;b1,b2,..bq;z) hypergeometric function,
1907 where @code{a} a list of length @code{p} and
1908 @code{b} a list of length @code{q}.
1909 @opencatbox{Categories:}
1910 @category{Bessel functions}
1911 @category{Special functions}
1912 @closecatbox
1913 @end deffn
1914
1915 @deffn {Function} hypergeometric ([@var{a1}, ..., @var{ap}],[@var{b1}, ... ,@var{bq}], x)
1916 The hypergeometric function. Unlike Maxima's @code{%f} hypergeometric
1917 function, the function @code{hypergeometric} is a simplifying
1918 function; also, @code{hypergeometric} supports complex double and
1919 big floating point evaluation. For the Gauss hypergeometric function,
1920 that is @math{p = 2} and @math{q = 1}, floating point evaluation
1921 outside the unit circle is supported, but in general, it is not
1922 supported.
1923
1924 When the option variable @code{expand_hypergeometric} is true (default
1925 is false) and one of the arguments @code{a1} through @code{ap} is a
1926 negative integer (a polynomial case), @code{hypergeometric} returns an
1927 expanded polynomial.
1928
1929 Examples:
1930
1931 @example
1932 (%i1)  hypergeometric([],[],x);
1933 (%o1) %e^x
1934 @end example
1935
1936 Polynomial cases automatically expand when @code{expand_hypergeometric} is true:
1937
1938 @example
1939 (%i2) hypergeometric([-3],[7],x);
1940 (%o2) hypergeometric([-3],[7],x)
1941
1942 (%i3) hypergeometric([-3],[7],x), expand_hypergeometric : true;
1943 (%o3) -x^3/504+3*x^2/56-3*x/7+1
1944 @end example
1945
1946 Both double float and big float evaluation is supported:
1947
1948 @example
1949 (%i4) hypergeometric([5.1],[7.1 + %i],0.42);
1950 (%o4)       1.346250786375334 - 0.0559061414208204 %i
1951 (%i5) hypergeometric([5,6],[8], 5.7 - %i);
1952 (%o5)     .007375824009774946 - .001049813688578674 %i
1953 (%i6) hypergeometric([5,6],[8], 5.7b0 - %i), fpprec : 30;
1954 (%o6) 7.37582400977494674506442010824b-3
1955                           - 1.04981368857867315858055393376b-3 %i
1956 @end example
1957 @end deffn
1958
1959 @node Parabolic Cylinder Functions, Functions and Variables for Special Functions, Hypergeometric Functions, Special Functions
1960 @section  Parabolic Cylinder Functions
1961
1962 The Parabolic Cylinder Functions are defined in Abramowitz and Stegun,
1963 @i{Handbook of Mathematical Functions}, Chapter 19.
1964
1965 Maxima has very limited knowledge of these functions.  They
1966 can be returned from function @code{hgfred}.
1967
1968 @deffn {Function} parabolic_cylinder_d (@var{v}, @var{z})
1969 The parabolic cylinder function @code{parabolic_cylinder_d(v,z)}. (A&S 19.3.1)
1970 @opencatbox{Categories:}
1971 @category{Special functions}
1972 @closecatbox
1973 @end deffn
1974
1975
1976
1977
1978 @node Functions and Variables for Special Functions,  , Parabolic Cylinder Functions, Special Functions
1979 @section Functions and Variables for Special Functions
1980
1981
1982 @anchor{specint}
1983 @deffn {Function} specint (exp(- s*@var{t}) * @var{expr}, @var{t})
1984
1985 Compute the Laplace transform of @var{expr} with respect to the variable @var{t}.
1986 The integrand @var{expr} may contain special functions.   The
1987 parameter @var{s} maybe be named something else; it is determined
1988 automatically, as the examples below show where @var{p} is used in
1989 some places.
1990
1991 The following special functions are handled by @code{specint}: incomplete gamma
1992 function, error functions (but not the error function @code{erfi}, it is easy to
1993 transform @code{erfi} e.g. to the error function @code{erf}), exponential
1994 integrals, bessel functions (including products of bessel functions), hankel
1995 functions, hermite and the laguerre polynomials.
1996
1997 Furthermore, @code{specint} can handle the hypergeometric function
1998 @code{%f[p,q]([],[],z)}, the whittaker function of the first kind
1999 @code{%m[u,k](z)} and of the second kind @code{%w[u,k](z)}.
2000
2001 The result may be in terms of special functions and can include unsimplified
2002 hypergeometric functions.
2003
2004 When @code{laplace} fails to find a Laplace transform, @code{specint} is called.
2005 Because @code{laplace} knows more general rules for Laplace transforms, it is
2006 preferable to use @code{laplace} and not @code{specint}.
2007
2008 @code{demo("hypgeo")} displays several examples of Laplace transforms computed by
2009 @code{specint}.
2010
2011 Examples:
2012 @c ===beg===
2013 @c assume (p > 0, a > 0)$
2014 @c specint (t^(1/2) * exp(-a*t/4) * exp(-p*t), t);
2015 @c specint (t^(1/2) * bessel_j(1, 2 * a^(1/2) * t^(1/2))
2016 @c               * exp(-p*t), t);
2017 @c ===end===
2018 @example
2019 (%i1) assume (p > 0, a > 0)$
2020 @group
2021 (%i2) specint (t^(1/2) * exp(-a*t/4) * exp(-p*t), t);
2022                            sqrt(%pi)
2023 (%o2)                     ------------
2024                                  a 3/2
2025                           2 (p + -)
2026                                  4
2027 @end group
2028 @group
2029 (%i3) specint (t^(1/2) * bessel_j(1, 2 * a^(1/2) * t^(1/2))
2030               * exp(-p*t), t);
2031                                    - a/p
2032                          sqrt(a) %e
2033 (%o3)                    ---------------
2034                                 2
2035                                p
2036 @end group
2037 @end example
2038
2039 Examples for exponential integrals:
2040
2041 @example
2042 (%i4) assume(s>0,a>0,s-a>0)$
2043 (%i5) ratsimp(specint(%e^(a*t)
2044                       *(log(a)+expintegral_e1(a*t))*%e^(-s*t),t));
2045                              log(s)
2046 (%o5)                        ------
2047                              s - a
2048 (%i6) logarc:true$
2049
2050 (%i7) gamma_expand:true$
2051
2052 radcan(specint((cos(t)*expintegral_si(t)
2053                      -sin(t)*expintegral_ci(t))*%e^(-s*t),t));
2054                              log(s)
2055 (%o8)                        ------
2056                               2
2057                              s  + 1
2058 ratsimp(specint((2*t*log(a)+2/a*sin(a*t)
2059                       -2*t*expintegral_ci(a*t))*%e^(-s*t),t));
2060                                2    2
2061                           log(s  + a )
2062 (%o9)                     ------------
2063                                 2
2064                                s
2065 @end example
2066
2067 Results when using the expansion of @code{gamma_incomplete} and when changing
2068 the representation to @code{expintegral_e1}:
2069
2070 @example
2071 (%i10) assume(s>0)$
2072 (%i11) specint(1/sqrt(%pi*t)*unit_step(t-k)*%e^(-s*t),t);
2073                                             1
2074                             gamma_incomplete(-, k s)
2075                                             2
2076 (%o11)                      ------------------------
2077                                sqrt(%pi) sqrt(s)
2078
2079 (%i12) gamma_expand:true$
2080 (%i13) specint(1/sqrt(%pi*t)*unit_step(t-k)*%e^(-s*t),t);
2081                               erfc(sqrt(k) sqrt(s))
2082 (%o13)                        ---------------------
2083                                      sqrt(s)
2084
2085 (%i14) expintrep:expintegral_e1$
2086 (%i15) ratsimp(specint(1/(t+a)^2*%e^(-s*t),t));
2087                               a s
2088                         a s %e    expintegral_e1(a s) - 1
2089 (%o15)                - ---------------------------------
2090                                         a
2091 @end example
2092
2093 @opencatbox{Categories:}
2094 @category{Laplace transform}
2095 @closecatbox
2096 @end deffn
2097
2098 @deffn {Function} hypergeometric_simp (@var{e})
2099
2100 @code{hypergeometric_simp} simplifies hypergeometric functions
2101 by applying @code{hgfred}
2102 to the arguments of any hypergeometric functions in the expression @var{e}.
2103
2104 Only instances of @code{hypergeometric} are affected;
2105 any @code{%f}, @code{%w}, and @code{%m} in the expression @var{e} are not affected.
2106 Any unsimplified hypergeometric functions are returned unchanged
2107 (instead of changing to @code{%f} as @code{hgfred} would).
2108
2109 @code{load(hypergeometric);} loads this function.
2110
2111 See also @mrefdot{hgfred}
2112
2113 Examples:
2114
2115 @c ===beg===
2116 @c load ("hypergeometric") $
2117 @c foo : [hypergeometric([1,1], [2], z), hypergeometric([1/2], [1], z)];
2118 @c hypergeometric_simp (foo);
2119 @c bar : hypergeometric([n], [m], z + 1);
2120 @c hypergeometric_simp (bar);
2121 @c ===end===
2122 @example
2123 (%i1) load ("hypergeometric") $
2124 (%i2) foo : [hypergeometric([1,1], [2], z), hypergeometric([1/2], [1], z)];
2125 (%o2) [hypergeometric([1, 1], [2], z),
2126                                                      1
2127                                      hypergeometric([-], [1], z)]
2128                                                      2
2129 (%i3) hypergeometric_simp (foo);
2130                  log(1 - z)              z    z/2
2131 (%o3)         [- ----------, bessel_i(0, -) %e   ]
2132                      z                   2
2133 (%i4) bar : hypergeometric([n], [m], z + 1);
2134 (%o4)            hypergeometric([n], [m], z + 1)
2135 (%i5) hypergeometric_simp (bar);
2136 (%o5)            hypergeometric([n], [m], z + 1)
2137 @end example
2138
2139 @opencatbox{Categories:}
2140 @category{Hypergeometric functions}
2141 @category{Simplification functions}
2142 @category{Special functions}
2143 @closecatbox
2144 @end deffn
2145
2146 @anchor{hgfred}
2147 @deffn {Function} hgfred (@var{a}, @var{b}, @var{t})
2148
2149 Simplify the generalized hypergeometric function in terms of other,
2150 simpler, forms.  @var{a} is a list of numerator parameters and @var{b}
2151 is a list of the denominator parameters.
2152
2153 If @code{hgfred} cannot simplify the hypergeometric function, it returns
2154 an expression of the form @code{%f[p,q]([a], [b], x)} where @var{p} is
2155 the number of elements in @var{a}, and @var{q} is the number of elements
2156 in @var{b}.  This is the usual @code{pFq} generalized hypergeometric
2157 function.
2158
2159 @example
2160 (%i1) assume(not(equal(z,0)));
2161 (%o1)                          [notequal(z, 0)]
2162 (%i2) hgfred([v+1/2],[2*v+1],2*%i*z);
2163
2164                      v/2                               %i z
2165                     4    bessel_j(v, z) gamma(v + 1) %e
2166 (%o2)               ---------------------------------------
2167                                        v
2168                                       z
2169 (%i3) hgfred([1,1],[2],z);
2170
2171                                    log(1 - z)
2172 (%o3)                            - ----------
2173                                        z
2174 (%i4) hgfred([a,a+1/2],[3/2],z^2);
2175
2176                                1 - 2 a          1 - 2 a
2177                         (z + 1)        - (1 - z)
2178 (%o4)                   -------------------------------
2179                                  2 (1 - 2 a) z
2180
2181 @end example
2182
2183 It can be beneficial to load orthopoly too as the following example
2184 shows.  Note that @var{L} is the generalized Laguerre polynomial.
2185
2186 @example
2187 (%i5) load(orthopoly)$
2188 (%i6) hgfred([-2],[a],z);
2189 @group
2190
2191                                     (a - 1)
2192                                  2 L       (z)
2193                                     2
2194 (%o6)                            -------------
2195                                    a (a + 1)
2196 @end group
2197 (%i7) ev(%);
2198
2199                                   2
2200                                  z        2 z
2201 (%o7)                         --------- - --- + 1
2202                               a (a + 1)    a
2203
2204 @end example
2205 @end deffn
2206
2207 @deffn {Function} lambert_w (@var{z})
2208 The principal branch of Lambert's W function W(z), the solution of
2209 @code{z = W(z) * exp(W(z))}.  (DLMF 4.13)
2210 @opencatbox{Categories:}
2211 @category{Special functions}
2212 @closecatbox
2213 @end deffn
2214
2215 @deffn {Function} generalized_lambert_w (@var{k}, @var{z})
2216 The @var{k}-th branch of Lambert's W function W(z), the solution of
2217 @code{z = W(z) * exp(W(z))}. (DLMF 4.13)
2218
2219 The principal branch, denoted Wp(z) in DLMF, is @code{lambert_w(z) = generalized_lambert_w(0,z)}.
2220
2221 The other branch with real values, denoted Wm(z) in DLMF, is @code{generalized_lambert_w(-1,z)}.
2222 @opencatbox{Categories:}
2223 @category{Special functions}
2224 @closecatbox
2225 @end deffn
2226
2227
2228
2229 @deffn {Function} nzeta (@var{z})
2230 The Plasma Dispersion Function
2231 @code{nzeta(z) = %i*sqrt(%pi)*exp(-z^2)*(1-erf(-%i*z))}
2232 @opencatbox{Categories:}
2233 @category{Special functions}
2234 @closecatbox
2235 @end deffn
2236
2237 @deffn {Function} nzetar (@var{z})
2238 Returns @code{realpart(nzeta(z))}.
2239 @opencatbox{Categories:}
2240 @category{Special functions}
2241 @closecatbox
2242 @end deffn
2243
2244 @deffn {Function} nzetai (@var{z})
2245 Returns @code{imagpart(nzeta(z))}.
2246 @opencatbox{Categories:}
2247 @category{Special functions}
2248 @closecatbox
2249 @end deffn
2250