doc/info/es/Special.es.texi

   1 @c English version 2013-07-30
   2 @menu
   3 * Introducción a las funciones especiales::
   4 * Funciones de Bessel::
   5 * Funciones de Airy::
   6 * Funciones Gamma y factorial::
   7 * Integral exponencial::
   8 * Función de error::
   9 * Funciones de Struve::
  10 * Funciones hipergeométricas::
  11 * Funciones de cilindro parabólico::
  12 * Funciones y variables para las funciones especiales::
  13 @end menu
  14
  15 @node Introducción a las funciones especiales, Funciones de Bessel, Funciones Especiales, Funciones Especiales
  16 @section Introducción a las funciones especiales
  17
  18 A continuación se especifican las notaciones correspondientes a las funciones especiales:
  19
  20 @example
  21 bessel_j (index, expr)    Función de Bessel de primera especie
  22 bessel_y (index, expr)    Función de Bessel de segunda especie
  23 bessel_i (index, expr)    Función de Bessel modificada de primera especie
  24 bessel_k (index, expr)    Función de Bessel modificada de segunda especie
  25 hankel_1 (v,z)            Función de Hankel de primera especie
  26 hankel_2 (v,z)            Función de Hankel de segunda especie
  27 struve_h (v,z)            Función H de Struve
  28 struve_l (v,z)            Función L de Struve
  29 %p[u,v] (z)               Función de Legendre de primera especie
  30 %q[u,v] (z)               Función de Legendre de segunda especie
  31 %f[p,q] ([], [], expr)    Función hipergeométrica generalizada
  32 gamma(z)                  Función Gamma
  33 gamma_incomplete_lower(a,z) Función Gamma incompleta inferior
  34 gamma_incomplete (a,z)    Extremo de la función Gamma incompleta
  35 hypergeometric(l1, l2, z) Función hipergeométrica
  36 @c IS slommel THE "LOMMEL" FUNCTION ?? NOT OTHERWISE MENTIONED IN TEXINFO FILES
  37 slommel
  38 %m[u,k] (z)               Función de Whittaker de primera especie
  39 %w[u,k] (z)               Función de Whittaker de segunda especie
  40 erfc (z)                  Complemento de la función de error, erf
  41 expintegral_e (v,z)       Integral exponencial E
  42 expintegral_e1 (z)        Integral exponencial E1
  43 expintegral_ei (z)        Integral exponencial Ei
  44 expintegral_li (z)        Integral logarítmica Li
  45 expintegral_si (z)        Integral exponencial Si
  46 expintegral_ci (z)        Integral exponencial Ci
  47 expintegral_shi (z)       Integral exponencial Shi
  48 expintegral_chi (z)       Integral exponencial Chi
  49 kelliptic (z)             Integral elíptica completa
  50                                   de primera especie (K)
  51 parabolic_cylinder_d(v,z) Función D de cilindro parabólico
  52 @end example
  53
  54
  55
  56
  57
  58 @node Funciones de Bessel, Funciones de Airy, Introducción a las funciones especiales, Funciones Especiales
  59 @section Funciones de Bessel
  60
  61
  62 @deffn {Función} bessel_j (@var{v}, @var{z})
  63 Función de Bessel de primera especie de orden @math{v} y argumento @math{z}.
  64
  65 La función @code{bessel_j} se define como
  66
  67 @ifnottex
  68 @example
  69                 inf
  70                 ====       k  - v - 2 k  v + 2 k
  71                 \     (- 1)  2          z
  72                  >    --------------------------
  73                 /        k! gamma(v + k + 1)
  74                 ====
  75                 k = 0
  76 @end example
  77 @end ifnottex
  78
  79 @tex
  80 $$\sum_{k=0}^{\infty }{{{\left(-1\right)^{k}\,\left(z\over 2\right)^{v+2\,k}
  81  }\over{k!\,\Gamma\left(v+k+1\right)}}}$$
  82 @end tex
  83
  84 aunque la serie infinita no se utiliza en los cálculos.
  85
  86 @end deffn
  87
  88 @deffn {Función} bessel_y (@var{v}, @var{z})
  89 Función de Bessel de segunda especie de orden @math{v} y argumento @math{z}.
  90
  91 La función @code{bessel_y} se define como
  92
  93 @ifnottex
  94 @example
  95               cos(%pi v) bessel_j(v, z) - bessel_j(-v, z)
  96               -------------------------------------------
  97                              sin(%pi v)
  98 @end example
  99 @end ifnottex
 100
 101 @tex
 102 $${{\cos \left(\pi\,v\right)\,J_{v}(z)-J_{-v}(z)}\over{
 103  \sin \left(\pi\,v\right)}}$$
 104 @end tex
 105
 106 si @math{v} no es un entero.  En caso de que  @math{v} sea un entero @math{n}, se calcula el límite cuando @math{v} se aproxima a @math{n}.
 107
 108 @end deffn
 109
 110
 111 @deffn {Función} bessel_i (@var{v}, @var{z})
 112 Función modificada de Bessel de primera especie de orden @math{v} y argumento @math{z}.
 113
 114 La función @code{bessel_i} se define como
 115
 116 @ifnottex
 117 @example
 118                     inf
 119                     ====   - v - 2 k  v + 2 k
 120                     \     2          z
 121                      >    -------------------
 122                     /     k! gamma(v + k + 1)
 123                     ====
 124                     k = 0
 125 @end example
 126 @end ifnottex
 127
 128 @tex
 129 $$\sum_{k=0}^{\infty } {{1\over{k!\,\Gamma
 130  \left(v+k+1\right)}} {\left(z\over 2\right)^{v+2\,k}}}$$
 131 @end tex
 132
 133 aunque la serie infinita no se utiliza en los cálculos.
 134
 135 @end deffn
 136
 137
 138 @deffn {Función} bessel_k (@var{v}, @var{z})
 139 Función modificada de Bessel de segunda especie de orden @math{v} y argumento @math{z}.
 140
 141 La función @code{bessel_k} se define como
 142
 143 @ifnottex
 144 @example
 145            %pi csc(%pi v) (bessel_i(-v, z) - bessel_i(v, z))
 146            -------------------------------------------------
 147                                   2
 148 @end example
 149 @end ifnottex
 150
 151 @tex
 152 $${{\pi\,\csc \left(\pi\,v\right)\,\left(I_{-v}(z)-I_{v}(z)\right)}\over{2}}$$
 153 @end tex
 154
 155 si @math{v} no es un entero.  Si @math{v} es igual al entero @math{n}, entonces se calcula el límite cuando @math{v} tiende a @math{n}.
 156 @end deffn
 157
 158
 159 @deffn {Función} hankel_1 (@var{v}, @var{z})
 160 Función de Hankel de primera especie de orden @math{v} y argumento @math{z}
 161 (A&S 9.1.3). La función @code{hankel_1} se define como
 162
 163 @example
 164    bessel_j(v,z) + %i * bessel_y(v,z)
 165 @end example
 166
 167 Maxima evalúa @code{hankel_1} numéricamente para el orden real @math{v}
 168 y el argumento complejo @math{z} en doble precisión (float). La evaluación
 169 numérica en gran precisión (bigfloat) y para órdenes complejos no está
 170 implementada.
 171
 172 Si @code{besselexpand} vale @code{true}, @code{hankel_1} se expande en
 173 términos de funciones elementales cuando el orden @math{v} es la mitad
 174 de un entero impar. Véase al respecto @code{besselexpand}.
 175
 176 Maxima reconoce la derivada de @code{hankel_1} con respecto del argumento @math{z}.
 177
 178 Ejemplos:
 179
 180 Evaluación numérica:
 181
 182 @c ===beg===
 183 @c hankel_1(1,0.5);
 184 @c hankel_1(1,0.5+%i);
 185 @c ===end===
 186 @example
 187 (%i1) hankel_1(1,0.5);
 188 (%o1)              .2422684576748738 - 1.471472392670243 %i
 189 (%i2) hankel_1(1,0.5+%i);
 190 (%o2)             - .2558287994862166 %i - 0.239575601883016
 191 @end example
 192
 193 No se soportan órdenes complejos. Maxima devuelve una forma nominal:
 194
 195 @c ===beg===
 196 @c hankel_1(%i,0.5+%i);
 197 @c ===end===
 198 @example
 199 (%i3) hankel_1(%i,0.5+%i);
 200 (%o3)                       hankel_1(%i, %i + 0.5)
 201 @end example
 202
 203 Expansión de @code{hankel_1} cuando @code{besselexpand} vale @code{true}:
 204
 205 @c ===beg===
 206 @c hankel_1(1/2,z),besselexpand:true;
 207 @c ===end===
 208 @example
 209 (%i4) hankel_1(1/2,z),besselexpand:true;
 210                       sqrt(2) sin(z) - sqrt(2) %i cos(z)
 211 (%o4)                 ----------------------------------
 212                               sqrt(%pi) sqrt(z)
 213 @end example
 214
 215 Derivada de @code{hankel_1} respecto del argumento @math{z}. No está
 216 soportada la derivada respecto del orden @math{v}. Maxima devuelve una forma nominal:
 217
 218 @c ===beg===
 219 @c diff(hankel_1(v,z),z);
 220 @c diff(hankel_1(v,z),v);
 221 @c ===end===
 222 @example
 223 (%i5) diff(hankel_1(v,z),z);
 224                     hankel_1(v - 1, z) - hankel_1(v + 1, z)
 225 (%o5)               ---------------------------------------
 226                                        2
 227 (%i6) diff(hankel_1(v,z),v);
 228                              d
 229 (%o6)                        -- (hankel_1(v, z))
 230                              dv
 231 @end example
 232
 233 @end deffn
 234
 235 @deffn {Función} hankel_2 (@var{v}, @var{z})
 236 Función de Hankel de segunda especie de orden @math{v} y argumento @math{z}
 237 (A&S 9.1.4). La función @code{hankel_2} se define como
 238
 239 @example
 240    bessel_j(v,z) - %i * bessel_y(v,z)
 241 @end example
 242
 243 Maxima evalúa @code{hankel_2} numéricamente para el orden real @math{v}
 244 y el argumento complejo @math{z} en doble precisión (float). La evaluación
 245 numérica en gran precisión (bigfloat) y para órdenes complejos no está
 246 implementada.
 247
 248 Si @code{besselexpand} vale @code{true}, @code{hankel_2} se expande en
 249 términos de funciones elementales cuando el orden @math{v} es la mitad
 250 de un entero impar. Véase al respecto @code{besselexpand}.
 251
 252 Maxima reconoce la derivada de @code{hankel_2} con respecto del argumento @math{z}.
 253
 254 Véanse ejemplos en @code{hankel_1}.
 255
 256 @end deffn
 257
 258 @defvr {Variable optativa} besselexpand
 259 Valor por defecto: @code{false}
 260
 261 Controla la expansión de las funciones de Bessel cuando el orden es la mitad de un entero impar. En tal caso, las funciones de Bessel se pueden expandir en términos de otras funciones elementales.  Si @code{besselexpand} vale @code{true}, se expande la función de Bessel.
 262
 263 @example
 264 (%i1) besselexpand: false$
 265 (%i2) bessel_j (3/2, z);
 266                                     3
 267 (%o2)                      bessel_j(-, z)
 268                                     2
 269 (%i3) besselexpand: true$
 270 (%i4) bessel_j (3/2, z);
 271                                         sin(z)   cos(z)
 272                        sqrt(2) sqrt(z) (------ - ------)
 273                                            2       z
 274                                           z
 275 (%o4)                  ---------------------------------
 276                                    sqrt(%pi)
 277 @end example
 278
 279 @end defvr
 280
 281
 282 @deffn {Función} scaled_bessel_i (@var{v}, @var{z})
 283
 284 Es la función de Bessel modificada de primera especie de
 285 orden @math{v} y argumento @math{z}, es decir
 286 @math{scaled_bessel_i(v,z) = exp(-abs(z))*bessel_i(v, z)}.
 287 Esta función es especialmente útil para calcular @math{bessel_i}
 288 cuando @math{z} es grande. Sin embargo, Maxima no sabe mucho más
 289 sobre esta función. En cálculos simbólicos, quizás sea
 290 preferible trabajar directamente con la expresión
 291 @code{exp(-abs(z))*bessel_i(v, z)}.
 292
 293 @end deffn
 294
 295
 296 @deffn {Función} scaled_bessel_i0 (@var{z})
 297
 298 Idéntica a @code{scaled_bessel_i(0,z)}.
 299
 300 @end deffn
 301
 302 @deffn {Función} scaled_bessel_i1 (@var{z})
 303
 304 Idéntica a @code{scaled_bessel_i(1,z)}.
 305
 306 @end deffn
 307
 308
 309 @deffn {Función} %s [@var{u},@var{v}] (@var{z})
 310
 311 Función s[u,v](z) de Lommel.
 312 Gradshteyn & Ryzhik 8.570.1.
 313
 314 @end deffn
 315
 316
 317
 318
 319
 320 @node Funciones de Airy, Funciones Gamma y factorial, Funciones de Bessel, Funciones Especiales
 321 @section Funciones de Airy
 322
 323 Las funciones de Airy Ai(x) y Bi(x) se definen en la sección 10.4.
 324 de Abramowitz and Stegun, @i{Handbook of Mathematical Functions}.
 325
 326 @code{y = Ai(x)} y @code{y = Bi(x)} son dos soluciones linealmente
 327 independientes de la ecuación diferencia de Airy
 328 @code{diff (y(x), x, 2) - x y(x) = 0}.
 329
 330 Si el argumento @code{x} es un número decimal en coma flotante
 331 real o complejo, se devolverá el valor numérico de la función.
 332
 333 @deffn {Función} airy_ai (@var{x})
 334 Función de Airy Ai(x).  (A&S 10.4.2)
 335
 336 La derivada @code{diff (airy_ai(x), x)} es @code{airy_dai(x)}.
 337
 338 Véanse @code{airy_bi}, @code{airy_dai} y @code{airy_dbi}.
 339 @end deffn
 340
 341
 342 @deffn {Función} airy_dai (@var{x})
 343 Es la derivada de la función Ai de Airy, @code{airy_ai(x)}.
 344
 345 Véase @code{airy_ai}.
 346 @end deffn
 347
 348
 349 @deffn {Función} airy_bi (@var{x})
 350 Es la función Bi de Airy, tal como la definen Abramowitz y Stegun,
 351 @i{Handbook of Mathematical Functions}, Sección 10.4. Se trata de la segunda solución de la ecuación de Airy @code{diff (y(x), x, 2) - x y(x) = 0}.
 352
 353 Si el argumento @code{x} es un número decimal real o complejo, se devolverá el valor numérico de @code{airy_bi} siempre que sea posible. En los otros casos, se devuelve la expresión sin evaluar.
 354
 355 La derivada @code{diff (airy_bi(x), x)} es @code{airy_dbi(x)}.
 356
 357 Véanse @code{airy_ai} y @code{airy_dbi}.
 358 @end deffn
 359
 360 @deffn {Función} airy_dbi (@var{x})
 361 Es la derivada de la función Bi de Airy, @code{airy_bi(x)}.
 362
 363 Véanse @code{airy_ai} y @code{airy_bi}.
 364 @end deffn
 365
 366
 367
 368
 369
 370 @node Funciones Gamma y factorial, Integral exponencial, Funciones de Airy, Funciones Especiales
 371 @section Funciones Gamma y factorial
 372
 373 Las funciones gamma, beta, psi y gamma incompleta están
 374 definidas en el capítulo 6 de Abramowitz y Stegun,
 375 @i{Handbook of Mathematical Functions}.
 376
 377
 378
 379
 380 @deffn {Función} bffac (@var{expr}, @var{n})
 381 Versión para "bigfloat" de la función factorial (Gamma desplazada). El segundo argumento indica cuántos dígitos se conservan y devuelven, pudiendo utilizarse para obtener algunas cifras extra.
 382
 383 @end deffn
 384
 385 @defvr {Variable optativa} algepsilon
 386 Valor por defecto: 10^8
 387
 388 El valor de @code{algepsilon} es usado por @code{algsys}.
 389
 390 @end defvr
 391
 392
 393
 394 @deffn {Función} bfpsi (@var{n}, @var{z}, @var{fpprec})
 395 @deffnx {Función} bfpsi0 (@var{z}, @var{fpprec})
 396 La función @code{bfpsi} es la poligamma de argumento real @var{z} y de orden el entero @var{n}. La función @code{bfpsi0} es la digamma.  La llamada @code{bfpsi0 (@var{z}, @var{fpprec})} equivale a @code{bfpsi (0, @var{z}, @var{fpprec})}.
 397
 398 Estas funciones devuelven valores "bigfloat". La variable @var{fpprec} es la precisión "bigfloat" del valor de retorno.
 399
 400 @c psi0(1) = -%gamma IS AN INTERESTING PROPERTY BUT IN THE ABSENCE OF ANY OTHER
 401 @c DISCUSSION OF THE PROPERTIES OF THIS FUNCTION, THIS STATEMENT SEEMS OUT OF PLACE.
 402 @c Note @code{-bfpsi0 (1, fpprec)} provides @code{%gamma} (Euler's constant) as a bigfloat.
 403
 404 @end deffn
 405
 406
 407
 408 @deffn {Función} cbffac (@var{z}, @var{fpprec})
 409 Calcula el factorial de números complejos de punto flotante grandes.
 410
 411 La instrucción @code{load ("bffac")} carga esta función.
 412
 413 @end deffn
 414
 415
 416
 417 @deffn {Función} gamma (@var{x})
 418
 419 La definición básica de la función gamma (A&S 6.1.1) es
 420
 421 @ifnottex
 422 @example
 423                                inf
 424                               /
 425                               [     z - 1   - t
 426                    gamma(z) = I    t      %e    dt
 427                               ]
 428                               /
 429                                0
 430 @end example
 431 @end ifnottex
 432 @tex
 433 $$\Gamma\left(z\right)=\int_{0}^{\infty }{t^{z-1}\,e^ {- t }\;dt}$$
 434 @end tex
 435
 436 Maxima simplifica @code{gamma} para enteros positivos y para fracciones positivas
 437 o negativas. Para fracciones de denominador dos, el resultado es un número
 438 racional multiplicado por @code{sqrt(%pi)}. La simplificación para valores
 439 enteros la controla @code{factlim}. Para enteros mayores que @code{factlim}
 440 el resultado numérico de la función factorial, la cual se utiliza para
 441 calcular @code{gamma}, producirá un desbordamiento. La simplificación
 442 para números racionales la controla @code{gammalim} para evitar desbordamientos.
 443 Véanse también @code{factlim} y @code{gammalim}.
 444
 445 Para enteros negativos, @code{gamma} no está definida.
 446
 447 Maxima puede evaluar @code{gamma} numéricamente para valores reales
 448 y complejos, tanto en formato float (doble precisión) como big float
 449 (precisión arbitraria).
 450
 451 La función @code{gamma} tiene simetría especular.
 452
 453 Si @code{gamma_expand} vale @code{true}, Maxima expande @code{gamma}
 454 para argumentos del tipo @code{z+n} y @code{z-n}, siendo @code{n}
 455 un entero.
 456
 457 Maxima conoce la derivada de @code{gamma}.
 458
 459 Ejemplos:
 460
 461 Simplificación para enteros, fracciones de denominador dos
 462 y números racionales:
 463
 464 @example
 465 (%i1) map('gamma,[1,2,3,4,5,6,7,8,9]);
 466 (%o1)               [1, 1, 2, 6, 24, 120, 720, 5040, 40320]
 467
 468 (%i2) map('gamma,[1/2,3/2,5/2,7/2]);
 469                            sqrt(%pi)  3 sqrt(%pi)  15 sqrt(%pi)
 470 (%o2)          [sqrt(%pi), ---------, -----------, ------------]
 471                                2           4            8
 472
 473 (%i3) map('gamma,[2/3,5/3,7/3]);
 474                                         2           1
 475                                 2 gamma(-)  4 gamma(-)
 476                             2           3           3
 477 (%o3)                [gamma(-), ----------, ----------]
 478                             3       3           9
 479 @end example
 480
 481 Evaluación numérica para valores reales y complejos:
 482
 483 @example
 484 (%i4) map('gamma,[2.5,2.5b0]);
 485 (%o4)             [1.329340388179137, 1.329340388179137b0]
 486
 487 (%i5) map('gamma,[1.0+%i,1.0b0+%i]);
 488 (%o5) [.4980156681183558 - .1549498283018108 %i,
 489                       4.980156681183561b-1 - 1.549498283018107b-1 %i]
 490 @end example
 491
 492 Simetría especular:
 493
 494 @example
 495 (%i6) declare(z,complex)$
 496 (%i7) conjugate(gamma(z));
 497 (%o7)                         gamma(conjugate(z))
 498 @end example
 499
 500 Maxima expande @code{gamma(z+n)} y @code{gamma(z-n)} si
 501 @code{gamma_expand} vale @code{true}:
 502
 503 @example
 504 (%i8) gamma_expand:true$
 505 (%i9) [gamma(z+1),gamma(z-1),gamma(z+2)/gamma(z+1)];
 506                                       gamma(z)
 507 (%o9)                    [z gamma(z), --------, z + 1]
 508                                        z - 1
 509 @end example
 510
 511 Derivada de @code{gamma}:
 512
 513 @example
 514 (%i10) diff(gamma(z),z);
 515 (%o10)                         psi (z) gamma(z)
 516                                   0
 517 @end example
 518
 519 Véase también @code{makegamma}.
 520
 521 La constante de Euler-Mascheroni es @code{%gamma}.
 522 @end deffn
 523
 524
 525 @deffn {Función} log_gamma (@var{z})
 526 Logaritmo natural de la función gamma.
 527 @end deffn
 528
 529
 530
 531 @deffn {Función} gamma_incomplete_lower (@var{a}, @var{z})
 532
 533 Función gamma incompleta inferior (A&S 6.5.2):
 534
 535 @ifnottex
 536 @example
 537                                     z
 538                                    /
 539                                    [  a - 1   - t
 540     gamma_incomplete_lower(a, z) = I t      %e    dt
 541                                    ]
 542                                    /
 543                                     0
 544 @end example
 545 @end ifnottex
 546 @tex
 547 $$\gamma\left(a , z\right)=\int_{0}^{z}{t^{a-1}\,e^ {- t }\;dt}$$
 548 @end tex
 549
 550 Véase también @code{gamma_incomplete} (función gamma incompleta superior).
 551 @end deffn
 552
 553
 554
 555 @deffn {Función} gamma_incomplete (@var{a},@var{z})
 556 Función gamma incompleta superior, A&S 6.5.3:
 557
 558 @ifnottex
 559 @example
 560                               inf
 561                              /
 562                              [     a - 1   - t
 563     gamma_incomplete(a, z) = I    t      %e    dt
 564                              ]
 565                              /
 566                               z
 567 @end example
 568 @end ifnottex
 569 @tex
 570 $$\Gamma\left(a , z\right)=\int_{z}^{\infty }{t^{a-1}\,e^ {- t }\;dt}$$
 571 @end tex
 572
 573 Véanse también @code{gamma_expand} para controlar cómo se expresa
 574 @code{gamma_incomplete} en términos de funciones elementales y de @code{erfc}.
 575
 576 Véanse también las funciones relacionadas @code{gamma_incomplete_regularized} y
 577 @code{gamma_incomplete_generalized}.
 578 @end deffn
 579
 580 @deffn {Función} gamma_incomplete_regularized (@var{a},@var{z})
 581 Función gamma incompleta superior regularizada, A&S 6.5.1.
 582
 583 @ifnottex
 584 @example
 585 gamma_incomplete_regularized(a, z) =
 586                                         gamma_incomplete(a, z)
 587                                         ----------------------
 588                                                gamma(a)
 589 @end example
 590 @end ifnottex
 591 @tex
 592 $${\it Q}\left(a , z\right)={{\Gamma\left(a , z\right)}\over{\Gamma\left(a\right)}}$$
 593 @end tex
 594
 595 Véanse también @code{gamma_expand} para controlar cómo se expresa
 596 @code{gamma_incomplete} en términos de funciones elementales y de @code{erfc}.
 597
 598 Véase también @code{gamma_incomplete}.
 599 @end deffn
 600
 601 @deffn {Función} gamma_incomplete_generalized (@var{a},@var{z1},@var{z1})
 602 Función gamma incompleta generalizada.
 603
 604 @ifnottex
 605 @example
 606 gamma_incomplete_generalized(a, z1, z2) =
 607                                                z2
 608                                               /
 609                                               [    a - 1   - t
 610                                               I   t      %e    dt
 611                                               ]
 612                                               /
 613                                                z1
 614 @end example
 615 @end ifnottex
 616 @tex
 617 $$\Gamma\left(a , z_{1}, z_{2}\right)=\int_{z_{1}}^{z_{2}}{t^{a-1}\,e^ {- t }\;dt}$$
 618 @end tex
 619
 620 Véanse también @code{gamma_incomplete} y @code{gamma_incomplete_regularized}.
 621 @end deffn
 622
 623
 624 @defvr {Variable opcional} gamma_expand
 625 Valor por defecto: @code{false}
 626
 627 @code{gamma_expand} controla la expansión de @code{gamma_incomplete}.
 628 Si @code{gamma_expand} vale @code{true}, @code{gamma_incomplete(v,z)}
 629 se expande en términos de
 630 @code{z}, @code{exp(z)} y @code{erfc(z)}, siempre que sea posible.
 631
 632 @example
 633 (%i1) gamma_incomplete(2,z);
 634 (%o1)                       gamma_incomplete(2, z)
 635 (%i2) gamma_expand:true;
 636 (%o2)                                true
 637 (%i3) gamma_incomplete(2,z);
 638                                            - z
 639 (%o3)                            (z + 1) %e
 640 @group
 641 (%i4) gamma_incomplete(3/2,z);
 642                               - z   sqrt(%pi) erfc(sqrt(z))
 643 (%o4)               sqrt(z) %e    + -----------------------
 644                                                2
 645 @end group
 646 @end example
 647 @end defvr
 648
 649
 650
 651 @defvr {Variable optativa} gammalim
 652 Valor por defecto: 10000
 653
 654 La variable @code{gammalim} controla la simplificación de la función gamma con argumentos enteros o racionales. Si el valor absoluto del argumento no es mayor que @code{gammalim}, entonces se realizará la simplificación. Nótese que la variable @code{factlim} también controla la simplificación del resultado de @code{gamma} con argumento entero.
 655
 656 @end defvr
 657
 658 @deffn {Función} makegamma (@var{expr})
 659 Transforma las funciones @code{binomial}, @code{factorial} y @code{beta} que aparecen en @var{expr} en funciones @code{gamma}.
 660
 661 Véase también @code{makefact}.
 662
 663 @end deffn
 664
 665
 666 @deffn {Función} beta (@var{a}, @var{b})
 667 La función beta se define como @code{gamma(a) gamma(b)/gamma(a+b)}
 668 (A&S 6.2.1).
 669
 670 Maxima simplifica la función beta para enteros positivos y números
 671 racionales cuya suma sea entera. Si @code{beta_args_sum_to_integer}
 672 vale @code{true}, Maxima también simplifica expresiones generales
 673 cuya suma sea también entera.
 674
 675 Cuando @var{a} o @var{b} sean nulos, la función beta no está definida.
 676
 677 En general, la función beta no está definida para enteros negativos.
 678 La excepción es para @var{a=-n}, siendo @var{n} un entero positivo
 679 y @var{b} otro entero positivo tal que @var{b<=n}, entonces es posible
 680 definir una continuación analítica. En este caso Maxima
 681 devuelve un resultado.
 682
 683 Si @code{beta_expand} vale @code{true}, expresiones como @code{beta(a+n,b)},
 684 @code{beta(a-n,b)}, @code{beta(a,b+n)} o @code{beta(a,b-n)}, siendo @code{n}
 685 entero, se simplifican.
 686
 687 Maxima puede evaluar la función beta para valores reales y complejos, tanto
 688 de tipo decimal flotante o big float. Para la evaluación numérica
 689 Maxima utiliza @code{log_gamma}:
 690
 691 @example
 692            - log_gamma(b + a) + log_gamma(b) + log_gamma(a)
 693          %e
 694 @end example
 695
 696 Maxima reconoce la simetría de la función beta.
 697
 698 Maxima conoce las derivadas de la función beta, tanto respecto de @var{a}
 699 como de @var{b}.
 700
 701 Para expresar la función beta como un cociente de funciones gamma,
 702 véase @code{makegamma}.
 703
 704 Ejemplos:
 705
 706 Simplificación cuando uno de sus argumentos es entero:
 707
 708 @example
 709 (%i1) [beta(2,3),beta(2,1/3),beta(2,a)];
 710                                1   9      1
 711 (%o1)                         [--, -, ---------]
 712                                12  4  a (a + 1)
 713 @end example
 714
 715 Simplificación para argumentos racionales que suman un entero:
 716
 717 @example
 718 (%i2) [beta(1/2,5/2),beta(1/3,2/3),beta(1/4,3/4)];
 719                           3 %pi   2 %pi
 720 (%o2)                    [-----, -------, sqrt(2) %pi]
 721                             8    sqrt(3)
 722 @end example
 723
 724 Cuando se iguala @code{beta_args_sum_to_integer} a @code{true} se
 725 simplifican expresiones más generales si la suma de los argumentos
 726 se reduce a un entero:
 727
 728 @example
 729 (%i3) beta_args_sum_to_integer:true$
 730 (%i4) beta(a+1,-a+2);
 731                                 %pi (a - 1) a
 732 (%o4)                         ------------------
 733                               2 sin(%pi (2 - a))
 734 @end example
 735
 736 Posibles valores cuando uno de los argumentos es entero negativo:
 737
 738 @example
 739 (%i5) [beta(-3,1),beta(-3,2),beta(-3,3)];
 740                                     1  1    1
 741 (%o5)                            [- -, -, - -]
 742                                     3  6    3
 743 @end example
 744
 745 @code{beta(a+n,b)} o @code{beta(a-n)} con @code{n} entero se simplifica
 746 si @code{beta_expand} vale @code{true}:
 747
 748 @example
 749 (%i6) beta_expand:true$
 750 (%i7) [beta(a+1,b),beta(a-1,b),beta(a+1,b)/beta(a,b+1)];
 751                     a beta(a, b)  beta(a, b) (b + a - 1)  a
 752 (%o7)              [------------, ----------------------, -]
 753                        b + a              a - 1           b
 754
 755 @end example
 756
 757 La función beta no está definida si uno de sus argumentos es cero:
 758
 759 @example
 760 (%i7) beta(0,b);
 761 beta: expected nonzero arguments; found 0, b
 762  -- an error.  To debug this try debugmode(true);
 763 @end example
 764
 765 Evaluación numérica para argumentos reales y complejos de tipo
 766 decimal flotante o big float:
 767
 768 @example
 769 (%i8) beta(2.5,2.3);
 770 (%o8) .08694748611299981
 771
 772 (%i9) beta(2.5,1.4+%i);
 773 (%o9) 0.0640144950796695 - .1502078053286415 %i
 774
 775 (%i10) beta(2.5b0,2.3b0);
 776 (%o10) 8.694748611299969b-2
 777
 778 (%i11) beta(2.5b0,1.4b0+%i);
 779 (%o11) 6.401449507966944b-2 - 1.502078053286415b-1 %i
 780 @end example
 781
 782 La función beta es simétrica con simetría especular:
 783
 784 @example
 785 (%i14) beta(a,b)-beta(b,a);
 786 (%o14)                                 0
 787 (%i15) declare(a,complex,b,complex)$
 788 (%i16) conjugate(beta(a,b));
 789 (%o16)                 beta(conjugate(a), conjugate(b))
 790 @end example
 791
 792 Derivada de la función beta respecto de @code{a}:
 793
 794 @example
 795 (%i17) diff(beta(a,b),a);
 796 (%o17)               - beta(a, b) (psi (b + a) - psi (a))
 797                                       0             0
 798 @end example
 799 @end deffn
 800
 801 @deffn {Función} beta_incomplete (@var{a}, @var{b}, @var{z})
 802 La definición básica de la función beta incompleta (A&S 6.6.1) es
 803
 804 @example
 805                        z
 806                       /
 807                       [         b - 1  a - 1
 808                       I  (1 - t)      t      dt
 809                       ]
 810                       /
 811                        0
 812 @end example
 813
 814 Esta definición es posible para @math{realpart(a)>0}, @math{realpart(b)>0}
 815 y @math{abs(z)<1}. Para otras situaciones, la función beta incompleta puede
 816 definirse por medio de una función hipergeométrica generalizada:
 817
 818 @example
 819    gamma(a) hypergeometric_generalized([a, 1 - b], [a + 1], z) z
 820 @end example
 821 (Véase Funcións.wolfram.com para una completa definición de la función beta
 822 incompleta.)
 823
 824 Para enteros negativos @math{a = -n} y enteros positivos @math{b=m} con
 825 @math{m<=n} la función beta incompleta se define como
 826
 827 @example
 828                             m - 1           k
 829                             ====  (1 - m)  z
 830                       n - 1 \            k
 831                      z       >    -----------
 832                             /     k! (n - k)
 833                             ====
 834                             k = 0
 835 @end example
 836 Maxima utiliza esta definición para simplificar @code{beta_incomplete}
 837 cuando @var{a} es entero negativo.
 838
 839 Cuando @var{a} es entero positivo, @code{beta_incomplete} se simplifica
 840 para cualesquiera argumentos @var{b} y @var{z}, y para @var{b} entero
 841 positivo para cualesquiera argumentos @var{a} y @var{z}, con la
 842 excepción de cuando @var{a} sea entero negativo.
 843
 844 Para @math{z=0} y @math{realpart(a)>0}, @code{beta_incomplete} se anula.
 845 Para @var{z=1} y @math{realpart(b)>0}, @code{beta_incomplete} se reduce a
 846 la función @code{beta(a,b)}.
 847
 848 Maxima evalúa @code{beta_incomplete} numéricamente para valores reales
 849 y complejos en forma decimal y big float. La evaluación numérica se
 850 realiza expandiendo la función beta incompleta en fracciones continuas.
 851
 852 Si @code{beta_expand} vale @code{true}, Maxima expande las expresiones
 853 @code{beta_incomplete(a+n,b,z)} y @code{beta_incomplete(a-n,b,z)},
 854 siendo @var{n} entero positivo.
 855
 856 Maxima conoce las derivadas de @code{beta_incomplete} con respecto a
 857 las variables @var{a}, @var{b} y @var{z}, así como la
 858 integral respecto de la variable @var{z}.
 859
 860 Ejemplos:
 861
 862 Simplificación para @var{a} entero positivo:
 863
 864 @example
 865 (%i1) beta_incomplete(2,b,z);
 866                                        b
 867                             1 - (1 - z)  (b z + 1)
 868 (%o1)                       ----------------------
 869                                   b (b + 1)
 870 @end example
 871
 872 Simplificación para @var{b} entero positivo:
 873
 874 @example
 875 (%i2) beta_incomplete(a,2,z);
 876                                                a
 877                               (a (1 - z) + 1) z
 878 (%o2)                         ------------------
 879                                   a (a + 1)
 880 @end example
 881
 882 Simplificación para @var{a} y @var{b} enteros positivos:
 883
 884 @example
 885 (%i3) beta_incomplete(3,2,z);
 886                                                3
 887                               (3 (1 - z) + 1) z
 888 (%o3)                         ------------------
 889                                       12
 890 @end example
 891
 892 Para @var{a} entero negativo y @math{b<=(-a)}:
 893
 894 @example
 895 (%i4) beta_incomplete(-3,1,z);
 896                                        1
 897 (%o4)                              - ----
 898                                         3
 899                                      3 z
 900 @end example
 901
 902 Simplificación para los valores @math{z=0} y @math{z=1}:
 903
 904 @example
 905 (%i5) assume(a>0,b>0)$
 906 (%i6) beta_incomplete(a,b,0);
 907 (%o6)                                 0
 908 (%i7) beta_incomplete(a,b,1);
 909 (%o7)                            beta(a, b)
 910 @end example
 911
 912 Evaluación numérica, tanto con float (precisión doble)
 913 como big float (precisión arbitraria):
 914
 915 @example
 916 (%i8) beta_incomplete(0.25,0.50,0.9);
 917 (%o8)                          4.594959440269333
 918 (%i9)  fpprec:25$
 919 (%i10) beta_incomplete(0.25,0.50,0.9b0);
 920 (%o10)                    4.594959440269324086971203b0
 921 @end example
 922
 923 Para @math{abs(z)>1}, @code{beta_incomplete} devuelve un
 924 resultado complejo:
 925
 926 @example
 927 (%i11) beta_incomplete(0.25,0.50,1.7);
 928 (%o11)              5.244115108584249 - 1.45518047787844 %i
 929 @end example
 930
 931 Resultados para argumentos complejos más generales:
 932
 933 @example
 934 (%i14) beta_incomplete(0.25+%i,1.0+%i,1.7+%i);
 935 (%o14)             2.726960675662536 - .3831175704269199 %i
 936 (%i15) beta_incomplete(1/2,5/4*%i,2.8+%i);
 937 (%o15)             13.04649635168716 %i - 5.802067956270001
 938 (%i16)
 939 @end example
 940
 941 Expansión cuando @code{beta_expand} vale @code{true}:
 942
 943 @example
 944 (%i23) beta_incomplete(a+1,b,z),beta_expand:true;
 945                                                        b  a
 946                    a beta_incomplete(a, b, z)   (1 - z)  z
 947 (%o23)             -------------------------- - -----------
 948                              b + a                 b + a
 949
 950 (%i24) beta_incomplete(a-1,b,z),beta_expand:true;
 951                                                            b  a - 1
 952            beta_incomplete(a, b, z) (- b - a + 1)   (1 - z)  z
 953 (%o24)     -------------------------------------- - ---------------
 954                            1 - a                         1 - a
 955 @end example
 956
 957 Derivada e integral de @code{beta_incomplete}:
 958
 959 @example
 960 @example
 961 (%i34) diff(beta_incomplete(a, b, z), z);
 962                               b - 1  a - 1
 963 (%o34)                 (1 - z)      z
 964 (%i35) integrate(beta_incomplete(a, b, z), z);
 965               b  a
 966        (1 - z)  z
 967 (%o35) ----------- + beta_incomplete(a, b, z) z
 968           b + a
 969                                        a beta_incomplete(a, b, z)
 970                                      - --------------------------
 971                                                  b + a
 972 (%i36) factor(diff(%, z));
 973 (%o36)              beta_incomplete(a, b, z)
 974 @end example
 975
 976 @end example
 977 @end deffn
 978
 979 @deffn {Función} beta_incomplete_regularized (@var{a}, @var{b}, @var{z})
 980 Función beta incompleta regularizada A&S 6.6.2,
 981 definida como
 982
 983 @example
 984 beta_incomplete_regularized(a, b, z) =
 985                                       beta_incomplete(a, b, z)
 986                                       ------------------------
 987                                              beta(a, b)
 988 @end example
 989
 990 Al igual que @code{beta_incomplete}, esta definición no es completa.
 991 Véase Funcións.wolfram.com para una definición completa de
 992 @code{beta_incomplete_regularized}.
 993
 994 @code{beta_incomplete_regularized} se simplifica para @var{a} o @var{b}
 995 entero positivo.
 996
 997 Para @math{z=0} y @math{realpart(a)>0}, @code{beta_incomplete_regularized} se anula.
 998 Para @var{z=1} y @math{realpart(b)>0}, @code{beta_incomplete_regularized} se reduce a 1.
 999
1000 Maxima evalúa @code{beta_incomplete_regularized} numéricamente para valores reales
1001 y complejos en forma decimal y big float.
1002
1003 Si @code{beta_expand} vale @code{true}, Maxima expande
1004 @code{beta_incomplete_regularized} para los argumentos @math{a+n} o @math{a-n},
1005 siendo @var{n} entero.
1006
1007 Maxima conoce las derivadas de @code{beta_incomplete_regularized} con respecto a
1008 las variables @var{a}, @var{b} y @var{z}, así como la
1009 integral respecto de la variable @var{z}.
1010
1011 Ejemplos:
1012
1013 Simplificación para @var{a} o @var{b} enteros positivos:
1014
1015 @example
1016 (%i1) beta_incomplete_regularized(2,b,z);
1017                                        b
1018 (%o1)                       1 - (1 - z)  (b z + 1)
1019
1020 (%i2) beta_incomplete_regularized(a,2,z);
1021                                                a
1022 (%o2)                         (a (1 - z) + 1) z
1023
1024 (%i3) beta_incomplete_regularized(3,2,z);
1025                                                3
1026 (%o3)                         (3 (1 - z) + 1) z
1027 @end example
1028
1029 Simplificación para los valores @math{z=0} y @math{z=1}:
1030
1031 @example
1032 (%i4) assume(a>0,b>0)$
1033 (%i5) beta_incomplete_regularized(a,b,0);
1034 (%o5)                                 0
1035 (%i6) beta_incomplete_regularized(a,b,1);
1036 (%o6)                                 1
1037 @end example
1038
1039 Evaluación numérica, tanto con float (precisión doble)
1040 como big float (precisión arbitraria):
1041
1042 @example
1043 (%i7) beta_incomplete_regularized(0.12,0.43,0.9);
1044 (%o7)                         .9114011367359802
1045 (%i8) fpprec:32$
1046 (%i9) beta_incomplete_regularized(0.12,0.43,0.9b0);
1047 (%o9)               9.1140113673598075519946998779975b-1
1048 (%i10) beta_incomplete_regularized(1+%i,3/3,1.5*%i);
1049 (%o10)             .2865367499935403 %i - 0.122995963334684
1050 (%i11) fpprec:20$
1051 (%i12) beta_incomplete_regularized(1+%i,3/3,1.5b0*%i);
1052 (%o12)      2.8653674999354036142b-1 %i - 1.2299596333468400163b-1
1053 @end example
1054
1055 Expansión cuando @code{beta_expand} vale @code{true}:
1056
1057 @example
1058 (%i13) beta_incomplete_regularized(a+1,b,z);
1059                                                      b  a
1060                                               (1 - z)  z
1061 (%o13) beta_incomplete_regularized(a, b, z) - ------------
1062                                               a beta(a, b)
1063 (%i14) beta_incomplete_regularized(a-1,b,z);
1064 (%o14) beta_incomplete_regularized(a, b, z)
1065                                                      b  a - 1
1066                                               (1 - z)  z
1067                                          - ----------------------
1068                                            beta(a, b) (b + a - 1)
1069
1070 @end example
1071
1072 Derivada e integral respecto de @var{z}:
1073
1074 @example
1075 (%i15) diff(beta_incomplete_regularized(a,b,z),z);
1076                               b - 1  a - 1
1077                        (1 - z)      z
1078 (%o15)                 -------------------
1079                            beta(a, b)
1080 (%i16) integrate(beta_incomplete_regularized(a,b,z),z);
1081 (%o16) beta_incomplete_regularized(a, b, z) z
1082                                                            b  a
1083                                                     (1 - z)  z
1084           a (beta_incomplete_regularized(a, b, z) - ------------)
1085                                                     a beta(a, b)
1086         - -------------------------------------------------------
1087                                    b + a
1088 @end example
1089
1090 @end deffn
1091
1092 @deffn {Función} beta_incomplete_generalized (@var{a}, @var{b}, @var{z1}, @var{z2})
1093 La definición básica de la función beta incompleta generalizada es
1094
1095 The basic definition of the generalized incomplete beta function is
1096
1097 @example
1098                       z2
1099                      /
1100                      [          b - 1  a - 1
1101                      I   (1 - t)      t      dt
1102                      ]
1103                      /
1104                       z1
1105 @end example
1106
1107 Maxima simplifica @code{beta_incomplete_regularized} para @var{a} y @var{b}
1108 enteros positivos.
1109
1110 Para @math{realpart(a)>0} y @math{z1=0} o @math{z2=0}, Maxima reduce
1111 @code{beta_incomplete_generalized} a @code{beta_incomplete}. Para
1112 @math{realpart(b)>0} y @math{z1=1} o @var{z2=1}, Maxima reduce a
1113 una expresión con @code{beta} y @code{beta_incomplete}.
1114
1115 Maxima evalúa @code{beta_incomplete_generalized} numéricamente para valores reales
1116 y complejos en forma decimal y big float.
1117
1118 Si @code{beta_expand} vale @code{true}, Maxima expande
1119 @code{beta_incomplete_generalized} para los argumentos @math{a+n} y @math{a-n},
1120 siendo @var{n} entero positivo.
1121
1122 Maxima conoce las derivadas de @code{beta_incomplete_generalized} con respecto a
1123 las variables @var{a}, @var{b}, @var{z1} y @var{z2}, así como la
1124 integral respecto de las variables @var{z1} y @var{z2}.
1125
1126 Ejemplos:
1127
1128 Maxima simplifica @code{beta_incomplete_generalized} para @var{a} y @var{b}
1129 enteros positivos:
1130 @example
1131 (%i1) beta_incomplete_generalized(2,b,z1,z2);
1132                           b                      b
1133                   (1 - z1)  (b z1 + 1) - (1 - z2)  (b z2 + 1)
1134 (%o1)             -------------------------------------------
1135                                    b (b + 1)
1136
1137 (%i2) beta_incomplete_generalized(a,2,z1,z2);
1138                                      a                      a
1139                   (a (1 - z2) + 1) z2  - (a (1 - z1) + 1) z1
1140 (%o2)             -------------------------------------------
1141                                    a (a + 1)
1142
1143 (%i3) beta_incomplete_generalized(3,2,z1,z2);
1144                   2      2                       2      2
1145           (1 - z1)  (3 z1  + 2 z1 + 1) - (1 - z2)  (3 z2  + 2 z2 + 1)
1146 (%o3)     -----------------------------------------------------------
1147                                       12
1148 @end example
1149
1150 Simplificación para los valores @math{z1=0}, @math{z2=0}, @math{z1=1}
1151 o @math{z2=1}:
1152 @example
1153 (%i4) assume(a > 0, b > 0)$
1154 (%i5) beta_incomplete_generalized(a,b,z1,0);
1155 (%o5)                    - beta_incomplete(a, b, z1)
1156
1157 (%i6) beta_incomplete_generalized(a,b,0,z2);
1158 (%o6)                    - beta_incomplete(a, b, z2)
1159
1160 (%i7) beta_incomplete_generalized(a,b,z1,1);
1161 (%o7)              beta(a, b) - beta_incomplete(a, b, z1)
1162
1163 (%i8) beta_incomplete_generalized(a,b,1,z2);
1164 (%o8)              beta_incomplete(a, b, z2) - beta(a, b)
1165 @end example
1166
1167 Evaluación numérica para argumentos reales, tanto con float
1168 (precisión doble) como big float (precisión arbitraria):
1169 @example
1170 (%i9) beta_incomplete_generalized(1/2,3/2,0.25,0.31);
1171 (%o9)                        .09638178086368676
1172
1173 (%i10) fpprec:32$
1174 (%i10) beta_incomplete_generalized(1/2,3/2,0.25,0.31b0);
1175 (%o10)               9.6381780863686935309170054689964b-2
1176 @end example
1177
1178 Evaluación numérica para argumentos complejos, tanto con float
1179 (precisión doble) como big float (precisión arbitraria):
1180 @example
1181 (%i11) beta_incomplete_generalized(1/2+%i,3/2+%i,0.25,0.31);
1182 (%o11)           - .09625463003205376 %i - .003323847735353769
1183 (%i12) fpprec:20$
1184 (%i13) beta_incomplete_generalized(1/2+%i,3/2+%i,0.25,0.31b0);
1185 (%o13)     - 9.6254630032054178691b-2 %i - 3.3238477353543591914b-3
1186 @end example
1187
1188 Expansión para @math{a+n} o @math{a-n}, siendo @var{n} entero positivo
1189 con @code{beta_expand} igual @code{true}:
1190 @example
1191 (%i14) beta_expand:true$
1192 (%i15) beta_incomplete_generalized(a+1,b,z1,z2);
1193                b   a           b   a
1194        (1 - z1)  z1  - (1 - z2)  z2
1195 (%o15) -----------------------------
1196                    b + a
1197                             a beta_incomplete_generalized(a, b, z1, z2)
1198                           + -------------------------------------------
1199                                                b + a
1200
1201 (%i16) beta_incomplete_generalized(a-1,b,z1,z2);
1202        beta_incomplete_generalized(a, b, z1, z2) (- b - a + 1)
1203 (%o16) -------------------------------------------------------
1204                                 1 - a
1205                                           b   a - 1           b   a - 1
1206                                   (1 - z2)  z2      - (1 - z1)  z1
1207                                 - -------------------------------------
1208                                                   1 - a
1209 @end example
1210
1211 Derivada respecto de la variable @var{z1} e integrales respecto de
1212 @var{z1} y @var{z2}:
1213 @example
1214 (%i17) diff(beta_incomplete_generalized(a,b,z1,z2),z1);
1215                                       b - 1   a - 1
1216 (%o17)                      - (1 - z1)      z1
1217
1218 (%i18) integrate(beta_incomplete_generalized(a,b,z1,z2),z1);
1219 (%o18) beta_incomplete_generalized(a, b, z1, z2) z1
1220                                         + beta_incomplete(a + 1, b, z1)
1221
1222 (%i19) integrate(beta_incomplete_generalized(a,b,z1,z2),z2);
1223 (%o19) beta_incomplete_generalized(a, b, z1, z2) z2
1224                                         - beta_incomplete(a + 1, b, z2)
1225 @end example
1226 @end deffn
1227
1228
1229 @defvr {Variable opcional} beta_expand
1230 Valor por defecto: false
1231
1232 Si @code{beta_expand} vale @code{true}, @code{beta(a,b)} y sus
1233 funciones relacionadas se expanden para argumentos del tipo
1234 @math{a+n} o @math{a-n}, siendo @math{n} un número entero.
1235 @end defvr
1236
1237 @defvr {Variable opcional} beta_args_sum_to_integer
1238 Valor por defecto: false
1239
1240 Si @code{beta_args_sum_to_integer} vale @code{true}, Maxima simplifica
1241 @code{beta(a,b)} cuando la suma de los argumentos @var{a} y @var{b} sea un entero.
1242 @end defvr
1243
1244
1245
1246 @deffn {Función} psi [@var{n}](@var{x})
1247
1248 Es la derivada de @code{log (gamma (@var{x}))} de orden @code{@var{n}+1},
1249 de tal manera que @code{psi[0](@var{x})} es la primera derivada,
1250 @code{psi[1](@var{x})} la segunda derivada y así
1251 sucesivamente.
1252
1253 En general, Maxima no sabe cómo calcular valores numéricos de
1254 @code{psi}, pero sí conoce el valor exacto para
1255 algunos argumentos racionales.
1256 Existen algunas variables globales para controlar en qué rangos
1257 racionales debe devolver @code{psi} resultados exactos, si ello es posible.
1258 Véanse las descripciones de @code{maxpsiposint}, @code{maxpsinegint},
1259 @code{maxpsifracnum} y @code{maxpsifracdenom}.
1260 En resumen, @var{x} debe alcanzar un valor entre @code{maxpsinegint} y
1261 @code{maxpsiposint}. Si el valor absoluto de la parte fraccional de
1262 @var{x} es racional y tiene un numerador menor que @code{maxpsifracnum}
1263 y un denominador menor que @code{maxpsifracdenom}, la función @code{psi}
1264 devolverá un valor exacto.
1265
1266 La función @code{bfpsi} del paquete @code{bffac} puede calcular
1267 valores numéricos.
1268
1269 @end deffn
1270
1271 @defvr {Variable opcional} maxpsiposint
1272 Valor por defecto: 20
1273
1274 La variable @code{maxpsiposint} guarda el mayor valor positivo para el
1275 que @code{psi[n](x)} intentará calcular un valor exacto.
1276
1277 @end defvr
1278
1279 @defvr {Variable opcional} maxpsinegint
1280 Valor por defecto: -10
1281
1282 La variable @code{maxpsinegint} guarda el menor valor negativo para el
1283 que @code{psi[n](x)} intentará calcular un valor exacto. Si
1284 @var{x} es menor que @code{maxnegint}, @code{psi[n](@var{x})} no devolverá
1285 una respuesta simplificada, aunque supiese cómo hacerlo.
1286
1287 @end defvr
1288
1289
1290 @defvr {Variable opcional} maxpsifracnum
1291 Valor por defecto: 6
1292
1293 Sea @var{x} un número racional menor que la unidad de la forma @code{p/q}.
1294 Si @code{p} es mayor que @code{maxpsifracnum}, entonces
1295 @code{psi[@var{n}](@var{x})} no devolverá una respuesta simplificada.
1296
1297 @end defvr
1298
1299 @defvr {Variable opcional} maxpsifracdenom
1300 Valor por defecto: 6
1301
1302 Sea @var{x} un número racional menor que la unidad de la forma @code{p/q}.
1303 Si @code{q} es mayor que @code{maxpsifracnum}, entonces
1304 @code{psi[@var{n}](@var{x})} no devolverá una respuesta simplificada.
1305
1306 @end defvr
1307
1308
1309 @deffn {Función} makefact (@var{expr})
1310 Transforma las funciones @code{binomial}, @code{gamma} y @code{beta} que aparecen en @var{expr} en su notación factorial.
1311
1312 Véase también @code{makegamma}.
1313
1314 @end deffn
1315
1316
1317 @deffn {Función} numfactor (@var{expr})
1318 Devuelve el factor numérico que multiplica a la expresión @var{expr}, la cual debe tener un único término.
1319
1320 @example
1321 (%i1) gamma (7/2);
1322                           15 sqrt(%pi)
1323 (%o1)                     ------------
1324                                8
1325 (%i2) numfactor (%);
1326                                15
1327 (%o2)                          --
1328                                8
1329 @end example
1330
1331 @end deffn
1332
1333
1334
1335
1336
1337
1338
1339 @node Integral exponencial, Función de error, Funciones Gamma y factorial, Funciones Especiales
1340 @section Integral exponencial
1341
1342 La integral exponencial y sus funciones relacionadas se
1343 definen en el capítulo 5 de Abramowitz y Stegun,
1344 @i{Handbook of Mathematical Functions}.
1345
1346
1347 @deffn {Función} expintegral_e1 (@var{z})
1348 La integral exponencial E1(z) (A&S 5.1.1)
1349 @end deffn
1350
1351 @deffn {Función} expintegral_ei (@var{z})
1352 La integral exponencial Ei(z) (A&S 5.1.2)
1353 @end deffn
1354
1355 @deffn {Función} expintegral_li (@var{z})
1356 La integral exponencial Li(z)  (A&S 5.1.3)
1357 @end deffn
1358
1359 @deffn {Función} expintegral_e (@var{n},@var{z})
1360 La integral exponencial En(z)  (A&S 5.1.4)
1361 @end deffn
1362
1363 @deffn {Función} expintegral_si (@var{z})
1364 La integral exponencial Si(z) (A&S 5.2.1)
1365 @end deffn
1366
1367 @deffn {Función} expintegral_ci (@var{z})
1368 La integral exponencial Ci(z) (A&S 5.2.2)
1369 @end deffn
1370
1371 @deffn {Función} expintegral_shi (@var{z})
1372 La integral exponencial Shi(z) (A&S 5.2.3)
1373 @end deffn
1374
1375 @deffn {Función} expintegral_chi (@var{z})
1376 La integral exponencial Chi(z) (A&S 5.2.4)
1377 @end deffn
1378
1379 @defvr {Option variable} expintrep
1380 Valor por defecto: false
1381
1382 Transforma la representación de la integral exponencial
1383 en términos de las funciones @code{gamma_incomplete},
1384 @code{expintegral_e1}, @code{expintegral_ei},
1385 @code{expintegral_li}, @code{expintegral_trig} y @code{expintegral_hyp}.
1386 @end defvr
1387
1388 @defvr {Option variable} expintexpand
1389 Valor por defecto: false
1390
1391 Expande la integral exponencial E[n](z)
1392 para valores medios de la integral en términos de
1393 las funciones Erfc o Erf y para positivos enteros
1394 en términos de Ei .
1395 @end defvr
1396
1397
1398
1399
1400
1401 @node Función de error, Funciones de Struve, Integral exponencial, Funciones Especiales
1402 @section Función de error
1403
1404 La función de error y sus asociadas se definen en el
1405 capítulo 7 de Abramowitz y Stegun,
1406 @i{Handbook of Mathematical Functions}.
1407
1408
1409 @deffn {Función} erf (@var{z})
1410 Función de error erf(z) (A&S 7.1.1)
1411
1412 Véase también @code{erfflag}.
1413 @end deffn
1414
1415 @deffn {Función} erfc (@var{z})
1416 Complemento de la función de error erfc(z) (A&S 7.1.2)
1417
1418 @code{erfc(z) = 1-erf(z)}
1419 @end deffn
1420
1421 @deffn {Función} erfi (@var{z})
1422 Función de error imaginaria.
1423
1424 @code{erfi(z) = -%i*erf(%i*z)}
1425 @end deffn
1426
1427 @deffn {Función} erf_generalized (@var{z1},@var{z2})
1428 Función de error generalizada Erf(z1,z2)
1429 @end deffn
1430
1431
1432 @deffn {Función} fresnel_c (@var{z})
1433 Integral de Fresnel @code{C(z) = integrate(cos((%pi/2)*t^2),t,0,z)}. (A&S 7.3.1)
1434
1435 La simplificación @code{fresnel_c(-x) = -fresnel_c(x)} se aplica cuando
1436 la variable global @code{trigsign} vale @code{true}.
1437
1438 La simplificación @code{fresnel_s(%i*x) =  -%i*fresnel_s(x)} se aplica cuando
1439 la variable global @code{%iargs} vale @code{true}.
1440
1441 Véanse también @code{erf_representation} y
1442 @code{hypergeometric_representation}.
1443 @end deffn
1444
1445 @deffn {Función} fresnel_s (@var{z})
1446 Integral de Fresnel S(z) = integrate(sin((%pi/2)*t^2),t,0,z). (A&S 7.3.2)
1447
1448 La simplificación fresnel_s(-x) = -fresnel_s(x) se aplica cuando
1449 la variable global @code{trigsign} vale @code{true}.
1450
1451 La simplificación fresnel_s(%i*x) =  %i*fresnel_s(x) se aplica cuando
1452 la variable global @code{%iargs} vale @code{true}.
1453
1454 Véanse también @code{erf_representation} y
1455 @code{hypergeometric_representation}.
1456 @end deffn
1457
1458 @defvr {Variable opcional} erf_representation
1459 Valor por defecto: false
1460
1461 Cuando valga @code{true} erfc, erfi, erf_generalized, fresnel_s
1462 y fresnel_c se transforman a erf.
1463 @end defvr
1464
1465 @defvr {Variable opcional} hypergeometric_representation
1466 Valor por defecto: false
1467
1468 Permite obtener la representación hipergeométrica
1469 de las funciones fresnel_s y fresnel_c.
1470 @end defvr
1471
1472
1473
1474
1475
1476
1477
1478 @node Funciones de Struve, Funciones hipergeométricas, Función de error, Funciones Especiales
1479 @section Funciones de Struve
1480
1481 Las funciones de Struve se definen en el capítulo
1482 12 de Abramowitz y Stegun, @i{Handbook of Mathematical Functions}.
1483
1484 @deffn {Función} struve_h (@var{v}, @var{z})
1485 Función H de Struve de orden @var{v} y argumento @var{z}, (A&S 12.1.1).
1486
1487 @end deffn
1488
1489 @deffn {Función} struve_l (@var{v}, @var{z})
1490 Función L modificada de Struve de orden @var{v} y argumento @var{z}, (A&S 12.2.1).
1491
1492 @end deffn
1493
1494
1495
1496
1497
1498 @node Funciones hipergeométricas, Funciones de cilindro parabólico, Funciones de Struve, Funciones Especiales
1499 @section Funciones hipergeométricas
1500
1501 Las funciones hipergeométricas se definen en los capítulos
1502 13 y 15 de Abramowitz y Stegun, @i{Handbook of Mathematical Functions}.
1503
1504 Maxima tiene un soporte limitado sobre estas funciones, que pueden
1505 aparecer en resultados devueltos por @code{hgfred}.
1506
1507 @deffn {Función} %m [@var{k},@var{u}] (@var{z})
1508 Función M de Whittaker
1509 @code{M[k,u](z) = exp(-z/2)*z^(1/2+u)*M(1/2+u-k,1+2*u,z)}.
1510 (A&S 13.1.32)
1511 @end deffn
1512
1513 @deffn {Función} %w [@var{k},@var{u}] (@var{z})
1514 Función W de Whittaker.  (A&S 13.1.33)
1515 @end deffn
1516
1517
1518 @deffn {Función} %f [@var{p},@var{q}] (@var{[a],[b],z})
1519 Es la función hipergeométrica pFq(a1,a2,..ap;b1,b2,..bq;z),
1520 donde @code{a} es una lista de longitud @code{p} y
1521 @code{b} otra lista de longitud @code{q}.
1522 @end deffn
1523
1524
1525 @deffn {Función} hypergeometric ([@var{a1}, ..., @var{ap}],[@var{b1}, ... ,@var{bq}], x)
1526 Es la función hipergeométrica. A diferencia de la función
1527 hipergeométrica @code{%f} de Maxima, la función @code{hypergeometric}
1528 es simplificadora; además, @code{hypergeometric} soporta la evaluación
1529 en doble (float) y gran (bigfloat) precisión. La evaluación
1530 numérica fuera del círculo unidad no está en general
1531 soportada, pero sí en el caso de la función
1532 hipergeométrica de Gauss, cuando @math{p = 2} y @math{q = 1}.
1533
1534 Si la variable opcional @code{expand_hypergeometric} vale @code{true},
1535 (el valor por defecto es @code{false}) y uno de los argumentos entr @code{a1}
1536 y @code{ap} es entero negativo (caso polinomial), entonces @code{hypergeometric}
1537 devuelve un polinomio expandido.
1538
1539 Ejemplos:
1540 @example
1541 (%i1)  hypergeometric([],[],x);
1542 (%o1) %e^x
1543 @end example
1544
1545 Los polinomios se expanden automáticamente cuando @code{expand_hypergeometric}
1546 vale @code{true}.
1547
1548 @example
1549 (%i2) hypergeometric([-3],[7],x);
1550 (%o2) hypergeometric([-3],[7],x)
1551
1552 (%i3) hypergeometric([-3],[7],x), expand_hypergeometric : true;
1553 (%o3) -x^3/504+3*x^2/56-3*x/7+1
1554 @end example
1555
1556 Se soporta la evaluación en doble (float) y gran (bigfloat) precisión:
1557
1558 @example
1559 (%i4) hypergeometric([5.1],[7.1 + %i],0.42);
1560 (%o4)       1.346250786375334 - 0.0559061414208204 %i
1561 (%i5) hypergeometric([5,6],[8], 5.7 - %i);
1562 (%o5)     .007375824009774946 - .001049813688578674 %i
1563 (%i6) hypergeometric([5,6],[8], 5.7b0 - %i), fpprec : 30;
1564 (%o6) 7.37582400977494674506442010824b-3
1565                           - 1.04981368857867315858055393376b-3 %i
1566 @end example
1567 @end deffn
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577 @node Funciones de cilindro parabólico, Funciones y variables para las funciones especiales, Funciones hipergeométricas, Funciones Especiales
1578 @section  Funciones de cilindro parabólico
1579
1580 Las funciones de cilindro parabólico se definen en el capítulo
1581 19 de Abramowitz y Stegun, @i{Handbook of Mathematical Functions}.
1582
1583 Maxima tiene un soporte limitado sobre estas funciones, que pueden
1584 aparecer en resultados devueltos por @code{hgfred}.
1585
1586 @deffn {Función} parabolic_cylinder_d (@var{v}, @var{z})
1587 Función de cilindro parabólico @code{parabolic_cylinder_d(v,z)}. (A&s 19.3.1)
1588 @end deffn
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600 @node Funciones y variables para las funciones especiales,  , Funciones de cilindro parabólico, Funciones Especiales
1601 @section Funciones y variables para las funciones especiales
1602
1603
1604 @deffn {Función} specint (exp(- s*@var{t}) * @var{expr}, @var{t})
1605
1606 Calcula la transformada de Laplace de @var{expr} respecto de
1607 la variable @var{t}. El integrando @var{expr} puede contener
1608 funciones especiales.
1609
1610 La función @code{specint} admite las funciones especiales siguientes:
1611 la gamma incompleta, las funciones de error (pero no @code{erfi}, siendo
1612 sencillo transformar @code{erfi} en la función de error @code{erf}),
1613 integrales exponenciales, funciones de Bessel (incluidos productos de
1614 funciones de Bessel), funciones de Hankel, de Hermite y los polinomios de
1615 Laguerre.
1616
1617 Además, @code{specint} también admite la función hipergeométrica
1618 @code{%f[p,q]([],[],z)}, la función de Whittaker de primera especie
1619 @code{%m[u,k](z)} y la de segunda especie @code{%w[u,k](z)}.
1620
1621 El resultado puede darse en términos de funciones especiales y es
1622 posible que incluya también funciones hipergeométricas sin
1623 simplificar.
1624
1625 Cuando @code{laplace} es incapaz de calcular la transformada de Laplace,
1626 entonces llama a la función @code{specint}. Puesto que @code{laplace}
1627 tiene programadas más reglas para calcular transformadas de Laplace,
1628 es preferible utilizar @code{laplace} en lugar de @code{specint}.
1629
1630 La ejecución de @code{demo(hypgeo)} muestra algunos ejemplos de
1631 transformadas de Laplace calculadas con @code{specint}.
1632
1633 Ejemplos:
1634 @c ===beg===
1635 @c assume (p > 0, a > 0)$
1636 @c specint (t^(1/2) * exp(-a*t/4) * exp(-p*t), t);
1637 @c specint (t^(1/2) * bessel_j(1, 2 * a^(1/2) * t^(1/2))
1638 @c               * exp(-p*t), t);
1639 @c ===end===
1640
1641 @example
1642 (%i1) assume (p > 0, a > 0)$
1643 (%i2) specint (t^(1/2) * exp(-a*t/4) * exp(-p*t), t);
1644                            sqrt(%pi)
1645 (%o2)                     ------------
1646                                  a 3/2
1647                           2 (p + -)
1648                                  4
1649 (%i3) specint (t^(1/2) * bessel_j(1, 2 * a^(1/2) * t^(1/2))
1650               * exp(-p*t), t);
1651                                    - a/p
1652                          sqrt(a) %e
1653 (%o3)                    ---------------
1654                                 2
1655                                p
1656 @end example
1657
1658 Ejemplos para integrales exponenciales:
1659
1660 @example
1661 (%i4) assume(s>0,a>0,s-a>0)$
1662 (%i5) ratsimp(specint(%e^(a*t)
1663                       *(log(a)+expintegral_e1(a*t))*%e^(-s*t),t));
1664                              log(s)
1665 (%o5)                        ------
1666                              s - a
1667 (%i6) logarc:true$
1668
1669 (%i7) gamma_expand:true$
1670
1671 radcan(specint((cos(t)*expintegral_si(t)
1672                      -sin(t)*expintegral_ci(t))*%e^(-s*t),t));
1673                              log(s)
1674 (%o8)                        ------
1675                               2
1676                              s  + 1
1677 ratsimp(specint((2*t*log(a)+2/a*sin(a*t)
1678                       -2*t*expintegral_ci(a*t))*%e^(-s*t),t));
1679                                2    2
1680                           log(s  + a )
1681 (%o9)                     ------------
1682                                 2
1683                                s
1684 @end example
1685
1686 Resultados cuando se utiliza la expansión de @code{gamma_incomplete}
1687 y se cambia la representación de @code{expintegral_e1}:
1688
1689 @example
1690 (%i10) assume(s>0)$
1691 (%i11) specint(1/sqrt(%pi*t)*unit_step(t-k)*%e^(-s*t),t);
1692                                             1
1693                             gamma_incomplete(-, k s)
1694                                             2
1695 (%o11)                      ------------------------
1696                                sqrt(%pi) sqrt(s)
1697
1698 (%i12) gamma_expand:true$
1699 (%i13) specint(1/sqrt(%pi*t)*unit_step(t-k)*%e^(-s*t),t);
1700                               erfc(sqrt(k) sqrt(s))
1701 (%o13)                        ---------------------
1702                                      sqrt(s)
1703
1704 (%i14) expintrep:expintegral_e1$
1705 (%i15) ratsimp(specint(1/(t+a)^2*%e^(-s*t),t));
1706                               a s
1707                         a s %e    expintegral_e1(a s) - 1
1708 (%o15)                - ---------------------------------
1709                                         a
1710 @end example
1711 @end deffn
1712
1713
1714 @deffn {Función} hgfred (@var{a}, @var{b}, @var{t})
1715
1716 Simplifica la función hipergeométrica generalizada en términos
1717 de otras funciones más sencillas. @var{a} es una lista de parámetros
1718 del numerador y @var{b} lo es de parámetros del denominador.
1719
1720 En caso de que @code{hgfred} no pueda simplificar la función hipergeométrica
1721 devolverá una expresión de la forma @code{%f[p,q]([a], [b], x)}, siendo @var{p}
1722 el número de elementos de @var{a} y @var{q} el de @var{b}. Esta es la
1723 función hipergeométrica generalizada @code{pFq}.
1724
1725 @example
1726 (%i1) assume(not(equal(z,0)));
1727 (%o1)                          [notequal(z, 0)]
1728 (%i2) hgfred([v+1/2],[2*v+1],2*%i*z);
1729
1730                      v/2                               %i z
1731                     4    bessel_j(v, z) gamma(v + 1) %e
1732 (%o2)               ---------------------------------------
1733                                        v
1734                                       z
1735 (%i3) hgfred([1,1],[2],z);
1736
1737                                    log(1 - z)
1738 (%o3)                            - ----------
1739                                        z
1740 (%i4) hgfred([a,a+1/2],[3/2],z^2);
1741
1742                                1 - 2 a          1 - 2 a
1743                         (z + 1)        - (1 - z)
1744 (%o4)                   -------------------------------
1745                                  2 (1 - 2 a) z
1746
1747 @end example
1748
1749 Tal como muestra el siguiente ejemplo, puede ser de utilidad cargar
1750 también el paquete @code{orthopoly}. Nótese que @var{L} es el
1751 polinomio generalizado de Laguerre.
1752
1753 @example
1754 (%i5) load("orthopoly")$
1755 (%i6) hgfred([-2],[a],z);
1756
1757                                     (a - 1)
1758                                  2 L       (z)
1759                                     2
1760 (%o6)                            -------------
1761                                    a (a + 1)
1762 (%i7) ev(%);
1763
1764                                   2
1765                                  z        2 z
1766 (%o7)                         --------- - --- + 1
1767                               a (a + 1)    a
1768
1769 @end example
1770
1771 @end deffn
1772
1773
1774 @deffn {Función} lambert_w (@var{z})
1775 Rama principal de la función W de Lambert, solución de
1776 la ecuación @code{z = W(z) * exp(W(z))}.  (DLMF 4.13)
1777 @end deffn
1778
1779 @deffn {Función} generalized_lambert_w (@var{k}, @var{z})
1780 @var{k}-ésima rama de la función W de Lambert's, W(z), solución de
1781 @code{z = W(z) * exp(W(z))}. (DLMF 4.13)
1782
1783 La rama principal, representada por Wp(z) en DLMF, es @code{lambert_w(z) = generalized_lambert_w(0,z)}.
1784
1785 La otra rama con valores reales, representada por Wm(z) en DLMF, es @code{generalized_lambert_w(-1,z)}.
1786 @end deffn
1787
1788 @deffn {Función} nzeta (@var{z})
1789 Función de dispersión del plasma.
1790 @code{nzeta(z) = %i*sqrt(%pi)*exp(-z^2)*(1-erf(-%i*z))}
1791 @end deffn
1792
1793 @deffn {Función} nzetar (@var{z})
1794 Devuelve @code{realpart(nzeta(z))}.
1795 @end deffn
1796
1797 @deffn {Función} nzetai (@var{z})
1798 Devuelve @code{imagpart(nzeta(z))}.
1799 @end deffn
1800
1801