1This is maxima.info, produced by makeinfo version 6.6 from maxima.texi. 2 3Este es el Manual de Maxima en versión Texinfo 4 5Copyright 1994, 2001 William F. Schelter 6 7START-INFO-DIR-ENTRY 8* Maxima: (maxima). Un sistema de cálculo simbólico 9END-INFO-DIR-ENTRY 10 11 12File: maxima.info, Node: Funciones de Airy, Next: Funciones Gamma y factorial, Prev: Funciones de Bessel, Up: Funciones Especiales 13 1415.3 Funciones de Airy 15====================== 16 17Las funciones de Airy Ai(x) y Bi(x) se definen en la sección 10.4. de 18Abramowitz and Stegun, Handbook of Mathematical Functions. 19 20'y = Ai(x)' y 'y = Bi(x)' son dos soluciones linealmente independientes 21de la ecuación diferencia de Airy 'diff (y(x), x, 2) - x y(x) = 0'. 22 23Si el argumento 'x' es un número decimal en coma flotante real o 24complejo, se devolverá el valor numérico de la función. 25 26 -- Función: airy_ai (<x>) 27 Función de Airy Ai(x). (A&S 10.4.2) 28 29 La derivada 'diff (airy_ai(x), x)' es 'airy_dai(x)'. 30 31 Véanse 'airy_bi', 'airy_dai' y 'airy_dbi'. 32 33 -- Función: airy_dai (<x>) 34 Es la derivada de la función Ai de Airy, 'airy_ai(x)'. 35 36 Véase 'airy_ai'. 37 38 -- Función: airy_bi (<x>) 39 Es la función Bi de Airy, tal como la definen Abramowitz y Stegun, 40 Handbook of Mathematical Functions, Sección 10.4. Se trata de la 41 segunda solución de la ecuación de Airy 'diff (y(x), x, 2) - x y(x) 42 = 0'. 43 44 Si el argumento 'x' es un número decimal real o complejo, se 45 devolverá el valor numérico de 'airy_bi' siempre que sea posible. 46 En los otros casos, se devuelve la expresión sin evaluar. 47 48 La derivada 'diff (airy_bi(x), x)' es 'airy_dbi(x)'. 49 50 Véanse 'airy_ai' y 'airy_dbi'. 51 52 -- Función: airy_dbi (<x>) 53 Es la derivada de la función Bi de Airy, 'airy_bi(x)'. 54 55 Véanse 'airy_ai' y 'airy_bi'. 56 57 58File: maxima.info, Node: Funciones Gamma y factorial, Next: Integral exponencial, Prev: Funciones de Airy, Up: Funciones Especiales 59 6015.4 Funciones Gamma y factorial 61================================ 62 63Las funciones gamma, beta, psi y gamma incompleta están definidas en el 64capítulo 6 de Abramowitz y Stegun, Handbook of Mathematical Functions. 65 66 -- Función: bffac (<expr>, <n>) 67 Versión para "bigfloat" de la función factorial (Gamma desplazada). 68 El segundo argumento indica cuántos dígitos se conservan y 69 devuelven, pudiendo utilizarse para obtener algunas cifras extra. 70 71 -- Variable optativa: algepsilon 72 Valor por defecto: 10^8 73 74 El valor de 'algepsilon' es usado por 'algsys'. 75 76 -- Función: bfpsi (<n>, <z>, <fpprec>) 77 -- Función: bfpsi0 (<z>, <fpprec>) 78 La función 'bfpsi' es la poligamma de argumento real <z> y de orden 79 el entero <n>. La función 'bfpsi0' es la digamma. La llamada 80 'bfpsi0 (<z>, <fpprec>)' equivale a 'bfpsi (0, <z>, <fpprec>)'. 81 82 Estas funciones devuelven valores "bigfloat". La variable <fpprec> 83 es la precisión "bigfloat" del valor de retorno. 84 85 -- Función: cbffac (<z>, <fpprec>) 86 Calcula el factorial de números complejos de punto flotante 87 grandes. 88 89 La instrucción 'load ("bffac")' carga esta función. 90 91 -- Función: gamma (<x>) 92 93 La definición básica de la función gamma (A&S 6.1.1) es 94 95 inf 96 / 97 [ z - 1 - t 98 gamma(z) = I t %e dt 99 ] 100 / 101 0 102 103 Maxima simplifica 'gamma' para enteros positivos y para fracciones 104 positivas o negativas. Para fracciones de denominador dos, el 105 resultado es un número racional multiplicado por 'sqrt(%pi)'. La 106 simplificación para valores enteros la controla 'factlim'. Para 107 enteros mayores que 'factlim' el resultado numérico de la función 108 factorial, la cual se utiliza para calcular 'gamma', producirá un 109 desbordamiento. La simplificación para números racionales la 110 controla 'gammalim' para evitar desbordamientos. Véanse también 111 'factlim' y 'gammalim'. 112 113 Para enteros negativos, 'gamma' no está definida. 114 115 Maxima puede evaluar 'gamma' numéricamente para valores reales y 116 complejos, tanto en formato float (doble precisión) como big float 117 (precisión arbitraria). 118 119 La función 'gamma' tiene simetría especular. 120 121 Si 'gamma_expand' vale 'true', Maxima expande 'gamma' para 122 argumentos del tipo 'z+n' y 'z-n', siendo 'n' un entero. 123 124 Maxima conoce la derivada de 'gamma'. 125 126 Ejemplos: 127 128 Simplificación para enteros, fracciones de denominador dos y 129 números racionales: 130 131 (%i1) map('gamma,[1,2,3,4,5,6,7,8,9]); 132 (%o1) [1, 1, 2, 6, 24, 120, 720, 5040, 40320] 133 134 (%i2) map('gamma,[1/2,3/2,5/2,7/2]); 135 sqrt(%pi) 3 sqrt(%pi) 15 sqrt(%pi) 136 (%o2) [sqrt(%pi), ---------, -----------, ------------] 137 2 4 8 138 139 (%i3) map('gamma,[2/3,5/3,7/3]); 140 2 1 141 2 gamma(-) 4 gamma(-) 142 2 3 3 143 (%o3) [gamma(-), ----------, ----------] 144 3 3 9 145 146 Evaluación numérica para valores reales y complejos: 147 148 (%i4) map('gamma,[2.5,2.5b0]); 149 (%o4) [1.329340388179137, 1.329340388179137b0] 150 151 (%i5) map('gamma,[1.0+%i,1.0b0+%i]); 152 (%o5) [.4980156681183558 - .1549498283018108 %i, 153 4.980156681183561b-1 - 1.549498283018107b-1 %i] 154 155 Simetría especular: 156 157 (%i6) declare(z,complex)$ 158 (%i7) conjugate(gamma(z)); 159 (%o7) gamma(conjugate(z)) 160 161 Maxima expande 'gamma(z+n)' y 'gamma(z-n)' si 'gamma_expand' vale 162 'true': 163 164 (%i8) gamma_expand:true$ 165 (%i9) [gamma(z+1),gamma(z-1),gamma(z+2)/gamma(z+1)]; 166 gamma(z) 167 (%o9) [z gamma(z), --------, z + 1] 168 z - 1 169 170 Derivada de 'gamma': 171 172 (%i10) diff(gamma(z),z); 173 (%o10) psi (z) gamma(z) 174 0 175 176 Véase también 'makegamma'. 177 178 La constante de Euler-Mascheroni es '%gamma'. 179 180 -- Función: log_gamma (<z>) 181 Logaritmo natural de la función gamma. 182 183 -- Función: gamma_incomplete_lower (<a>, <z>) 184 185 Función gamma incompleta inferior (A&S 6.5.2): 186 187 z 188 / 189 [ a - 1 - t 190 gamma_incomplete_lower(a, z) = I t %e dt 191 ] 192 / 193 0 194 195 Véase también 'gamma_incomplete' (función gamma incompleta 196 superior). 197 198 -- Función: gamma_incomplete (<a>,<z>) 199 Función gamma incompleta superior, A&S 6.5.3: 200 201 inf 202 / 203 [ a - 1 - t 204 gamma_incomplete(a, z) = I t %e dt 205 ] 206 / 207 z 208 209 Véanse también 'gamma_expand' para controlar cómo se expresa 210 'gamma_incomplete' en términos de funciones elementales y de 211 'erfc'. 212 213 Véanse también las funciones relacionadas 214 'gamma_incomplete_regularized' y 'gamma_incomplete_generalized'. 215 216 -- Función: gamma_incomplete_regularized (<a>,<z>) 217 Función gamma incompleta superior regularizada, A&S 6.5.1. 218 219 gamma_incomplete_regularized(a, z) = 220 gamma_incomplete(a, z) 221 ---------------------- 222 gamma(a) 223 224 Véanse también 'gamma_expand' para controlar cómo se expresa 225 'gamma_incomplete' en términos de funciones elementales y de 226 'erfc'. 227 228 Véase también 'gamma_incomplete'. 229 230 -- Función: gamma_incomplete_generalized (<a>,<z1>,<z1>) 231 Función gamma incompleta generalizada. 232 233 gamma_incomplete_generalized(a, z1, z2) = 234 z2 235 / 236 [ a - 1 - t 237 I t %e dt 238 ] 239 / 240 z1 241 242 Véanse también 'gamma_incomplete' y 'gamma_incomplete_regularized'. 243 244 -- Variable opcional: gamma_expand 245 Valor por defecto: 'false' 246 247 'gamma_expand' controla la expansión de 'gamma_incomplete'. Si 248 'gamma_expand' vale 'true', 'gamma_incomplete(v,z)' se expande en 249 términos de 'z', 'exp(z)' y 'erfc(z)', siempre que sea posible. 250 251 (%i1) gamma_incomplete(2,z); 252 (%o1) gamma_incomplete(2, z) 253 (%i2) gamma_expand:true; 254 (%o2) true 255 (%i3) gamma_incomplete(2,z); 256 - z 257 (%o3) (z + 1) %e 258 (%i4) gamma_incomplete(3/2,z); 259 - z sqrt(%pi) erfc(sqrt(z)) 260 (%o4) sqrt(z) %e + ----------------------- 261 2 262 263 -- Variable optativa: gammalim 264 Valor por defecto: 10000 265 266 La variable 'gammalim' controla la simplificación de la función 267 gamma con argumentos enteros o racionales. Si el valor absoluto 268 del argumento no es mayor que 'gammalim', entonces se realizará la 269 simplificación. Nótese que la variable 'factlim' también controla 270 la simplificación del resultado de 'gamma' con argumento entero. 271 272 -- Función: makegamma (<expr>) 273 Transforma las funciones 'binomial', 'factorial' y 'beta' que 274 aparecen en <expr> en funciones 'gamma'. 275 276 Véase también 'makefact'. 277 278 -- Función: beta (<a>, <b>) 279 La función beta se define como 'gamma(a) gamma(b)/gamma(a+b)' (A&S 280 6.2.1). 281 282 Maxima simplifica la función beta para enteros positivos y números 283 racionales cuya suma sea entera. Si 'beta_args_sum_to_integer' 284 vale 'true', Maxima también simplifica expresiones generales cuya 285 suma sea también entera. 286 287 Cuando <a> o <b> sean nulos, la función beta no está definida. 288 289 En general, la función beta no está definida para enteros 290 negativos. La excepción es para <a=-n>, siendo <n> un entero 291 positivo y <b> otro entero positivo tal que <b<=n>, entonces es 292 posible definir una continuación analítica. En este caso Maxima 293 devuelve un resultado. 294 295 Si 'beta_expand' vale 'true', expresiones como 'beta(a+n,b)', 296 'beta(a-n,b)', 'beta(a,b+n)' o 'beta(a,b-n)', siendo 'n' entero, se 297 simplifican. 298 299 Maxima puede evaluar la función beta para valores reales y 300 complejos, tanto de tipo decimal flotante o big float. Para la 301 evaluación numérica Maxima utiliza 'log_gamma': 302 303 - log_gamma(b + a) + log_gamma(b) + log_gamma(a) 304 %e 305 306 Maxima reconoce la simetría de la función beta. 307 308 Maxima conoce las derivadas de la función beta, tanto respecto de 309 <a> como de <b>. 310 311 Para expresar la función beta como un cociente de funciones gamma, 312 véase 'makegamma'. 313 314 Ejemplos: 315 316 Simplificación cuando uno de sus argumentos es entero: 317 318 (%i1) [beta(2,3),beta(2,1/3),beta(2,a)]; 319 1 9 1 320 (%o1) [--, -, ---------] 321 12 4 a (a + 1) 322 323 Simplificación para argumentos racionales que suman un entero: 324 325 (%i2) [beta(1/2,5/2),beta(1/3,2/3),beta(1/4,3/4)]; 326 3 %pi 2 %pi 327 (%o2) [-----, -------, sqrt(2) %pi] 328 8 sqrt(3) 329 330 Cuando se iguala 'beta_args_sum_to_integer' a 'true' se simplifican 331 expresiones más generales si la suma de los argumentos se reduce a 332 un entero: 333 334 (%i3) beta_args_sum_to_integer:true$ 335 (%i4) beta(a+1,-a+2); 336 %pi (a - 1) a 337 (%o4) ------------------ 338 2 sin(%pi (2 - a)) 339 340 Posibles valores cuando uno de los argumentos es entero negativo: 341 342 (%i5) [beta(-3,1),beta(-3,2),beta(-3,3)]; 343 1 1 1 344 (%o5) [- -, -, - -] 345 3 6 3 346 347 'beta(a+n,b)' o 'beta(a-n)' con 'n' entero se simplifica si 348 'beta_expand' vale 'true': 349 350 (%i6) beta_expand:true$ 351 (%i7) [beta(a+1,b),beta(a-1,b),beta(a+1,b)/beta(a,b+1)]; 352 a beta(a, b) beta(a, b) (b + a - 1) a 353 (%o7) [------------, ----------------------, -] 354 b + a a - 1 b 355 356 357 La función beta no está definida si uno de sus argumentos es cero: 358 359 (%i7) beta(0,b); 360 beta: expected nonzero arguments; found 0, b 361 -- an error. To debug this try debugmode(true); 362 363 Evaluación numérica para argumentos reales y complejos de tipo 364 decimal flotante o big float: 365 366 (%i8) beta(2.5,2.3); 367 (%o8) .08694748611299981 368 369 (%i9) beta(2.5,1.4+%i); 370 (%o9) 0.0640144950796695 - .1502078053286415 %i 371 372 (%i10) beta(2.5b0,2.3b0); 373 (%o10) 8.694748611299969b-2 374 375 (%i11) beta(2.5b0,1.4b0+%i); 376 (%o11) 6.401449507966944b-2 - 1.502078053286415b-1 %i 377 378 La función beta es simétrica con simetría especular: 379 380 (%i14) beta(a,b)-beta(b,a); 381 (%o14) 0 382 (%i15) declare(a,complex,b,complex)$ 383 (%i16) conjugate(beta(a,b)); 384 (%o16) beta(conjugate(a), conjugate(b)) 385 386 Derivada de la función beta respecto de 'a': 387 388 (%i17) diff(beta(a,b),a); 389 (%o17) - beta(a, b) (psi (b + a) - psi (a)) 390 0 0 391 392 -- Función: beta_incomplete (<a>, <b>, <z>) 393 La definición básica de la función beta incompleta (A&S 6.6.1) es 394 395 z 396 / 397 [ b - 1 a - 1 398 I (1 - t) t dt 399 ] 400 / 401 0 402 403 Esta definición es posible para realpart(a)>0, realpart(b)>0 y 404 abs(z)<1. Para otras situaciones, la función beta incompleta puede 405 definirse por medio de una función hipergeométrica generalizada: 406 407 gamma(a) hypergeometric_generalized([a, 1 - b], [a + 1], z) z 408 (Véase Funcións.wolfram.com para una completa definición de la 409 función beta incompleta.) 410 411 Para enteros negativos a = -n y enteros positivos b=m con m<=n la 412 función beta incompleta se define como 413 414 m - 1 k 415 ==== (1 - m) z 416 n - 1 \ k 417 z > ----------- 418 / k! (n - k) 419 ==== 420 k = 0 421 Maxima utiliza esta definición para simplificar 'beta_incomplete' 422 cuando <a> es entero negativo. 423 424 Cuando <a> es entero positivo, 'beta_incomplete' se simplifica para 425 cualesquiera argumentos <b> y <z>, y para <b> entero positivo para 426 cualesquiera argumentos <a> y <z>, con la excepción de cuando <a> 427 sea entero negativo. 428 429 Para z=0 y realpart(a)>0, 'beta_incomplete' se anula. Para <z=1> y 430 realpart(b)>0, 'beta_incomplete' se reduce a la función 431 'beta(a,b)'. 432 433 Maxima evalúa 'beta_incomplete' numéricamente para valores reales y 434 complejos en forma decimal y big float. La evaluación numérica se 435 realiza expandiendo la función beta incompleta en fracciones 436 continuas. 437 438 Si 'beta_expand' vale 'true', Maxima expande las expresiones 439 'beta_incomplete(a+n,b,z)' y 'beta_incomplete(a-n,b,z)', siendo <n> 440 entero positivo. 441 442 Maxima conoce las derivadas de 'beta_incomplete' con respecto a las 443 variables <a>, <b> y <z>, así como la integral respecto de la 444 variable <z>. 445 446 Ejemplos: 447 448 Simplificación para <a> entero positivo: 449 450 (%i1) beta_incomplete(2,b,z); 451 b 452 1 - (1 - z) (b z + 1) 453 (%o1) ---------------------- 454 b (b + 1) 455 456 Simplificación para <b> entero positivo: 457 458 (%i2) beta_incomplete(a,2,z); 459 a 460 (a (1 - z) + 1) z 461 (%o2) ------------------ 462 a (a + 1) 463 464 Simplificación para <a> y <b> enteros positivos: 465 466 (%i3) beta_incomplete(3,2,z); 467 3 468 (3 (1 - z) + 1) z 469 (%o3) ------------------ 470 12 471 472 Para <a> entero negativo y b<=(-a): 473 474 (%i4) beta_incomplete(-3,1,z); 475 1 476 (%o4) - ---- 477 3 478 3 z 479 480 Simplificación para los valores z=0 y z=1: 481 482 (%i5) assume(a>0,b>0)$ 483 (%i6) beta_incomplete(a,b,0); 484 (%o6) 0 485 (%i7) beta_incomplete(a,b,1); 486 (%o7) beta(a, b) 487 488 Evaluación numérica, tanto con float (precisión doble) como big 489 float (precisión arbitraria): 490 491 (%i8) beta_incomplete(0.25,0.50,0.9); 492 (%o8) 4.594959440269333 493 (%i9) fpprec:25$ 494 (%i10) beta_incomplete(0.25,0.50,0.9b0); 495 (%o10) 4.594959440269324086971203b0 496 497 Para abs(z)>1, 'beta_incomplete' devuelve un resultado complejo: 498 499 (%i11) beta_incomplete(0.25,0.50,1.7); 500 (%o11) 5.244115108584249 - 1.45518047787844 %i 501 502 Resultados para argumentos complejos más generales: 503 504 (%i14) beta_incomplete(0.25+%i,1.0+%i,1.7+%i); 505 (%o14) 2.726960675662536 - .3831175704269199 %i 506 (%i15) beta_incomplete(1/2,5/4*%i,2.8+%i); 507 (%o15) 13.04649635168716 %i - 5.802067956270001 508 (%i16) 509 510 Expansión cuando 'beta_expand' vale 'true': 511 512 (%i23) beta_incomplete(a+1,b,z),beta_expand:true; 513 b a 514 a beta_incomplete(a, b, z) (1 - z) z 515 (%o23) -------------------------- - ----------- 516 b + a b + a 517 518 (%i24) beta_incomplete(a-1,b,z),beta_expand:true; 519 b a - 1 520 beta_incomplete(a, b, z) (- b - a + 1) (1 - z) z 521 (%o24) -------------------------------------- - --------------- 522 1 - a 1 - a 523 524 Derivada e integral de 'beta_incomplete': 525 526 (%i34) diff(beta_incomplete(a, b, z), z); 527 b - 1 a - 1 528 (%o34) (1 - z) z 529 (%i35) integrate(beta_incomplete(a, b, z), z); 530 b a 531 (1 - z) z 532 (%o35) ----------- + beta_incomplete(a, b, z) z 533 b + a 534 a beta_incomplete(a, b, z) 535 - -------------------------- 536 b + a 537 (%i36) factor(diff(%, z)); 538 (%o36) beta_incomplete(a, b, z) 539 540 541 -- Función: beta_incomplete_regularized (<a>, <b>, <z>) 542 Función beta incompleta regularizada A&S 6.6.2, definida como 543 544 beta_incomplete_regularized(a, b, z) = 545 beta_incomplete(a, b, z) 546 ------------------------ 547 beta(a, b) 548 549 Al igual que 'beta_incomplete', esta definición no es completa. 550 Véase Funcións.wolfram.com para una definición completa de 551 'beta_incomplete_regularized'. 552 553 'beta_incomplete_regularized' se simplifica para <a> o <b> entero 554 positivo. 555 556 Para z=0 y realpart(a)>0, 'beta_incomplete_regularized' se anula. 557 Para <z=1> y realpart(b)>0, 'beta_incomplete_regularized' se reduce 558 a 1. 559 560 Maxima evalúa 'beta_incomplete_regularized' numéricamente para 561 valores reales y complejos en forma decimal y big float. 562 563 Si 'beta_expand' vale 'true', Maxima expande 564 'beta_incomplete_regularized' para los argumentos a+n o a-n, siendo 565 <n> entero. 566 567 Maxima conoce las derivadas de 'beta_incomplete_regularized' con 568 respecto a las variables <a>, <b> y <z>, así como la integral 569 respecto de la variable <z>. 570 571 Ejemplos: 572 573 Simplificación para <a> o <b> enteros positivos: 574 575 (%i1) beta_incomplete_regularized(2,b,z); 576 b 577 (%o1) 1 - (1 - z) (b z + 1) 578 579 (%i2) beta_incomplete_regularized(a,2,z); 580 a 581 (%o2) (a (1 - z) + 1) z 582 583 (%i3) beta_incomplete_regularized(3,2,z); 584 3 585 (%o3) (3 (1 - z) + 1) z 586 587 Simplificación para los valores z=0 y z=1: 588 589 (%i4) assume(a>0,b>0)$ 590 (%i5) beta_incomplete_regularized(a,b,0); 591 (%o5) 0 592 (%i6) beta_incomplete_regularized(a,b,1); 593 (%o6) 1 594 595 Evaluación numérica, tanto con float (precisión doble) como big 596 float (precisión arbitraria): 597 598 (%i7) beta_incomplete_regularized(0.12,0.43,0.9); 599 (%o7) .9114011367359802 600 (%i8) fpprec:32$ 601 (%i9) beta_incomplete_regularized(0.12,0.43,0.9b0); 602 (%o9) 9.1140113673598075519946998779975b-1 603 (%i10) beta_incomplete_regularized(1+%i,3/3,1.5*%i); 604 (%o10) .2865367499935403 %i - 0.122995963334684 605 (%i11) fpprec:20$ 606 (%i12) beta_incomplete_regularized(1+%i,3/3,1.5b0*%i); 607 (%o12) 2.8653674999354036142b-1 %i - 1.2299596333468400163b-1 608 609 Expansión cuando 'beta_expand' vale 'true': 610 611 (%i13) beta_incomplete_regularized(a+1,b,z); 612 b a 613 (1 - z) z 614 (%o13) beta_incomplete_regularized(a, b, z) - ------------ 615 a beta(a, b) 616 (%i14) beta_incomplete_regularized(a-1,b,z); 617 (%o14) beta_incomplete_regularized(a, b, z) 618 b a - 1 619 (1 - z) z 620 - ---------------------- 621 beta(a, b) (b + a - 1) 622 623 624 Derivada e integral respecto de <z>: 625 626 (%i15) diff(beta_incomplete_regularized(a,b,z),z); 627 b - 1 a - 1 628 (1 - z) z 629 (%o15) ------------------- 630 beta(a, b) 631 (%i16) integrate(beta_incomplete_regularized(a,b,z),z); 632 (%o16) beta_incomplete_regularized(a, b, z) z 633 b a 634 (1 - z) z 635 a (beta_incomplete_regularized(a, b, z) - ------------) 636 a beta(a, b) 637 - ------------------------------------------------------- 638 b + a 639 640 -- Función: beta_incomplete_generalized (<a>, <b>, <z1>, <z2>) 641 La definición básica de la función beta incompleta generalizada es 642 643 The basic definition of the generalized incomplete beta function is 644 645 z2 646 / 647 [ b - 1 a - 1 648 I (1 - t) t dt 649 ] 650 / 651 z1 652 653 Maxima simplifica 'beta_incomplete_regularized' para <a> y <b> 654 enteros positivos. 655 656 Para realpart(a)>0 y z1=0 o z2=0, Maxima reduce 657 'beta_incomplete_generalized' a 'beta_incomplete'. Para 658 realpart(b)>0 y z1=1 o <z2=1>, Maxima reduce a una expresión con 659 'beta' y 'beta_incomplete'. 660 661 Maxima evalúa 'beta_incomplete_generalized' numéricamente para 662 valores reales y complejos en forma decimal y big float. 663 664 Si 'beta_expand' vale 'true', Maxima expande 665 'beta_incomplete_generalized' para los argumentos a+n y a-n, siendo 666 <n> entero positivo. 667 668 Maxima conoce las derivadas de 'beta_incomplete_generalized' con 669 respecto a las variables <a>, <b>, <z1> y <z2>, así como la 670 integral respecto de las variables <z1> y <z2>. 671 672 Ejemplos: 673 674 Maxima simplifica 'beta_incomplete_generalized' para <a> y <b> 675 enteros positivos: 676 (%i1) beta_incomplete_generalized(2,b,z1,z2); 677 b b 678 (1 - z1) (b z1 + 1) - (1 - z2) (b z2 + 1) 679 (%o1) ------------------------------------------- 680 b (b + 1) 681 682 (%i2) beta_incomplete_generalized(a,2,z1,z2); 683 a a 684 (a (1 - z2) + 1) z2 - (a (1 - z1) + 1) z1 685 (%o2) ------------------------------------------- 686 a (a + 1) 687 688 (%i3) beta_incomplete_generalized(3,2,z1,z2); 689 2 2 2 2 690 (1 - z1) (3 z1 + 2 z1 + 1) - (1 - z2) (3 z2 + 2 z2 + 1) 691 (%o3) ----------------------------------------------------------- 692 12 693 694 Simplificación para los valores z1=0, z2=0, z1=1 o z2=1: 695 (%i4) assume(a > 0, b > 0)$ 696 (%i5) beta_incomplete_generalized(a,b,z1,0); 697 (%o5) - beta_incomplete(a, b, z1) 698 699 (%i6) beta_incomplete_generalized(a,b,0,z2); 700 (%o6) - beta_incomplete(a, b, z2) 701 702 (%i7) beta_incomplete_generalized(a,b,z1,1); 703 (%o7) beta(a, b) - beta_incomplete(a, b, z1) 704 705 (%i8) beta_incomplete_generalized(a,b,1,z2); 706 (%o8) beta_incomplete(a, b, z2) - beta(a, b) 707 708 Evaluación numérica para argumentos reales, tanto con float 709 (precisión doble) como big float (precisión arbitraria): 710 (%i9) beta_incomplete_generalized(1/2,3/2,0.25,0.31); 711 (%o9) .09638178086368676 712 713 (%i10) fpprec:32$ 714 (%i10) beta_incomplete_generalized(1/2,3/2,0.25,0.31b0); 715 (%o10) 9.6381780863686935309170054689964b-2 716 717 Evaluación numérica para argumentos complejos, tanto con float 718 (precisión doble) como big float (precisión arbitraria): 719 (%i11) beta_incomplete_generalized(1/2+%i,3/2+%i,0.25,0.31); 720 (%o11) - .09625463003205376 %i - .003323847735353769 721 (%i12) fpprec:20$ 722 (%i13) beta_incomplete_generalized(1/2+%i,3/2+%i,0.25,0.31b0); 723 (%o13) - 9.6254630032054178691b-2 %i - 3.3238477353543591914b-3 724 725 Expansión para a+n o a-n, siendo <n> entero positivo con 726 'beta_expand' igual 'true': 727 (%i14) beta_expand:true$ 728 (%i15) beta_incomplete_generalized(a+1,b,z1,z2); 729 b a b a 730 (1 - z1) z1 - (1 - z2) z2 731 (%o15) ----------------------------- 732 b + a 733 a beta_incomplete_generalized(a, b, z1, z2) 734 + ------------------------------------------- 735 b + a 736 737 (%i16) beta_incomplete_generalized(a-1,b,z1,z2); 738 beta_incomplete_generalized(a, b, z1, z2) (- b - a + 1) 739 (%o16) ------------------------------------------------------- 740 1 - a 741 b a - 1 b a - 1 742 (1 - z2) z2 - (1 - z1) z1 743 - ------------------------------------- 744 1 - a 745 746 Derivada respecto de la variable <z1> e integrales respecto de <z1> 747 y <z2>: 748 (%i17) diff(beta_incomplete_generalized(a,b,z1,z2),z1); 749 b - 1 a - 1 750 (%o17) - (1 - z1) z1 751 752 (%i18) integrate(beta_incomplete_generalized(a,b,z1,z2),z1); 753 (%o18) beta_incomplete_generalized(a, b, z1, z2) z1 754 + beta_incomplete(a + 1, b, z1) 755 756 (%i19) integrate(beta_incomplete_generalized(a,b,z1,z2),z2); 757 (%o19) beta_incomplete_generalized(a, b, z1, z2) z2 758 - beta_incomplete(a + 1, b, z2) 759 760 -- Variable opcional: beta_expand 761 Valor por defecto: false 762 763 Si 'beta_expand' vale 'true', 'beta(a,b)' y sus funciones 764 relacionadas se expanden para argumentos del tipo a+n o a-n, siendo 765 n un número entero. 766 767 -- Variable opcional: beta_args_sum_to_integer 768 Valor por defecto: false 769 770 Si 'beta_args_sum_to_integer' vale 'true', Maxima simplifica 771 'beta(a,b)' cuando la suma de los argumentos <a> y <b> sea un 772 entero. 773 774 -- Función: psi [<n>](<x>) 775 776 Es la derivada de 'log (gamma (<x>))' de orden '<n>+1', de tal 777 manera que 'psi[0](<x>)' es la primera derivada, 'psi[1](<x>)' la 778 segunda derivada y así sucesivamente. 779 780 En general, Maxima no sabe cómo calcular valores numéricos de 781 'psi', pero sí conoce el valor exacto para algunos argumentos 782 racionales. Existen algunas variables globales para controlar en 783 qué rangos racionales debe devolver 'psi' resultados exactos, si 784 ello es posible. Véanse las descripciones de 'maxpsiposint', 785 'maxpsinegint', 'maxpsifracnum' y 'maxpsifracdenom'. En resumen, 786 <x> debe alcanzar un valor entre 'maxpsinegint' y 'maxpsiposint'. 787 Si el valor absoluto de la parte fraccional de <x> es racional y 788 tiene un numerador menor que 'maxpsifracnum' y un denominador menor 789 que 'maxpsifracdenom', la función 'psi' devolverá un valor exacto. 790 791 La función 'bfpsi' del paquete 'bffac' puede calcular valores 792 numéricos. 793 794 -- Variable opcional: maxpsiposint 795 Valor por defecto: 20 796 797 La variable 'maxpsiposint' guarda el mayor valor positivo para el 798 que 'psi[n](x)' intentará calcular un valor exacto. 799 800 -- Variable opcional: maxpsinegint 801 Valor por defecto: -10 802 803 La variable 'maxpsinegint' guarda el menor valor negativo para el 804 que 'psi[n](x)' intentará calcular un valor exacto. Si <x> es 805 menor que 'maxnegint', 'psi[n](<x>)' no devolverá una respuesta 806 simplificada, aunque supiese cómo hacerlo. 807 808 -- Variable opcional: maxpsifracnum 809 Valor por defecto: 6 810 811 Sea <x> un número racional menor que la unidad de la forma 'p/q'. 812 Si 'p' es mayor que 'maxpsifracnum', entonces 'psi[<n>](<x>)' no 813 devolverá una respuesta simplificada. 814 815 -- Variable opcional: maxpsifracdenom 816 Valor por defecto: 6 817 818 Sea <x> un número racional menor que la unidad de la forma 'p/q'. 819 Si 'q' es mayor que 'maxpsifracnum', entonces 'psi[<n>](<x>)' no 820 devolverá una respuesta simplificada. 821 822 -- Función: makefact (<expr>) 823 Transforma las funciones 'binomial', 'gamma' y 'beta' que aparecen 824 en <expr> en su notación factorial. 825 826 Véase también 'makegamma'. 827 828 -- Función: numfactor (<expr>) 829 Devuelve el factor numérico que multiplica a la expresión <expr>, 830 la cual debe tener un único término. 831 832 (%i1) gamma (7/2); 833 15 sqrt(%pi) 834 (%o1) ------------ 835 8 836 (%i2) numfactor (%); 837 15 838 (%o2) -- 839 8 840 841 842File: maxima.info, Node: Integral exponencial, Next: Función de error, Prev: Funciones Gamma y factorial, Up: Funciones Especiales 843 84415.5 Integral exponencial 845========================= 846 847La integral exponencial y sus funciones relacionadas se definen en el 848capítulo 5 de Abramowitz y Stegun, Handbook of Mathematical Functions. 849 850 -- Función: expintegral_e1 (<z>) 851 La integral exponencial E1(z) (A&S 5.1.1) 852 853 -- Función: expintegral_ei (<z>) 854 La integral exponencial Ei(z) (A&S 5.1.2) 855 856 -- Función: expintegral_li (<z>) 857 La integral exponencial Li(z) (A&S 5.1.3) 858 859 -- Función: expintegral_e (<n>,<z>) 860 La integral exponencial En(z) (A&S 5.1.4) 861 862 -- Función: expintegral_si (<z>) 863 La integral exponencial Si(z) (A&S 5.2.1) 864 865 -- Función: expintegral_ci (<z>) 866 La integral exponencial Ci(z) (A&S 5.2.2) 867 868 -- Función: expintegral_shi (<z>) 869 La integral exponencial Shi(z) (A&S 5.2.3) 870 871 -- Función: expintegral_chi (<z>) 872 La integral exponencial Chi(z) (A&S 5.2.4) 873 874 -- Option variable: expintrep 875 Valor por defecto: false 876 877 Transforma la representación de la integral exponencial en términos 878 de las funciones 'gamma_incomplete', 'expintegral_e1', 879 'expintegral_ei', 'expintegral_li', 'expintegral_trig' y 880 'expintegral_hyp'. 881 882 -- Option variable: expintexpand 883 Valor por defecto: false 884 885 Expande la integral exponencial E[n](z) para valores medios de la 886 integral en términos de las funciones Erfc o Erf y para positivos 887 enteros en términos de Ei . 888 889 890File: maxima.info, Node: Función de error, Next: Funciones de Struve, Prev: Integral exponencial, Up: Funciones Especiales 891 89215.6 Función de error 893===================== 894 895La función de error y sus asociadas se definen en el capítulo 7 de 896Abramowitz y Stegun, Handbook of Mathematical Functions. 897 898 -- Función: erf (<z>) 899 Función de error erf(z) (A&S 7.1.1) 900 901 Véase también 'erfflag'. 902 903 -- Función: erfc (<z>) 904 Complemento de la función de error erfc(z) (A&S 7.1.2) 905 906 'erfc(z) = 1-erf(z)' 907 908 -- Función: erfi (<z>) 909 Función de error imaginaria. 910 911 'erfi(z) = -%i*erf(%i*z)' 912 913 -- Función: erf_generalized (<z1>,<z2>) 914 Función de error generalizada Erf(z1,z2) 915 916 -- Función: fresnel_c (<z>) 917 Integral de Fresnel 'C(z) = integrate(cos((%pi/2)*t^2),t,0,z)'. 918 (A&S 7.3.1) 919 920 La simplificación 'fresnel_c(-x) = -fresnel_c(x)' se aplica cuando 921 la variable global 'trigsign' vale 'true'. 922 923 La simplificación 'fresnel_s(%i*x) = -%i*fresnel_s(x)' se aplica 924 cuando la variable global '%iargs' vale 'true'. 925 926 Véanse también 'erf_representation' y 927 'hypergeometric_representation'. 928 929 -- Función: fresnel_s (<z>) 930 Integral de Fresnel S(z) = integrate(sin((%pi/2)*t^2),t,0,z). (A&S 931 7.3.2) 932 933 La simplificación fresnel_s(-x) = -fresnel_s(x) se aplica cuando la 934 variable global 'trigsign' vale 'true'. 935 936 La simplificación fresnel_s(%i*x) = %i*fresnel_s(x) se aplica 937 cuando la variable global '%iargs' vale 'true'. 938 939 Véanse también 'erf_representation' y 940 'hypergeometric_representation'. 941 942 -- Variable opcional: erf_representation 943 Valor por defecto: false 944 945 Cuando valga 'true' erfc, erfi, erf_generalized, fresnel_s y 946 fresnel_c se transforman a erf. 947 948 -- Variable opcional: hypergeometric_representation 949 Valor por defecto: false 950 951 Permite obtener la representación hipergeométrica de las funciones 952 fresnel_s y fresnel_c. 953 954 955File: maxima.info, Node: Funciones de Struve, Next: Funciones hipergeométricas, Prev: Función de error, Up: Funciones Especiales 956 95715.7 Funciones de Struve 958======================== 959 960Las funciones de Struve se definen en el capítulo 12 de Abramowitz y 961Stegun, Handbook of Mathematical Functions. 962 963 -- Función: struve_h (<v>, <z>) 964 Función H de Struve de orden <v> y argumento <z>, (A&S 12.1.1). 965 966 -- Función: struve_l (<v>, <z>) 967 Función L modificada de Struve de orden <v> y argumento <z>, (A&S 968 12.2.1). 969 970 971File: maxima.info, Node: Funciones hipergeométricas, Next: Funciones de cilindro parabólico, Prev: Funciones de Struve, Up: Funciones Especiales 972 97315.8 Funciones hipergeométricas 974=============================== 975 976Las funciones hipergeométricas se definen en los capítulos 13 y 15 de 977Abramowitz y Stegun, Handbook of Mathematical Functions. 978 979Maxima tiene un soporte limitado sobre estas funciones, que pueden 980aparecer en resultados devueltos por 'hgfred'. 981 982 -- Función: %m [<k>,<u>] (<z>) 983 Función M de Whittaker 'M[k,u](z) = 984 exp(-z/2)*z^(1/2+u)*M(1/2+u-k,1+2*u,z)'. (A&S 13.1.32) 985 986 -- Función: %w [<k>,<u>] (<z>) 987 Función W de Whittaker. (A&S 13.1.33) 988 989 -- Función: %f [<p>,<q>] (<[a],[b],z>) 990 Es la función hipergeométrica pFq(a1,a2,..ap;b1,b2,..bq;z), donde 991 'a' es una lista de longitud 'p' y 'b' otra lista de longitud 'q'. 992 993 -- Función: hypergeometric ([<a1>, ..., <ap>],[<b1>, ... ,<bq>], x) 994 Es la función hipergeométrica. A diferencia de la función 995 hipergeométrica '%f' de Maxima, la función 'hypergeometric' es 996 simplificadora; además, 'hypergeometric' soporta la evaluación en 997 doble (float) y gran (bigfloat) precisión. La evaluación numérica 998 fuera del círculo unidad no está en general soportada, pero sí en 999 el caso de la función hipergeométrica de Gauss, cuando p = 2 y q = 1000 1. 1001 1002 Si la variable opcional 'expand_hypergeometric' vale 'true', (el 1003 valor por defecto es 'false') y uno de los argumentos entr 'a1' y 1004 'ap' es entero negativo (caso polinomial), entonces 1005 'hypergeometric' devuelve un polinomio expandido. 1006 1007 Ejemplos: 1008 (%i1) hypergeometric([],[],x); 1009 (%o1) %e^x 1010 1011 Los polinomios se expanden automáticamente cuando 1012 'expand_hypergeometric' vale 'true'. 1013 1014 (%i2) hypergeometric([-3],[7],x); 1015 (%o2) hypergeometric([-3],[7],x) 1016 1017 (%i3) hypergeometric([-3],[7],x), expand_hypergeometric : true; 1018 (%o3) -x^3/504+3*x^2/56-3*x/7+1 1019 1020 Se soporta la evaluación en doble (float) y gran (bigfloat) 1021 precisión: 1022 1023 (%i4) hypergeometric([5.1],[7.1 + %i],0.42); 1024 (%o4) 1.346250786375334 - 0.0559061414208204 %i 1025 (%i5) hypergeometric([5,6],[8], 5.7 - %i); 1026 (%o5) .007375824009774946 - .001049813688578674 %i 1027 (%i6) hypergeometric([5,6],[8], 5.7b0 - %i), fpprec : 30; 1028 (%o6) 7.37582400977494674506442010824b-3 1029 - 1.04981368857867315858055393376b-3 %i 1030 1031 1032File: maxima.info, Node: Funciones de cilindro parabólico, Next: Funciones y variables para las funciones especiales, Prev: Funciones hipergeométricas, Up: Funciones Especiales 1033 103415.9 Funciones de cilindro parabólico 1035===================================== 1036 1037Las funciones de cilindro parabólico se definen en el capítulo 19 de 1038Abramowitz y Stegun, Handbook of Mathematical Functions. 1039 1040Maxima tiene un soporte limitado sobre estas funciones, que pueden 1041aparecer en resultados devueltos por 'hgfred'. 1042 1043 -- Función: parabolic_cylinder_d (<v>, <z>) 1044 Función de cilindro parabólico 'parabolic_cylinder_d(v,z)'. (A&s 1045 19.3.1) 1046 1047 1048File: maxima.info, Node: Funciones y variables para las funciones especiales, Prev: Funciones de cilindro parabólico, Up: Funciones Especiales 1049 105015.10 Funciones y variables para las funciones especiales 1051========================================================= 1052 1053 -- Función: specint (exp(- s*<t>) * <expr>, <t>) 1054 1055 Calcula la transformada de Laplace de <expr> respecto de la 1056 variable <t>. El integrando <expr> puede contener funciones 1057 especiales. 1058 1059 La función 'specint' admite las funciones especiales siguientes: la 1060 gamma incompleta, las funciones de error (pero no 'erfi', siendo 1061 sencillo transformar 'erfi' en la función de error 'erf'), 1062 integrales exponenciales, funciones de Bessel (incluidos productos 1063 de funciones de Bessel), funciones de Hankel, de Hermite y los 1064 polinomios de Laguerre. 1065 1066 Además, 'specint' también admite la función hipergeométrica 1067 '%f[p,q]([],[],z)', la función de Whittaker de primera especie 1068 '%m[u,k](z)' y la de segunda especie '%w[u,k](z)'. 1069 1070 El resultado puede darse en términos de funciones especiales y es 1071 posible que incluya también funciones hipergeométricas sin 1072 simplificar. 1073 1074 Cuando 'laplace' es incapaz de calcular la transformada de Laplace, 1075 entonces llama a la función 'specint'. Puesto que 'laplace' tiene 1076 programadas más reglas para calcular transformadas de Laplace, es 1077 preferible utilizar 'laplace' en lugar de 'specint'. 1078 1079 La ejecución de 'demo(hypgeo)' muestra algunos ejemplos de 1080 transformadas de Laplace calculadas con 'specint'. 1081 1082 Ejemplos: 1083 1084 (%i1) assume (p > 0, a > 0)$ 1085 (%i2) specint (t^(1/2) * exp(-a*t/4) * exp(-p*t), t); 1086 sqrt(%pi) 1087 (%o2) ------------ 1088 a 3/2 1089 2 (p + -) 1090 4 1091 (%i3) specint (t^(1/2) * bessel_j(1, 2 * a^(1/2) * t^(1/2)) 1092 * exp(-p*t), t); 1093 - a/p 1094 sqrt(a) %e 1095 (%o3) --------------- 1096 2 1097 p 1098 1099 Ejemplos para integrales exponenciales: 1100 1101 (%i4) assume(s>0,a>0,s-a>0)$ 1102 (%i5) ratsimp(specint(%e^(a*t) 1103 *(log(a)+expintegral_e1(a*t))*%e^(-s*t),t)); 1104 log(s) 1105 (%o5) ------ 1106 s - a 1107 (%i6) logarc:true$ 1108 1109 (%i7) gamma_expand:true$ 1110 1111 radcan(specint((cos(t)*expintegral_si(t) 1112 -sin(t)*expintegral_ci(t))*%e^(-s*t),t)); 1113 log(s) 1114 (%o8) ------ 1115 2 1116 s + 1 1117 ratsimp(specint((2*t*log(a)+2/a*sin(a*t) 1118 -2*t*expintegral_ci(a*t))*%e^(-s*t),t)); 1119 2 2 1120 log(s + a ) 1121 (%o9) ------------ 1122 2 1123 s 1124 1125 Resultados cuando se utiliza la expansión de 'gamma_incomplete' y 1126 se cambia la representación de 'expintegral_e1': 1127 1128 (%i10) assume(s>0)$ 1129 (%i11) specint(1/sqrt(%pi*t)*unit_step(t-k)*%e^(-s*t),t); 1130 1 1131 gamma_incomplete(-, k s) 1132 2 1133 (%o11) ------------------------ 1134 sqrt(%pi) sqrt(s) 1135 1136 (%i12) gamma_expand:true$ 1137 (%i13) specint(1/sqrt(%pi*t)*unit_step(t-k)*%e^(-s*t),t); 1138 erfc(sqrt(k) sqrt(s)) 1139 (%o13) --------------------- 1140 sqrt(s) 1141 1142 (%i14) expintrep:expintegral_e1$ 1143 (%i15) ratsimp(specint(1/(t+a)^2*%e^(-s*t),t)); 1144 a s 1145 a s %e expintegral_e1(a s) - 1 1146 (%o15) - --------------------------------- 1147 a 1148 1149 -- Función: hgfred (<a>, <b>, <t>) 1150 1151 Simplifica la función hipergeométrica generalizada en términos de 1152 otras funciones más sencillas. <a> es una lista de parámetros del 1153 numerador y <b> lo es de parámetros del denominador. 1154 1155 En caso de que 'hgfred' no pueda simplificar la función 1156 hipergeométrica devolverá una expresión de la forma '%f[p,q]([a], 1157 [b], x)', siendo <p> el número de elementos de <a> y <q> el de <b>. 1158 Esta es la función hipergeométrica generalizada 'pFq'. 1159 1160 (%i1) assume(not(equal(z,0))); 1161 (%o1) [notequal(z, 0)] 1162 (%i2) hgfred([v+1/2],[2*v+1],2*%i*z); 1163 1164 v/2 %i z 1165 4 bessel_j(v, z) gamma(v + 1) %e 1166 (%o2) --------------------------------------- 1167 v 1168 z 1169 (%i3) hgfred([1,1],[2],z); 1170 1171 log(1 - z) 1172 (%o3) - ---------- 1173 z 1174 (%i4) hgfred([a,a+1/2],[3/2],z^2); 1175 1176 1 - 2 a 1 - 2 a 1177 (z + 1) - (1 - z) 1178 (%o4) ------------------------------- 1179 2 (1 - 2 a) z 1180 1181 1182 Tal como muestra el siguiente ejemplo, puede ser de utilidad cargar 1183 también el paquete 'orthopoly'. Nótese que <L> es el polinomio 1184 generalizado de Laguerre. 1185 1186 (%i5) load(orthopoly)$ 1187 (%i6) hgfred([-2],[a],z); 1188 1189 (a - 1) 1190 2 L (z) 1191 2 1192 (%o6) ------------- 1193 a (a + 1) 1194 (%i7) ev(%); 1195 1196 2 1197 z 2 z 1198 (%o7) --------- - --- + 1 1199 a (a + 1) a 1200 1201 1202 -- Función: lambert_w (<z>) 1203 Rama principal de la función W de Lambert, solución de la ecuación 1204 'z = W(z) * exp(W(z))'. (DLMF 4.13) 1205 1206 -- Función: generalized_lambert_w (<k>, <z>) 1207 <k>-ésima rama de la función W de Lambert's, W(z), solución de 'z = 1208 W(z) * exp(W(z))'. (DLMF 4.13) 1209 1210 La rama principal, representada por Wp(z) en DLMF, es 'lambert_w(z) 1211 = generalized_lambert_w(0,z)'. 1212 1213 La otra rama con valores reales, representada por Wm(z) en DLMF, es 1214 'generalized_lambert_w(-1,z)'. 1215 1216 -- Función: nzeta (<z>) 1217 Función de dispersión del plasma. 'nzeta(z) = 1218 %i*sqrt(%pi)*exp(-z^2)*(1-erf(-%i*z))' 1219 1220 -- Función: nzetar (<z>) 1221 Devuelve 'realpart(nzeta(z))'. 1222 1223 -- Función: nzetai (<z>) 1224 Devuelve 'imagpart(nzeta(z))'. 1225 1226 1227File: maxima.info, Node: Funciones elípticas, Next: Límites, Prev: Funciones Especiales, Up: Top 1228 122916 Funciones elípticas 1230********************** 1231 1232* Menu: 1233 1234* Introducción a las funciones e integrales elípticas:: 1235* Funciones y variables para funciones elípticas:: 1236* Funciones y variables para integrales elípticas:: 1237 1238 1239File: maxima.info, Node: Introducción a las funciones e integrales elípticas, Next: Funciones y variables para funciones elípticas, Prev: Funciones elípticas, Up: Funciones elípticas 1240 124116.1 Introducción a las funciones e integrales elípticas 1242======================================================== 1243 1244Maxima da soporte para las funciones elípticas jacobianas y para las 1245integrales elípticas completas e incompletas. Esto incluye la 1246manipulación simbólica de estas funciones y su evaluación numérica. Las 1247definiciones de estas funciones y de muchas de sus propiedades se pueden 1248encontrar en Abramowitz y Stegun, capítulos 16-17, que es la fuente 1249principal utilizada para su programación en Maxima, aunque existen 1250algunas diferencias. 1251 1252En particular, todas las funciones e integrales elípticas utilizan el 1253parámero m en lugar del módulo k o del ángulo alfa. Esta es una de las 1254diferencias con Abramowitz y Stegun, que utilizan el ángulo para las 1255funciones elípticas. Las siguientes relaciones son válidas: 1256 1257m = k^2 y k = sin(alfa). 1258 1259Las funciones e integrales elípticas en Maxima tienen como objetivo 1260primordial dar soporte al cálculo simbólico, de ahí que también estén 1261incluidas la mayoría de las derivadas e integrales asociadas a estas 1262funciones. No obstante lo anterior, si los argumentos dados a las 1263funciones son decimales en coma flotante, los resultados también serán 1264decimales. 1265 1266Sin embargo, la mayoría de las propiedades no realacionadas con las 1267derivadas de las funciones e integrales elípticas todavía no han sido 1268programadas en Maxima. 1269 1270Algunos ejemplos de funciones elípticas: 1271 (%i1) jacobi_sn (u, m); 1272 (%o1) jacobi_sn(u, m) 1273 (%i2) jacobi_sn (u, 1); 1274 (%o2) tanh(u) 1275 (%i3) jacobi_sn (u, 0); 1276 (%o3) sin(u) 1277 (%i4) diff (jacobi_sn (u, m), u); 1278 (%o4) jacobi_cn(u, m) jacobi_dn(u, m) 1279 (%i5) diff (jacobi_sn (u, m), m); 1280 (%o5) jacobi_cn(u, m) jacobi_dn(u, m) 1281 1282 elliptic_e(asin(jacobi_sn(u, m)), m) 1283 (u - ------------------------------------)/(2 m) 1284 1 - m 1285 1286 2 1287 jacobi_cn (u, m) jacobi_sn(u, m) 1288 + -------------------------------- 1289 2 (1 - m) 1290 1291Algunos ejemplos de integrales elípticas: 1292 (%i1) elliptic_f (phi, m); 1293 (%o1) elliptic_f(phi, m) 1294 (%i2) elliptic_f (phi, 0); 1295 (%o2) phi 1296 (%i3) elliptic_f (phi, 1); 1297 phi %pi 1298 (%o3) log(tan(--- + ---)) 1299 2 4 1300 (%i4) elliptic_e (phi, 1); 1301 (%o4) sin(phi) 1302 (%i5) elliptic_e (phi, 0); 1303 (%o5) phi 1304 (%i6) elliptic_kc (1/2); 1305 1 1306 (%o6) elliptic_kc(-) 1307 2 1308 (%i7) makegamma (%); 1309 2 1 1310 gamma (-) 1311 4 1312 (%o7) ----------- 1313 4 sqrt(%pi) 1314 (%i8) diff (elliptic_f (phi, m), phi); 1315 1 1316 (%o8) --------------------- 1317 2 1318 sqrt(1 - m sin (phi)) 1319 (%i9) diff (elliptic_f (phi, m), m); 1320 elliptic_e(phi, m) - (1 - m) elliptic_f(phi, m) 1321 (%o9) (----------------------------------------------- 1322 m 1323 1324 cos(phi) sin(phi) 1325 - ---------------------)/(2 (1 - m)) 1326 2 1327 sqrt(1 - m sin (phi)) 1328 1329El paquete para funciones e integrales elípticas fue programado por 1330Raymond Toy. Se distribuye, igual que Maxima, bajo la General Public 1331License (GPL). 1332 1333 1334File: maxima.info, Node: Funciones y variables para funciones elípticas, Next: Funciones y variables para integrales elípticas, Prev: Introducción a las funciones e integrales elípticas, Up: Funciones elípticas 1335 133616.2 Funciones y variables para funciones elípticas 1337=================================================== 1338 1339 -- Función: jacobi_sn (<u>, <m>) 1340 Función elíptica jacobiana sn(u,m). 1341 1342 -- Función: jacobi_cn (<u>, <m>) 1343 Función elíptica jacobiana cn(u,m). 1344 1345 -- Función: jacobi_dn (<u>, <m>) 1346 Función elíptica jacobiana dn(u,m). 1347 1348 -- Función: jacobi_ns (<u>, <m>) 1349 Función elíptica jacobiana ns(u,m) = 1/sn(u,m). 1350 1351 -- Función: jacobi_sc (<u>, <m>) 1352 Función elíptica jacobiana sc(u,m) = sn(u,m)/cn(u,m). 1353 1354 -- Función: jacobi_sd (<u>, <m>) 1355 Función elíptica jacobiana sd(u,m) = sn(u,m)/dn(u,m). 1356 1357 -- Función: jacobi_nc (<u>, <m>) 1358 Función elíptica jacobiana nc(u,m) = 1/cn(u,m). 1359 1360 -- Función: jacobi_cs (<u>, <m>) 1361 Función elíptica jacobiana cs(u,m) = cn(u,m)/sn(u,m). 1362 1363 -- Función: jacobi_cd (<u>, <m>) 1364 Función elíptica jacobiana cd(u,m) = cn(u,m)/dn(u,m). 1365 1366 -- Función: jacobi_nd (<u>, <m>) 1367 Función elíptica jacobiana nc(u,m) = 1/cn(u,m). 1368 1369 -- Función: jacobi_ds (<u>, <m>) 1370 Función elíptica jacobiana ds(u,m) = dn(u,m)/sn(u,m). 1371 1372 -- Función: jacobi_dc (<u>, <m>) 1373 Función elíptica jacobiana dc(u,m) = dn(u,m)/cn(u,m). 1374 1375 -- Función: inverse_jacobi_sn (<u>, <m>) 1376 Inversa de la función elíptica jacobiana sn(u,m). 1377 1378 -- Función: inverse_jacobi_cn (<u>, <m>) 1379 Inversa de la función elíptica jacobiana cn(u,m). 1380 1381 -- Función: inverse_jacobi_dn (<u>, <m>) 1382 Inversa de la función elíptica jacobiana dn(u,m). 1383 1384 -- Función: inverse_jacobi_ns (<u>, <m>) 1385 Inversa de la función elíptica jacobiana ns(u,m). 1386 1387 -- Función: inverse_jacobi_sc (<u>, <m>) 1388 Inversa de la función elíptica jacobiana sc(u,m). 1389 1390 -- Función: inverse_jacobi_sd (<u>, <m>) 1391 Inversa de la función elíptica jacobiana sd(u,m). 1392 1393 -- Función: inverse_jacobi_nc (<u>, <m>) 1394 Inversa de la función elíptica jacobiana nc(u,m). 1395 1396 -- Función: inverse_jacobi_cs (<u>, <m>) 1397 Inversa de la función elíptica jacobiana cs(u,m). 1398 1399 -- Función: inverse_jacobi_cd (<u>, <m>) 1400 Inversa de la función elíptica jacobiana cd(u,m). 1401 1402 -- Función: inverse_jacobi_nd (<u>, <m>) 1403 Inversa de la función elíptica jacobiana nc(u,m). 1404 1405 -- Función: inverse_jacobi_ds (<u>, <m>) 1406 Inversa de la función elíptica jacobiana ds(u,m). 1407 1408 -- Función: inverse_jacobi_dc (<u>, <m>) 1409 Inversa de la función elíptica jacobiana dc(u,m). 1410 1411 1412File: maxima.info, Node: Funciones y variables para integrales elípticas, Prev: Funciones y variables para funciones elípticas, Up: Funciones elípticas 1413 141416.3 Funciones y variables para integrales elípticas 1415==================================================== 1416 1417 -- Función: elliptic_f (<phi>, <m>) 1418 Integral elíptica incompleta de primera especie, definida como 1419 1420 integrate(1/sqrt(1 - m*sin(x)^2), x, 0, phi) 1421 1422 Véanse también 'elliptic_e' y 'elliptic_kc'. 1423 1424 -- Función: elliptic_e (<phi>, <m>) 1425 Integral elíptica incompleta de segunda especie, definida como 1426 1427 elliptic_e(phi, m) = integrate(sqrt(1 - m*sin(x)^2), x, 0, phi) 1428 1429 Véanse también 'elliptic_e' y 'elliptic_ec'. 1430 1431 -- Función: elliptic_eu (<u>, <m>) 1432 Integral elíptica incompleta de segunda especie, definida como 1433 1434 integrate(dn(v,m)^2,v,0,u) = integrate(sqrt(1-m*t^2)/sqrt(1-t^2), 1435 t, 0, tau) 1436 1437 donde tau = sn(u,m). 1438 1439 Esto se relaciona con 'elliptic_e' mediante 1440 1441 elliptic_eu(u, m) = elliptic_e(asin(sn(u,m)),m) 1442 1443 Véase también 'elliptic_e'. 1444 1445 -- Función: elliptic_pi (<n>, <phi>, <m>) 1446 Integral elíptica incompleta de tercera especie, definida como 1447 1448 integrate(1/(1-n*sin(x)^2)/sqrt(1 - m*sin(x)^2), x, 0, phi) 1449 1450 Maxima sólo conoce la derivada respecto de phi. 1451 1452 -- Función: elliptic_kc (<m>) 1453 Integral elíptica completa de primera especie, definida como 1454 1455 integrate(1/sqrt(1 - m*sin(x)^2), x, 0, %pi/2) 1456 1457 Para algunos valores de m, se conoce el valor de la integral en 1458 términos de la función Gamma. Hágase uso de 'makegamma' para 1459 realizar su cálculo. 1460 1461 -- Función: elliptic_ec (<m>) 1462 Integral elíptica completa de segunda especie, definida como 1463 1464 integrate(sqrt(1 - m*sin(x)^2), x, 0, %pi/2) 1465 1466 Para algunos valores de m, se conoce el valor de la integral en 1467 términos de la función Gamma. Hágase uso de 'makegamma' para 1468 realizar su cálculo. 1469 1470 1471File: maxima.info, Node: Límites, Next: Diferenciación, Prev: Funciones elípticas, Up: Top 1472 147317 Límites 1474********** 1475 1476* Menu: 1477 1478* Funciones y variables para límites:: 1479 1480 1481File: maxima.info, Node: Funciones y variables para límites, Prev: Límites, Up: Límites 1482 148317.1 Funciones y variables para límites 1484======================================= 1485 1486 -- Variable optativa: lhospitallim 1487 Valor por defecto: 4 1488 1489 Es el número máximo de veces que la regla de L'Hopital es aplicada 1490 en la función 'limit', evitando bucles infinitos al iterar la regla 1491 en casos como 'limit (cot(x)/csc(x), x, 0)'. 1492 1493 -- Función: limit (<expr>, <x>, <val>, <dir>) 1494 -- Función: limit (<expr>, <x>, <val>) 1495 -- Función: limit (<expr>) 1496 Calcula el límite de <expr> cuando la variable real <x> se aproxima 1497 al valor <val> desde la dirección <dir>. El argumento <dir> puede 1498 ser el valor 'plus' para un límite por la derecha, 'minus' para un 1499 límite por la izquierda o simplemente se omite para indicar un 1500 límite en ambos sentidos. 1501 1502 La función 'limit' utiliza los símbolos especiales siguientes: 1503 'inf' (más infinito) y 'minf' (menos infinito). En el resultado 1504 también puede hacer uso de 'und' (indefinido), 'ind' (indefinido 1505 pero acotado) y 'infinity' (infinito complejo). 1506 1507 'infinity' (infinito complejo) es el resultado que se obtiene 1508 cuando el límite del módulo de la expresión es infinito positivo, 1509 pero el propio límite de la expresión no es infinito positivo ni 1510 negativo. Esto sucede, por ejemplo, cuando el límite del argumento 1511 complejo es una constante, como en 'limit(log(x), x, minf)', o 1512 cuando el argumento complejo oscila, como en 'limit((-2)^x, x, 1513 inf)', o en aquellos casos en los que el argumento complejo es 1514 diferente por cualquiera de los lados de un límite, como en 1515 'limit(1/x, x, 0)' o 'limit(log(x), x, 0)'. 1516 1517 La variable 'lhospitallim' guarda el número máximo de veces que la 1518 regla de L'Hopital es aplicada en la función 'limit', evitando 1519 bucles infinitos al iterar la regla en casos como 'limit 1520 (cot(x)/csc(x), x, 0)'. 1521 1522 Si la variable 'tlimswitch' vale 'true', hará que la función 1523 'limit' utilice desarrollos de Taylor siempre que le sea posible. 1524 1525 La variable 'limsubst' evita que la función 'limit' realice 1526 sustituciones sobre formas desconocidas, a fin de evitar fallos 1527 tales como que 'limit (f(n)/f(n+1), n, inf)' devuelva 1. Dándole a 1528 'limsubst' el valor 'true' se permitirán tales sustituciones. 1529 1530 La función 'limit' con un solo argumento se utiliza frecuentemente 1531 para simplificar expresiones constantes, como por ejemplo 'limit 1532 (inf-1)'. 1533 1534 La instrucción 'example (limit)' muestra algunos ejemplos. 1535 1536 Para información sobre el método utilizado véase Wang, P., 1537 "Evaluation of Definite Integrals by Symbolic Manipulation", Ph.D. 1538 thesis, MAC TR-92, October 1971. 1539 1540 -- Variable optativa: limsubst 1541 Valor por defecto: 'false' 1542 1543 La variable 'limsubst' evita que la función 'limit' realice 1544 sustituciones sobre formas desconocidas, a fin de evitar fallos 1545 tales como que 'limit (f(n)/f(n+1), n, inf)' devuelva 1. Dándole a 1546 'limsubst' el valor 'true' se permitirán tales sustituciones. 1547 1548 -- Función: tlimit (<expr>, <x>, <val>, <dir>) 1549 -- Función: tlimit (<expr>, <x>, <val>) 1550 -- Función: tlimit (<expr>) 1551 Calcula el límite del desarrollo de Taylor de la expresión 'expr' 1552 de variable 'x' en el punto 'val' en la dirección 'dir'. 1553 1554 -- Variable optativa: tlimswitch 1555 Valor por defecto: 'true' 1556 1557 Si 'tlimswitch' vale 'true', la función 'limit' utilizará un 1558 desarrollo de Taylor si el límite de la expresión dada no se puede 1559 calcular directamente. Esto permite el cálculo de límites como 1560 'limit(x/(x-1)-1/log(x),x,1,plus)'. Si 'tlimswitch' vale 'false' y 1561 el límite de la expresión no se puede calcular directamente, la 1562 función 'limit' devolverá una expresión sin evaluar. 1563 1564 1565File: maxima.info, Node: Diferenciación, Next: Integración, Prev: Límites, Up: Top 1566 156718 Diferenciación 1568***************** 1569 1570* Menu: 1571 1572* Funciones y variables para la diferenciación:: 1573 1574 1575File: maxima.info, Node: Funciones y variables para la diferenciación, Prev: Diferenciación, Up: Diferenciación 1576 157718.1 Funciones y variables para la diferenciación 1578================================================= 1579 1580 -- Función: antid (<expr>, <x>, <u(x)>) 1581 Devuelve una lista con dos elementos, de manera que se pueda 1582 calcular la antiderivada de <expr> respecto de <x> a partir de la 1583 lista. La expresión <expr> puede contener una función no 1584 especificada <u> y sus derivadas. 1585 1586 Sea <L> la lista con dos elementos que devuelve la función 'antid'. 1587 Entonces, '<L>[1] + 'integrate (<L>[2], <x>)' es una antiderivada 1588 de <expr> con respecto a <x>. 1589 1590 Si la ejecución de 'antid' resulta exitosa, el segundo elemento de 1591 la lista retornada es cero. En caso contrario, el segundo elemento 1592 es distinto de cero y el primero puede ser nulo o no. Si 'antid' 1593 no es capaz de hacer ningún progreso, el primer elemento es nulo y 1594 el segundo no nulo. 1595 1596 Es necesario ejecutar 'load ("antid")' para cargar esta función. 1597 El paquete 'antid' define también las funciones 'nonzeroandfreeof' 1598 y 'linear'. 1599 1600 La función 'antid' está relacionada con 'antidiff' como se indica a 1601 continuación. Sea <L> la lista devuelta por la función 'antid'. 1602 Entonces, el resultado de 'antidiff' es igual a '<L>[1] + 1603 'integrate (<L>[2], <x>)', donde <x> es la variable de integración. 1604 1605 Ejemplos: 1606 1607 (%i1) load ("antid")$ 1608 (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x); 1609 z(x) d 1610 (%o2) y(x) %e (-- (z(x))) 1611 dx 1612 (%i3) a1: antid (expr, x, z(x)); 1613 z(x) z(x) d 1614 (%o3) [y(x) %e , - %e (-- (y(x)))] 1615 dx 1616 (%i4) a2: antidiff (expr, x, z(x)); 1617 / 1618 z(x) [ z(x) d 1619 (%o4) y(x) %e - I %e (-- (y(x))) dx 1620 ] dx 1621 / 1622 (%i5) a2 - (first (a1) + 'integrate (second (a1), x)); 1623 (%o5) 0 1624 (%i6) antid (expr, x, y(x)); 1625 z(x) d 1626 (%o6) [0, y(x) %e (-- (z(x)))] 1627 dx 1628 (%i7) antidiff (expr, x, y(x)); 1629 / 1630 [ z(x) d 1631 (%o7) I y(x) %e (-- (z(x))) dx 1632 ] dx 1633 / 1634 1635 -- Función: antidiff (<expr>, <x>, <u>(<x>)) 1636 Devuelve la antiderivada de <expr> respecto de <x>. La expresión 1637 <expr> puede contener una función no especificada <u> y sus 1638 derivadas. 1639 1640 Cuando 'antidiff' se ejecuta con éxito, la expresión resultante no 1641 tiene símbolos integrales (esto es, no tiene referencias a la 1642 función 'integrate'). En otro caso, 'antidiff' devuelve una 1643 expresión que se encuentra total o parcialmente bajo el signo de 1644 integración. Si 'antidiff' no puede ralizar ningún progreso, el 1645 valor devuelto se encuentra completamente bajo la integral. 1646 1647 Es necesario ejecutar 'load ("antid")' para cargar esta función. 1648 El paquete 'antid' define también las funciones 'nonzeroandfreeof' 1649 y 'linear'. 1650 1651 La función 'antidiff' está relacionada con 'antid' como se indica a 1652 continuación. Sea <L> la lista de dos elementos que devuelve 1653 'antid'. Entonces, el valor retornado por 'antidiff' es igual a 1654 '<L>[1] + 'integrate (<L>[2], <x>)', donde <x> es la variable de 1655 integración. 1656 1657 Ejemplos: 1658 1659 (%i1) load ("antid")$ 1660 (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x); 1661 z(x) d 1662 (%o2) y(x) %e (-- (z(x))) 1663 dx 1664 (%i3) a1: antid (expr, x, z(x)); 1665 z(x) z(x) d 1666 (%o3) [y(x) %e , - %e (-- (y(x)))] 1667 dx 1668 (%i4) a2: antidiff (expr, x, z(x)); 1669 / 1670 z(x) [ z(x) d 1671 (%o4) y(x) %e - I %e (-- (y(x))) dx 1672 ] dx 1673 / 1674 (%i5) a2 - (first (a1) + 'integrate (second (a1), x)); 1675 (%o5) 0 1676 (%i6) antid (expr, x, y(x)); 1677 z(x) d 1678 (%o6) [0, y(x) %e (-- (z(x)))] 1679 dx 1680 (%i7) antidiff (expr, x, y(x)); 1681 / 1682 [ z(x) d 1683 (%o7) I y(x) %e (-- (z(x))) dx 1684 ] dx 1685 / 1686 1687 -- Función: at (<expr>, [<eqn_1>, ..., <eqn_n>]) 1688 -- Función: at (<expr>, <eqn>) 1689 Evalúa la expresión <expr> asignando a las variables los valores 1690 especificados para ellas en la lista de ecuaciones '[<eqn_1>, ..., 1691 <eqn_n>]' o en la ecuación simple <eqn>. 1692 1693 Si una subexpresión depende de cualquiera de las variables para la 1694 cual se especifica un valor, pero no puede ser evaluado, entonces 1695 'at' devuelve una forma nominal. 1696 1697 La función 'at' realiza múltiples sustituciones en serie, no en 1698 paralelo. 1699 1700 Véase también 'atvalue'. Para otras funciones que también llevan a 1701 cabo sustituciones, consúltense 'subst' y 'ev'. 1702 1703 Ejemplos: 1704 1705 (%i1) atvalue (f(x,y), [x = 0, y = 1], a^2); 1706 2 1707 (%o1) a 1708 (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y); 1709 (%o2) @2 + 1 1710 (%i3) printprops (all, atvalue); 1711 ! 1712 d ! 1713 --- (f(@1, @2))! = @2 + 1 1714 d@1 ! 1715 !@1 = 0 1716 1717 2 1718 f(0, 1) = a 1719 1720 (%o3) done 1721 (%i4) diff (4*f(x, y)^2 - u(x, y)^2, x); 1722 d d 1723 (%o4) 8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y))) 1724 dx dx 1725 (%i5) at (%, [x = 0, y = 1]); 1726 ! 1727 2 d ! 1728 (%o5) 16 a - 2 u(0, 1) (-- (u(x, y))! ) 1729 dx ! 1730 !x = 0, y = 1 1731 1732 -- Propiedad: atomgrad 1733 1734 La propiedad 'atomgrad' es asignada por 'gradef'. 1735 1736 -- Función: atvalue (<expr>, [<x_1> = <a_1>, ..., <x_m> = <a_m>], <c>) 1737 -- Función: atvalue (<expr>, <x_1> = <a_1>, <c>) 1738 Asigna el valor <c> a <expr> en el punto '<x> = <a>'. 1739 1740 La expresión <expr> es una función del tipo '<f>(<x_1>, ..., 1741 <x_m>)', o una derivada, 'diff (<f>(<x_1>, ..., <x_m>), <x_1>, 1742 <n_1>, ..., <x_n>, <n_m>)' en la que aparecen los argumentos de la 1743 función de forma explícita. Los símbolos <n_i> se refieren al 1744 orden de diferenciación respecto de <x_i>. 1745 1746 El punto en el que 'atvalue' establece el valor se especifica 1747 mediante la lista de ecuaciones '[<x_1> = <a_1>, ..., <x_m> = 1748 <a_m>]'. Si hay una única variable <x_1>, la ecuación puede 1749 escribirse sin formar parte de una lista. 1750 1751 La llamada 'printprops ([<f_1>, <f_2>, ...], atvalue)' muestra los 1752 valores asignados por 'atvalue' a las funciones '<f_1>, <f_2>, 1753 ...'. La llamada 'printprops (<f>, atvalue)' muestra los valores 1754 asignados por 'atvalue' a la función <f>. La llamada 'printprops 1755 (all, atvalue)' muestra los valores asignados por 'atvalue' a todas 1756 las funciones. 1757 1758 Los símbolos '@1', '@2', ... representan las variables <x_1>, 1759 <x_2>, ... cuando se muestran los valores asignados por 'atvalue'. 1760 1761 La función 'atvalue' evalúa sus argumentos y devuelve <c>, el valor 1762 asignado. 1763 1764 Ejemplos: 1765 1766 (%i1) atvalue (f(x,y), [x = 0, y = 1], a^2); 1767 2 1768 (%o1) a 1769 (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y); 1770 (%o2) @2 + 1 1771 (%i3) printprops (all, atvalue); 1772 ! 1773 d ! 1774 --- (f(@1, @2))! = @2 + 1 1775 d@1 ! 1776 !@1 = 0 1777 1778 2 1779 f(0, 1) = a 1780 1781 (%o3) done 1782 (%i4) diff (4*f(x,y)^2 - u(x,y)^2, x); 1783 d d 1784 (%o4) 8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y))) 1785 dx dx 1786 (%i5) at (%, [x = 0, y = 1]); 1787 ! 1788 2 d ! 1789 (%o5) 16 a - 2 u(0, 1) (-- (u(x, y))! ) 1790 dx ! 1791 !x = 0, y = 1 1792 1793 -- Función: cartan - 1794 El cálculo exterior de formas diferenciales es una herramienta 1795 básica de la geometría diferencial desarrollada por Elie Cartan, 1796 teniendo importantes aplicaciones en la teoría de ecuaciones 1797 diferenciales en derivadas parciales. El paquete 'cartan' dispone 1798 de las funciones 'ext_diff' y 'lie_diff', así como de los 1799 operadores '~' (producto exterior) y '|' (contracción de una forma 1800 con un vector). La orden 'demo (tensor)' permite ver una breve 1801 descripción de estas instrucciones, junto con ejemplos. 1802 1803 El paquete 'cartan' fue escrito por F.B. Estabrook y H.D. 1804 Wahlquist. 1805 1806 -- Función: del (<x>) 1807 La expresión 'del (<x>)' representa el diferencial de la variable 1808 x. 1809 1810 La función 'diff' devuelve una expresión que contiene a 'del' si no 1811 se ha especificado una variable independiente. En este caso, el 1812 valor retornado es el llamado "diferencial total". 1813 1814 Ejemplos: 1815 1816 (%i1) diff (log (x)); 1817 del(x) 1818 (%o1) ------ 1819 x 1820 (%i2) diff (exp (x*y)); 1821 x y x y 1822 (%o2) x %e del(y) + y %e del(x) 1823 (%i3) diff (x*y*z); 1824 (%o3) x y del(z) + x z del(y) + y z del(x) 1825 1826 -- Función: delta (<t>) 1827 Es la función delta de Dirac. 1828 1829 En el estado actual de desarrollo de Maxima, sólo 'laplace' 1830 reconoce la función 'delta'. 1831 1832 Ejemplo: 1833 1834 (%i1) laplace (delta (t - a) * sin(b*t), t, s); 1835 Is a positive, negative, or zero? 1836 1837 p; 1838 - a s 1839 (%o1) sin(a b) %e 1840 1841 -- Variable del sistema: dependencies 1842 Valor por defecto: '[]' 1843 1844 La variable 'dependencies' es la lista de átomos que tienen algún 1845 tipo de dependencia funcional, asignada por 'depends' o 'gradef'. 1846 La lista 'dependencies' es acumulativa: cada llamada a 'depends' o 1847 'gradef' añade elementos adicionales. 1848 1849 Véanse 'depends' y 'gradef'. 1850 1851 -- Función: depends (<f_1>, <x_1>, ..., <f_n>, <x_n>) 1852 Declara dependencias funcionales entre variables con el propósito 1853 de calcular derivadas. En ausencia de una dependencia declarada, 1854 'diff (f, x)' devuelve cero. Si se declara 'depends (f, x)', 'diff 1855 (f, x)' devuelve una derivada simbólica (esto es, una expresión con 1856 'diff'). 1857 1858 Cada argumento <f_1>, <x_1>, etc., puede ser el nombre de una 1859 variable, de un arreglo o una lista de nombres. Cada elemento de 1860 <f_i> (quizás un único elemento) se declara como dependiente de 1861 cada elemento de <x_i> (quizás también un único elemento). Si 1862 alguno de los <f_i> es el nombre de un arreglo o contiene el nombre 1863 de un arreglo, todos los elemento del arregl dependen de <x_i>. 1864 1865 La función 'diff' reconoce dependencias indirectas establecidas por 1866 'depends' y aplica la regla de la cadena en tales casos. 1867 1868 La instrucción 'remove (<f>, dependency)' borra todas las 1869 dependencias declaradas para <f>. 1870 1871 La función 'depends' devuelve una lista con las dependencias que 1872 han sido establecidas. Las dependencias se añaden a la variable 1873 global 'dependencies'. La función 'depends' evalúa sus argumentos. 1874 1875 La función 'diff' es la única instrucción de Maxima que reconoce 1876 las dependencias establecidas por 'depends'. Otras funciones 1877 ('integrate', 'laplace', etc.) solamente reconocen dependencias 1878 explícitamente representadas por sus argumentos. Por ejemplo, 1879 'integrate' no reconoce la dependencia de 'f' respecto de 'x' a 1880 menos que se represente explícitamente como 'integrate (f(x), x)'. 1881 1882 (%i1) depends ([f, g], x); 1883 (%o1) [f(x), g(x)] 1884 (%i2) depends ([r, s], [u, v, w]); 1885 (%o2) [r(u, v, w), s(u, v, w)] 1886 (%i3) depends (u, t); 1887 (%o3) [u(t)] 1888 (%i4) dependencies; 1889 (%o4) [f(x), g(x), r(u, v, w), s(u, v, w), u(t)] 1890 (%i5) diff (r.s, u); 1891 dr ds 1892 (%o5) -- . s + r . -- 1893 du du 1894 1895 (%i6) diff (r.s, t); 1896 dr du ds du 1897 (%o6) -- -- . s + r . -- -- 1898 du dt du dt 1899 1900 (%i7) remove (r, dependency); 1901 (%o7) done 1902 (%i8) diff (r.s, t); 1903 ds du 1904 (%o8) r . -- -- 1905 du dt 1906 1907 -- Variable optativa: derivabbrev 1908 Valor por defecto: 'false' 1909 1910 Si 'derivabbrev' vale 'true', las derivadas simbólicas (esto es, 1911 expresiones con 'diff') se muestran como subíndices. En otro caso, 1912 las derivadas se muestran en la notación de Leibniz, 'dy/dx'. 1913 1914 -- Función: derivdegree (<expr>, <y>, <x>) 1915 Devuelve el mayor grado de la derivada de la variable dependiente 1916 <y> respecto de la variable independiente <x> que aparece en 1917 <expr>. 1918 1919 Ejemplo: 1920 (%i1) 'diff (y, x, 2) + 'diff (y, z, 3) + 'diff (y, x) * x^2; 1921 3 2 1922 d y d y 2 dy 1923 (%o1) --- + --- + x -- 1924 3 2 dx 1925 dz dx 1926 (%i2) derivdegree (%, y, x); 1927 (%o2) 2 1928 1929 -- Función: derivlist (<var_1>, ..., <var_k>) 1930 Hace que las derivadas calculadas por la instrucción 'ev' se 1931 calculen respecto de las variables indicadas. 1932 1933 -- Variable optativa: derivsubst 1934 Valor por defecto: 'false' 1935 1936 Si 'derivsubst' vale 'true', una sustitución no sintáctica del 1937 estilo 'subst (x, 'diff (y, t), 'diff (y, t, 2))' devuelve ''diff 1938 (x, t)'. 1939 1940 -- Función: diff (<expr>, <x_1>, <n_1>, ..., <x_m>, <n_m>) 1941 -- Función: diff (<expr>, <x>, <n>) 1942 -- Función: diff (<expr>, <x>) 1943 -- Función: diff (<expr>) 1944 Devuelve la derivada o diferencial de <expr> respecto de alguna o 1945 de todas las variables presentes en <expr>. 1946 1947 La llamada 'diff (<expr>, <x>, <n>)' devuelve la <n>-esima derivada 1948 de <expr> respecto de <x>. 1949 1950 La llamada 'diff (<expr>, <x_1>, <n_1>, ..., <x_m>, <n_m>)' 1951 devuelve la derivada parcial de <expr> con respecto de <x_1>, ..., 1952 <x_m>. Equivale a 'diff (... (diff (<expr>, <x_m>, <n_m>) ...), 1953 <x_1>, <n_1>)'. 1954 1955 La llamada 'diff (<expr>, <x>)' devuelve la primera derivada de 1956 <expr> respecto de la variable <x>. 1957 1958 La llamada 'diff (<expr>)' devuelve el diferencial total de <expr>, 1959 esto es, la suma de las derivadas de <expr> respecto de cada una de 1960 sus variables, multiplicadas por el diferencial 'del' de cada una 1961 de ellas. 1962 1963 La forma nominal de 'diff' es necesaria en algunos contextos, como 1964 para definir ecuaciones diferenciales. En tales casos, 'diff' 1965 puede ir precedida de un apóstrofo (como ''diff') para evitar el 1966 cálculo de la derivada. 1967 1968 Si 'derivabbrev' vale 'true', las derivadas se muestran como 1969 subíndices. En otro caso, se muestran en la notación de Leibniz, 1970 'dy/dx'. 1971 1972 Ejemplos: 1973 1974 (%i1) diff (exp (f(x)), x, 2); 1975 2 1976 f(x) d f(x) d 2 1977 (%o1) %e (--- (f(x))) + %e (-- (f(x))) 1978 2 dx 1979 dx 1980 (%i2) derivabbrev: true$ 1981 (%i3) 'integrate (f(x, y), y, g(x), h(x)); 1982 h(x) 1983 / 1984 [ 1985 (%o3) I f(x, y) dy 1986 ] 1987 / 1988 g(x) 1989 (%i4) diff (%, x); 1990 h(x) 1991 / 1992 [ 1993 (%o4) I f(x, y) dy + f(x, h(x)) h(x) - f(x, g(x)) g(x) 1994 ] x x x 1995 / 1996 g(x) 1997 1998 Para el paquete sobre tensores se han introducido las siguientes 1999 modificaciones: 2000 2001 (1) Las derivadas de los objetos indexados en <expr> tendrán las 2002 variables <x_i> añadidas como argumentos adicionales. Entonces se 2003 ordenarán todos los índices de derivadas. 2004 2005 (2) Las <x_i> pueden ser enteros entre 1 hasta el valor de la 2006 variable 'dimension' [valor por defecto: 4]. Esto hará que la 2007 diferenciación sea llevada a cabo con respecto al <x_i>-ésimo 2008 número de la lista 'coordinates', la cual debería contener una 2009 lista con los nombres de las coordenadas, por ejemplo, '[x, y, z, 2010 t]'. Si 'coordinates' es una variableis atómica, entonces esa 2011 variable será utilizada como variable de diferenciación. Se 2012 permite la utilización de arreglos con los nombres de las 2013 coordenadas o nombres con subíndices, como 'X[1]', 'X[2]', ... to 2014 be used. Si a 'coordinates' no se le ha asignado ningún valor, 2015 entonces las variables serán tratadas como se ha indicado en (1). 2016 2017 -- Símbolo especial: diff 2018 2019 Si el nombre 'diff' está presente en una llamada a la función 'ev' 2020 en modo 'evflag', entonces se calculan todas las derivadas 2021 presentes en 'expr'. 2022 2023 -- Función: express (<expr>) 2024 Transforma los nombres de los operadores diferenciales en 2025 expresiones que contienen derivadas parciales. Los operadores 2026 reconocidos por la función 'express' son: 'grad' (gradiente), 'div' 2027 (divergencia), 'curl' (rotacional), 'laplacian' (laplaciano) y '~' 2028 (producto vectorial). 2029 2030 Las derivadas simbólicas (es decir, las que incluyen la forma 2031 nominal 'diff') que aparecen en la expresión devuelta por 2032 'express', se pueden calcular pasándole a 'ev' el argumento 'diff', 2033 o escribiéndolo directamente en la línea de comandos. En este 2034 contexto, 'diff' actúa como 'evfun'. 2035 2036 Es necesario ejecutar 'load ("vect")' para cargar esta función. 2037 2038 Ejemplos: 2039 2040 (%i1) load ("vect")$ 2041 (%i2) grad (x^2 + y^2 + z^2); 2042 2 2 2 2043 (%o2) grad (z + y + x ) 2044 (%i3) express (%); 2045 d 2 2 2 d 2 2 2 d 2 2 2 2046 (%o3) [-- (z + y + x ), -- (z + y + x ), -- (z + y + x )] 2047 dx dy dz 2048 (%i4) ev (%, diff); 2049 (%o4) [2 x, 2 y, 2 z] 2050 (%i5) div ([x^2, y^2, z^2]); 2051 2 2 2 2052 (%o5) div [x , y , z ] 2053 (%i6) express (%); 2054 d 2 d 2 d 2 2055 (%o6) -- (z ) + -- (y ) + -- (x ) 2056 dz dy dx 2057 (%i7) ev (%, diff); 2058 (%o7) 2 z + 2 y + 2 x 2059 (%i8) curl ([x^2, y^2, z^2]); 2060 2 2 2 2061 (%o8) curl [x , y , z ] 2062 (%i9) express (%); 2063 d 2 d 2 d 2 d 2 d 2 d 2 2064 (%o9) [-- (z ) - -- (y ), -- (x ) - -- (z ), -- (y ) - -- (x )] 2065 dy dz dz dx dx dy 2066 (%i10) ev (%, diff); 2067 (%o10) [0, 0, 0] 2068 (%i11) laplacian (x^2 * y^2 * z^2); 2069 2 2 2 2070 (%o11) laplacian (x y z ) 2071 (%i12) express (%); 2072 2 2 2 2073 d 2 2 2 d 2 2 2 d 2 2 2 2074 (%o12) --- (x y z ) + --- (x y z ) + --- (x y z ) 2075 2 2 2 2076 dz dy dx 2077 (%i13) ev (%, diff); 2078 2 2 2 2 2 2 2079 (%o13) 2 y z + 2 x z + 2 x y 2080 (%i14) [a, b, c] ~ [x, y, z]; 2081 (%o14) [a, b, c] ~ [x, y, z] 2082 (%i15) express (%); 2083 (%o15) [b z - c y, c x - a z, a y - b x] 2084 2085 -- Función: gradef (<f>(<x_1>, ..., <x_n>), <g_1>, ..., <g_m>) 2086 -- Función: gradef (<a>, <x>, <expr>) 2087 Define las derivadas parciales, o componentes del gradiente, de la 2088 función <f> o variable <a>. 2089 2090 La llamada 'gradef (<f>(<x_1>, ..., <x_n>), <g_1>, ..., <g_m>)' 2091 define 'd<f>/d<x_i>' como <g_i>, donde <g_i> es una expresión; 2092 <g_i> puede ser una llamada a función, pero no el nombre de una 2093 función. El número de derivadas parciales <m> puede ser menor que 2094 el número de argumentos <n>, en cuyo caso las derivadas se definen 2095 solamente con respecto a <x_1>, ...., <x_m>. 2096 2097 La llamada 'gradef (<a>, <x>, <expr>)' define la derivada de la 2098 variable <a> respecto de <x> en <expr>. Con esto se establece la 2099 dependencia de <a> respecto de <x> a través de 'depends (<a>, 2100 <x>)'. 2101 2102 El primer argumento '<f>(<x_1>, ..., <x_n>)' o <a> no se evalúa, 2103 pero sí lo hacen el resto de argumentos <g_1>, ..., <g_m>. La 2104 llamada a 'gradef' devuelve la función o variable para la que se 2105 define la derivada parcial. 2106 2107 La instrucción 'gradef' puede redefinir las derivadas de las 2108 funciones propias de Maxima. Por ejemplo, 'gradef (sin(x), sqrt (1 2109 - sin(x)^2))' redefine la derivada de 'sin'. 2110 2111 La instrucción 'gradef' no puede definir derivadas parciales de 2112 funciones subindicadas. 2113 2114 La llamada 'printprops ([<f_1>, ..., <f_n>], gradef)' muestra las 2115 derivadas parciales de las funciones <f_1>, ..., <f_n>, tal como 2116 las definió 'gradef'. 2117 2118 La llamada 'printprops ([<a_n>, ..., <a_n>], atomgrad)' muestra las 2119 derivadas parciales de las variables <a_n>, ..., <a_n>, tal como 2120 las definió 'gradef'. 2121 2122 La variable 'gradefs' contiene la lista de las funciones para las 2123 que se han definido derivadas parciales con la instrucción 2124 'gradef', pero no incluye las variables para las que se han 2125 definido las derivadas parciales. 2126 2127 Los gradientes son necesarios cuando una función no se conoce 2128 explícitamente pero sí sus primeras derivadas y es necesario 2129 calcular las derivadas de orden mayor. 2130 2131 -- Variable del sistema: gradefs 2132 Valor por defecto: '[]' 2133 2134 La variable 'gradefs' contiene la lista de las funciones para las 2135 que se han definido derivadas parciales con la instrucción 2136 'gradef', pero no incluye las variables para las que se han 2137 definido las derivadas parciales. 2138 2139 -- Función: laplace (<expr>, <t>, <s>) 2140 Calcula la transformada de Laplace de <expr> con respecto de la 2141 variable <t> y parámetro de transformación <s>. 2142 2143 La función 'laplace' reconoce en <expr> las funciones 'delta', 2144 'exp', 'log', 'sin', 'cos', 'sinh', 'cosh' y 'erf', así como 2145 'derivative', 'integrate', 'sum' y 'ilt'. Si 'laplace' no 2146 encuentra una transformada, entonces llama a la función 'specint', 2147 la cual puede encontrar la transformada de Laplace de expresiones 2148 con funciones especiales, tales como las de Bessel. 'specint' 2149 también puede manipular la función 'unit_step'. Véase 'specint' 2150 para más información. 2151 2152 Cuando tampoco 'specint' sea capaz de encontrar una solución, se 2153 devolverá una forma nominal. 2154 2155 La función 'laplace' reconoce integrales de convolución de la forma 2156 'integrate (f(x) * g(t - x), x, 0, t)', no pudiendo reconocer otros 2157 tipos de convoluciones. 2158 2159 Las relaciones funcionales se deben representar explícitamente en 2160 <expr>; las relaciones implícitas establecidas por 'depends' no son 2161 reconocidas. Así, si <f> depende de <x> y <y>, 'f (x, y)' debe 2162 aparecer en <expr>. 2163 2164 Véase también 'ilt', la transformada inversa de Laplace. 2165 2166 Ejemplos: 2167 2168 (%i1) laplace (exp (2*t + a) * sin(t) * t, t, s); 2169 a 2170 %e (2 s - 4) 2171 (%o1) --------------- 2172 2 2 2173 (s - 4 s + 5) 2174 (%i2) laplace ('diff (f (x), x), x, s); 2175 (%o2) s laplace(f(x), x, s) - f(0) 2176 (%i3) diff (diff (delta (t), t), t); 2177 2 2178 d 2179 (%o3) --- (delta(t)) 2180 2 2181 dt 2182 (%i4) laplace (%, t, s); 2183 ! 2184 d ! 2 2185 (%o4) - -- (delta(t))! + s - delta(0) s 2186 dt ! 2187 !t = 0 2188 (%i5) assume(a>0)$ 2189 (%i6) laplace(gamma_incomplete(a,t),t,s),gamma_expand:true; 2190 - a - 1 2191 gamma(a) gamma(a) s 2192 (%o6) -------- - ----------------- 2193 s 1 a 2194 (- + 1) 2195 s 2196 (%i7) factor(laplace(gamma_incomplete(1/2,t),t,s)); 2197 s + 1 2198 sqrt(%pi) (sqrt(s) sqrt(-----) - 1) 2199 s 2200 (%o7) ----------------------------------- 2201 3/2 s + 1 2202 s sqrt(-----) 2203 s 2204 (%i8) assume(exp(%pi*s)>1)$ 2205 (%i9) laplace(sum((-1)^n*unit_step(t-n*%pi)*sin(t),n,0,inf),t,s),simpsum; 2206 %i %i 2207 ------------------------ - ------------------------ 2208 - %pi s - %pi s 2209 (s + %i) (1 - %e ) (s - %i) (1 - %e ) 2210 (%o9) --------------------------------------------------- 2211 2 2212 (%i9) factor(%); 2213 %pi s 2214 %e 2215 (%o9) ------------------------------- 2216 %pi s 2217 (s - %i) (s + %i) (%e - 1) 2218 2219 2220 2221File: maxima.info, Node: Integración, Next: Ecuaciones, Prev: Diferenciación, Up: Top 2222 222319 Integración 2224************** 2225 2226* Menu: 2227 2228* Introducción a la integración:: 2229* Funciones y variables para integración:: 2230* Introducción a QUADPACK:: 2231* Funciones y variables para QUADPACK:: 2232 2233 2234File: maxima.info, Node: Introducción a la integración, Next: Funciones y variables para integración, Prev: Integración, Up: Integración 2235 223619.1 Introducción a la integración 2237================================== 2238 2239Maxima tiene varias rutinas para calcular integrales. La función 2240'integrate' hace uso de la mayor parte de ellas. También está el 2241paquete 'antid', que opera con funciones no especificadas y sus 2242derivadas. Para usos numéricos se dispone de la batería de integradores 2243adaptativos de 'QUADPACK', como 'quad_qag', 'quad_qags', etc., que se 2244describen en la sección 'QUADPACK'. También se trabajan funciones 2245hipergeométricas, véase 'specint' para más detalles. En términos 2246generales, Maxima sólo opera con funciones que son integrables en 2247términos de funciones elementales, como las racionales, trigonométricas, 2248logarítmicas, exponenciales, radicales, etc., y unas pocas extensiones 2249de éstas, como la función de error o los dilogaritmos. No opera con 2250integrales en términos de funciones desconocidas, como 'g(x)' o 'h(x)'. 2251 2252 2253File: maxima.info, Node: Funciones y variables para integración, Next: Introducción a QUADPACK, Prev: Introducción a la integración, Up: Integración 2254 225519.2 Funciones y variables para integración 2256=========================================== 2257 2258 -- Función: changevar (<expr>, <f(x,y)>, <y>, <x>) 2259 Hace el cambio de variable dado por '<f(x,y)> = 0' en todas las 2260 integrales que aparecen en <expr> con la integración respecto de 2261 <x>. La nueva variable será <y>. 2262 2263 (%i1) assume(a > 0)$ 2264 (%i2) 'integrate (%e**sqrt(a*y), y, 0, 4); 2265 4 2266 / 2267 [ sqrt(a) sqrt(y) 2268 (%o2) I %e dy 2269 ] 2270 / 2271 0 2272 (%i3) changevar (%, y-z^2/a, z, y); 2273 0 2274 / 2275 [ abs(z) 2276 2 I z %e dz 2277 ] 2278 / 2279 - 2 sqrt(a) 2280 (%o3) - ---------------------------- 2281 a 2282 2283 Si una expresión contiene formas nominales, como aquélla en la que 2284 aparece ''integrate' en el ejemplo, podrá ser evaluada por 'ev' si 2285 se utiliza el término 'nouns'. Por ejemplo, la expresión devuelta 2286 por 'changevar' se puede evaluar haciendo 'ev (%o3, nouns)'. 2287 2288 La función 'changevar' también se puede utilizar para cambiar los 2289 índices de una suma o producto. Sin embargo, debe tenerse en 2290 cuenta que cuando se realiza un cambio en una suma o producto, el 2291 mismo debe expresarse en términos de sumas, como 'i = j+ ...', no 2292 como una función de mayor grado. 2293 2294 Ejemplo: 2295 2296 (%i4) sum (a[i]*x^(i-2), i, 0, inf); 2297 inf 2298 ==== 2299 \ i - 2 2300 (%o4) > a x 2301 / i 2302 ==== 2303 i = 0 2304 (%i5) changevar (%, i-2-n, n, i); 2305 inf 2306 ==== 2307 \ n 2308 (%o5) > a x 2309 / n + 2 2310 ==== 2311 n = - 2 2312 2313 -- Función: dblint (<f>, <r>, <s>, <a>, <b>) 2314 Es una rutina para integrales dobles escrita en lenguaje Maxima y 2315 posteriormente traducida y compilada a código máquina. La 2316 instrucción 'load (dblint)' carga esta función. Utiliza el método 2317 de Simpson en las dos direcciones 'x' e 'y' para calcular 2318 2319 /b /s(x) 2320 | | 2321 | | f(x,y) dy dx 2322 | | 2323 /a /r(x) 2324 2325 La función <f> debe ser una función traducida o compilada de dos 2326 variables, a la vez que <r> y <s> deben ser cada una de ellas una 2327 función traducida o compilada de una variable, mientras que <a> y 2328 <b> deben ser números en coma flotante. La rutina tiene dos 2329 variables globales que determinan el número de divisiones de los 2330 intervalos 'x' e 'y': 'dblint_x' y 'dblint_y', ambos con un valor 2331 por defecto de 10, pero que pueden cambiarse de forma independiente 2332 a otros valores enteros (hay '2*dblint_x+1' puntos a calcular en la 2333 dirección 'x' y '2*dblint_y+1' en la dirección 'y'). La rutina 2334 subdivide el eje X y luego para cada valor de X calcula primero 2335 '<r>(x)' y '<s>(x)'; entonces se subdivide el eje Y entre '<r>(x)' 2336 y '<s>(x)', evaluándose la integral a lo largo del eje Y aplicando 2337 la regla de Simpson; a continuación, se evalúa la integral a lo 2338 largo del eje X utilizando también la regla de Simpson tomando como 2339 valores de función las integrales sobre Y. Este procedimiento puede 2340 ser numéricamente inestable por múltiples motivos, pero es 2341 razonablemente rápido: evítese su uso con funciones con grandes 2342 oscilaciones o que tengan singularidades. Las integrales del eje Y 2343 dependen de la proximidad de los límites '<r>(x)' y '<s>(x)', de 2344 manera que si la distancia '<s>(x) - <r>(x)' varía rápidamente con 2345 X, puede dar lugar errores importantes debido a truncamientos de 2346 diferente amplitud en las integrales de Y. Se puede aumentar 2347 'dblint_x' y 'dblint_y' al objeto de mejorar el recubrimiento de la 2348 región de integración, pero a costa del tiempo de cómputo. Es 2349 necesario que las funciones <f>, <r> y <s> estén traducidas o 2350 compiladas antes de utilizar 'dblint', lo cual redundará en una 2351 mejora del tiempo de ejecución de varios órdenes de magnitud 2352 respecto de la ejecución de código interpretado. 2353 2354 -- Función: defint (<expr>, <x>, <a>, <b>) 2355 Intenta calcular una integral definida. La función 'defint' es 2356 invocada por 'integrate' cuando se especifican los límites de 2357 integración, por ejemplo 'integrate (<expr>, <x>, <a>, <b>)'. Así, 2358 desde el punto de vista del usuario, es suficiente con utilizar 2359 'integrate'. 2360 2361 La función 'defint' devuelve una expresión simbólica, bien sea el 2362 resultado calculado o la forma nominal. Véase 'quad_qag' y sus 2363 funciones relacionadas para aproximaciones numéricas de integrales 2364 definidas. 2365 2366 -- Variable optativa: erfflag 2367 Valor por defecto: 'true' 2368 2369 Si 'erfflag' vale 'false', la función 'risch' no introduce la 2370 función 'erf' en el resultado si no había ninguna en el integrando. 2371 2372 -- Función: ilt (<expr>, <s>, <t>) 2373 Calcula la transformada inversa de Laplace de <expr> con respecto 2374 de <s> y parámetro <t>. El argumento <expr> debe ser una fracción 2375 de polinomios cuyo denominador tenga sólo factores lineales y 2376 cuadráticos. Utilizando las funciones 'laplace' y 'ilt', junto con 2377 las funciones 'solve' o 'linsolve', el usuario podrá resolver 2378 ciertas ecuaciones integrales. 2379 2380 (%i1) 'integrate (sinh(a*x)*f(t-x), x, 0, t) + b*f(t) = t**2; 2381 t 2382 / 2383 [ 2 2384 (%o1) I f(t - x) sinh(a x) dx + b f(t) = t 2385 ] 2386 / 2387 0 2388 (%i2) laplace (%, t, s); 2389 a laplace(f(t), t, s) 2 2390 (%o2) b laplace(f(t), t, s) + --------------------- = -- 2391 2 2 3 2392 s - a s 2393 (%i3) linsolve ([%], ['laplace(f(t), t, s)]); 2394 2 2 2395 2 s - 2 a 2396 (%o3) [laplace(f(t), t, s) = --------------------] 2397 5 2 3 2398 b s + (a - a b) s 2399 (%i4) ilt (rhs (first (%)), s, t); 2400 Is a b (a b - 1) positive, negative, or zero? 2401 2402 pos; 2403 sqrt(a b (a b - 1)) t 2404 2 cosh(---------------------) 2 2405 b a t 2406 (%o4) - ----------------------------- + ------- 2407 3 2 2 a b - 1 2408 a b - 2 a b + a 2409 2410 2 2411 + ------------------ 2412 3 2 2 2413 a b - 2 a b + a 2414 2415 -- Variable opcional: intanalysis 2416 Valor por defecto: 'true' 2417 2418 Cuando vale 'true', la integración definida trata de encontrar 2419 polos en el integrando dentro del intervalo de integración. Si 2420 encuentra alguno, entonces la integral se calcula como valor 2421 principal. Si 'intanalysis' vale 'false', entonces no se realiza 2422 esta comprobación y la integración se realiza sin tener en cuenta 2423 los polos. 2424 2425 Véase también 'ldefint'. 2426 2427 Ejemplos: 2428 2429 Maxima puede calcular las siguientes integrales cuando a 2430 'intanalysis' se le asigna el valor 'false': 2431 2432 (%i1) integrate(1/(sqrt(x)+1),x,0,1); 2433 1 2434 / 2435 [ 1 2436 (%o1) I ----------- dx 2437 ] sqrt(x) + 1 2438 / 2439 0 2440 2441 (%i2) integrate(1/(sqrt(x)+1),x,0,1),intanalysis:false; 2442 (%o2) 2 - 2 log(2) 2443 2444 (%i3) integrate(cos(a)/sqrt((tan(a))^2 +1),a,-%pi/2,%pi/2); 2445 The number 1 isn't in the domain of atanh 2446 -- an error. To debug this try: debugmode(true); 2447 2448 (%i4) intanalysis:false$ 2449 (%i5) integrate(cos(a)/sqrt((tan(a))^2+1),a,-%pi/2,%pi/2); 2450 %pi 2451 (%o5) --- 2452 2 2453 2454 -- Función: integrate (<expr>, <x>) 2455 -- Función: integrate (<expr>, <x>, <a>, <b>) 2456 Calcula simbólicamente la integral de <expr> respecto de <x>. La 2457 llamada 'integrate (<expr>, <x>)' resuelve una integral indefinida, 2458 mientras que 'integrate (<expr>, <x>, <a>, <b>)' resuelve una 2459 integral definida con límites de integración <a> y <b>. Los 2460 límites no pueden contener a <x>. El argumento <a> no necesita ser 2461 menor que <b>. Si <b> es igual a <a>, 'integrate' devuelve cero. 2462 2463 Véase 'quad_qag' y funciones relacionadas para la aproximación 2464 numérica de integrales definidas. Véase 'residue' para el cálculo 2465 de residuos (integración compleja). Véase 'antid' para un método 2466 alternativo de resolución de integrales indefinidas. 2467 2468 Se obtendrá una integral (es decir, una expresión sin 'integrate') 2469 si 'integrate' tiene éxito en el cálculo. En otro caso, la 2470 respuesta es la forma nominal de la integral (esto es, el operador 2471 ''integrate' precedido de apóstrofo) o una expresión que contiene 2472 una o más formas nominales. La forma nominal de 'integrate' se 2473 muestra con un símbolo integral. 2474 2475 En ciertos casos es útil proporcionar una forma nominal 'a mano', 2476 haciendo preceder 'integrate' con una comilla simple o apóstrofo, 2477 como en ''integrate (<expr>, <x>)'. Por ejemplo, la integral puede 2478 depender de algunos parámetros que todavía no han sido calculados. 2479 La forma nominal puede aplicarse después a sus argumentos haciendo 2480 'ev (<i>, nouns)' donde <i> es la forma nominal de interés. 2481 2482 La función 'integrate' trata de manera diferente las integrales 2483 definidas de las indefinidas, empleando una batería de heurísticas 2484 especial para cada caso. Casos especiales de integrales definidas 2485 incluyen las que tienen límites de integración iguales a cero o a 2486 infinito ('inf' o 'minf'), funciones trigonométricas con límites de 2487 integración igual a cero y '%pi' o '2 %pi', funciones racionales, 2488 integrales relacionadas con las funciones 'beta' y 'psi' y algunas 2489 integrales logarítmicas y trigonométricas. El tratamiento de 2490 funciones racionales puede incluir el cálculo de residuos. Si no 2491 se reconoce ninguno de los casos especiales, se intenta resolver la 2492 integral idefinida y evaluarla en los límites de integración. Esto 2493 incluye tomar límites cuando alguno de los extremos del intervalo 2494 de integración se acerca a más infinito o a menos infinito; véase 2495 también 'ldefint'. 2496 2497 Casos especiales de integrales indefinidas incluyen a las funciones 2498 trigonométricas, exponenciales, logarítmicas y racionales. La 2499 función 'integrate' también hace uso de una pequeña tabla de 2500 integrales elementales. 2501 2502 La función 'integrate' puede llevar a cabo cambios de variable si 2503 el integrando es de la forma 'f(g(x)) * diff(g(x), x)', entonces 2504 'integrate' trata de encontrar una subexpresión de 'g(x)' tal que 2505 la derivada de 'g(x)' divida el integrando. Esta búsqueda puede 2506 hacer uso de las derivadas establecidas con la función 'gradef'. 2507 Véanse también 'changevar' y 'antid'. 2508 2509 Si ninguna de las heurísticas descritas resuelve la integral 2510 indefinida, se ejecuta el algoritmo de Risch. La variable 'risch' 2511 puede utilizarse como una 'evflag', en una llamada a 'ev' o en la 2512 línea de comandos por ejemplo, 'ev (integrate (<expr>, <x>), 2513 risch)' o 'integrate (<expr>, <x>), risch'. Si 'risch' está 2514 presenta, 'integrate' llama a la función 'risch' sin intentar 2515 primero las heurísticas. Véase también 'risch'. 2516 2517 La función 'integrate' opera únicamente con relaciones funcionales 2518 que se representen explícitamente con la notación 'f(x)', sin 2519 considerar las dependencias implícitas establecidas mediante la 2520 función 'depends'. 2521 2522 Es posible que 'integrate' necesite conocer alguna propiedad de 2523 alguno de los parámetros presentes en el integrando, en cuyo caso 2524 'integrate' consultará en primer lugar la base de datos creada con 2525 'assume', y si la variable de interés no se encuentra ahí, 2526 'integrate' le preguntará al usuario. Dependiendo de la pregunta, 2527 posibles respuestas son: 'yes;', 'no;', 'pos;', 'zero;' o 'neg;'. 2528 2529 Por defecto, 'integrate' no se considera lineal. Véanse 'declare' 2530 y 'linear'. 2531 2532 La función 'integrate' intentará la integración por partes sólo en 2533 casos especiales. 2534 2535 Ejemplos: 2536 2537 * Integrales elementales indefinidas y definidas. 2538 2539 (%i1) integrate (sin(x)^3, x); 2540 3 2541 cos (x) 2542 (%o1) ------- - cos(x) 2543 3 2544 (%i2) integrate (x/ sqrt (b^2 - x^2), x); 2545 2 2 2546 (%o2) - sqrt(b - x ) 2547 (%i3) integrate (cos(x)^2 * exp(x), x, 0, %pi); 2548 %pi 2549 3 %e 3 2550 (%o3) ------- - - 2551 5 5 2552 (%i4) integrate (x^2 * exp(-x^2), x, minf, inf); 2553 sqrt(%pi) 2554 (%o4) --------- 2555 2 2556 2557 * Utilización de 'assume' e interacción. 2558 2559 (%i1) assume (a > 1)$ 2560 (%i2) integrate (x**a/(x+1)**(5/2), x, 0, inf); 2561 2 a + 2 2562 Is ------- an integer? 2563 5 2564 2565 no; 2566 Is 2 a - 3 positive, negative, or zero? 2567 2568 neg; 2569 3 2570 (%o2) beta(a + 1, - - a) 2571 2 2572 2573 * Cambio de variable. En este ejemplo hay dos cambios de 2574 variable: uno utilizando una derivada establecida con 'gradef' 2575 y otra utilizando la derivada 'diff(r(x))' de una función no 2576 especificada 'r(x)'. 2577 2578 (%i3) gradef (q(x), sin(x**2)); 2579 (%o3) q(x) 2580 (%i4) diff (log (q (r (x))), x); 2581 d 2 2582 (-- (r(x))) sin(r (x)) 2583 dx 2584 (%o4) ---------------------- 2585 q(r(x)) 2586 (%i5) integrate (%, x); 2587 (%o5) log(q(r(x))) 2588 2589 * El valor devuelto contiene la forma nominal ''integrate'. En 2590 este ejemplo, Maxima puede extraer un factor del denominador 2591 de una función racional, pero no puede factorizar el resto. 2592 La función 'grind' muestra la forma nominal ''integrate' del 2593 resultado. Véase también 'integrate_use_rootsof' para más 2594 información sobre integrales de funciones racionales. 2595 2596 (%i1) expand ((x-4) * (x^3+2*x+1)); 2597 4 3 2 2598 (%o1) x - 4 x + 2 x - 7 x - 4 2599 (%i2) integrate (1/%, x); 2600 / 2 2601 [ x + 4 x + 18 2602 I ------------- dx 2603 ] 3 2604 log(x - 4) / x + 2 x + 1 2605 (%o2) ---------- - ------------------ 2606 73 73 2607 (%i3) grind (%); 2608 log(x-4)/73-('integrate((x^2+4*x+18)/(x^3+2*x+1),x))/73$ 2609 2610 * Definición de una función mediante una integral. El cuerpo de 2611 una función no se evalúa cuando ésta se define, de manera que 2612 el cuerpo de 'f_1' en este ejemplo contiene la forma nominal 2613 de 'integrate'. El operador comilla-comilla '''' hace que se 2614 evalúe la integral y su resultado será el que defina a la 2615 función 'f_2'. 2616 2617 (%i1) f_1 (a) := integrate (x^3, x, 1, a); 2618 3 2619 (%o1) f_1(a) := integrate(x , x, 1, a) 2620 (%i2) ev (f_1 (7), nouns); 2621 (%o2) 600 2622 (%i3) /* Note parentheses around integrate(...) here */ 2623 f_2 (a) := ''(integrate (x^3, x, 1, a)); 2624 4 2625 a 1 2626 (%o3) f_2(a) := -- - - 2627 4 4 2628 (%i4) f_2 (7); 2629 (%o4) 600 2630 2631 -- Variable del sistema: integration_constant 2632 Valor por defecto: '%c' 2633 2634 Cuando una constante de integración se crea durante la integración 2635 definida de una ecuación, el nombre de la constante se construye 2636 concatenando 'integration_constant' y 2637 'integration_constant_counter'. 2638 2639 A 'integration_constant' se le puede asignar un símbolo cualquiera. 2640 2641 Ejemplos: 2642 2643 (%i1) integrate (x^2 = 1, x); 2644 3 2645 x 2646 (%o1) -- = x + %c1 2647 3 2648 (%i2) integration_constant : 'k; 2649 (%o2) k 2650 (%i3) integrate (x^2 = 1, x); 2651 3 2652 x 2653 (%o3) -- = x + k2 2654 3 2655 2656 -- Variable del sistema: integration_constant_counter 2657 Valor por defecto: 0 2658 2659 Cuando una constante de integración se crea durante la integración 2660 definida de una ecuación, el nombre de la constante se construye 2661 concatenando 'integration_constant' y 2662 'integration_constant_counter'. 2663 2664 La variable 'integration_constant_counter' se incrementa antes de 2665 construir la constante de integración siguiente. 2666 2667 Ejemplos: 2668 2669 (%i1) integrate (x^2 = 1, x); 2670 3 2671 x 2672 (%o1) -- = x + %c1 2673 3 2674 (%i2) integrate (x^2 = 1, x); 2675 3 2676 x 2677 (%o2) -- = x + %c2 2678 3 2679 (%i3) integrate (x^2 = 1, x); 2680 3 2681 x 2682 (%o3) -- = x + %c3 2683 3 2684 (%i4) reset (integration_constant_counter); 2685 (%o4) [integration_constant_counter] 2686 (%i5) integrate (x^2 = 1, x); 2687 3 2688 x 2689 (%o5) -- = x + %c1 2690 3 2691 2692 -- Variable optativa: integrate_use_rootsof 2693 Valor por defecto: 'false' 2694 2695 Si 'integrate_use_rootsof' vale 'true' y el denominador de una 2696 función racional no se puede factorizar, 'integrate' devuelve la 2697 integral como una suma respecto de las raíces desconocidas del 2698 denominador. 2699 2700 Por ejemplo, dándole a 'integrate_use_rootsof' el valor 'false', 2701 'integrate' devuelve la integral no resuelta de la función racional 2702 en forma nominal: 2703 2704 (%i1) integrate_use_rootsof: false$ 2705 (%i2) integrate (1/(1+x+x^5), x); 2706 / 2 2707 [ x - 4 x + 5 2708 I ------------ dx 2 x + 1 2709 ] 3 2 2 5 atan(-------) 2710 / x - x + 1 log(x + x + 1) sqrt(3) 2711 (%o2) ----------------- - --------------- + --------------- 2712 7 14 7 sqrt(3) 2713 2714 Si ahora se le da a la variable el valor 'true', la parte no 2715 resuelta de la integral se expresa como una suma cuyos sumandos 2716 dependen de las raíces del denominador de la función racional: 2717 2718 (%i3) integrate_use_rootsof: true$ 2719 (%i4) integrate (1/(1+x+x^5), x); 2720 ==== 2 2721 \ (%r4 - 4 %r4 + 5) log(x - %r4) 2722 > ------------------------------- 2723 / 2 2724 ==== 3 %r4 - 2 %r4 2725 3 2 2726 %r4 in rootsof(%r4 - %r4 + 1, %r4) 2727 (%o4) ---------------------------------------------------------- 2728 7 2729 2730 2 x + 1 2731 2 5 atan(-------) 2732 log(x + x + 1) sqrt(3) 2733 - --------------- + --------------- 2734 14 7 sqrt(3) 2735 2736 Alternativamente, el usuario puede calcular las raíces del 2737 denominador separadamente y luego representar el integrando en 2738 función de dichas raíces, como por ejemplo '1/((x - a)*(x - b)*(x - 2739 c))' o '1/((x^2 - (a+b)*x + a*b)*(x - c))' si el denominador es un 2740 polinomio de tercer grado. En algunos casos, esto ayudará a Maxima 2741 mejorar sus resultados. 2742 2743 -- Función: ldefint (<expr>, <x>, <a>, <b>) 2744 Calcula la integral definida de <expr> utilizando 'limit' tras el 2745 cálculo de la integral indefinida de <expr> respecto a <x> en los 2746 extremos de integración <b> y <a>. Si no consigue calcular la 2747 integral definida, 'ldefint' devuelve una expresión con los límites 2748 en forma nominal. 2749 2750 La función 'integrate' no llama a 'ldefint', de modo que la 2751 ejecución de 'ldefint (<expr>, <x>, <a>, <b>)' puede dar un 2752 resultado diferente que 'integrate (<expr>, <x>, <a>, <b>)'. La 2753 función 'ldefint' siempre utiliza el mismo método para calcular la 2754 integral definida, mientras que 'integrate' puede hacer uso de 2755 varias heurísticas y reconocer así casos especiales. 2756 2757 -- Función: residue (<expr>, <z>, <z_0>) 2758 Calcula el residuo en el plano complejo de la expresión <expr> 2759 cuando la variable <z> toma el valor <z_0>. El residuo es el 2760 coeficiente de '(<z> - <z_0>)^(-1)' en el desarrollo de Laurent de 2761 <expr>. 2762 2763 (%i1) residue (s/(s**2+a**2), s, a*%i); 2764 1 2765 (%o1) - 2766 2 2767 (%i2) residue (sin(a*x)/x**4, x, 0); 2768 3 2769 a 2770 (%o2) - -- 2771 6 2772 2773 -- Función: risch (<expr>, <x>) 2774 Integra <expr> respecto de <x> utilizando el caso trascendental del 2775 algoritmo de Risch. El caso algebraico del algoritmo de Risch no 2776 se ha implementado. Este método trata los casos de exponenciales y 2777 logaritmos anidados que no resuelve el procedimiento principal de 2778 'integrate'. La función 'integrate' llamará automáticamente a 2779 'risch' si se presentan estos casos. 2780 2781 Si la variable 'erfflag' vale 'false', evita que 'risch' introduzca 2782 la función 'erf' en la respuesta si ésta no estaba presente 2783 previamente en el integrando. 2784 2785 (%i1) risch (x^2*erf(x), x); 2786 2 2787 3 2 - x 2788 %pi x erf(x) + (sqrt(%pi) x + sqrt(%pi)) %e 2789 (%o1) ------------------------------------------------- 2790 3 %pi 2791 (%i2) diff(%, x), ratsimp; 2792 2 2793 (%o2) x erf(x) 2794 2795 -- Función: tldefint (<expr>, <x>, <a>, <b>) 2796 Equivale a 'ldefint' cuando 'tlimswitch' vale 'true'. 2797 2798 2799File: maxima.info, Node: Introducción a QUADPACK, Next: Funciones y variables para QUADPACK, Prev: Funciones y variables para integración, Up: Integración 2800 280119.3 Introducción a QUADPACK 2802============================ 2803 2804QUADPACK es un conjunto de funciones para el cálculo numérico de 2805integrales definidas de una variable. Se creó a partir de un trabajo 2806conjunto de R. Piessens (1), E. de Doncker (2), C. Ueberhuber (3), and 2807D. Kahaner (4). 2808 2809La librería QUADPACK incluida en Maxima es una traducción automática 2810(mediante el programa 'f2cl') del código fuente Fortran de QUADPACK tal 2811como se encuentra en la SLATEC Common Mathematical Library,Versión 4.1 2812(5). La librería SLATEC está fechada en julio de 1993, pero las 2813funciones QUADPACK fueron escritas algunos años antes. Hay otra versión 2814de QUADPACK en Netlib (6), pero no está claro hasta qué punto difiere de 2815la que forma parte de la librería SLATEC. 2816 2817Las funciones QUADPACK incluidas en Maxima son todas automáticas, en el 2818sentido de que estas funciones intentan calcular sus resultados con una 2819exactitud especificada, requiriendo un número indeterminado de 2820evaluaciones de funciones. La traducción a Lisp que Maxima hace de 2821QUADPACK incluye también algunas funciones que no son automáticas, pero 2822que no son accesibles desde el nivel de Maxima. 2823 2824Se puede encontrar más información sobre QUADPACK en el libro (7). 2825 282619.3.1 Perspectiva general 2827-------------------------- 2828 2829'quad_qag' 2830 Integración de una función general en un intervalo finito. La 2831 función 'quad_qag' implementa un integrador global adaptativo 2832 simple utilizando una estrategia de Aind (Piessens, 1973). Se 2833 puede escoger entre seis pares de fórmulas de cuadratura de 2834 Gauss-Kronrod para la regla de evaluación. Las reglas de rango 2835 superior son útiles en los casos en los que los integrandos tienen 2836 un alto grado de oscilación. 2837 2838'quad_qags' 2839 Integración de una función general en un intervalo finito. La 2840 función 'quad_qags' implementa la subdivisión de intervalos global 2841 adaptativa con extrapolación (de Doncker, 1978) mediante el 2842 algoritmo Epsilon (Wynn, 1956). 2843 2844'quad_qagi' 2845 Integración de una función general en un intervalo infinito o 2846 semi-infinito. El intervalo se proyecta sobre un intervalo finito 2847 y luego se aplica la misma estrategia que en 'quad_qags'. 2848 2849'quad_qawo' 2850 Integración de cos(omega x) f(x) o sin(omega x) f(x) en un 2851 intervalo finito, siendo omega una constante. La regla de 2852 evaluación se basa en la técnica modificada de Clenshaw-Curtis. La 2853 función 'quad_qawo' aplica la subdivisión adaptativa con 2854 extrapolación, de forma similar a 'quad_qags'. 2855 2856'quad_qawf' 2857 Calcula la transformada seno o coseno de Fourier en un intervalo 2858 semi-infinito. Se aplica el mismo método que en 'quad_qawo' a 2859 sucesivos intervalos finitos, acelerando la convergencia mediante 2860 el algoritmo Epsilon (Wynn, 1956). 2861 2862'quad_qaws' 2863 Integración de w(x) f(x) en un intervalo finito [a, b], siendo w 2864 una función de la forma (x - a)^alpha (b - x)^beta v(x), con v(x) 2865 igual a 1, a log(x - a), a log(b - x) o a log(x - a) log(b - x) y 2866 con alpha > -1, y beta > -1. Se aplica una estrategia de 2867 subdivisión adaptativa global, con integración de Clenshaw-Curtis 2868 modificada en los subintervalos que contienen a a y a b. 2869 2870'quad_qawc' 2871 Calcula el valor principal de Cauchy de f(x)/(x - c) en un 2872 intervalo finito (a, b) para una c dada. La estrategia es global 2873 adaptativa, utilizando la integración de Clenshaw-Curtis modificada 2874 en los subintervalos que contienen a x = c. 2875 2876'quad_qagp' 2877 Básicamente hace lo mismo que 'quad_qags', pero los puntos de 2878 singularidad o discontinuidad deben ser aportados por el usuario. 2879 Esto hace que el cálculo de una buena solución sea más fácil para 2880 el integrador. 2881 2882 ---------- Footnotes ---------- 2883 2884 (1) Applied Mathematics and Programming Division, K.U. Leuven 2885 2886 (2) Applied Mathematics and Programming Division, K.U. Leuven 2887 2888 (3) Institut für Mathematik, T.U. Wien 2889 2890 (4) National Bureau of Standards, Washington, D.C., U.S.A 2891 2892 (5) <http://www.netlib.org/slatec> 2893 2894 (6) <http://www.netlib.org/quadpack> 2895 2896 (7) R. Piessens, E. de Doncker-Kapenga, C.W. Uberhuber, and D.K. 2897Kahaner. QUADPACK: A Subroutine Package for Automatic Integration. 2898Berlin: Springer-Verlag, 1983, ISBN 0387125531. 2899 2900 2901File: maxima.info, Node: Funciones y variables para QUADPACK, Prev: Introducción a QUADPACK, Up: Integración 2902 290319.4 Funciones y variables para QUADPACK 2904======================================== 2905 2906 -- Función: quad_qag (<f(x)>, <x>, <a>, <b>, <key>, [<epsrel>, 2907 <epsabs>, <limit>]) 2908 -- Función: quad_qag (<f>, <x>, <a>, <b>, <key>, [<epsrel>, <epsabs>, 2909 <limit>]) 2910 Integración de una función general en un intervalo finito. La 2911 función 'quad_qag' implementa un integrador global adaptativo 2912 simple utilizando una estrategia de Aind (Piessens, 1973). Se 2913 puede escoger entre seis pares de fórmulas de cuadratura de 2914 Gauss-Kronrod para la regla de evaluación. Las reglas de rango 2915 superior son útiles en los casos en los que los integrandos tienen 2916 un alto grado de oscilación. 2917 2918 La función 'quad_qag' calcula numéricamente la integral 2919 2920 integrate (f(x), x, a, b) 2921 2922 utilizando un integrador adaptativo simple. 2923 2924 La función a integrar es <f(x)>, con variable independiente <x>, 2925 siendo el intervalo de integración el comprendido entre <a> y <b>. 2926 El argumento <key> indica el integrador a utilizar y debe ser un 2927 número entero entre 1 y 6, ambos inclusive. El valor de <key> 2928 selecciona el orden de la regla de integración de Gauss-Kronrod. 2929 Las reglas de rango superior son útiles en los casos en los que los 2930 integrandos tienen un alto grado de oscilación. 2931 2932 El integrando se puede especificar con el nombre de una función u 2933 operador de Maxima o de Lisp, como una expresión lambda o como una 2934 expresión general de Maxima. 2935 2936 La integración numérica se hace de forma adaptativa particionando 2937 la región de integración en subintervalos hasta conseguir la 2938 precisión requerida. 2939 2940 Los argumentos opcionales pueden especificarse en cualquier orden. 2941 Todos ellos toman la forma 'key=val'. Tales argumentos son: 2942 2943 'epsrel' 2944 Error relativo deseado de la aproximación. El valor por 2945 defecto es 1d-8. 2946 'epsabs' 2947 Error absoluto deseado de la aproximación. El valor por 2948 defecto es 0. 2949 'limit' 2950 Tamaño del array interno utilizado para realizar la 2951 cuadratura. <limit> es el número máximo de subintervalos a 2952 utilizar. El valor por defecto es 200. 2953 2954 La función 'quad_qag' devuelve una lista de cuatro elementos: 2955 2956 * la aproximación a la integral, 2957 * el error absoluto estimado de la aproximación, 2958 * el número de evaluaciones del integrando, 2959 * un código de error. 2960 2961 El código de error (el cuarto elemento del resultado) puede tener 2962 los siguientes valores: 2963 2964 '0' 2965 si no ha habido problemas; 2966 '1' 2967 si se utilizaron demasiados intervalos; 2968 '2' 2969 si se encontró un número excesivo de errores de redondeo; 2970 '3' 2971 si el integrando ha tenido un comportamiento extraño frente a 2972 la integración; 2973 '6' 2974 si los argumentos de entrada no son válidos. 2975 2976 Ejemplos: 2977 2978 (%i1) quad_qag (x^(1/2)*log(1/x), x, 0, 1, 3, 'epsrel=5d-8); 2979 (%o1) [.4444444444492108, 3.1700968502883E-9, 961, 0] 2980 (%i2) integrate (x^(1/2)*log(1/x), x, 0, 1); 2981 4 2982 (%o2) - 2983 9 2984 2985 -- Función: quad_qags (<f(x)>, <x>, <a>, <b>, [<epsrel>, <epsabs>, 2986 <limit>]) 2987 -- Función: quad_qags (<f>, <x>, <a>, <b>, [<epsrel>, <epsabs>, 2988 <limit>]) 2989 Integración de una función general en un intervalo finito. La 2990 función 'quad_qags' implementa la subdivisión de intervalos global 2991 adaptativa con extrapolación (de Doncker, 1978) mediante el 2992 algoritmo Epsilon (Wynn, 1956). 2993 2994 La función 'quad_qags' calcula la integral 2995 2996 integrate (f(x), x, a, b) 2997 2998 La función a integrar es <f(x)>, de variable independiente <x>, 2999 siendo el intervalo de integración el comprendido entre <a> y <b>. 3000 3001 El integrando se puede especificar con el nombre de una función u 3002 operador de Maxima o de Lisp, como una expresión lambda o como una 3003 expresión general de Maxima. 3004 3005 Los argumentos opcionales pueden especificarse en cualquier orden. 3006 Todos ellos toman la forma 'key=val'. Tales argumentos son: 3007 3008 'epsrel' 3009 Error relativo deseado de la aproximación. El valor por 3010 defecto es 1d-8. 3011 'epsabs' 3012 Error absoluto deseado de la aproximación. El valor por 3013 defecto es 0. 3014 'limit' 3015 Tamaño del array interno utilizado para realizar la 3016 cuadratura. <limit> es el número máximo de subintervalos a 3017 utilizar. El valor por defecto es 200. 3018 3019 La función 'quad_qags' devuelve una lista de cuatro elementos: 3020 3021 * la aproximación a la integral, 3022 * el error absoluto estimado de la aproximación, 3023 * el número de evaluaciones del integrando, 3024 * un código de error. 3025 3026 El código de error (el cuarto elemento del resultado) puede tener 3027 los siguientes valores: 3028 3029 '0' 3030 si no ha habido problemas; 3031 '1' 3032 si se utilizaron demasiados intervalos; 3033 '2' 3034 si se encontró un número excesivo de errores de redondeo; 3035 '3' 3036 si el integrando ha tenido un comportamiento extraño frente a 3037 la integración; 3038 '4' 3039 fallo de convergencia; 3040 '5' 3041 la integral es probablemente divergente o de convergencia 3042 lenta; 3043 '6' 3044 si los argumentos de entrada no son válidos. 3045 3046 Ejemplos: 3047 3048 (%i1) quad_qags (x^(1/2)*log(1/x), x, 0, 1, 'epsrel=1d-10); 3049 (%o1) [.4444444444444448, 1.11022302462516E-15, 315, 0] 3050 3051 Nótese que 'quad_qags' es más precisa y eficiente que 'quad_qag' 3052 para este integrando. 3053 3054 -- Función: quad_qagi (<f(x)>, <x>, <a>, <b>, [<epsrel>, <epsabs>, 3055 <limit>]) 3056 -- Función: quad_qagi (<f>, <x>, <a>, <b>, [<epsrel>, <epsabs>, 3057 <limit>]) 3058 3059 Integración de una función general en un intervalo infinito o 3060 semi-infinito. El intervalo se proyecta sobre un intervalo finito 3061 y luego se aplica la misma estrategia que en 'quad_qags'. 3062 3063 La función 'quad_qagi' calcula cualquiera las siguientes 3064 integrales: 3065 3066 integrate (f(x), x, a, inf) 3067 3068 integrate (f(x), x, minf, a) 3069 3070 integrate (f(x), x, minf, inf) 3071 3072 utilizando la rutina QAGI de Quadpack QAGI. La función a integrar 3073 es <f(x)>, con variable independiente <x>, siendo el intervalo de 3074 integración de rango infinito. 3075 3076 El integrando se puede especificar con el nombre de una función u 3077 operador de Maxima o de Lisp, como una expresión lambda o como una 3078 expresión general de Maxima. 3079 3080 Uno de los límites de integración debe ser infinito. De no ser 3081 así, 'quad_qagi' devolverá una forma nominal. 3082 3083 Los argumentos opcionales pueden especificarse en cualquier orden. 3084 Todos ellos toman la forma 'key=val'. Tales argumentos son: 3085 3086 'epsrel' 3087 Error relativo deseado de la aproximación. El valor por 3088 defecto es 1d-8. 3089 'epsabs' 3090 Error absoluto deseado de la aproximación. El valor por 3091 defecto es 0. 3092 'limit' 3093 Tamaño del array interno utilizado para realizar la 3094 cuadratura. <limit> es el número máximo de subintervalos a 3095 utilizar. El valor por defecto es 200. 3096 3097 La función 'quad_qagi' devuelve una lista de cuatro elementos: 3098 3099 * la aproximación a la integral, 3100 * el error absoluto estimado de la aproximación, 3101 * el número de evaluaciones del integrando, 3102 * un código de error. 3103 3104 El código de error (el cuarto elemento del resultado) puede tener 3105 los siguientes valores: 3106 3107 '0' 3108 si no ha habido problemas; 3109 '1' 3110 si se utilizaron demasiados intervalos; 3111 '2' 3112 si se encontró un número excesivo de errores de redondeo; 3113 '3' 3114 si el integrando ha tenido un comportamiento extraño frente a 3115 la integración; 3116 '4' 3117 fallo de convergencia; 3118 '5' 3119 la integral es probablemente divergente o de convergencia 3120 lenta; 3121 '6' 3122 si los argumentos de entrada no son válidos. 3123 3124 Ejemplos: 3125 3126 (%i1) quad_qagi (x^2*exp(-4*x), x, 0, inf, 'epsrel=1d-8); 3127 (%o1) [0.03125, 2.95916102995002E-11, 105, 0] 3128 (%i2) integrate (x^2*exp(-4*x), x, 0, inf); 3129 1 3130 (%o2) -- 3131 32 3132 3133 -- Función: quad_qawc (<f(x)>, <x>, <c>, <a>, <b>, [<epsrel>, <epsabs>, 3134 <limit>]) 3135 -- Función: quad_qawc (<f>, <x>, <c>, <a>, <b>, [<epsrel>, <epsabs>, 3136 <limit>]) 3137 Calcula el valor principal de Cauchy de f(x)/(x - c) en un 3138 intervalo finito (a, b) para una c dada. La estrategia es global 3139 adaptativa, utilizando la integración de Clenshaw-Curtis modificada 3140 en los subintervalos que contienen a x = c. 3141 3142 La función 'quad_qawc' calcula el valor principal de Cauchy de 3143 3144 integrate (f(x)/(x - c), x, a, b) 3145 3146 utilizando la rutina QAWC de Quadpack. La función a integrar es 3147 '<f(x)>/(<x> - <c>)', con variable independiente <x>, siendo el 3148 intervalo de integración el comprendido entre <a> y <b>. 3149 3150 El integrando se puede especificar con el nombre de una función u 3151 operador de Maxima o de Lisp, como una expresión lambda o como una 3152 expresión general de Maxima. 3153 3154 Los argumentos opcionales pueden especificarse en cualquier orden. 3155 Todos ellos toman la forma 'key=val'. Tales argumentos son: 3156 3157 'epsrel' 3158 Error relativo deseado de la aproximación. El valor por 3159 defecto es 1d-8. 3160 'epsabs' 3161 Error absoluto deseado de la aproximación. El valor por 3162 defecto es 0. 3163 'limit' 3164 Tamaño del array interno utilizado para realizar la 3165 cuadratura. <limit> es el número máximo de subintervalos a 3166 utilizar. El valor por defecto es 200. 3167 3168 'quad_qawc' returns a list of four elements: 3169 3170 * la aproximación a la integral, 3171 * el error absoluto estimado de la aproximación, 3172 * el número de evaluaciones del integrando, 3173 * un código de error. 3174 3175 El código de error (el cuarto elemento del resultado) puede tener 3176 los siguientes valores: 3177 3178 '0' 3179 si no ha habido problemas; 3180 '1' 3181 si se utilizaron demasiados intervalos; 3182 '2' 3183 si se encontró un número excesivo de errores de redondeo; 3184 '3' 3185 si el integrando ha tenido un comportamiento extraño frente a 3186 la integración; 3187 '6' 3188 si los argumentos de entrada no son válidos. 3189 3190 Ejemplos: 3191 3192 (%i1) quad_qawc (2^(-5)*((x-1)^2+4^(-5))^(-1), x, 2, 0, 5, 3193 'epsrel=1d-7); 3194 (%o1) [- 3.130120337415925, 1.306830140249558E-8, 495, 0] 3195 (%i2) integrate (2^(-alpha)*(((x-1)^2 + 4^(-alpha))*(x-2))^(-1), 3196 x, 0, 5); 3197 Principal Value 3198 alpha 9 4 9 3199 4 log(-------------- + --------------) 3200 alpha + 3 alpha + 3 3201 4 + 4 4 + 4 3202 (%o2) (------------------------------------------- 3203 alpha 3204 2 4 + 2 3205 3 alpha 3 alpha 3206 ------- ------- 3207 2 alpha/2 2 alpha/2 3208 4 atan(4 ) 4 atan(- 4 4 ) 3209 - ----------------------- + ---------------------------) 3210 alpha alpha 3211 4 + 1 4 + 1 3212 alpha 3213 /2 3214 (%i3) ev (%, alpha=5, numer); 3215 (%o3) - 3.130120337415917 3216 3217 -- Función: quad_qawf (<f(x)>, <x>, <a>, <omega>, <trig>, [<epsabs>, 3218 <limit>, <maxp1>, <limlst>]) 3219 -- Función: quad_qawf (<f>, <x>, <a>, <omega>, <trig>, [<epsabs>, 3220 <limit>, <maxp1>, <limlst>]) 3221 Calcula la transformada seno o coseno de Fourier en un intervalo 3222 semi-infinito. Se aplica el mismo método que en 'quad_qawo' a 3223 sucesivos intervalos finitos, acelerando la convergencia mediante 3224 el algoritmo Epsilon (Wynn, 1956). 3225 3226 La función 'quad_qawf' calcula la integral 3227 3228 integrate (f(x)*w(x), x, a, inf) 3229 3230 La función peso w se selecciona mediante <trig>: 3231 3232 'cos' 3233 w(x) = cos (omega x) 3234 'sin' 3235 w(x) = sin (omega x) 3236 3237 El integrando se puede especificar con el nombre de una función u 3238 operador de Maxima o de Lisp, como una expresión lambda o como una 3239 expresión general de Maxima 3240 3241 Los argumentos opcionales pueden especificarse en cualquier orden. 3242 Todos ellos toman la forma 'key=val'. Tales argumentos son: 3243 3244 'epsabs' 3245 El error absoluto deseado para la aproximación. El valor por 3246 defecto es 1d-10. 3247 'limit' 3248 Tamaño del arreglo interno de trabajo. (<limit> - <limlst>)/2 3249 es el número máximo de subintervalos para la partición. El 3250 valor por defecto es 200. 3251 'maxp1' 3252 Número máximo de momentos de Chebyshev. Debe ser mayor que 0. 3253 El valor por defecto es 100. 3254 'limlst' 3255 Cota superior del número de ciclos. Debe ser mayor o igual 3256 que 3. El valor por defecto es 10. 3257 3258 'quad_qawf' returns a list of four elements: 3259 3260 * la aproximación a la integral, 3261 * el error absoluto estimado de la aproximación, 3262 * el número de evaluaciones del integrando, 3263 * un código de error. 3264 3265 El código de error (el cuarto elemento del resultado) puede tener 3266 los siguientes valores: 3267 3268 '0' 3269 si no ha habido problemas; 3270 '1' 3271 si se utilizaron demasiados intervalos; 3272 '2' 3273 si se encontró un número excesivo de errores de redondeo; 3274 '3' 3275 si el integrando ha tenido un comportamiento extraño frente a 3276 la integración; 3277 '6' 3278 si los argumentos de entrada no son válidos. 3279 3280 Ejemplos: 3281 3282 (%i1) quad_qawf (exp(-x^2), x, 0, 1, 'cos, 'epsabs=1d-9); 3283 (%o1) [.6901942235215714, 2.84846300257552E-11, 215, 0] 3284 (%i2) integrate (exp(-x^2)*cos(x), x, 0, inf); 3285 - 1/4 3286 %e sqrt(%pi) 3287 (%o2) ----------------- 3288 2 3289 (%i3) ev (%, numer); 3290 (%o3) .6901942235215714 3291 3292 -- Función: quad_qawo (<f(x)>, <x>, <a>, <b>, <omega>, <trig>, 3293 [<epsrel>, <epsabs>, <limit>, <maxp1>, <limlst>]) 3294 -- Función: quad_qawo (<f>, <x>, <a>, <b>, <omega>, <trig>, [<epsrel>, 3295 <epsabs>, <limit>, <maxp1>, <limlst>]) 3296 Integración de cos(omega x) f(x) o sin(omega x) f(x) en un 3297 intervalo finito, siendo omega una constante. La regla de 3298 evaluación se basa en la técnica modificada de Clenshaw-Curtis. La 3299 función 'quad_qawo' aplica la subdivisión adaptativa con 3300 extrapolación, de forma similar a 'quad_qags'. 3301 3302 La función 'quad_qawo' realiza la integración utilizando la rutina 3303 QAWO de Quadpack: 3304 3305 integrate (f(x)*w(x), x, a, b) 3306 3307 La función peso w se selecciona mediante <trig>: 3308 3309 'cos' 3310 w(x) = cos (omega x) 3311 'sin' 3312 w(x) = sin (omega x) 3313 3314 El integrando se puede especificar con el nombre de una función u 3315 operador de Maxima o de Lisp, como una expresión lambda o como una 3316 expresión general de Maxima 3317 3318 Los argumentos opcionales pueden especificarse en cualquier orden. 3319 Todos ellos toman la forma 'key=val'. Tales argumentos son: 3320 3321 'epsrel' 3322 El error absoluto deseado para la aproximación. El valor por 3323 defecto es 1d-8. 3324 'epsabs' 3325 Error absoluto deseado de la aproximación. El valor por 3326 defecto es 0. 3327 'limit' 3328 Tamaño del arreglo interno de trabajo. <limit>/2 es el número 3329 máximo de subintervalos para la partición. El valor por 3330 defecto es 200. 3331 'maxp1' 3332 Número máximo de momentos de Chebyshev. Debe ser mayor que 0. 3333 El valor por defecto es 100. 3334 'limlst' 3335 Cota superior del número de ciclos. Debe ser mayor o igual 3336 que 3. El valor por defecto es 10. 3337 3338 'quad_qawo' returns a list of four elements: 3339 3340 * la aproximación a la integral, 3341 * el error absoluto estimado de la aproximación, 3342 * el número de evaluaciones del integrando, 3343 * un código de error. 3344 3345 El código de error (el cuarto elemento del resultado) puede tener 3346 los siguientes valores: 3347 3348 '0' 3349 si no ha habido problemas; 3350 '1' 3351 si se utilizaron demasiados intervalos; 3352 '2' 3353 si se encontró un número excesivo de errores de redondeo; 3354 '3' 3355 si el integrando ha tenido un comportamiento extraño frente a 3356 la integración; 3357 '6' 3358 si los argumentos de entrada no son válidos. 3359 3360 Ejemplos: 3361 3362 (%i1) quad_qawo (x^(-1/2)*exp(-2^(-2)*x), x, 1d-8, 20*2^2, 1, cos); 3363 (%o1) [1.376043389877692, 4.72710759424899E-11, 765, 0] 3364 (%i2) rectform (integrate (x^(-1/2)*exp(-2^(-alpha)*x) * cos(x), 3365 x, 0, inf)); 3366 alpha/2 - 1/2 2 alpha 3367 sqrt(%pi) 2 sqrt(sqrt(2 + 1) + 1) 3368 (%o2) ----------------------------------------------------- 3369 2 alpha 3370 sqrt(2 + 1) 3371 (%i3) ev (%, alpha=2, numer); 3372 (%o3) 1.376043390090716 3373 3374 -- Función: quad_qaws (<f(x)>, <x>, <a>, <b>, <alpha>, <beta>, <wfun>, 3375 [<epsrel>, <epsabs>, <limit>]) 3376 -- Función: quad_qaws (<f>, <x>, <a>, <b>, <alpha>, <beta>, <wfun>, 3377 [<epsrel>, <epsabs>, <limit>]) 3378 Integración de w(x) f(x) en un intervalo finito [a, b], siendo w 3379 una función de la forma (x - a)^alpha (b - x)^beta v(x), con v(x) 3380 igual a 1, a log(x - a), a log(b - x) o a log(x - a) log(b - x) y 3381 con alpha > -1, y beta > -1. Se aplica una estrategia de 3382 subdivisión adaptativa global, con integración de Clenshaw-Curtis 3383 modificada en los subintervalos que contienen a a y a b. 3384 3385 La función 'quad_qaws' realiza la integración utizando la rutina 3386 QAWS de Quadpack: 3387 3388 integrate (f(x)*w(x), x, a, b) 3389 3390 La función peso w se selecciona mediante <wfun>: 3391 3392 '1' 3393 w(x) = (x - a)^alfa (b - x)^beta 3394 '2' 3395 w(x) = (x - a)^alfa (b - x)^beta log(x - a) 3396 '3' 3397 w(x) = (x - a)^alfa (b - x)^beta log(b - x) 3398 '4' 3399 w(x) = (x - a)^alfa (b - x)^beta log(x - a) log(b - x) 3400 3401 El integrando se puede especificar con el nombre de una función u 3402 operador de Maxima o de Lisp, como una expresión lambda o como una 3403 expresión general de Maxima 3404 3405 Los argumentos opcionales pueden especificarse en cualquier orden. 3406 Todos ellos toman la forma 'key=val'. Tales argumentos son: 3407 3408 'epsrel' 3409 El error absoluto deseado para la aproximación. El valor por 3410 defecto es 1d-8. 3411 'epsabs' 3412 Error absoluto deseado de la aproximación. El valor por 3413 defecto es 0. 3414 'limit' 3415 Tamaño del array interno utilizado para realizar la 3416 cuadratura. (<limit> - <limlst>)/2 es el número máximo de 3417 subintervalos a utilizar. El valor por defecto es 200. 3418 3419 'quad_qaws' returns a list of four elements: 3420 3421 * la aproximación a la integral, 3422 * el error absoluto estimado de la aproximación, 3423 * el número de evaluaciones del integrando, 3424 * un código de error. 3425 3426 El código de error (el cuarto elemento del resultado) puede tener 3427 los siguientes valores: 3428 3429 '0' 3430 si no ha habido problemas; 3431 '1' 3432 si se utilizaron demasiados intervalos; 3433 '2' 3434 si se encontró un número excesivo de errores de redondeo; 3435 '3' 3436 si el integrando ha tenido un comportamiento extraño frente a 3437 la integración; 3438 '6' 3439 si los argumentos de entrada no son válidos. 3440 3441 Ejemplos: 3442 3443 (%i1) quad_qaws (1/(x+1+2^(-4)), x, -1, 1, -0.5, -0.5, 1, 3444 'epsabs=1d-9); 3445 (%o1) [8.750097361672832, 1.24321522715422E-10, 170, 0] 3446 (%i2) integrate ((1-x*x)^(-1/2)/(x+1+2^(-alpha)), x, -1, 1); 3447 alpha 3448 Is 4 2 - 1 positive, negative, or zero? 3449 3450 pos; 3451 alpha alpha 3452 2 %pi 2 sqrt(2 2 + 1) 3453 (%o2) ------------------------------- 3454 alpha 3455 4 2 + 2 3456 (%i3) ev (%, alpha=4, numer); 3457 (%o3) 8.750097361672829 3458 3459 -- Fución: quad_qagp (<f(x)>, <x>, <a>, <b>, <points>, [<epsrel>, 3460 <epsabs>, <limit>]) 3461 -- Fución: quad_qagp (<f>, <x>, <a>, <b>, <points>, [<epsrel>, 3462 <epsabs>, <limit>]) 3463 3464 Integra una función general sobre un intervalo acotado. La función 3465 'quad_qagp' implementa un método adaptativo global de subdivisión 3466 del intervalo con extrapolación (de Doncker, 1978) basado en el 3467 algoritmo Epsilon (Wynn, 1956). 3468 3469 'quad_qagp' calcula la integral 3470 3471 integrate (f(x), x, a, b) 3472 3473 La función a integrar es <f(x)>, con variable independiente <x>, en 3474 el intervalo limitado por <a> y <b>. 3475 3476 El integrando puede especificarse mediante el nombre de una función 3477 de Maxima o de Lisp o un operador, como una expresión lambda de 3478 Maxima, o como una expresión general de Maxima. 3479 3480 Para ayudar al integrador, el usuario debe aportar una lista de 3481 puntos donde el integrando es singular o discontinuo. 3482 3483 Las opciones se suministran como argumentos y se pueden escribir en 3484 cualquier orden. Deben tomar la forma 'opción=valor'. Las 3485 opciones son: 3486 3487 'epsrel' 3488 Error relativo de aproximación deseado. Valor por defecto es 3489 1d-8. 3490 'epsabs' 3491 Error absoluto de aproximación deseado. Valor por defecto es 3492 0. 3493 'limit' 3494 Tamaño del array interno de trabajo. <limit> es el máximo 3495 número de subintervalos a utilizar. Valor por defecto es 200. 3496 3497 'quad_qagp' devuelve una lista con cuatro elementos: 3498 3499 * una aproximación a la integral, 3500 * el error absoluto estimado de la aproximación, 3501 * el número de evaluaciones del integrando, 3502 * un código de error. 3503 3504 El código de error (cuarto elemento de la lista devuelta) puede 3505 tener los siguientes valores: 3506 3507 '0' 3508 no se encontraron errores; 3509 '1' 3510 se han hecho demasiados subintervalos; 3511 '2' 3512 se detectó un error de redondeo muy grande; 3513 '3' 3514 se ha observado un comportamiento del integrando 3515 extremadamente malo; 3516 '4' 3517 fallo de convergencia; 3518 '5' 3519 la integral es probablemente divergengente o converge muy 3520 lentamente; 3521 '6' 3522 entrada inválida. 3523 3524 Ejemplos: 3525 3526 (%i1) quad_qagp(x^3*log(abs((x^2-1)*(x^2-2))),x,0,3,[1,sqrt(2)]); 3527 (%o1) [52.74074838347143, 2.6247632689546663e-7, 1029, 0] 3528 (%i2) quad_qags(x^3*log(abs((x^2-1)*(x^2-2))), x, 0, 3); 3529 (%o2) [52.74074847951494, 4.088443219529836e-7, 1869, 0] 3530 3531 El integrando tiene singularidades en '1' y 'sqrt(2)', de manera 3532 que suministramos estos puntos a 'quad_qagp'. También se observa 3533 que 'quad_qagp' es más exacto y eficiente que 'quad_qags'. 3534 3535 -- Fución: quad_control (<parameter>, [<value>]) 3536 3537 Controla la gestión de los errores de 'QUADPACK'. El parámetro 3538 debe ser uno de los siguientes símbolos: 3539 3540 'current_error' 3541 El número de error actual. 3542 'control' 3543 Controla si los mensajes se imprimen o no. Si el valor es 3544 cero o menor, los mensajes se suprimen. 3545 'max_message' 3546 El máximo número de veces que se imprime cualquier mensaje. 3547 3548 Si no se da <value>, entonces se devuelve el valor actual asociado 3549 a <parameter>. En cambio, si se da <value>, se hace la asignación 3550 correspondiente a <parameter>, adquiriendo este nuevo valor. 3551 3552 3553File: maxima.info, Node: Ecuaciones, Next: Ecuaciones Diferenciales, Prev: Integración, Up: Top 3554 355520 Ecuaciones 3556************* 3557 3558* Menu: 3559 3560* Funciones y variable para las ecuaciones:: 3561 3562 3563File: maxima.info, Node: Funciones y variable para las ecuaciones, Prev: Ecuaciones, Up: Ecuaciones 3564 356520.1 Funciones y variable para las ecuaciones 3566============================================= 3567 3568 -- Variable del sistema: %rnum_list 3569 Valor por defecto: '[]' 3570 3571 La variable '%rnum_list' es la lista de variables introducidas en 3572 las soluciones por la funciones 'solve' y 'algsys'. Las variables 3573 '%r' se añaden a '%rnum_list' en su orden de creación. Esto es 3574 útil para hacer sustituciones en la solución a posteriori. 3575 3576 (%i1) solve ([x + y = 3], [x,y]); 3577 (%o1) [[x = 3 - %r1, y = %r1]] 3578 (%i2) %rnum_list; 3579 (%o2) [%r1] 3580 (%i3) sol : solve ([x + 2*y + 3*z = 4], [x,y,z]); 3581 (%o3) [[x = - 2 %r3 - 3 %r2 + 4, y = %r3, z = %r2]] 3582 (%i4) %rnum_list; 3583 (%o4) [%r2, %r3] 3584 (%i5) for i : 1 thru length (%rnum_list) do 3585 sol : subst (t[i], %rnum_list[i], sol)$ 3586 (%i6) sol; 3587 (%o6) [[x = - 2 t - 3 t + 4, y = t , z = t ]] 3588 2 1 2 1 3589 3590 -- Variable opcional: algepsilon 3591 Valor por defecto: 10^8 3592 3593 La variable 'algepsilon' es utilizada por 'algsys'. 3594 3595 -- Variable opcional: algexact 3596 Valor por defecto: 'false' 3597 3598 El contenido de la variable 'algexact' afecta al comportamiento de 3599 'algsys' de la siguiente forma: 3600 3601 Si 'algexact' vale 'true', 'algsys' llamará siempre a 'solve' y 3602 luego utilizará 'realroots'. 3603 3604 Si 'algexact' vale 'false', 'solve' será llamada sólo si la 3605 ecuación no es univariante, o si es cuadrática o bicuadrática. 3606 3607 Sin embargo, 'algexact: true' no garantiza que únicamente se 3608 obtengan soluciones exactas, ya que aunque 'algsys' intente siempre 3609 dar soluciones exactas, dará resultados aproximados si no encuentra 3610 una solución mejor. 3611 3612 -- Función: algsys ([<expr_1>, ..., <expr_m>], [<x_1>, ..., <x_n>]) 3613 -- Función: algsys ([<eqn_1>, ..., <eqn_m>], [<x_1>, ..., <x_n>]) 3614 3615 Resuelve el sistema de ecuaciones polinómicas <expr_1>, ..., 3616 <expr_m> o las ecuaciones <eqn_1>, ..., <eqn_m> para las variables 3617 <x_1>, ..., <x_n>. La expresión <expr> equivale a la ecuación 3618 '<expr> = 0'. Puede haber más ecuaciones que variables o 3619 viceversa. 3620 3621 La función 'algsys' devuelve una lista de soluciones, cada una de 3622 las cuales consistente a su vez en una lista de ecuaciones 3623 asociando valores a las variables <x_1>, ..., <x_n> que satisfacen 3624 el sistema de ecuaciones. Si 'algsys' no puede encontrar 3625 soluciones devuelve la lista vacía '[]'. 3626 3627 Si es necesario se introducen en la solución los símbolos '%r1', 3628 '%r2', ..., para representar parámetros arbitrarios; estas 3629 variables también se añaden a la lista '%rnum_list'. 3630 3631 El proceso que se sigue es el siguiente: 3632 3633 (1) Primero se factorizan las ecuaciones y se reparten en 3634 subsistemas. 3635 3636 (2) Para cada subsistema <S_i>, se seleccionan una ecuación <E> y 3637 una variable <x>. Se elige la variable que tenga grado menor. 3638 Entonces se calcula el resultado de <E> y <E_j> respecto de <x>, 3639 siendo las <E_j> el resto de ecuaciones del subsistema <S_i>. De 3640 aquí se obtiene otro subsistema <S_i'> con una incógnita menos, ya 3641 que <x> ha sido eliminada. El proceso ahora vuelve al paso (1). 3642 3643 (3) En ocasiones se obtiene un subsistema consistente en una única 3644 ecuación. Si la ecuación es multivariante y no se han introducido 3645 aproximaciones en formato decimal de coma flotante, entonces se 3646 llama a 'solve' para tratar de encontrar una solución exacta. 3647 3648 En algunos casos, 'solve' no puede encontrar la solución, o si lo 3649 consigue puede que el resultado tenga una expresión muy grande. 3650 3651 Si la ecuación tiene una sóla incógnita y es lineal, o cuadrática o 3652 bicuadrática, entonces se llama a la función 'solve' si no se han 3653 introducido aproximaciones en formato decimal. Si se han 3654 introducido aproximaciones, o si hay más de una incógnita, o si no 3655 es lineal, ni cuadrática ni bicuadrática, y si la variables 3656 'realonly' vale 'true', entonces se llama a la función 'realroots' 3657 para calcular las soluciones reales. Si 'realonly' vale 'false', 3658 entonces se llama a 'allroots' para obtener las soluciones reales y 3659 complejas. 3660 3661 Si 'algsys' devuelve una solución que tiene menos dígitos 3662 significativos de los requeridos, el usuario puede cambiar a 3663 voluntad el valor de 'algepsilon' para obtener mayor precisión. 3664 3665 Si 'algexact' vale 'true', se llamará siempre a 'solve'. 3666 3667 Cuando 'algsys' encuentra una ecuación con múltiples incógnitas y 3668 que contiene aproximaciones en coma flotante (normalmente debido a 3669 la imposibilidad de encontrar soluciones exactas en pasos 3670 anteriores), entonces no intenta aplicar los métodos exactos a 3671 estas ecuaciones y presenta el mensaje: "'algsys' cannot solve - 3672 system too complicated." 3673 3674 Las interacciones con 'radcan' pueden dar lugar a expresiones 3675 grandes o complicadas. En tal caso, puede ser posible aislar 3676 partes del resultado con 'pickapart' o 'reveal'. 3677 3678 Ocasionalmente, 'radcan' puede introducir la unidad imaginaria '%i' 3679 en una solución que de hecho es real. 3680 3681 Ejemplos: 3682 3683 (%i1) e1: 2*x*(1 - a1) - 2*(x - 1)*a2; 3684 (%o1) 2 (1 - a1) x - 2 a2 (x - 1) 3685 (%i2) e2: a2 - a1; 3686 (%o2) a2 - a1 3687 (%i3) e3: a1*(-y - x^2 + 1); 3688 2 3689 (%o3) a1 (- y - x + 1) 3690 (%i4) e4: a2*(y - (x - 1)^2); 3691 2 3692 (%o4) a2 (y - (x - 1) ) 3693 (%i5) algsys ([e1, e2, e3, e4], [x, y, a1, a2]); 3694 (%o5) [[x = 0, y = %r1, a1 = 0, a2 = 0], 3695 3696 [x = 1, y = 0, a1 = 1, a2 = 1]] 3697 (%i6) e1: x^2 - y^2; 3698 2 2 3699 (%o6) x - y 3700 (%i7) e2: -1 - y + 2*y^2 - x + x^2; 3701 2 2 3702 (%o7) 2 y - y + x - x - 1 3703 (%i8) algsys ([e1, e2], [x, y]); 3704 1 1 3705 (%o8) [[x = - -------, y = -------], 3706 sqrt(3) sqrt(3) 3707 3708 1 1 1 1 3709 [x = -------, y = - -------], [x = - -, y = - -], [x = 1, y = 1]] 3710 sqrt(3) sqrt(3) 3 3 3711 3712 -- Función: allroots (<expr>) 3713 -- Función: allroots (<eqn>) 3714 3715 Calcula aproximaciones numéricas de las raíces reales y complejas 3716 del polinomio <expr> o ecuación polinómica <eqn> de una variable. 3717 3718 Si la variable 'polyfactor' vale 'true' hace que la función 3719 'allroots' factorice el polinomio para números reales si el 3720 polinomio es real, o para números complejos si el polinomio es 3721 complejo. 3722 3723 La función 'allroots' puede dar resultados inexactos en caso de que 3724 haya raíces múltiples. Si el polinomio es real, 'allroots 3725 (%i*<p>)') puede alcanzar mejores aproximaciones que 'allroots 3726 (<p>)', ya que 'allroots' ejecuta entonces un algoritmo diferente. 3727 3728 La función 'allroots' no opera sobre expresiones no polinómicas, 3729 pues requiere que el numerador sea reducible a un polinomio y el 3730 denominador sea, como mucho, un número complejo. 3731 3732 Para polinomios complejos se utiliza el algoritmo de Jenkins y 3733 Traub descrito en (Algorithm 419, Comm. ACM, vol. 15, (1972), p. 3734 97). Para polinomios reales se utiliza el algoritmo de Jenkins 3735 descrito en (Algorithm 493, ACM TOMS, vol. 1, (1975), p.178). 3736 3737 Ejemplos: 3738 3739 (%i1) eqn: (1 + 2*x)^3 = 13.5*(1 + x^5); 3740 3 5 3741 (%o1) (2 x + 1) = 13.5 (x + 1) 3742 (%i2) soln: allroots (eqn); 3743 (%o2) [x = .8296749902129361, x = - 1.015755543828121, 3744 3745 x = .9659625152196369 %i - .4069597231924075, 3746 3747 x = - .9659625152196369 %i - .4069597231924075, x = 1.0] 3748 (%i3) for e in soln 3749 do (e2: subst (e, eqn), disp (expand (lhs(e2) - rhs(e2)))); 3750 - 3.5527136788005E-15 3751 3752 - 5.32907051820075E-15 3753 3754 4.44089209850063E-15 %i - 4.88498130835069E-15 3755 3756 - 4.44089209850063E-15 %i - 4.88498130835069E-15 3757 3758 3.5527136788005E-15 3759 3760 (%o3) done 3761 (%i4) polyfactor: true$ 3762 (%i5) allroots (eqn); 3763 (%o5) - 13.5 (x - 1.0) (x - .8296749902129361) 3764 3765 2 3766 (x + 1.015755543828121) (x + .8139194463848151 x 3767 3768 + 1.098699797110288) 3769 3770 -- Función: bfallroots (<expr>) 3771 -- Función: bfallroots (<eqn>) 3772 Calcula aproximaciones numéricas de las raíces reales y complejas 3773 del polinomio <expr> o de la ecuación polinómica <eqn> de una 3774 variable. 3775 3776 En todos los aspectos, 'bfallroots' es idéntica a 'allroots', 3777 excepto que 'bfallroots' calcula las raíces en formato bigfloat 3778 (números decimales de precisión arbitraria). 3779 3780 Véase 'allroots' para más información. 3781 3782 -- Variable opcional: backsubst 3783 Valor por defecto: 'true' 3784 3785 Si 'backsubst' vale 'false', evita la retrosustitución en 3786 'linsolve' tras la triangularización de las ecuaciones. Esto puede 3787 ser de utilidad en problemas muy grandes, en los que la 3788 retrosustitución puede provocar la generación de expresiones 3789 extremadamente largas. 3790 3791 (%i1) eq1 : x + y + z = 6$ 3792 (%i2) eq2 : x - y + z = 2$ 3793 (%i3) eq3 : x + y - z = 0$ 3794 (%i4) backsubst : false$ 3795 (%i5) linsolve ([eq1, eq2, eq3], [x,y,z]); 3796 (%o5) [x = z - y, y = 2, z = 3] 3797 (%i6) backsubst : true$ 3798 (%i7) linsolve ([eq1, eq2, eq3], [x,y,z]); 3799 (%o7) [x = 1, y = 2, z = 3] 3800 3801 -- Variable opcional: breakup 3802 Valor por defecto: 'true' 3803 3804 Si 'breakup' vale 'true', 'solve' expresa sus soluciones a las 3805 ecuaciones cúbicas y cuárticas en términos de subexpresiones 3806 comunes, las cuales son asignadas a etiquetas del tipo '%t1', 3807 '%t2', etc. En otro caso, no se identifican subexpresiones 3808 comunes. 3809 3810 La asignación 'breakup: true' sólo tiene efecto cuando 3811 'programmode' vale 'false'. 3812 3813 Ejemplos: 3814 3815 (%i1) programmode: false$ 3816 (%i2) breakup: true$ 3817 (%i3) solve (x^3 + x^2 - 1); 3818 3819 sqrt(23) 25 1/3 3820 (%t3) (--------- + --) 3821 6 sqrt(3) 54 3822 Solution: 3823 3824 sqrt(3) %i 1 3825 ---------- - - 3826 sqrt(3) %i 1 2 2 1 3827 (%t4) x = (- ---------- - -) %t3 + -------------- - - 3828 2 2 9 %t3 3 3829 3830 sqrt(3) %i 1 3831 - ---------- - - 3832 sqrt(3) %i 1 2 2 1 3833 (%t5) x = (---------- - -) %t3 + ---------------- - - 3834 2 2 9 %t3 3 3835 3836 1 1 3837 (%t6) x = %t3 + ----- - - 3838 9 %t3 3 3839 (%o6) [%t4, %t5, %t6] 3840 (%i6) breakup: false$ 3841 (%i7) solve (x^3 + x^2 - 1); 3842 Solution: 3843 3844 sqrt(3) %i 1 3845 ---------- - - 3846 2 2 sqrt(23) 25 1/3 3847 (%t7) x = --------------------- + (--------- + --) 3848 sqrt(23) 25 1/3 6 sqrt(3) 54 3849 9 (--------- + --) 3850 6 sqrt(3) 54 3851 3852 sqrt(3) %i 1 1 3853 (- ---------- - -) - - 3854 2 2 3 3855 3856 sqrt(23) 25 1/3 sqrt(3) %i 1 3857 (%t8) x = (--------- + --) (---------- - -) 3858 6 sqrt(3) 54 2 2 3859 3860 sqrt(3) %i 1 3861 - ---------- - - 3862 2 2 1 3863 + --------------------- - - 3864 sqrt(23) 25 1/3 3 3865 9 (--------- + --) 3866 6 sqrt(3) 54 3867 3868 sqrt(23) 25 1/3 1 1 3869 (%t9) x = (--------- + --) + --------------------- - - 3870 6 sqrt(3) 54 sqrt(23) 25 1/3 3 3871 9 (--------- + --) 3872 6 sqrt(3) 54 3873 (%o9) [%t7, %t8, %t9] 3874 3875 -- Función: dimension (<eqn>) 3876 -- Función: dimension (<eqn_1>, ..., <eqn_n>) 3877 3878 El paquete 'dimen' es para análisis dimensional. La instrucción 3879 'load ("dimen")' carga el paquete y 'demo ("dimen")' presenta una 3880 pequeña demostración. 3881 3882 -- Variable opcional: dispflag 3883 Valor por defecto: 'true' 3884 3885 Si 'dispflag' vale 'false', entonces se inhibirá que Maxima muestre 3886 resultados de las funciones que resuelven ecuaciones cuando éstas 3887 son llamadas desde dentro de un bloque ('block'). Cuando un bloque 3888 termina con el signo del dólar, $, a la variable 'dispflag' se le 3889 asigna 'false'. 3890 3891 -- Función: funcsolve (<eqn>, <g>(<t>)) 3892 3893 Devuelve '[<g>(<t>) = ...]' o '[]', dependiendo de que exista o no 3894 una función racional '<g>(<t>)' que satisfaga <eqn>, la cual debe 3895 ser un polinomio de primer orden, lineal para '<g>(<t>)' y 3896 '<g>(<t>+1)' 3897 3898 (%i1) eqn: (n + 1)*f(n) - (n + 3)*f(n + 1)/(n + 1) 3899 = (n - 1)/(n + 2); 3900 (n + 3) f(n + 1) n - 1 3901 (%o1) (n + 1) f(n) - ---------------- = ----- 3902 n + 1 n + 2 3903 (%i2) funcsolve (eqn, f(n)); 3904 3905 Dependent equations eliminated: (4 3) 3906 n 3907 (%o2) f(n) = --------------- 3908 (n + 1) (n + 2) 3909 3910 Aviso: esta es una implemetación rudimentaria, por lo que debe ser 3911 utilizada con cautela. 3912 3913 -- Variable opcional: globalsolve 3914 Valor por defecto: 'false' 3915 3916 Si 'globalsolve' vale 'true', a las incógnitas de las ecuaciones se 3917 les asignan las soluciones encontradas por 'linsolve' y por 'solve' 3918 cuando se resuelven sistemas de dos o más ecuaciones lineales. 3919 3920 Si 'globalsolve' vale 'false', las soluciones encontradas por 3921 'linsolve' y por 'solve' cuando se resuelven sistemas de dos o más 3922 ecuaciones lineales se expresan como ecuaciones y a las incógnitas 3923 no se le asignan valores. 3924 3925 Cuando se resuelven ecuaciones que no son sistemas de dos o más 3926 ecuaciones lineales, 'solve' ignora el valor de 'globalsolve'. 3927 Otras funciones que resuelven ecuaciones (como 'algsys') ignoran 3928 siempre el valor de 'globalsolve'. 3929 3930 Ejemplos: 3931 3932 (%i1) globalsolve: true$ 3933 (%i2) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]); 3934 Solution 3935 3936 17 3937 (%t2) x : -- 3938 7 3939 3940 1 3941 (%t3) y : - - 3942 7 3943 (%o3) [[%t2, %t3]] 3944 (%i3) x; 3945 17 3946 (%o3) -- 3947 7 3948 (%i4) y; 3949 1 3950 (%o4) - - 3951 7 3952 (%i5) globalsolve: false$ 3953 (%i6) kill (x, y)$ 3954 (%i7) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]); 3955 Solution 3956 3957 17 3958 (%t7) x = -- 3959 7 3960 3961 1 3962 (%t8) y = - - 3963 7 3964 (%o8) [[%t7, %t8]] 3965 (%i8) x; 3966 (%o8) x 3967 (%i9) y; 3968 (%o9) y 3969 3970 -- Función: ieqn (<ie>, <unk>, <tech>, <n>, <guess>) 3971 El paquete 'inteqn' se dedica a la resolución de ecuaciones 3972 integrales. Para hacer uso de él, ejecutar la instrucción 'load 3973 ("inteqn")'. 3974 3975 El argumento <ie> es la ecuación integral; <unk> es la función 3976 incógnita; <tech> es el método a aplicar para efectuar la 3977 resolución del problema (<tech> = 'first' significa: aplica el 3978 primer método que encuentre una solución; <tech> = 'all' significa: 3979 aplica todos los métodos posibles); <n> es el número máximo de 3980 términos que debe tomar 'taylor', 'neumann', 'firstkindseries' o 3981 'fredseries' (también es el máximo nivel de recursión para el 3982 método de diferenciación); <guess> es la solución candidata inicial 3983 para 'neumann' o 'firstkindseries'. 3984 3985 Valores por defecto para los argumentos segundo a quinto son: 3986 3987 <unk>: '<p>(<x>)', donde <p> es la primera función desconocida que 3988 Maxima encuentra en el integrando y <x> es la variable que actúa 3989 como argumento en la primera aparición de <p> encontrada fuera de 3990 una integral en el caso de ecuaciones de segunda especie 3991 ('secondkind'), o es la única variable aparte de la de integración 3992 en el caso de ecuaciones de primera especie ('firstkind'). Si el 3993 intento de encontrar <x> falla, el usuario será consultado para 3994 suministrar una variable independiente. 3995 3996 -- Variable opcional: ieqnprint 3997 Valor por defecto: 'true' 3998 3999 La variable 'ieqnprint' controla el comportamiento del resultado 4000 retornado por la instrucción 'ieqn'. Si 'ieqnprint' vale 'false', 4001 la lista devuelta por la función 'ieqn' tiene el formato 4002 4003 [<solución>, <método utilizado>, <nterms>, <variable>] 4004 4005 donde <variable> estará ausente si la solución es exacta; en otro 4006 caso, será la palabra 'approximate' o 'incomplete' según que la 4007 solución sea inexacta o que no tenga forma explícita, 4008 respectivamente. Si se ha utilizado un método basado en series, 4009 <nterms> es el número de términos utilizado, que puede ser menor 4010 que el 'n' dado a 'ieqn'. 4011 4012 -- Función: lhs (<expr>) 4013 Devuelve el miembro izquierdo (es decir, el primer argumento) de la 4014 expresión <expr>, cuando el operador de <expr> es uno de los 4015 operadores de relación '< <= = # equal notequal >= >', o un 4016 operadores de asignación ':= ::= : ::', o un operador infijo 4017 binario definido por el usuario mediante 'infix'. 4018 4019 Si <expr> es un átomo o si su operador es diferente de los citados 4020 más arriba, 'lhs' devuelve <expr>. 4021 4022 Véase también 'rhs'. 4023 4024 Ejemplo: 4025 4026 (%i1) e: aa + bb = cc; 4027 (%o1) bb + aa = cc 4028 (%i2) lhs (e); 4029 (%o2) bb + aa 4030 (%i3) rhs (e); 4031 (%o3) cc 4032 (%i4) [lhs (aa < bb), lhs (aa <= bb), 4033 lhs (aa >= bb), lhs (aa > bb)]; 4034 (%o4) [aa, aa, aa, aa] 4035 (%i5) [lhs (aa = bb), lhs (aa # bb), lhs (equal (aa, bb)), 4036 lhs (notequal (aa, bb))]; 4037 (%o5) [aa, aa, aa, aa] 4038 (%i6) e1: '(foo(x) := 2*x); 4039 (%o6) foo(x) := 2 x 4040 (%i7) e2: '(bar(y) ::= 3*y); 4041 (%o7) bar(y) ::= 3 y 4042 (%i8) e3: '(x : y); 4043 (%o8) x : y 4044 (%i9) e4: '(x :: y); 4045 (%o9) x :: y 4046 (%i10) [lhs (e1), lhs (e2), lhs (e3), lhs (e4)]; 4047 (%o10) [foo(x), bar(y), x, x] 4048 (%i11) infix ("]["); 4049 (%o11) ][ 4050 (%i12) lhs (aa ][ bb); 4051 (%o12) aa 4052 4053 -- Función: linsolve ([<expr_1>, ..., <expr_m>], [<x_1>, ..., <x_n>]) 4054 Resuelve la lista de ecuaciones lineales simultáneas para la lista 4055 de variables. Las expresiones deben ser polinomios lineales 4056 respecto de las variables o ecuaciones. 4057 4058 Si 'globalsolve' vale 'true', a cada incógnita se le asigna el 4059 valor de la solución encontrada. 4060 4061 Si 'backsubst' vale 'false', 'linsolve' no hace la sustitución tras 4062 la triangulariación de las ecuaciones. Esto puede ser necesario en 4063 problemas muy grandes en los que la sustitución puede dar lugar a 4064 la generación de expresiones enormes. 4065 4066 Si 'linsolve_params' vale 'true', 'linsolve' también genera 4067 símbolos '%r' para representar parámetros arbitrarios como los 4068 descritos para la función 'algsys'. Si vale 'false', el resultado 4069 devuelto por 'linsolve' expresará, si es el sistema es 4070 indeterminado, unas variables en función de otras. 4071 4072 Si 'programmode' vale 'false', 'linsolve' muestra la solución con 4073 etiquetas de expresiones intermedias ('%t') y devuelve las lista de 4074 etiquetas. 4075 4076 (%i1) e1: x + z = y; 4077 (%o1) z + x = y 4078 (%i2) e2: 2*a*x - y = 2*a^2; 4079 2 4080 (%o2) 2 a x - y = 2 a 4081 (%i3) e3: y - 2*z = 2; 4082 (%o3) y - 2 z = 2 4083 (%i4) [globalsolve: false, programmode: true]; 4084 (%o4) [false, true] 4085 (%i5) linsolve ([e1, e2, e3], [x, y, z]); 4086 (%o5) [x = a + 1, y = 2 a, z = a - 1] 4087 (%i6) [globalsolve: false, programmode: false]; 4088 (%o6) [false, false] 4089 (%i7) linsolve ([e1, e2, e3], [x, y, z]); 4090 Solution 4091 4092 (%t7) z = a - 1 4093 4094 (%t8) y = 2 a 4095 4096 (%t9) x = a + 1 4097 (%o9) [%t7, %t8, %t9] 4098 (%i9) ''%; 4099 (%o9) [z = a - 1, y = 2 a, x = a + 1] 4100 (%i10) [globalsolve: true, programmode: false]; 4101 (%o10) [true, false] 4102 (%i11) linsolve ([e1, e2, e3], [x, y, z]); 4103 Solution 4104 4105 (%t11) z : a - 1 4106 4107 (%t12) y : 2 a 4108 4109 (%t13) x : a + 1 4110 (%o13) [%t11, %t12, %t13] 4111 (%i13) ''%; 4112 (%o13) [z : a - 1, y : 2 a, x : a + 1] 4113 (%i14) [x, y, z]; 4114 (%o14) [a + 1, 2 a, a - 1] 4115 (%i15) [globalsolve: true, programmode: true]; 4116 (%o15) [true, true] 4117 (%i16) linsolve ([e1, e2, e3], '[x, y, z]); 4118 (%o16) [x : a + 1, y : 2 a, z : a - 1] 4119 (%i17) [x, y, z]; 4120 (%o17) [a + 1, 2 a, a - 1] 4121 4122 -- Variable opcional: linsolvewarn 4123 Valor por defecto: 'true' 4124 4125 Si 'linsolvewarn' vale 'true', 'linsolve' mostrará el mensaje: 4126 "Dependent equations eliminated". 4127 4128 -- Variable opcional: linsolve_params 4129 Valor por defecto: 'true' 4130 4131 Si 'linsolve_params' vale 'true', 'linsolve' también genera 4132 símbolos '%r' para representar parámetros arbitrarios como los 4133 descritos para la función 'algsys'. Si vale 'false', el resultado 4134 devuelto por 'linsolve' expresará, si es el sistema es 4135 indeterminado, unas variables en función de otras. 4136 4137 -- System variable: multiplicities 4138 Valor por defecto: 'not_set_yet' 4139 4140 La variable 'multiplicities' es una con las multiplicidades de las 4141 soluciones encontradas por 'solve' o 'realroots'. 4142 4143 -- Función: nroots (<p>, <low>, <high>) 4144 Devuelve el número de raíces reales del polinomio real univariante 4145 <p> en el intervalo semiabierto '(<low>, <high>]'. Los extremos 4146 del intervalo pueden ser 'minf' o 'inf', menos y más infinito. 4147 4148 La función 'nroots' utiliza el método de las secuencias de Sturm. 4149 4150 (%i1) p: x^10 - 2*x^4 + 1/2$ 4151 (%i2) nroots (p, -6, 9.1); 4152 (%o2) 4 4153 4154 -- Función: nthroot (<p>, <n>) 4155 4156 Siendo 'p' un polinomio de coeficientes enteros y 'n' un entero 4157 positivo, 'nthroot' devuelve un polinomio 'q', también de 4158 coeficientes enteros, tal que 'q^n=p', o un mensaje de error 4159 indicando que 'p' no es una 'n'-potencia exacta. Esta función es 4160 bastante más rápida que 'factor' y que 'sqfr'. 4161 4162 -- Variable opcional: polyfactor 4163 Valor por defecto: 'false' 4164 4165 Cuando 'polyfactor' vale 'true', las funciones 'allroots' y 4166 'bfallroots' factorizan el polinomio sobre los números reales si el 4167 polinomio es real, o factoriza sobre los complejos si el polinomio 4168 es complejo. 4169 4170 Véase un ejemplo en 'allroots'. 4171 4172 -- Variable opcional: programmode 4173 Valor por defecto: 'true' 4174 4175 Si 'programmode' vale 'true', 'solve', 'realroots', 'allroots' y 4176 'linsolve' devuelve sus soluciones como elementos de una lista. 4177 4178 Si 'programmode' vale 'false', 'solve' y las demás crean 4179 expresiones intermedias etiquetadas '%t1', 't2', etc., y les asinan 4180 las soluciones. 4181 4182 (%i1) solve(x^2+x+1); 4183 sqrt(3) %i + 1 sqrt(3) %i - 1 4184 (%o1) [x = - --------------, x = --------------] 4185 2 2 4186 (%i2) programmode:false$ 4187 (%i3) solve(x^2+x+1); 4188 Solution: 4189 4190 sqrt(3) %i + 1 4191 (%t3) x = - -------------- 4192 2 4193 4194 sqrt(3) %i - 1 4195 (%t4) x = -------------- 4196 2 4197 (%o4) [%t4, %t5] 4198 4199 -- Variable opcional: realonly 4200 Valor por defecto: 'false' 4201 4202 Si 'realonly' vale 'true', 'algsys' sólo devuelve aquellas 4203 soluciones exentas de la constante '%i'. 4204 4205 -- Función: realroots (<expr>, <bound>) 4206 -- Función: realroots (<eqn>, <bound>) 4207 -- Función: realroots (<expr>) 4208 -- Función: realroots (<eqn>) 4209 Calcula aproximaciones racionales de las raíces reales del 4210 polinomio <expr> o de la ecuación polinómica <eqn> de una variable, 4211 dentro de la tolerancia especificada por <bound>. Los coeficientes 4212 de <expr> o de <eqn> deben ser números literales, por lo que las 4213 constantes simbólicas como '%pi' no son aceptadas. 4214 4215 La función 'realroots' guarda las multiplicidades de las raíces 4216 encontradas en la variable global 'multiplicities'. 4217 4218 La función 'realroots' genera una secuencia de Sturm para acotar 4219 cada raíz, aplicando después el método de bisección para afinar las 4220 aproximaciones. Todos los coeficientes se convierten a formas 4221 racionales equivalentes antes de comenzar la búsqueda de las 4222 raíces, de modo que los cálculos se realizan con aritmética exacta 4223 racional. Incluso en el caso de que algunos coeficientes sean 4224 números decimales en coma flotante, los resultados son racionales, 4225 a menos que se les fuerce a ser decimales con las variables 'float' 4226 o 'numer'. 4227 4228 Si <bound> es menor que la unidad, todas las raíces enteras se 4229 expresan en forma exacta. Si no se especifica <bound>, se le 4230 supone igual al valor de la variable global 'rootsepsilon'. 4231 4232 Si la variable global 'programmode' vale 'true', la función 4233 'realroots' devuelve una lista de la forma '[x = <x_1>, x = <x_2>, 4234 ...]'. Si 'programmode' vale 'false', 'realroots' crea etiquetas 4235 '%t1', '%t2', ... para las expresiones intermedias, les asigna 4236 valores y, finalmente, devuelve la lista de etiquetas. 4237 4238 Ejemplos: 4239 4240 (%i1) realroots (-1 - x + x^5, 5e-6); 4241 612003 4242 (%o1) [x = ------] 4243 524288 4244 (%i2) ev (%[1], float); 4245 (%o2) x = 1.167303085327148 4246 (%i3) ev (-1 - x + x^5, %); 4247 (%o3) - 7.396496210176905E-6 4248 4249 (%i1) realroots (expand ((1 - x)^5 * (2 - x)^3 * (3 - x)), 1e-20); 4250 (%o1) [x = 1, x = 2, x = 3] 4251 (%i2) multiplicities; 4252 (%o2) [5, 3, 1] 4253 4254 -- Función: rhs (<expr>) 4255 Devuelve el miembro derecho (es decir, el segundo argumento) de la 4256 expresión <expr>, cuando el operador de <expr> es uno de los 4257 operadores de relación '< <= = # equal notequal >= >', o un 4258 operadores de asignación ':= ::= : ::', o un operador infijo 4259 binario definido por el usuario mediante 'infix'. 4260 4261 Si <expr> es un átomo o si su operador es diferente de los citados 4262 más arriba, 'rhs' devuelve <expr>. 4263 4264 Véase también 'lhs'. 4265 4266 Ejemplo: 4267 4268 (%i1) e: aa + bb = cc; 4269 (%o1) bb + aa = cc 4270 (%i2) lhs (e); 4271 (%o2) bb + aa 4272 (%i3) rhs (e); 4273 (%o3) cc 4274 (%i4) [rhs (aa < bb), rhs (aa <= bb), 4275 rhs (aa >= bb), rhs (aa > bb)]; 4276 (%o4) [bb, bb, bb, bb] 4277 (%i5) [rhs (aa = bb), rhs (aa # bb), rhs (equal (aa, bb)), 4278 rhs (notequal (aa, bb))]; 4279 (%o5) [bb, bb, bb, bb] 4280 (%i6) e1: '(foo(x) := 2*x); 4281 (%o6) foo(x) := 2 x 4282 (%i7) e2: '(bar(y) ::= 3*y); 4283 (%o7) bar(y) ::= 3 y 4284 (%i8) e3: '(x : y); 4285 (%o8) x : y 4286 (%i9) e4: '(x :: y); 4287 (%o9) x :: y 4288 (%i10) [rhs (e1), rhs (e2), rhs (e3), rhs (e4)]; 4289 (%o10) [2 x, 3 y, y, y] 4290 (%i11) infix ("]["); 4291 (%o11) ][ 4292 (%i12) rhs (aa ][ bb); 4293 (%o12) bb 4294 4295 -- Variable opcional: rootsconmode 4296 Valor por defecto: 'true' 4297 4298 La variable 'rootsconmode' controla el comportamiento de la 4299 instrucción 'rootscontract'. Véase 'rootscontract' para más 4300 detalles. 4301 4302 -- Función: rootscontract (<expr>) 4303 Convierte productos de raíces en raíces de productos. Por ejemplo, 4304 'rootscontract (sqrt(x)*y^(3/2))' devuelve 'sqrt(x*y^3)'. 4305 4306 Si 'radexpand' vale 'true' y 'domain' vale 'real', 'rootscontract' 4307 convierte 'abs' en 'sqrt', por ejemplo, 'rootscontract 4308 (abs(x)*sqrt(y))' devuelve 'sqrt(x^2*y)'. 4309 4310 La opción 'rootsconmode' afecta el resultado de 'rootscontract' 4311 como sigue: 4312 4313 Problema Valor de Resultadod de 4314 rootsconmode rootscontract 4315 4316 x^(1/2)*y^(3/2) false (x*y^3)^(1/2) 4317 x^(1/2)*y^(1/4) false x^(1/2)*y^(1/4) 4318 x^(1/2)*y^(1/4) true (x*y^(1/2))^(1/2) 4319 x^(1/2)*y^(1/3) true x^(1/2)*y^(1/3) 4320 x^(1/2)*y^(1/4) all (x^2*y)^(1/4) 4321 x^(1/2)*y^(1/3) all (x^3*y^2)^(1/6) 4322 4323 Si 'rootsconmode' vale 'false', 'rootscontract' contrae sólamente 4324 respecto de exponentes racionales cuyos denominadores sean iguales. 4325 La clave para los ejemplos 'rootsconmode: true' es simplemente que 4326 2 divide a 4 pero no a 3. La asignación 'rootsconmode: all' hace 4327 que se calcule el mínimo común múltiplo de los denominadores de los 4328 exponentes. 4329 4330 La función 'rootscontract' utiliza 'ratsimp' de forma similar a 4331 como lo hace 'logcontract'. 4332 4333 Ejemplos: 4334 4335 (%i1) rootsconmode: false$ 4336 (%i2) rootscontract (x^(1/2)*y^(3/2)); 4337 3 4338 (%o2) sqrt(x y ) 4339 (%i3) rootscontract (x^(1/2)*y^(1/4)); 4340 1/4 4341 (%o3) sqrt(x) y 4342 (%i4) rootsconmode: true$ 4343 (%i5) rootscontract (x^(1/2)*y^(1/4)); 4344 (%o5) sqrt(x sqrt(y)) 4345 (%i6) rootscontract (x^(1/2)*y^(1/3)); 4346 1/3 4347 (%o6) sqrt(x) y 4348 (%i7) rootsconmode: all$ 4349 (%i8) rootscontract (x^(1/2)*y^(1/4)); 4350 2 1/4 4351 (%o8) (x y) 4352 (%i9) rootscontract (x^(1/2)*y^(1/3)); 4353 3 2 1/6 4354 (%o9) (x y ) 4355 (%i10) rootsconmode: false$ 4356 (%i11) rootscontract (sqrt(sqrt(x) + sqrt(1 + x)) 4357 *sqrt(sqrt(1 + x) - sqrt(x))); 4358 (%o11) 1 4359 (%i12) rootsconmode: true$ 4360 (%i13) rootscontract (sqrt(5 + sqrt(5)) - 5^(1/4)*sqrt(1 + sqrt(5))); 4361 (%o13) 0 4362 4363 -- Variable opcional: rootsepsilon 4364 Valor por defecto: 1.0e-7 4365 4366 La variable 'rootsepsilon' es la tolerancia que establece el 4367 intervalo de confianza para las raíces calculadas por la función 4368 'realroots'. 4369 4370 -- Función: solve (<expr>, <x>) 4371 -- Función: solve (<expr>) 4372 -- Función: solve ([<eqn_1>, ..., <eqn_n>], [<x_1>, ..., <x_n>]) 4373 4374 Resuelve la ecuación algebraica <expr> de incógnita <x> y devuelve 4375 una lista de igualdades con la <x> despejada. Si <expr> no es una 4376 igualdad, se supone que se quiere resolver la ecuación '<expr> = 4377 0'. El argumento <x> puede ser una función (por ejemplo, 'f(x)'), 4378 u otra expresión no atómica, excepto una suma o producto. Puede 4379 omitirse <x> si <expr> contiene solamente una variable. El 4380 argumento <expr> puede ser una expresión racional y puede contener 4381 funciones trigonométricas, exponenciales, etc. 4382 4383 Se utiliza el siguiente método de resolución: 4384 4385 Sea <E> la expresión y <X> la incógnita. Si <E> es lineal respecto 4386 de <X> entonces <X> se resuelve de forma trivial. En caso 4387 contrario, si <E> es de la forma 'A*X^N + B' entonces el resultado 4388 es '(-B/A)^1/N)' multiplicado por las 'N'-ésimas raíces de la 4389 unidad. 4390 4391 Si <E> no es lineal respecto de <X> entonces el máximo común 4392 divisor de los exponentes de <X> en <E> (supóngase que es <N>) se 4393 divide entre los exponentes y la multiplicidad de las raíces se 4394 multiplica por <N>. Entonces es llamado recursivamente 'solve' 4395 para este resultado. Si <E> es factorizable entonces 'solve' es 4396 invocado para cada uno de los factores. Finalmente, 'solve' usará, 4397 según sea necesario, las fórmulas cuadrática, cúbica o cuártica. 4398 4399 En caso de que <E> sea un polinomio respecto de una función de la 4400 incógnita, por ejemplo 'F(X)', entonces se calcula primero para 4401 'F(X)' (sea <C> el resultado obtenido), entonces la ecuación 4402 'F(X)=C' se resuelve para <X> en el supuesto que se conozca la 4403 inversa de la función <F>. 4404 4405 Si la variable 'breakup' vale 'false' hará que 'solve' muestre las 4406 soluciones de las ecuaciones cúbicas o cuárticas como expresiones 4407 únicas, en lugar de utilizar varias subexpresiones comunes, que es 4408 el formato por defecto. 4409 4410 A la variable 'multiplicities' se le asignará una lista con las 4411 multiplicidades de las soluciones individuales devueltas por 4412 'solve', 'realroots' o 'allroots'. La instrucción 'apropos 4413 (solve)' hará que se muestren las variables optativas que de algún 4414 modo afectan al comportamiento de 'solve'. Se podrá luego utilizar 4415 la función 'describe' para aquellas variables cuyo objeto no esté 4416 claro. 4417 4418 La llamada 'solve ([<eqn_1>, ..., <eqn_n>], [<x_1>, ..., <x_n>])' 4419 resuelve un sistema de ecuaciones polinómicas simultáneas (lineales 4420 o no) llamando a 'linsolve' o 'algsys' y devuelve una lista de 4421 listas con soluciones para las incógnitas. En caso de haberse 4422 llamado a 'linsolve' esta lista contendrá una única lista de 4423 soluciones. La llamada a 'solve' tiene dos listas como argumentos. 4424 La primera lista tiene las ecuaciones a resolver y la segunda son 4425 las incógnitas cuyos valores se quieren calcular. Si el número de 4426 variables en las ecuaciones es igual al número de incógnitas, el 4427 segundo argumento puede omitirse. 4428 4429 Si 'programmode' vale 'false', 'solve' muestra la solución con 4430 etiquetas de expresiones intermedias ('%t') y devuelve las lista de 4431 etiquetas. 4432 4433 Si 'globalsolve' vale 'true' y el problema consiste en resolver un 4434 sistema de dos o más ecuaciones lineales, a cada incógnita se le 4435 asigna el valor encontrado en la resolución del sistema. 4436 4437 Ejemplos: 4438 (%i1) solve (asin (cos (3*x))*(f(x) - 1), x); 4439 4440 SOLVE is using arc-trig functions to get a solution. 4441 Some solutions will be lost. 4442 %pi 4443 (%o1) [x = ---, f(x) = 1] 4444 6 4445 (%i2) ev (solve (5^f(x) = 125, f(x)), solveradcan); 4446 log(125) 4447 (%o2) [f(x) = --------] 4448 log(5) 4449 (%i3) [4*x^2 - y^2 = 12, x*y - x = 2]; 4450 2 2 4451 (%o3) [4 x - y = 12, x y - x = 2] 4452 (%i4) solve (%, [x, y]); 4453 (%o4) [[x = 2, y = 2], [x = .5202594388652008 %i 4454 4455 - .1331240357358706, y = .0767837852378778 4456 4457 - 3.608003221870287 %i], [x = - .5202594388652008 %i 4458 4459 - .1331240357358706, y = 3.608003221870287 %i 4460 4461 + .0767837852378778], [x = - 1.733751846381093, 4462 4463 y = - .1535675710019696]] 4464 (%i5) solve (1 + a*x + x^3, x); 4465 3 4466 sqrt(3) %i 1 sqrt(4 a + 27) 1 1/3 4467 (%o5) [x = (- ---------- - -) (--------------- - -) 4468 2 2 6 sqrt(3) 2 4469 4470 sqrt(3) %i 1 4471 (---------- - -) a 4472 2 2 4473 - --------------------------, x = 4474 3 4475 sqrt(4 a + 27) 1 1/3 4476 3 (--------------- - -) 4477 6 sqrt(3) 2 4478 4479 3 4480 sqrt(3) %i 1 sqrt(4 a + 27) 1 1/3 4481 (---------- - -) (--------------- - -) 4482 2 2 6 sqrt(3) 2 4483 4484 sqrt(3) %i 1 4485 (- ---------- - -) a 4486 2 2 4487 - --------------------------, x = 4488 3 4489 sqrt(4 a + 27) 1 1/3 4490 3 (--------------- - -) 4491 6 sqrt(3) 2 4492 4493 3 4494 sqrt(4 a + 27) 1 1/3 a 4495 (--------------- - -) - --------------------------] 4496 6 sqrt(3) 2 3 4497 sqrt(4 a + 27) 1 1/3 4498 3 (--------------- - -) 4499 6 sqrt(3) 2 4500 (%i6) solve (x^3 - 1); 4501 sqrt(3) %i - 1 sqrt(3) %i + 1 4502 (%o6) [x = --------------, x = - --------------, x = 1] 4503 2 2 4504 (%i7) solve (x^6 - 1); 4505 sqrt(3) %i + 1 sqrt(3) %i - 1 4506 (%o7) [x = --------------, x = --------------, x = - 1, 4507 2 2 4508 4509 sqrt(3) %i + 1 sqrt(3) %i - 1 4510 x = - --------------, x = - --------------, x = 1] 4511 2 2 4512 (%i8) ev (x^6 - 1, %[1]); 4513 6 4514 (sqrt(3) %i + 1) 4515 (%o8) ----------------- - 1 4516 64 4517 (%i9) expand (%); 4518 (%o9) 0 4519 (%i10) x^2 - 1; 4520 2 4521 (%o10) x - 1 4522 (%i11) solve (%, x); 4523 (%o11) [x = - 1, x = 1] 4524 (%i12) ev (%th(2), %[1]); 4525 (%o12) 0 4526 4527 Los í '%r' se utilizan para indicar parámetros en las soluciones. 4528 4529 (%i1) solve([x+y=1,2*x+2*y=2],[x,y]); 4530 4531 solve: dependent equations eliminated: (2) 4532 (%o1) [[x = 1 - %r1, y = %r1]] 4533 4534 Véanse 'algsys' y '%rnum_list' para más información. 4535 4536 -- Variable opcional: solvedecomposes 4537 Valor por defecto: 'true' 4538 4539 Si 'solvedecomposes' vale 'true', 'solve' llama a 'polydecomp' en 4540 caso de que se le pida resolver ecuaciones polinómicas. 4541 4542 -- Variable opcional: solveexplicit 4543 Valor por defecto: 'false' 4544 4545 Si 'solveexplicit' vale 'true', le inhibe a 'solve' devolver 4546 soluciones implícitas, esto es, soluciones de la forma 'F(x) = 0', 4547 donde 'F' es cierta función. 4548 4549 -- Variable opcional: solvefactors 4550 Valor por defecto: 'true' 4551 4552 Si 'solvefactors' vale 'false', 'solve' no intenta factorizar la 4553 expresión. Este valor 'false' puede ser útil en algunos casos en 4554 los que la factorización no es necesaria. 4555 4556 -- Variable opcional: solvenullwarn 4557 Valor por defecto: 'true' 4558 4559 Si 'solvenullwarn' vale 'true', 'solve' muestra un mensaje de aviso 4560 si es llamado con una lista de ecuaciones vacía o con una lista de 4561 incógnitas vacía. Por ejemplo, 'solve ([], [])' imprimirá dos 4562 mensajes de aviso y devolverá '[]'. 4563 4564 -- Variable opcional: solveradcan 4565 Valor por defecto: 'false' 4566 4567 Si 'solveradcan' vale 'true', 'solve' llama a 'radcan', lo que hará 4568 que 'solve' se ejecute de forma más lenta, pero permitirá que se 4569 resuelvan ciertas ecuaciones que contengan exponenciales y 4570 logaritmos. 4571 4572 -- Variable opcional: solvetrigwarn 4573 Valor por defecto: 'true' 4574 4575 Si 'solvetrigwarn' vale 'true', 'solve' puede presentar un mensaje 4576 diciendo que está utilizando funciones trigonométricas inversas 4577 para resolver la ecuación, y que por lo tanto puede estar ignorando 4578 algunas soluciones. 4579 4580 4581File: maxima.info, Node: Ecuaciones Diferenciales, Next: Métodos numéricos, Prev: Ecuaciones, Up: Top 4582 458321 Ecuaciones Diferenciales 4584*************************** 4585 4586* Menu: 4587 4588* Introducción a las ecuaciones diferenciales:: 4589* Funciones y variables para ecuaciones diferenciales:: 4590 4591 4592File: maxima.info, Node: Introducción a las ecuaciones diferenciales, Next: Funciones y variables para ecuaciones diferenciales, Prev: Ecuaciones Diferenciales, Up: Ecuaciones Diferenciales 4593 459421.1 Introducción a las ecuaciones diferenciales 4595================================================ 4596 4597Esta sección describe las funciones disponibles en Maxima para el 4598cálculo de las soluciones analíticas de ciertos tipos de ecuaciones de 4599primer y segundo orden. Para las soluciones numéricas de sistemas de 4600ecuaciones diferenciales, véase el paquete adicional 'dynamics'. Para 4601las representaciones gráficas en el espacio de fases, véase el paquete 4602'plotdf'. 4603 4604 4605File: maxima.info, Node: Funciones y variables para ecuaciones diferenciales, Prev: Introducción a las ecuaciones diferenciales, Up: Ecuaciones Diferenciales 4606 460721.2 Funciones y variables para ecuaciones diferenciales. 4608========================================================= 4609 4610 -- Función: bc2 (<soluc>, <xval1>, <yval1>, <xval2>, <yval2>) 4611 Resuelve el problema del valor en la frontera para ecuaciones 4612 diferenciales de segundo orden. Aquí, <soluc> es una solución 4613 general de la ecuación, como las que calcula 'ode2', <xval1> 4614 especifica el valor de la variable independiente en el primer punto 4615 mediante una expresión de la forma '<x> = <x0>', mientras que 4616 <yval1> hace lo propio para la variable dependiente. Las 4617 expresiones <xval2> y <yval2> dan los valores de estas mismas 4618 variables en un segundo punto, utilizando el mismo formato. 4619 4620 -- Función: desolve (<ecu>, <x>) 4621 -- Función: desolve ([<eqn_1>, ..., <eqn_n>], [<x_1>, ..., <x_n>]) 4622 4623 La función 'desolve' resuelve sistemas de ecuaciones diferenciales 4624 ordinarias lineales utilizando la transformada de Laplace. Aquí 4625 las <eqi> ('i'=1,..,n) son ecuaciones diferenciales con variables 4626 dependientes <x_1>, ..., <x_n>. La dependencia funcional de <x_1>, 4627 ..., <x_n> respecto de una variable independiente, por ejemplo <x>, 4628 debe indicarse explícitamente, tanto en las variables como en las 4629 derivadas. Por ejemplo, 4630 4631 eqn_1: 'diff(f,x,2) = sin(x) + 'diff(g,x); 4632 eqn_2: 'diff(f,x) + x^2 - f = 2*'diff(g,x,2); 4633 4634 no es el formato apropiado. El método correcto es 4635 4636 eqn_1: 'diff(f(x),x,2) = sin(x) + 'diff(g(x),x); 4637 eqn_2: 'diff(f(x),x) + x^2 - f(x) = 2*'diff(g(x),x,2); 4638 4639 La llamada a la función 'desolve' sería entonces 4640 desolve([eqn_1, eqn_2], [f(x),g(x)]); 4641 4642 Si las condiciones iniciales en 'x=0' son conocidas, deben ser 4643 suministradas antes de llamar a 'desolve' haciendo uso previo de la 4644 función 'atvalue', 4645 4646 (%i1) 'diff(f(x),x)='diff(g(x),x)+sin(x); 4647 d d 4648 (%o1) -- (f(x)) = -- (g(x)) + sin(x) 4649 dx dx 4650 (%i2) 'diff(g(x),x,2)='diff(f(x),x)-cos(x); 4651 2 4652 d d 4653 (%o2) --- (g(x)) = -- (f(x)) - cos(x) 4654 2 dx 4655 dx 4656 (%i3) atvalue('diff(g(x),x),x=0,a); 4657 (%o3) a 4658 (%i4) atvalue(f(x),x=0,1); 4659 (%o4) 1 4660 (%i5) desolve([%o1,%o2],[f(x),g(x)]); 4661 x 4662 (%o5) [f(x) = a %e - a + 1, g(x) = 4663 4664 x 4665 cos(x) + a %e - a + g(0) - 1] 4666 (%i6) [%o1,%o2],%o5,diff; 4667 x x x x 4668 (%o6) [a %e = a %e , a %e - cos(x) = a %e - cos(x)] 4669 4670 4671 Si 'desolve' no encuentra una solución, entonces devuelve 'false'. 4672 4673 -- Función: ic1 (<soluc>, <xval>, <yval>) 4674 4675 Resuelve el problema del valor inicial en ecuaciones diferenciales 4676 de primer orden. Aquí, <soluc> es una solución general de la 4677 ecuación, como las que calcula 'ode2', <xval> es una ecuación de la 4678 forma '<x> = <x0>' para la variable independiente y <yval> es una 4679 ecuación de la forma '<y> = <y0>' para la variable dependiente. 4680 Véase 'ode2' para un ejemplo sobre su utilización. 4681 4682 -- Función: ic2 (<soluc>, <xval>, <yval>, <dval>) 4683 4684 Resuelve el problema del valor inicial en ecuaciones diferenciales 4685 de segundo orden. Aquí, <soluc> es una solución general de la 4686 ecuación, como las que calcula 'ode2', <xval> es una ecuación de la 4687 forma '<x> = <x0>' para la variable independiente y <yval> es una 4688 ecuación de la forma '<y> = <y0>' para la variable dependiente, 4689 siendo <dval> una expresión de la forma 'diff(<y>,<x>) = <dy0>' que 4690 especifica la primera derivada de la variable dependiente respecto 4691 de la independiente en el punto <xval>. 4692 4693 Véase 'ode2' para un ejemplo de su uso. 4694 4695 -- Función: ode2 (<ecu>, <dvar>, <ivar>) 4696 La función 'ode2' resuelve ecuaciones diferenciales ordinarias de 4697 primer y segundo orden. Admite tres argumentos: una ecuación 4698 diferencial ordinaria <ecu>, la variable dependiente <dvar> y la 4699 variable independiente <ivar>. Si ha tenido éxito en la resolución 4700 de la ecuación, devuelve una solución, explícita o implícita, para 4701 la variable dependiente. El símbolo '%c' se utiliza para 4702 representar la constante en el caso de ecuaciones de primer orden y 4703 los símbolos '%k1' y '%k2' son las constantes de las ecuaciones de 4704 segundo orden. Si por cualquier razón 'ode2' no puede calcular la 4705 solución, devolverá 'false', acompañado quizás de un mensaje de 4706 error. Los métodos utilizados para las ecuaciones de primer orden, 4707 en el orden en que se hace la tentativa de resolución son: lineal, 4708 separable, exacto (pudiendo solicitar en este caso un factor de 4709 integración), homogéneo, ecuación de Bernoulli y un método 4710 homogéneo generalizado. Para las ecuaciones de segundo orden: 4711 coeficiente constante, exacto, homogéneo lineal con coeficientes no 4712 constantes que pueden ser transformados en coeficientes constantes, 4713 ecuación equidimensional o de Euler, método de variación de 4714 parámetros y ecuaciones exentas de las variables dependientes o 4715 independientes de manera que se puedan reducir a dos ecuaciones 4716 lineales de primer a ser resueltas secuencialmente. Durante el 4717 proceso de resolución de ecuaciones diferenciales ordinarias, 4718 ciertas variables se utilizan con el único propósito de suministrar 4719 información al usuario: 'method' almacena el método utilizado para 4720 encontrar la solución (como por ejemplo 'linear'), 'intfactor' para 4721 el factor de integración que se haya podido utilizar, 'odeindex' 4722 para el índice del método de Bernoulli o el homogéneo generalizado 4723 y 'yp' para la solución particular del método de variación de 4724 parámetros. 4725 4726 A fin de resolver problemas con valores iniciales y problemas con 4727 valores en la frontera, la función 'ic1' está disponible para 4728 ecuaciones de primer orden y las funciones 'ic2' y 'bc2' para 4729 problemas de valores iniciales y de frontera, respectivamente, en 4730 el caso de las ecuaciones de segundo orden. 4731 4732 Ejemplo: 4733 4734 (%i1) x^2*'diff(y,x) + 3*y*x = sin(x)/x; 4735 2 dy sin(x) 4736 (%o1) x -- + 3 x y = ------ 4737 dx x 4738 (%i2) ode2(%,y,x); 4739 %c - cos(x) 4740 (%o2) y = ----------- 4741 3 4742 x 4743 (%i3) ic1(%o2,x=%pi,y=0); 4744 cos(x) + 1 4745 (%o3) y = - ---------- 4746 3 4747 x 4748 (%i4) 'diff(y,x,2) + y*'diff(y,x)^3 = 0; 4749 2 4750 d y dy 3 4751 (%o4) --- + y (--) = 0 4752 2 dx 4753 dx 4754 (%i5) ode2(%,y,x); 4755 3 4756 y + 6 %k1 y 4757 (%o5) ------------ = x + %k2 4758 6 4759 (%i6) ratsimp(ic2(%o5,x=0,y=0,'diff(y,x)=2)); 4760 3 4761 2 y - 3 y 4762 (%o6) - ---------- = x 4763 6 4764 (%i7) bc2(%o5,x=0,y=1,x=1,y=3); 4765 3 4766 y - 10 y 3 4767 (%o7) --------- = x - - 4768 6 2 4769 4770 4771 4772File: maxima.info, Node: Métodos numéricos, Next: Matrices y Álgebra Lineal, Prev: Ecuaciones Diferenciales, Up: Top 4773 477422 Métodos numéricos 4775******************** 4776 4777* Menu: 4778 4779* Introducción a la transformada rápida de Fourier:: 4780* Funciones y variables para la transformada rápida de Fourier:: 4781* Funciones para la resolución numérica de ecuaciones:: 4782* Introducción a la resolución numérica de ecuaciones diferenciales:: 4783* Funciones para la resolución numérica de ecuaciones diferenciales:: 4784 4785 4786File: maxima.info, Node: Introducción a la transformada rápida de Fourier, Next: Funciones y variables para la transformada rápida de Fourier, Prev: Métodos numéricos, Up: Métodos numéricos 4787 478822.1 Introducción a la transformada rápida de Fourier 4789===================================================== 4790 4791El paquete 'fft' contiene funciones para el cálculo numérico (no 4792simbólico) de la transformada rápida de Fourier. 4793 4794 4795File: maxima.info, Node: Funciones y variables para la transformada rápida de Fourier, Next: Funciones para la resolución numérica de ecuaciones, Prev: Introducción a la transformada rápida de Fourier, Up: Métodos numéricos 4796 479722.2 Funciones y variables para la transformada rápida de Fourier 4798================================================================= 4799 4800 -- Función: polartorect (<magnitude_array>, <phase_array>) 4801 4802 Transforma valores complejos de la forma 'r %e^(%i t)' a la forma 4803 'a + b %i', siendo <r> el módulo y <t> la fase. Ambos valores <r> 4804 y <t> son arrays unidimensionales cuyos tamños son iguales a la 4805 misma potencia de dos. 4806 4807 Los valores originales de los arrays de entrada son reemplazados 4808 por las partes real e imaginaria, 'a' y 'b', de los 4809 correspondientes números complejos. El resultado se calcula como 4810 4811 a = r cos(t) 4812 b = r sin(t) 4813 4814 'polartorect' es la función inversa de 'recttopolar'. 4815 4816 Para utilizar esta función ejecútese antes 'load(fft)'. Véase 4817 también 'fft'. 4818 4819 -- Función: recttopolar (<real_array>, <imaginary_array>) 4820 4821 Transforma valores complejos de la forma 'a + b %i' a la forma 'r 4822 %e^(%i t)', siendo <a> la parte real y <a> la imaginaria. Ambos 4823 valores <a> y <b> son arrays unidimensionales cuyos tamños son 4824 iguales a la misma potencia de dos. 4825 4826 Los valores originales de los arrays de entrada son reemplazados 4827 por los módulos y las fases, 'r' y 't', de los correspondientes 4828 números complejos. El resultado se calcula como 4829 4830 r = sqrt(a^2 + b^2) 4831 t = atan2(b, a) 4832 4833 El ángulo calculado pertence al rango de '-%pi' a '%pi'. 4834 4835 'recttopolar' es la función inversa de 'polartorect'. 4836 4837 Para utilizar esta función ejecútese antes 'load(fft)'. Véase 4838 también 'fft'. 4839 4840 -- Función: inverse_fft (<y>) 4841 4842 Calcula la transformada inversa rápida de Fourier. 4843 4844 <y> es una lista o array (declarado o no) que contiene los datos a 4845 transformar. El número de elementos debe ser una potencia de dos. 4846 Los elementos deben ser números literales (enteros, racionales, de 4847 punto flotante o decimales grandes), constantes simbólicas, 4848 expresiones del tipo 'a + b*%i', siendo 'a' y 'b' números 4849 literales, o constantes simbólicas. 4850 4851 La función 'inverse_fft' devuelve un nuevo objeto del mismo tipo 4852 que <y>, el cual no se ve modificado. Los resultados se calculan 4853 siempre como decimales o expresiones 'a + b*%i', siendo 'a' y 'b' 4854 decimales. 4855 4856 La transformada inversa discreta de Fourier se define como se 4857 indica a continuación. Si 'x' es el resultado de la transformada 4858 inversa, entonces para 'j' entre 0 y 'n - 1' se tiene 4859 4860 x[j] = sum(y[k] exp(-2 %i %pi j k / n), k, 0, n - 1) 4861 4862 Para utilizar esta función ejecútese antes 'load(fft)'. 4863 4864 Véanse también 'fft' (transformada directa), 'recttopolar' y 4865 'polartorect'. 4866 4867 Ejemplos: 4868 4869 Datos reales. 4870 4871 (%i1) load (fft) $ 4872 (%i2) fpprintprec : 4 $ 4873 (%i3) L : [1, 2, 3, 4, -1, -2, -3, -4] $ 4874 (%i4) L1 : inverse_fft (L); 4875 (%o4) [0.0, 14.49 %i - .8284, 0.0, 2.485 %i + 4.828, 0.0, 4876 4.828 - 2.485 %i, 0.0, - 14.49 %i - .8284] 4877 (%i5) L2 : fft (L1); 4878 (%o5) [1.0, 2.0 - 2.168L-19 %i, 3.0 - 7.525L-20 %i, 4879 4.0 - 4.256L-19 %i, - 1.0, 2.168L-19 %i - 2.0, 4880 7.525L-20 %i - 3.0, 4.256L-19 %i - 4.0] 4881 (%i6) lmax (abs (L2 - L)); 4882 (%o6) 3.545L-16 4883 4884 Datos complejos. 4885 4886 (%i1) load (fft) $ 4887 (%i2) fpprintprec : 4 $ 4888 (%i3) L : [1, 1 + %i, 1 - %i, -1, -1, 1 - %i, 1 + %i, 1] $ 4889 (%i4) L1 : inverse_fft (L); 4890 (%o4) [4.0, 2.711L-19 %i + 4.0, 2.0 %i - 2.0, 4891 - 2.828 %i - 2.828, 0.0, 5.421L-20 %i + 4.0, - 2.0 %i - 2.0, 4892 2.828 %i + 2.828] 4893 (%i5) L2 : fft (L1); 4894 (%o5) [4.066E-20 %i + 1.0, 1.0 %i + 1.0, 1.0 - 1.0 %i, 4895 1.55L-19 %i - 1.0, - 4.066E-20 %i - 1.0, 1.0 - 1.0 %i, 4896 1.0 %i + 1.0, 1.0 - 7.368L-20 %i] 4897 (%i6) lmax (abs (L2 - L)); 4898 (%o6) 6.841L-17 4899 4900 -- Función: fft (<x>) 4901 4902 Calcula la transformada rápida compleja de Fourier. 4903 4904 <x> es una lista o array (declarado o no) que contiene los datos a 4905 transformar. El número de elementos debe ser una potencia de dos. 4906 Los elementos deben ser números literales (enteros, racionales, de 4907 punto flotante o decimales grandes), constantes simbólicas, 4908 expresiones del tipo 'a + b*%i', siendo 'a' y 'b' números 4909 literales, o constantes simbólicas. 4910 4911 La función 'fft' devuelve un nuevo objeto del mismo tipo que <x>, 4912 el cual no se ve modificado. Los resultados se calculan siempre 4913 como decimales o expresiones 'a + b*%i', siendo 'a' y 'b' 4914 decimales. 4915 4916 La transformada discreta de Fourier se define como se indica a 4917 continuación. Si 'y' es el resultado de la transformada inversa, 4918 entonces para 'k' entre 0 y 'n - 1' se tiene 4919 4920 y[k] = (1/n) sum(x[j] exp(+2 %i %pi j k / n), j, 0, n - 1) 4921 4922 Si los datos <x> son reales, los coeficientes reales 'a' y 'b' se 4923 pueden calcular de manera que 4924 4925 x[j] = sum(a[k]*cos(2*%pi*j*k/n)+b[k]*sin(2*%pi*j*k/n), k, 0, n/2) 4926 4927 con 4928 4929 a[0] = realpart (y[0]) 4930 b[0] = 0 4931 4932 y, para k entre 1 y n/2 - 1, 4933 4934 a[k] = realpart (y[k] + y[n - k]) 4935 b[k] = imagpart (y[n - k] - y[k]) 4936 4937 y 4938 4939 a[n/2] = realpart (y[n/2]) 4940 b[n/2] = 0 4941 4942 Para utilizar esta función ejecútese antes 'load(fft)'. 4943 4944 Véanse también 'inverse_fft' (transformada inversa), 'recttopolar' 4945 y 'polartorect'. 4946 4947 Ejemplos: 4948 4949 Datos reales. 4950 4951 (%i1) load (fft) $ 4952 (%i2) fpprintprec : 4 $ 4953 (%i3) L : [1, 2, 3, 4, -1, -2, -3, -4] $ 4954 (%i4) L1 : fft (L); 4955 (%o4) [0.0, - 1.811 %i - .1036, 0.0, .6036 - .3107 %i, 0.0, 4956 .3107 %i + .6036, 0.0, 1.811 %i - .1036] 4957 (%i5) L2 : inverse_fft (L1); 4958 (%o5) [1.0, 2.168L-19 %i + 2.0, 7.525L-20 %i + 3.0, 4959 4.256L-19 %i + 4.0, - 1.0, - 2.168L-19 %i - 2.0, 4960 - 7.525L-20 %i - 3.0, - 4.256L-19 %i - 4.0] 4961 (%i6) lmax (abs (L2 - L)); 4962 (%o6) 3.545L-16 4963 4964 Datos complejos. 4965 4966 (%i1) load (fft) $ 4967 (%i2) fpprintprec : 4 $ 4968 (%i3) L : [1, 1 + %i, 1 - %i, -1, -1, 1 - %i, 1 + %i, 1] $ 4969 (%i4) L1 : fft (L); 4970 (%o4) [0.5, .3536 %i + .3536, - 0.25 %i - 0.25, 4971 0.5 - 6.776L-21 %i, 0.0, - .3536 %i - .3536, 0.25 %i - 0.25, 4972 0.5 - 3.388L-20 %i] 4973 (%i5) L2 : inverse_fft (L1); 4974 (%o5) [1.0 - 4.066E-20 %i, 1.0 %i + 1.0, 1.0 - 1.0 %i, 4975 - 1.008L-19 %i - 1.0, 4.066E-20 %i - 1.0, 1.0 - 1.0 %i, 4976 1.0 %i + 1.0, 1.947L-20 %i + 1.0] 4977 (%i6) lmax (abs (L2 - L)); 4978 (%o6) 6.83L-17 4979 4980 Cálculo de los coeficientes del seno y coseno. 4981 4982 (%i1) load (fft) $ 4983 (%i2) fpprintprec : 4 $ 4984 (%i3) L : [1, 2, 3, 4, 5, 6, 7, 8] $ 4985 (%i4) n : length (L) $ 4986 (%i5) x : make_array (any, n) $ 4987 (%i6) fillarray (x, L) $ 4988 (%i7) y : fft (x) $ 4989 (%i8) a : make_array (any, n/2 + 1) $ 4990 (%i9) b : make_array (any, n/2 + 1) $ 4991 (%i10) a[0] : realpart (y[0]) $ 4992 (%i11) b[0] : 0 $ 4993 (%i12) for k : 1 thru n/2 - 1 do 4994 (a[k] : realpart (y[k] + y[n - k]), 4995 b[k] : imagpart (y[n - k] - y[k])); 4996 (%o12) done 4997 (%i13) a[n/2] : y[n/2] $ 4998 (%i14) b[n/2] : 0 $ 4999 (%i15) listarray (a); 5000 (%o15) [4.5, - 1.0, - 1.0, - 1.0, - 0.5] 5001 (%i16) listarray (b); 5002 (%o16) [0, - 2.414, - 1.0, - .4142, 0] 5003 (%i17) f(j) := sum (a[k] * cos (2*%pi*j*k / n) + b[k] * sin (2*%pi*j*k / n), k, 0, n/2) $ 5004 (%i18) makelist (float (f (j)), j, 0, n - 1); 5005 (%o18) [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0] 5006 5007 5008File: maxima.info, Node: Funciones para la resolución numérica de ecuaciones, Next: Introducción a la resolución numérica de ecuaciones diferenciales, Prev: Funciones y variables para la transformada rápida de Fourier, Up: Métodos numéricos 5009 501022.3 Funciones para la resolución numérica de ecuaciones 5011======================================================== 5012 5013 -- Función: horner (<expr>, <x>) 5014 -- Función: horner (<expr>) 5015 Cambia el formato de <expr> según la regla de Horner utilizando <x> 5016 como variable principal, si ésta se especifica. El argumento 'x' 5017 se puede omitir, en cuyo caso se considerará como variable 5018 principal la de <expr> en su formato racional canónico (CRE). 5019 5020 La función 'horner' puede mejorar las estabilidad si 'expr' va a 5021 ser numéricamente evaluada. También es útil si Maxima se utiliza 5022 para generar programas que serán ejecutados en Fortran. Véase 5023 también 'stringout'. 5024 5025 (%i1) expr: 1e-155*x^2 - 5.5*x + 5.2e155; 5026 2 5027 (%o1) 1.0E-155 x - 5.5 x + 5.2E+155 5028 (%i2) expr2: horner (%, x), keepfloat: true; 5029 (%o2) (1.0E-155 x - 5.5) x + 5.2E+155 5030 (%i3) ev (expr, x=1e155); 5031 Maxima encountered a Lisp error: 5032 5033 floating point overflow 5034 5035 Automatically continuing. 5036 To reenable the Lisp debugger set *debugger-hook* to nil. 5037 (%i4) ev (expr2, x=1e155); 5038 (%o4) 7.0E+154 5039 5040 -- Función: find_root (<expr>, <x>, <a>, <b>, [<abserr>, <relerr>]) 5041 -- Función: find_root (<f>, <a>, <b>, [<abserr>, <relerr>]) 5042 -- Función: bf_find_root (<expr>, <x>, <a>, <b>, [<abserr>, <relerr>]) 5043 -- Función: bf_find_root (<f>, <a>, <b>, [<abserr>, <relerr>]) 5044 -- Variable opcional: find_root_error 5045 -- Variable opcional: find_root_abs 5046 -- Variable opcional: find_root_rel 5047 5048 Calcula una raíz de la expresión <expr> o de la función <f> en el 5049 intervalo cerrado [<a>, <b>]. La expresión <expr> puede ser una 5050 ecuación, en cuyo caso 'find_root' busca una raíz de 'lhs(<expr>) - 5051 rhs(<expr>)'. 5052 5053 Dado que Maxima puede evaluar <expr> o <f> en [<a>, <b>], entonces, 5054 si <expr> o <f> es continua, 'find_root' encuentrará la raíz 5055 buscada, o raíces, en caso de existir varias. 5056 5057 La función 'find_root' aplica al principio la búsqueda por 5058 bipartición. Si la expresión es lo suficientemente suave, entonces 5059 'find_root' aplicará el método de interpolación lineal. 5060 5061 'bf_find_root' es una versión de 'find_root' para números reales de 5062 precisión arbitraria (bigfloat). La función se evalúa utilizando 5063 la aritmética de estos números, devolviendo un resultado numérico 5064 de este tipo. En cualquier otro aspecto, 'bf_find_root' es 5065 idéntica a 'find_root', siendo la explicación que sigue igualmente 5066 válida para 'bf_find_root'. 5067 5068 La precisión de 'find_root' está controlada por 'abserr' y 5069 'relerr', que son claves opcionales para 'find_root'. Estas claves 5070 toman la forma 'key=val'. Las claves disponibles son: 5071 5072 'abserr' 5073 Error absoluto deseado de la función en la raíz. El valor por 5074 defecto es 'find_root_abs'. 5075 'relerr' 5076 Error relativo deseado de la raíz. El valor por defecto es 5077 'find_root_rel'. 5078 5079 'find_root' se detiene cuando la función alcanza un valor menor o 5080 igual que 'abserr', o si las sucesivas aproximaciones <x_0>, <x_1> 5081 difieren en no más que 'relerr * max(abs(x_0), abs(x_1))'. Los 5082 valores por defecto de 'find_root_abs' y 'find_root_rel' son ambos 5083 cero. 5084 5085 'find_root' espera que la función en cuestión tenga signos 5086 diferentes en los extremos del intervalo. Si la función toma 5087 valores numéricos en ambos extremos y estos números son del mismo 5088 signo, entonces el comportamiento de 'find_root' se controla con 5089 'find_root_error'. Cuando 'find_root_error' vale 'true', 5090 'find_root' devuelve un mensaje de error; en caso contrario, 5091 'find_root' devuelve el valor de 'find_root_error'. El valor por 5092 defecto de 'find_root_error' es 'true'. 5093 5094 Si en algún momento del proceso de búsqueda <f> alcanza un valor no 5095 numérico, 'find_root' devuelve una expresión parcialmente evaluada. 5096 5097 Se ignora el orden de <a> y <b>; la región de búsqueda es [min(<a>, 5098 <b>), max(<a>, <b>)]. 5099 5100 Ejemplos: 5101 5102 (%i1) f(x) := sin(x) - x/2; 5103 x 5104 (%o1) f(x) := sin(x) - - 5105 2 5106 (%i2) find_root (sin(x) - x/2, x, 0.1, %pi); 5107 (%o2) 1.895494267033981 5108 (%i3) find_root (sin(x) = x/2, x, 0.1, %pi); 5109 (%o3) 1.895494267033981 5110 (%i4) find_root (f(x), x, 0.1, %pi); 5111 (%o4) 1.895494267033981 5112 (%i5) find_root (f, 0.1, %pi); 5113 (%o5) 1.895494267033981 5114 (%i6) find_root (exp(x) = y, x, 0, 100); 5115 x 5116 (%o6) find_root(%e = y, x, 0.0, 100.0) 5117 (%i7) find_root (exp(x) = y, x, 0, 100), y = 10; 5118 (%o7) 2.302585092994046 5119 (%i8) log (10.0); 5120 (%o8) 2.302585092994046 5121 (%i9) fpprec:32; 5122 (%o9) 32 5123 (%i10) bf_find_root (exp(x) = y, x, 0, 100), y = 10; 5124 (%o10) 2.3025850929940456840179914546844b0 5125 (%i11) log(10b0); 5126 (%o11) 2.3025850929940456840179914546844b0 5127 5128 -- Función: newton (<expr>, <x>, <x_0>, <eps>) 5129 Devuelve una solución aproximada de '<expr> = 0' obtenida por el 5130 método de Newton, considerando <expr> como una función de una 5131 variable, <x>. La búsqueda comienza con '<x> = <x_0>' y continúa 5132 hasta que se verifique 'abs(<expr>) < <eps>', donde <expr> se 5133 evalúa con el valor actual de <x>. 5134 5135 La función 'newton' permite que en <expr> haya variables no 5136 definidas, siempre y cuando la condición de terminación 5137 'abs(<expr>) < <eps>' pueda reducirse a un valor lógico 'true' o 5138 'false'; de este modo, no es necesario que <expr> tome un valor 5139 numérico. 5140 5141 Ejecútese 'load(newton1)' para cargar esta función. 5142 5143 Véanse también 'realroots', 'allroots', 'find_root' y 'mnewton'. 5144 5145 Ejemplos: 5146 5147 (%i1) load (newton1); 5148 (%o1) /usr/share/maxima/5.10.0cvs/share/numeric/newton1.mac 5149 (%i2) newton (cos (u), u, 1, 1/100); 5150 (%o2) 1.570675277161251 5151 (%i3) ev (cos (u), u = %); 5152 (%o3) 1.2104963335033528E-4 5153 (%i4) assume (a > 0); 5154 (%o4) [a > 0] 5155 (%i5) newton (x^2 - a^2, x, a/2, a^2/100); 5156 (%o5) 1.00030487804878 a 5157 (%i6) ev (x^2 - a^2, x = %); 5158 2 5159 (%o6) 6.098490481853958E-4 a 5160 5161 5162File: maxima.info, Node: Introducción a la resolución numérica de ecuaciones diferenciales, Next: Funciones para la resolución numérica de ecuaciones diferenciales, Prev: Funciones para la resolución numérica de ecuaciones, Up: Métodos numéricos 5163 516422.4 Introducción a la resolución numérica de ecuaciones diferenciales 5165====================================================================== 5166 5167Las ecuaciones diferenciales ordinarias (EDO) que se resuelven con las 5168funciones de esta sección deben tener la forma 5169 dy 5170 -- = F(x,y) 5171 dx 5172la cual es una EDO de primer orden. Las ecuaciones diferenciales de 5173orden <n> deben escribirse como un sistema de <n> ecuaciones de primer 5174orden del tipo anterior. Por ejemplo, una EDO de segundo orden debe 5175escribirse como un sistema de dos ecuaciones, 5176 dx dy 5177 -- = G(x,y,t) -- = F(x,y,t) 5178 dt dt 5179 5180El primer argumento de las funciones debe ser una lista con las 5181expresiones de los miembros derechos de las EDOs. Las variables cuyas 5182derivadas se representan por las expresiones anteriores deben darse en 5183una segunda lista. En el caso antes citado, las variables son <x> y 5184<y>. La variable independiente, <t> en los mismos ejemplos anteriores, 5185pueden darse mediante una opción adicional. Si las expresiones dadas no 5186dependen de esa variable independiente, el sistema recibe el nombre de 5187autónomo. 5188 5189 5190File: maxima.info, Node: Funciones para la resolución numérica de ecuaciones diferenciales, Prev: Introducción a la resolución numérica de ecuaciones diferenciales, Up: Métodos numéricos 5191 519222.5 Funciones para la resolución numérica de ecuaciones diferenciales 5193====================================================================== 5194 5195 -- Función: plotdf (<dydx>, ...options...) 5196 -- Función: plotdf (<dvdu>, '['<u>,<v>']', ...options...) 5197 -- Función: plotdf ('['<dxdt>,<dydt>']', ...options...) 5198 -- Función: plotdf ('['<dudt>,<dvdt>']', '['<u>,<v>']', ...options...) 5199 Dibuja un campo de direcciones en dos dimensiones <x> y <y>. 5200 5201 <dydx>, <dxdt> y <dydt> son expresiones que dependen de <x> y <y>. 5202 Además de esas dos variables, las dos expresiones pueden depender 5203 de un conjunto de parámetros, con valores numéricos que son dados 5204 por medio de la opción 'parameters' (la sintaxis de esa opción se 5205 explica mas al frente), o con un rango de posibles valores 5206 definidos con la opción <sliders>. 5207 5208 Varias otras opciones se pueden incluir dentro del comando, o 5209 seleccionadas en el menú. Haciendo click en un punto del gráfico 5210 se puede hacer que sea dibujada la curva integral que pasa por ese 5211 punto; lo mismo puede ser hecho dando las coordenadas del punto con 5212 la opción 'trajectory_at' dentro del comando plotdf. La dirección 5213 de integración se puede controlar con la opción 'direction', que 5214 acepta valores de _forward_, _backward_ ou _both_. El número de 5215 pasos realizado en la integración numérica se controla con la 5216 opción 'nsteps' y el incremento del tiempo en cada paso con la 5217 opción 'tstep'. Se usa el método de Adams Moulton para hacer la 5218 integración numérica; también es posible cambiar para el método de 5219 Runge-Kutta de cuarto orden con ajuste de pasos. 5220 5221 Menú de la ventana del gráfico: 5222 5223 El menú de la ventana gráfica dispone de las siguientes opciones: 5224 _Zoom_, que permite cambiar el comportamiento del ratón, de manera 5225 que hará posible el hacer zoom en la región del gráfico haciendo 5226 clic con el botón izquierdo. Cada clic agranda la imagen 5227 manteniendo como centro de la misma el punto sobre el cual se ha 5228 hecho clic. Manteniendo pulsada la tecla <Shift> mientras se hace 5229 clic, retrocede al tamaño anterior. Para reanudar el cálculo de 5230 las trayectorias cuando se hace clic, seleccine la opción 5231 _Integrate_ del menú. 5232 5233 La opción _Config_ del menú se puede utilizar para cambiar la(s) 5234 EDO(S) y algunos otros ajustes. Después de hacer los cambios, se 5235 debe utilizar la opción _Replot_ para activar los nuevos ajustes. 5236 Si en el campo _Trajectory at_ del menú de diálogo de _Config_ se 5237 introducen un par de coordenadas y luego se pulsa la tecla 5238 <retorno>, se mostrará una nueva curva integral, además de las ya 5239 dibujadas. Si se selecciona la opción _Replot_, sólo se mostrará 5240 la última curva integral seleccionada. 5241 5242 Manteniendo pulsado el botón derecho del ratón mientras se mueve el 5243 cursor, se puede arrastrar el gráfico horizontal y verticalmente. 5244 Otros parámetros, como pueden ser el número de pasos, el valor 5245 inicial de <t>, las coordenadas del centro y el radio, pueden 5246 cambiarse en el submenú de la opción _Config_. 5247 5248 Con la opción _Save_, se puede obtener una copia del gráfico en una 5249 impresora Postscript o guardarlo en un fichero Postscript. Para 5250 optar entre la impresión o guardar en fichero, se debe seleccionar 5251 _Print Options_ en la ventana de diálogo de _Config_. Una vez 5252 cubiertos los campos de la ventana de diálogo de _Save_, será 5253 necesario seleccionar la opción _Save_ del primer menú para crear 5254 el fichero o imprimir el gráfico. 5255 5256 Opciones gráficas: 5257 5258 La función 'plotdf' admite varias opciones, cada una de las cuales 5259 es una lista de dos o más elementos. El primer elemento es el 5260 nombre de la opción, y el resto está formado por el valor o valores 5261 asignados a dicha opción. 5262 5263 La función 'plotdf' reconoce las siguientes opciones: 5264 5265 * "tstep" establece la amplitud de los incrementos en la 5266 variable independiente <t>, utilizados para calcular la curva 5267 integral. Si se aporta sólo una expresión <dydx>, la variable 5268 <x> será directamente proporcional a <t>. El valor por 5269 defecto es 0.1. 5270 5271 * "nsteps" establece el número de pasos de longitud 'tstep' que 5272 se utilizarán en la variable independiente para calcular la 5273 curva integral. El valor por defecto es 100. 5274 5275 * "direction" establece la dirección de la variable 5276 independiente que será seguida para calcular una curva 5277 integral. Valores posibles son: 'forward', para hacer que la 5278 variable independiente aumente 'nsteps' veces, con incrementos 5279 'tstep'; 'backward', para hacer que la variable independiente 5280 disminuya; 'both', para extender la curva integral 'nsteps' 5281 pasos hacia adelante y 'nsteps' pasos hacia atrás. Las 5282 palabras 'right' y 'left' se pueden utilizar como sinónimos de 5283 'forward' y 'backward'. El valor por defecto es 'both'. 5284 5285 * "tinitial" establece el valor inicial de la variable <t> 5286 utilizado para calcular curvas integrales. Puesto que las 5287 ecuaciones diferenciales son autónomas, esta opción sólo 5288 aparecerá en los gráficos de las curvas como funciones de <t>. 5289 El valor por defecto es 0. 5290 5291 * "versus_t" se utiliza para crear una segunda ventana gráfica, 5292 con el gráfico de una curva integral, como dos funciones <x>, 5293 <y>, de variable independiente <t>. Si se le da a 'versus_t' 5294 cualquier valor diferente de 0, se mostrará la segunda ventana 5295 gráfica, la cual incluye otro menú, similar al de la ventana 5296 principal. El valor por defecto es 0. 5297 5298 * "trajectory_at" establece las coordenadas <xinitial> y 5299 <yinitial> para el extremo inicial de la curva integral. No 5300 tiene asignado valor por defecto. 5301 5302 * "parameters" establece una lista de parámetros, junto con sus 5303 valores numéricos, que son utilizados en la definición de la 5304 ecuación diferencial. Los nombres de los parámetros y sus 5305 valores deben escribirse en formato de cadena de caracteres 5306 como una secuencia de pares 'nombre=valor' separados por 5307 comas. 5308 5309 * "sliders" establece una lista de parámetros que se cambiarán 5310 interactivamente utilizando barras de deslizamiento, así como 5311 los rangos de variación de dichos parámetros. Los nombres de 5312 los parámetros y sus rangos deben escribirse en formato de 5313 cadena de caracteres como una secuencia de pares 5314 'nombre=min:max' separados por comas. 5315 5316 * "xfun" establece una cadena de caracteres con funciones de <x> 5317 separadas por puntos y comas para ser representadas por encima 5318 del campo de direcciones. Estas funciones serán interpretadas 5319 por Tcl, no por Maxima. 5320 5321 * "xradius" es la mitad de la longitud del rango de valores a 5322 representar en la dirección x. El valor por defecto es 10. 5323 5324 * "yradius" es la mitad de la longitud del rango de valores a 5325 representar en la dirección y. El valor por defecto es 10. 5326 5327 * "xcenter" es la coordenada x del punto situado en el centro 5328 del gráfico. El valor por defecto es 0. 5329 5330 * "ycenter" es la coordenada y del punto situado en el centro 5331 del gráfico. El valor por defecto es 0. 5332 5333 * "width" establece el ancho de la ventana gráfica en píxeles. 5334 El valor por defecto es 500. 5335 5336 * "height" establece la altura de la ventana gráfica en píxeles. 5337 El valor por defecto es 500. 5338 5339 Ejemplos: 5340 5341 NOTA: Dependiendo de la interface que se use para Maxima, las 5342 funciones que usan 'openmath', incluida 'plotdf', pueden 5343 desencadenar un fallo si terminan en punto y coma, en vez del 5344 símbolo de dólar. Para evitar problemas, se usará el símbolo de 5345 dólar en todos ejemplos. 5346 5347 * Para mostrar el campo de direcciones de la ecuación 5348 diferencial y' = exp(-x) + y y la solución que pasa por (2, 5349 -0.1): 5350 (%i1) load("plotdf")$ 5351 5352 (%i2) plotdf(exp(-x)+y,[trajectory_at,2,-0.1]); 5353 5354 * Para mostrar el campo de direcciones de la ecuación diff(y,x) 5355 = x - y^2 y la solución de condición inicial y(-1) = 3, se 5356 puede utilizar la sentencia: 5357 (%i3) plotdf(x-y^2,[xfun,"sqrt(x);-sqrt(x)"], 5358 [trajectory_at,-1,3], [direction,forward], 5359 [yradius,5],[xcenter,6]); 5360 El gráfico también muestra la función y = sqrt(x). 5361 5362 * El siguiente ejemplo muestra el campo de direcciones de un 5363 oscilador armónico, definido por las ecuaciones dx/dt = y y 5364 dy/dt = -k*x/m, y la curva integral que pasa por (x,y) = 5365 (6,0), con una barra de deslizamiento que permitirá cambiar el 5366 valor de m interactivamente (k permanece fijo a 2): 5367 (%i4) plotdf([y,-k*x/m],[parameters,"m=2,k=2"], 5368 [sliders,"m=1:5"], [trajectory_at,6,0]); 5369 5370 * Para representar el campo de direcciones de la ecuación de 5371 Duffing, m*x''+c*x'+k*x+b*x^3 = 0, se introduce la variable 5372 y=x' y se hace: 5373 (%i5) plotdf([y,-(k*x + c*y + b*x^3)/m], 5374 [parameters,"k=-1,m=1.0,c=0,b=1"], 5375 [sliders,"k=-2:2,m=-1:1"],[tstep,0.1]); 5376 5377 * El campo de direcciones de un péndulo amortiguado, incluyendo 5378 la solución para condiciones iniciales dadas, con una barra de 5379 deslizamiento que se puede utilizar para cambiar el valor de 5380 la masa, m, y con el gráfico de las dos variables de estado 5381 como funciones del tiempo: 5382 5383 (%i6) plotdf([y,-g*sin(x)/l - b*y/m/l], 5384 [parameters,"g=9.8,l=0.5,m=0.3,b=0.05"], 5385 [trajectory_at,1.05,-9],[tstep,0.01], 5386 [xradius,6],[yradius,14], 5387 [xcenter,-4],[direction,forward],[nsteps,300], 5388 [sliders,"m=0.1:1"], [versus_t,1]); 5389 5390 -- Función: ploteq (<exp>, ...options...) 5391 5392 Dibuja curvas equipotenciales para <exp>, que debe ser una 5393 expresión dependiente de dos variables. Las curvas se obtienen 5394 integrando la ecuación diferencial que define las trayectorias 5395 ortogonales a las soluciones del sistema autónomo que se obtiene 5396 del gradiente de la expresión dada. El dibujo también puede 5397 mostrar las curvas integrales de ese sistema de gradientes (opción 5398 'fieldlines'). 5399 5400 Este programa también necesita Xmaxima, incluso si se ejecuta 5401 Maxima desde una consola, pues el dibujo se creará por el código Tk 5402 de Xmaxima. Por defecto, la región dibujada estará vacía hasta que 5403 el usuario haga clic en un punto, dé sus coordenadas a través del 5404 menú o mediante la opción 'trajectory_at'. 5405 5406 La mayor parte de opciones aceptadas por 'plotdf' se pueden 5407 utilizar también con 'ploteq' y el aspecto del interfaz es el mismo 5408 que el descrito para 'plotdf'. 5409 5410 Ejemplo: 5411 5412 (%i1) V: 900/((x+1)^2+y^2)^(1/2)-900/((x-1)^2+y^2)^(1/2)$ 5413 (%i2) ploteq(V,[x,-2,2],[y,-2,2],[fieldlines,"blue"])$ 5414 5415 Haciendo clic sobre un punto se dibujará la curva equipotencial que 5416 pasa por ese punto (en rojo) y la trayectoria ortogonal (en azul). 5417 5418 -- Función: rk (<ODE>, <var>, <initial>, <dominio>) 5419 -- Función: rk ([<ODE1>,...,<ODEm>], [<v1>,...,<vm>], 5420 [<init1>,...,<initm>], <dominio>) 5421 5422 La primera forma se usa para resolver numéricamente una ecuación 5423 diferencial ordinaria de primer orden (EDO), y la segunda forma 5424 resuelve numéricamente un sistema de <m> de esas ecuaciones, usando 5425 el método de Runge-Kutta de cuarto orden. <var> representa la 5426 variable dependiente. EDO debe ser una expresión que dependa 5427 únicamente de las variables independiente y dependente, y define la 5428 derivada de la variable dependiente en función de la variable 5429 independiente. 5430 5431 La variable independiente se representa con <dominio>, que debe ser 5432 una lista con cuatro elementos, como por ejemplo: 5433 [t, 0, 10, 0.1] 5434 el primer elemento de la lista identifica la variable 5435 independiente, el segundo y tercer elementos son los valores 5436 inicial y final para esa variable, y el último elemento da el valor 5437 de los incrementos que deberán ser usados dentro de ese intervalo. 5438 5439 Si se van a resolver <m> ecuaciones, deberá haber <m> variables 5440 dependientes <v1>, <v2>, ..., <vm>. Los valores iniciales para 5441 esas variables serán <inic1>, <inic2>, ..., <inicm>. Continuará 5442 existiendo apenas una variable independiente definida por la lista 5443 <domain>, como en el caso anterior. <EDO1>, ..., <EDOm> son las 5444 expresiones que definen las derivadas de cada una de las variables 5445 dependientes en función de la variable independiente. Las únicas 5446 variables que pueden aparecer en cada una de esas expresiones son 5447 la variable independiente y cualquiera de las variables 5448 dependientes. Es importante que las derivadas <EDO1>, ..., <EDOm> 5449 sean colocadas en la lista en el mismo orden en que fueron 5450 agrupadas las variables dependientes; por ejemplo, el tercer 5451 elemento de la lista será interpretado como la derivada de la 5452 tercera variable dependiente. 5453 5454 El programa intenta integrar las ecuaciones desde el valor inicial 5455 de la variable independiente, hasta el valor final, usando 5456 incrementos fijos. Si en algún paso una de las variables 5457 dependientes toma un valor absoluto muy grande, la integración será 5458 suspendida en ese punto. El resultado será una lista con un número 5459 de elementos igual al número de iteraciones realizadas. Cada 5460 elemento en la lista de resultados es también una lista con <m>+1 5461 elementos: el valor de la variable independiente, seguido de los 5462 valores de las variables dependientes correspondientes a ese punto. 5463 5464 5465File: maxima.info, Node: Matrices y Álgebra Lineal, Next: Afines, Prev: Métodos numéricos, Up: Top 5466 546723 Matrices y Álgebra Lineal 5468**************************** 5469 5470* Menu: 5471 5472* Introducción a las matrices y el álgebra lineal:: 5473* Funciones y variables para las matrices y el álgebra lineal:: 5474 5475 5476File: maxima.info, Node: Introducción a las matrices y el álgebra lineal, Next: Funciones y variables para las matrices y el álgebra lineal, Prev: Matrices y Álgebra Lineal, Up: Matrices y Álgebra Lineal 5477 547823.1 Introducción a las matrices y el álgebra lineal 5479==================================================== 5480 5481* Menu: 5482 5483* Operador punto:: 5484* Vectores:: 5485* Paquete eigen:: 5486 5487 5488File: maxima.info, Node: Operador punto, Next: Vectores, Prev: Introducción a las matrices y el álgebra lineal, Up: Introducción a las matrices y el álgebra lineal 5489 549023.1.1 Operador punto 5491--------------------- 5492 5493El operador '.' realiza la multiplicación matricial y el producto 5494escalar. Cuando los operandos son dos matrices columna o matrices fila 5495'a' y 'b', la expresión 'a.b' es equivalente a 'sum (a[i]*b[i], i, 1, 5496length(a))'. Si 'a' y 'b' no son complejos, estamos en el caso del 5497producto escalar. En caso de ser 'a' y 'b' vectores en el campo 5498complejo, el producto escalar se define como 'conjugate(a).b'; la 5499función 'innerproduct' del paquete 'eigen' realiza el producto escalar 5500complejo. 5501 5502Cuando los operandos son matrices de índole más general, el resultado 5503que se obtiene es el producto matricial de 'a' por 'b'. El número de 5504filas de 'b' debe ser igual al número de columnas de 'a', y el resultado 5505tiene un número de filas igual al de 'a' y un número de columnas igual 5506al de 'b'. 5507 5508Al objeto de distinguir '.' como operador aritmético del punto decimal 5509de la notación en coma flotante, puede ser necesario dejar espacios a 5510ambos lados. Por ejemplo, '5.e3' es '5000.0' pero '5 . e3' es '5' por 5511'e3'. 5512 5513Hay algunas variables globales que controlan la simplificación de 5514expresiones que contengan al operador '.', a saber, 'dot', 5515'dot0nscsimp', 'dot0simp', 'dot1simp', 'dotassoc', 'dotconstrules', 5516'dotdistrib', 'dotexptsimp', 'dotident', y 'dotscrules'. 5517 5518 5519File: maxima.info, Node: Vectores, Next: Paquete eigen, Prev: Operador punto, Up: Introducción a las matrices y el álgebra lineal 5520 552123.1.2 Vectores 5522--------------- 5523 5524El paquete 'vect' define funciones para análisis vectorial. Para cargar 5525el paquete en memoria se debe hacer 'load ("vect")' y con 'demo 5526("vect")' se presenta una demostración sobre las funciones del paquete. 5527 5528El paquete de análisis vectorial puede combinar y simplificar 5529expresiones simbólicas que incluyan productos escalares y vectoriales, 5530junto con los operadores de gradiente, divergencia, rotacional y 5531laplaciano. La distribución de estos operadores sobre sumas o productos 5532se gobierna por ciertas variables, al igual que otras transformaciones, 5533incluida la expansión en componentes en cualquier sistema de coordenadas 5534especificado. También hay funciones para obtener el potencial escalar o 5535vectorial de un campo. 5536 5537El paquete 'vect' contiene las siguientes funciones: 'vectorsimp', 5538'scalefactors', 'express', 'potential' y 'vectorpotential'. 5539 5540Por defecto, el paquete 'vect' no declara el operador '.' como 5541conmutativo. Para transformarlo en conmutativo, se debe ejecutar 5542previamente la instrucción 'declare(".", commutative)'. 5543 5544 5545File: maxima.info, Node: Paquete eigen, Prev: Vectores, Up: Introducción a las matrices y el álgebra lineal 5546 554723.1.3 Paquete eigen 5548-------------------- 5549 5550El paquete 'eigen' contiene funciones para el cálculo simbólico de 5551valores y vectores propios. Maxima carga el paquete automáticamente si 5552se hace una llamada a cualquiera de las dos funciones 'eigenvalues' o 5553'eigenvectors'. El paquete se puede cargar de forma explícita mediante 5554'load ("eigen")'. 5555 5556La instrucción 'demo ("eigen")' hace una demostración de las funciones 5557de este paquete; 'batch ("eigen")' realiza la misma demostración pero 5558sin pausas entre los sucesivos cálculos. 5559 5560Las funciones del paquete 'eigen' son 'innerproduct', 'unitvector', 5561'columnvector', 'gramschmidt', 'eigenvalues', 'eigenvectors', 5562'uniteigenvectors' y 'similaritytransform'. 5563 5564 5565File: maxima.info, Node: Funciones y variables para las matrices y el álgebra lineal, Prev: Introducción a las matrices y el álgebra lineal, Up: Matrices y Álgebra Lineal 5566 556723.2 Funciones y variables para las matrices y el álgebra lineal 5568================================================================ 5569 5570 -- Función: addcol (<M>, <lista_1>, ..., <lista_n>) 5571 Añade la/s columna/s dada/s por la/s lista/s (o matrices) a la 5572 matriz <M>. 5573 5574 -- Función: addrow (<M>, <lista_1>, ..., <lista_n>) 5575 Añade la/s fila/s dada/s por la/s lista/s (o matrices) a la matriz 5576 <M>. 5577 5578 -- Función: adjoint (<M>) 5579 Devuelve el adjunto de la matriz <M>. La matriz adjunta es la 5580 transpuesta de la matriz de cofactores de <M>. 5581 5582 -- Función: augcoefmatrix ([<eqn_1>, ..., <eqn_m>], [<x_1>, ..., 5583 <x_n>]) 5584 Devuelve la matriz aumentada de coeficientes del sistema de 5585 ecuaciones lineales <eqn_1>, ..., <eqn_m> de variables <x_1>, ..., 5586 <x_n>. Se trata de la matriz de coeficientes con una columna 5587 adicional para los términos constantes de cada ecuación, es decir, 5588 aquellos términos que no dependen de las variables <x_1>, ..., 5589 <x_n>. 5590 5591 (%i1) m: [2*x - (a - 1)*y = 5*b, c + b*y + a*x = 0]$ 5592 (%i2) augcoefmatrix (m, [x, y]); 5593 [ 2 1 - a - 5 b ] 5594 (%o2) [ ] 5595 [ a b c ] 5596 5597 -- Función: cauchy_matrix ([<x_1>,<x_2>, ..., <x_m>], [<y_1>,<y_2>, 5598 ..., <y_n>]) 5599 -- Función: cauchy_matrix ([<x_1>,<x_2>, ..., <x_n>]) 5600 5601 Devuelve una matriz de Cauchy <n> by <m> de elementos <a[i,j]> = 5602 1/(<x_i>+<y_i>). El segundo elemento de 'cauchy_matrix' es 5603 opcional, y en caso de no estar presente, los elementos serán de la 5604 forma <a[i,j]> = 1/(<x_i>+<x_j>). 5605 5606 Observación: en la literatura, la matriz de Cauchy se define a 5607 veces con sus elementos de la forma <a[i,j]> = 1/(<x_i>-<y_i>). 5608 5609 Ejemplos: 5610 5611 (%i1) cauchy_matrix([x1,x2],[y1,y2]); 5612 [ 1 1 ] 5613 [ ------- ------- ] 5614 [ y1 + x1 y2 + x1 ] 5615 (%o1) [ ] 5616 [ 1 1 ] 5617 [ ------- ------- ] 5618 [ y1 + x2 y2 + x2 ] 5619 5620 (%i2) cauchy_matrix([x1,x2]); 5621 [ 1 1 ] 5622 [ ---- ------- ] 5623 [ 2 x1 x2 + x1 ] 5624 (%o2) [ ] 5625 [ 1 1 ] 5626 [ ------- ---- ] 5627 [ x2 + x1 2 x2 ] 5628 5629 -- Función: charpoly (<M>, <x>) 5630 Calcula el polinomio característico de la matriz <M> respecto de la 5631 variable <x>. Esto es, 'determinant (<M> - diagmatrix (length 5632 (<M>), <x>))'. 5633 5634 (%i1) a: matrix ([3, 1], [2, 4]); 5635 [ 3 1 ] 5636 (%o1) [ ] 5637 [ 2 4 ] 5638 (%i2) expand (charpoly (a, lambda)); 5639 2 5640 (%o2) lambda - 7 lambda + 10 5641 (%i3) (programmode: true, solve (%)); 5642 (%o3) [lambda = 5, lambda = 2] 5643 (%i4) matrix ([x1], [x2]); 5644 [ x1 ] 5645 (%o4) [ ] 5646 [ x2 ] 5647 (%i5) ev (a . % - lambda*%, %th(2)[1]); 5648 [ x2 - 2 x1 ] 5649 (%o5) [ ] 5650 [ 2 x1 - x2 ] 5651 (%i6) %[1, 1] = 0; 5652 (%o6) x2 - 2 x1 = 0 5653 (%i7) x2^2 + x1^2 = 1; 5654 2 2 5655 (%o7) x2 + x1 = 1 5656 (%i8) solve ([%th(2), %], [x1, x2]); 5657 1 2 5658 (%o8) [[x1 = - -------, x2 = - -------], 5659 sqrt(5) sqrt(5) 5660 5661 1 2 5662 [x1 = -------, x2 = -------]] 5663 sqrt(5) sqrt(5) 5664 5665 -- Función: coefmatrix ([<eqn_1>, ..., <eqn_m>], [<x_1>, ..., <x_n>]) 5666 Devuelve la matriz de coeficientes para las variables <x_1>, ..., 5667 <x_n> del sistema de ecuaciones lineales <eqn_1>, ..., <eqn_m>. 5668 5669 (%i1) coefmatrix([2*x-(a-1)*y+5*b = 0, b*y+a*x = 3], [x,y]); 5670 [ 2 1 - a ] 5671 (%o1) [ ] 5672 [ a b ] 5673 5674 -- Función: col (<M>, <i>) 5675 Devuelve la <i>-ésima columna de la matriz <M>. El resultado es 5676 una matriz de una sola columna. 5677 5678 -- Función: columnvector (<L>) 5679 -- Función: covect (<L>) 5680 Devuelve una matriz con una columna y 'length (<L>)' filas, 5681 conteniendo los elementos de la lista <L>. 5682 5683 La llamada 'covect' es un sinónimo de 'columnvector'. 5684 5685 Es necesario cargar la función haciendo 'load ("eigen")'. 5686 5687 Ejemplo: 5688 5689 (%i1) load ("eigen")$ 5690 Warning - you are redefining the Macsyma function eigenvalues 5691 Warning - you are redefining the Macsyma function eigenvectors 5692 (%i2) columnvector ([aa, bb, cc, dd]); 5693 [ aa ] 5694 [ ] 5695 [ bb ] 5696 (%o2) [ ] 5697 [ cc ] 5698 [ ] 5699 [ dd ] 5700 5701 -- Función: copymatrix (<M>) 5702 Devuelve una copia de la matriz <M>. Esta es la única manera de 5703 obtener una réplica de <M> además de la de copiar elemento a 5704 elemento. 5705 5706 Nótese que una asignación de una matriz a otra, como en 'm2: m1', 5707 no hace una copia de 'm1'. Asignaciones del tipo 'm2 [i,j]: x' o 5708 'setelmx (x, i, j, m2' también modifica 'm1 [i,j]'. Si se crea una 5709 copia con 'copymatrix' y luego se hacen asignaciones se tendrá una 5710 copia separada y modificada. 5711 5712 -- Función: determinant (<M>) 5713 Calcula el determinante de <M> por un método similar al de 5714 eliminación de Gauss 5715 5716 La forma del resultado depende del valor asignado a 'ratmx'. 5717 5718 Existe una rutina especial para calcular determinantes de matrices 5719 con elementos dispersas, la cual será invocada cuando las variables 5720 'ratmx' y 'sparse' valgan ambas 'true'. 5721 5722 -- Variable opcional: detout 5723 Valor por defecto: 'false' 5724 5725 Cuando 'detout' vale 'true', el determinante de la matriz cuya 5726 inversa se calcula aparece como un factor fuera de la matriz. 5727 5728 Para que esta variable surta efecto, 'doallmxops' y 'doscmxops' 5729 deberían tener el valor 'false' (véanse sus descripciones). 5730 Alternativamente, esta variable puede ser suministrada a 'ev'. 5731 5732 Ejemplo: 5733 5734 (%i1) m: matrix ([a, b], [c, d]); 5735 [ a b ] 5736 (%o1) [ ] 5737 [ c d ] 5738 (%i2) detout: true$ 5739 (%i3) doallmxops: false$ 5740 (%i4) doscmxops: false$ 5741 (%i5) invert (m); 5742 [ d - b ] 5743 [ ] 5744 [ - c a ] 5745 (%o5) ------------ 5746 a d - b c 5747 5748 -- Función: diagmatrix (<n>, <x>) 5749 Devuelve una matriz diagonal de orden <n> con los elementos de la 5750 diagonal todos ellos iguales a <x>. La llamada 'diagmatrix (<n>, 5751 1)' devuelve una matriz identidad (igual que 'ident (<n>)'). 5752 5753 La variable <n> debe ser un número entero, en caso contrario 5754 'diagmatrix' envía un mensaje de error. 5755 5756 <x> puede ser cualquier tipo de expresión, incluso otra matriz. Si 5757 <x> es una matriz, no se copia; todos los elementos de la diagonal 5758 son iguales a <x>. 5759 5760 -- Variable opcional: doallmxops 5761 Valor por defecto: 'true' 5762 5763 Cuando 'doallmxops' vale 'true', todas las operaciones relacionadas 5764 con matrices son llevadas a cabo. Cuando es 'false', entonces las 5765 selecciones para 'dot' controlan las operaciones a ejecutar. 5766 5767 -- Variable opcional: domxexpt 5768 Valor por defecto: 'true' 5769 5770 Cuando 'domxexpt' vale 'true', un exponente matricial, como 'exp 5771 (<M>)' donde <M> es una matriz, se interpreta como una matriz cuyo 5772 elemento '[i,j' es igual a 'exp (m[i,j])'. En otro caso, 'exp 5773 (<M>)' se evalúa como 'exp (ev(<M>))'. 5774 5775 La variable 'domxexpt' afecta a todas las expresiones de la forma 5776 '<base>^<exponente>' donde <base> es una expresión escalar o 5777 constante y <exponente> es una lista o matriz. 5778 5779 Ejemplo: 5780 5781 (%i1) m: matrix ([1, %i], [a+b, %pi]); 5782 [ 1 %i ] 5783 (%o1) [ ] 5784 [ b + a %pi ] 5785 (%i2) domxexpt: false$ 5786 (%i3) (1 - c)^m; 5787 [ 1 %i ] 5788 [ ] 5789 [ b + a %pi ] 5790 (%o3) (1 - c) 5791 (%i4) domxexpt: true$ 5792 (%i5) (1 - c)^m; 5793 [ %i ] 5794 [ 1 - c (1 - c) ] 5795 (%o5) [ ] 5796 [ b + a %pi ] 5797 [ (1 - c) (1 - c) ] 5798 5799 -- Variable opcional: domxmxops 5800 Valor por defecto: 'true' 5801 5802 Cuando 'domxmxops' vale 'true', se realizan todas las operaciones 5803 entre matrices o entre matrices y listas (pero no las operaciones 5804 entre matrices y escalares); si esta variable es 'false' tales 5805 operaciones no se realizan. 5806 5807 -- Variable opcional: domxnctimes 5808 Valor por defecto: 'false' 5809 5810 Cuando 'domxnctimes' vale 'true', se calculan los productos no 5811 conmutativos entre matrices. 5812 5813 -- Variable opcional: dontfactor 5814 Valor por defecto: '[]' 5815 5816 En 'dontfactor' puede guardarse una lista de variables respecto de 5817 las cuales no se realizarán factorizaciones. Inicialmente, la 5818 lista está vacía. 5819 5820 -- Variable opcional: doscmxops 5821 Valor por defecto: 'false' 5822 5823 Cuando 'doscmxops' vale 'true', se realizan las operaciones entre 5824 escalares y matrices. 5825 5826 -- Variable opcional: doscmxplus 5827 Valor por defecto: 'false' 5828 5829 Cuando 'doscmxplus' vale 'true', las operaciones entre escalares y 5830 matrices dan como resultado una matriz. 5831 5832 -- Variable opcional: dot0nscsimp 5833 Valor por defecto: 'true' 5834 5835 (Esta descripción no está clara en la versión inglesa original.) 5836 5837 -- Variable opcional: dotassoc 5838 Valor por defecto: 'true' 5839 5840 Cuando 'dotassoc' vale 'true', una expresión como '(A.B).C' se 5841 transforma en 'A.(B.C)'. 5842 5843 -- Variable opcional: dotconstrules 5844 Valor por defecto: 'true' 5845 5846 Cuando 'dotconstrules' vale 'true', un producto no conmutativo de 5847 una constante con otro término se transforma en un producto 5848 conmutativo. 5849 5850 -- Variable opcional: dotdistrib 5851 Valor por defecto: 'false' 5852 5853 Cuando 'dotdistrib' vale 'true', una expresión como 'A.(B + C)' se 5854 transforma en 'A.B + A.C'. 5855 5856 -- Variable opcional: dotexptsimp 5857 Valor por defecto: 'true' 5858 5859 Cuando 'dotexptsimp' vale 'true', una expresión como 'A.A' se 5860 transforma en 'A^^2'. 5861 5862 -- Variable opcional: dotident 5863 Valor por defecto: 1 5864 5865 El valor de la variable 'dotident' es el resultado devuelto por 5866 'X^^0'. 5867 5868 -- Variable opcional: dotscrules 5869 Valor por defecto: 'false' 5870 5871 Cuando 'dotscrules' vale 'true', una expresión como 'A.SC' o 'SC.A' 5872 se transforma en 'SC*A' y 'A.(SC*B)' en 'SC*(A.B)'. 5873 5874 -- Función: echelon (<M>) 5875 Devuelve la forma escalonada de la matriz <M>, obtenida por 5876 eliminación gaussiana. La forma escalonada se calcula a partir de 5877 <M> mediante operaciones elementales con sus filas, de tal manera 5878 que el primer elemento no nulo de cada fila en la matriz resultado 5879 es la unidad y que cada elemento de la columna por debajo del 5880 primer uno de cada fila sean todos ceros. 5881 5882 La función 'triangularize' también lleva a cabo la eliminación 5883 gaussiana, pero no normaliza el primer elemento no nulo de cada 5884 fila. 5885 5886 Otras funciones, como 'lu_factor' y 'cholesky', también dan como 5887 resultados matrices triangularizadas. 5888 5889 (%i1) M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]); 5890 [ 3 7 aa bb ] 5891 [ ] 5892 (%o1) [ - 1 8 5 2 ] 5893 [ ] 5894 [ 9 2 11 4 ] 5895 (%i2) echelon (M); 5896 [ 1 - 8 - 5 - 2 ] 5897 [ ] 5898 [ 28 11 ] 5899 [ 0 1 -- -- ] 5900 (%o2) [ 37 37 ] 5901 [ ] 5902 [ 37 bb - 119 ] 5903 [ 0 0 1 ----------- ] 5904 [ 37 aa - 313 ] 5905 5906 -- Función: eigenvalues (<M>) 5907 -- Función: eivals (<M>) 5908 Devuelve una lista con dos sublistas. La primera sublista la 5909 forman los valores propios de la matriz <M> y la segunda sus 5910 multiplicidades correspondientes. 5911 5912 El nombre 'eivals' es un sinónimo de 'eigenvalues'. 5913 5914 La función 'eigenvalues' llama a la función 'solve' para calcular 5915 las raíces del polinomio característico de la matriz. En 5916 ocasiones, 'solve' no podrá encontrar dichas raíces, en cuyo caso 5917 otras funciones de este paquete no trabajarán correctamente, a 5918 excepción de 'innerproduct', 'unitvector', 'columnvector' y 5919 'gramschmidt'. 5920 5921 En algunos casos los valores propios encontrados por 'solve' serán 5922 expresiones complicadas, las cuales se podrán simplificar haciendo 5923 uso de otras funciones. 5924 5925 El paquete 'eigen.mac' se carga en memoria de forma automática 5926 cuando se invocan 'eigenvalues' o 'eigenvectors'. Si 'eigen.mac' 5927 no está ya cargado, 'load ("eigen")' lo carga. Tras la carga, 5928 todas las funciones y variables del paquete estarán activas. 5929 5930 -- Función: eigenvectors (<M>) 5931 -- Función: eivects (<M>) 5932 5933 Calcula los vectores propios de la matriz <M>. El resultado 5934 devuelto es una lista con dos elementos; el primero está formado 5935 por dos listas, la primera con los valores propios de <M> y la 5936 segunda con sus respectivas multiplicidades, el segundo elemento es 5937 una lista de listas de vectores propios, una por cada valor propio, 5938 pudiendo haber uno o más vectores propios en cada lista. 5939 5940 Tomando la matriz <M> como argumento, devuelve una lista de listas, 5941 la primera de las cuales es la salida de 'eigenvalues' y las 5942 siguientes son los vectorios propios de la matriz asociados a los 5943 valores propios correspondientes. Los vectores propios calculados 5944 son los vectores propios por la derecha. 5945 5946 El nombre 'eivects' es un sinónimo de 'eigenvectors'. 5947 5948 El paquete 'eigen.mac' se carga en memoria de forma automática 5949 cuando se invocan 'eigenvalues' o 'eigenvectors'. Si 'eigen.mac' 5950 no está ya cargado, 'load ("eigen")' lo carga. Tras la carga, 5951 todas las funciones y variables del paquete estarán activas. 5952 5953 Las variables que afectan a esta función son: 5954 5955 'nondiagonalizable' toma el valor 'true' o 'false' dependiendo de 5956 si la matriz no es diagonalizable o diagonalizable tras la 5957 ejecución de 'eigenvectors'. 5958 5959 'hermitianmatrix', si vale 'true', entonces los vectores propios 5960 degenerados de la matriz hermítica son ortogonalizados mediante el 5961 algoritmo de Gram-Schmidt. 5962 5963 'knowneigvals', si vale 'true', entonces el paquete 'eigen' da por 5964 sentado que los valores propios de la matriz son conocidos por el 5965 usuario y almacenados en la variable global 'listeigvals'. 5966 'listeigvals' debería ser similar a la salida de 'eigenvalues'. 5967 5968 La función 'algsys' se utiliza aquí para calcular los vectores 5969 propios. A veces, 'algsys' no podrá calcular una solución. En 5970 algunos casos, será posible simplificar los valores propios 5971 calculándolos en primer lugar con 'eigenvalues' y luego utilizando 5972 otras funciones para simplificarlos. Tras la simplificación, 5973 'eigenvectors' podrá ser llamada otra vez con la variable 5974 'knowneigvals' ajustada al valor 'true'. 5975 5976 Véase también 'eigenvalues'. 5977 5978 Ejemplos: 5979 5980 Una matriz con un único vector propio por cada valor propio. 5981 5982 (%i1) M1 : matrix ([11, -1], [1, 7]); 5983 [ 11 - 1 ] 5984 (%o1) [ ] 5985 [ 1 7 ] 5986 (%i2) [vals, vecs] : eigenvectors (M1); 5987 (%o2) [[[9 - sqrt(3), sqrt(3) + 9], [1, 1]], 5988 [[[1, sqrt(3) + 2]], [[1, 2 - sqrt(3)]]]] 5989 (%i3) for i thru length (vals[1]) do disp (val[i] = vals[1][i], 5990 mult[i] = vals[2][i], vec[i] = vecs[i]); 5991 val = 9 - sqrt(3) 5992 1 5993 5994 mult = 1 5995 1 5996 5997 vec = [[1, sqrt(3) + 2]] 5998 1 5999 6000 val = sqrt(3) + 9 6001 2 6002 6003 mult = 1 6004 2 6005 6006 vec = [[1, 2 - sqrt(3)]] 6007 2 6008 6009 (%o3) done 6010 6011 Una matriz con dos vectores propios para uno de los valores 6012 propios. 6013 6014 (%i1) M1 : matrix ([0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 2, 0], [0, 0, 0, 2]); 6015 [ 0 1 0 0 ] 6016 [ ] 6017 [ 0 0 0 0 ] 6018 (%o1) [ ] 6019 [ 0 0 2 0 ] 6020 [ ] 6021 [ 0 0 0 2 ] 6022 (%i2) [vals, vecs] : eigenvectors (M1); 6023 (%o2) [[[0, 2], [2, 2]], [[[1, 0, 0, 0]], 6024 [[0, 0, 1, 0], [0, 0, 0, 1]]]] 6025 (%i3) for i thru length (vals[1]) do disp (val[i] = vals[1][i], 6026 mult[i] = vals[2][i], vec[i] = vecs[i]); 6027 val = 0 6028 1 6029 6030 mult = 2 6031 1 6032 6033 vec = [[1, 0, 0, 0]] 6034 1 6035 6036 val = 2 6037 2 6038 6039 mult = 2 6040 2 6041 6042 vec = [[0, 0, 1, 0], [0, 0, 0, 1]] 6043 2 6044 6045 (%o3) done 6046 6047 -- Función: ematrix (<m>, <n>, <x>, <i>, <j>) 6048 Devuelve una matriz de orden <m> por <n>, con todos sus elementos 6049 nulos, excepto el que ocupa la posición '[<i>, <j>]', que es igual 6050 a <x>. 6051 6052 -- Función: entermatrix (<m>, <n>) 6053 Devuelve una matriz de orden <m> por <n>, cuyos elementos son 6054 leidos de forma interactiva. 6055 6056 Si <n> es igual a <m>, Maxima pregunta por el tipo de matriz 6057 (diagonal, simétrica, antisimétrica o general) y luego por cada 6058 elemento. Cada respuesta introducida por el usuario debe terminar 6059 con un punto y coma ';' o con un signo de dólar '$'. 6060 6061 Si <n> y <m> no son iguales, Maxima pregunta por el valor de cada 6062 elemento. 6063 6064 Los elementos de la matriz pueden ser cualquier tipo de expresión, 6065 que en todo caso será evaluada. 'entermatrix' evalúa sus 6066 argumentos. 6067 6068 (%i1) n: 3$ 6069 (%i2) m: entermatrix (n, n)$ 6070 6071 Is the matrix 1. Diagonal 2. Symmetric 3. Antisymmetric 6072 4. General 6073 Answer 1, 2, 3 or 4 : 6074 1$ 6075 Row 1 Column 1: 6076 (a+b)^n$ 6077 Row 2 Column 2: 6078 (a+b)^(n+1)$ 6079 Row 3 Column 3: 6080 (a+b)^(n+2)$ 6081 6082 Matrix entered. 6083 (%i3) m; 6084 [ 3 ] 6085 [ (b + a) 0 0 ] 6086 [ ] 6087 (%o3) [ 4 ] 6088 [ 0 (b + a) 0 ] 6089 [ ] 6090 [ 5 ] 6091 [ 0 0 (b + a) ] 6092 6093 -- Función: genmatrix (<a>, <i_2>, <j_2>, <i_1>, <j_1>) 6094 -- Función: genmatrix (<a>, <i_2>, <j_2>, <i_1>) 6095 -- Función: genmatrix (<a>, <i_2>, <j_2>) 6096 Devuelve una matriz generada a partir de <a>, siendo 6097 '<a>[<i_1>,<j_1>]' el elemento superior izquierdo y 6098 '<a>[<i_2>,<j_2>]' el inferior derecho de la matriz. Aquí <a> se 6099 declara como una arreglo (creado por 'array', pero no por 6100 'make_array'), o un array no declarado, o una función array, o una 6101 expresión lambda de dos argumentos. (An array function is created 6102 like other functions with ':=' or 'define', but arguments are 6103 enclosed in square brackets instead of parentheses.) 6104 6105 Si se omite <j_1>, entonces se le asigna el valor <i_1>. Si tanto 6106 <j_1> como <i_1> se omiten, a las dos variables se le asigna el 6107 valor 1. 6108 6109 Si un elemento 'i,j' del arreglo no está definido, se le asignará 6110 el elemento simbólico '<a>[i,j]'. 6111 6112 (%i1) h [i, j] := 1 / (i + j - 1); 6113 1 6114 (%o1) h := --------- 6115 i, j i + j - 1 6116 (%i2) genmatrix (h, 3, 3); 6117 [ 1 1 ] 6118 [ 1 - - ] 6119 [ 2 3 ] 6120 [ ] 6121 [ 1 1 1 ] 6122 (%o2) [ - - - ] 6123 [ 2 3 4 ] 6124 [ ] 6125 [ 1 1 1 ] 6126 [ - - - ] 6127 [ 3 4 5 ] 6128 (%i3) array (a, fixnum, 2, 2); 6129 (%o3) a 6130 (%i4) a [1, 1] : %e; 6131 (%o4) %e 6132 (%i5) a [2, 2] : %pi; 6133 (%o5) %pi 6134 (%i6) genmatrix (a, 2, 2); 6135 [ %e 0 ] 6136 (%o6) [ ] 6137 [ 0 %pi ] 6138 (%i7) genmatrix (lambda ([i, j], j - i), 3, 3); 6139 [ 0 1 2 ] 6140 [ ] 6141 (%o7) [ - 1 0 1 ] 6142 [ ] 6143 [ - 2 - 1 0 ] 6144 (%i8) genmatrix (B, 2, 2); 6145 [ B B ] 6146 [ 1, 1 1, 2 ] 6147 (%o8) [ ] 6148 [ B B ] 6149 [ 2, 1 2, 2 ] 6150 6151 -- Función: gramschmidt (<x>) 6152 -- Función: gramschmidt (<x>, <F>) 6153 6154 Ejecuta el algoritmo de ortogonalización de Gram-Schmidt sobre <x>, 6155 que puede ser una matriz o una lista de listas. La función 6156 'gramschmidt' no altera el valor de <x>. El producto interno por 6157 defecto empleado en 'gramschmidt' es 'innerproduct', o <F>, si se 6158 ha hecho uso de esta opción. 6159 6160 Si <x> es una matriz, el algoritmo se aplica a las filas de <x>. 6161 Si <x> es una lista de listas, el algoritmo se aplica a las 6162 sublistas, las cuales deben tener el mismo número de miembros. En 6163 cualquier caso, el valor devuelto es una lista de listas, cuyas 6164 sublistas son ortogonales. 6165 6166 La función 'factor' es invocada en cada paso del algoritmo para 6167 simplificar resultados intermedios. Como consecuencia, el valor 6168 retornado puede contener enteros factorizados. 6169 6170 El nombre 'gschmit' es sinónimo de 'gramschmidt'. 6171 6172 Es necesario cargar la función haciendo 'load ("eigen")'. 6173 6174 Ejemplo: 6175 6176 Algoritmo de Gram-Schmidt utilizando el producto interno por 6177 defecto. 6178 6179 (%i1) load (eigen)$ 6180 (%i2) x: matrix ([1, 2, 3], [9, 18, 30], [12, 48, 60]); 6181 [ 1 2 3 ] 6182 [ ] 6183 (%o2) [ 9 18 30 ] 6184 [ ] 6185 [ 12 48 60 ] 6186 (%i3) y: gramschmidt (x); 6187 2 2 4 3 6188 3 3 3 5 2 3 2 3 6189 (%o3) [[1, 2, 3], [- ---, - --, ---], [- ----, ----, 0]] 6190 2 7 7 2 7 5 5 6191 (%i4) map (innerproduct, [y[1], y[2], y[3]], [y[2], y[3], y[1]]); 6192 (%o4) [0, 0, 0] 6193 6194 Algoritmo de Gram-Schmidt utilizando un producto interno 6195 especificado por el usuario. 6196 6197 (%i1) load (eigen)$ 6198 (%i2) ip (f, g) := integrate (f * g, u, a, b); 6199 (%o2) ip(f, g) := integrate(f g, u, a, b) 6200 (%i3) y : gramschmidt ([1, sin(u), cos(u)], ip), a= -%pi/2, b=%pi/2; 6201 %pi cos(u) - 2 6202 (%o3) [1, sin(u), --------------] 6203 %pi 6204 (%i4) map (ip, [y[1], y[2], y[3]], [y[2], y[3], y[1]]), a= -%pi/2, b=%pi/2; 6205 (%o4) [0, 0, 0] 6206 6207 -- Función: ident (<n>) 6208 Devuelve la matriz identidad de orden <n>. 6209 6210 -- Función: innerproduct (<x>, <y>) 6211 -- Función: inprod (<x>, <y>) 6212 Devuelve el producto interior o escalar de <x> por <y>, que deben 6213 ser listas de igual longitud, o ambas matrices columa o fila de 6214 igual longitud. El valor devuelto es 'conjugate (x) . y', donde 6215 '.' es el operador de multiplicación no conmutativa. 6216 6217 Es necesario cargar la función haciendo 'load ("eigen")'. 6218 6219 El nombre 'inprod' es sinónimo de 'innerproduct'. 6220 6221 -- Función: invert (<M>) 6222 Devuelve la inversa de la matriz <M>, calculada por el método del 6223 adjunto. 6224 6225 La implementación actual no es eficiente para matrices de orden 6226 grande. 6227 6228 Cuando 'detout' vale 'true', el determinante se deja fuera de la 6229 inversa a modo de factor escalar. 6230 6231 Los elementos de la matriz inversa no se expanden. Si <M> tiene 6232 elementos polinómicos, se puede mejorar el aspecto del resultado 6233 haciendo 'expand (invert (m)), detout'. 6234 6235 Véase la descripción de '^^' (exponente no conmutativo) para 6236 información sobre otro método para invertir matrices. 6237 6238 -- Función: list_matrix_entries (<M>) 6239 Devuelve una lista con todos los elementos de la matriz <M>. 6240 6241 Ejemplo: 6242 6243 (%i1) list_matrix_entries(matrix([a,b],[c,d])); 6244 (%o1) [a, b, c, d] 6245 6246 -- Variable opcional: lmxchar 6247 Valor por defecto: '[' 6248 6249 La variable 'lmxchar' guarda el carácter a mostrar como delimitador 6250 izquierdo de la matriz. Véase también 'rmxchar'. 6251 6252 Ejemplo: 6253 6254 (%i1) lmxchar: "|"$ 6255 (%i2) matrix ([a, b, c], [d, e, f], [g, h, i]); 6256 | a b c ] 6257 | ] 6258 (%o2) | d e f ] 6259 | ] 6260 | g h i ] 6261 6262 -- Función: matrix (<fila_1>, ..., <fila_n>) 6263 Devuelve una matriz rectangular con las filas <fila_1>, ..., 6264 <fila_n>. Cada fila es una lista de expresiones. Todas las filas 6265 deben tener el mismo número de miembros. 6266 6267 Las operaciones '+' (suma), '-' (resta), '*' (multiplicación) y '/' 6268 (división), se llevan a cabo elemento a elemento cuando los 6269 operandos son dos matrices, un escalar y una matriz o una matriz 6270 con un escalar. La operación '^' (exponenciación, equivalente a 6271 '**') se lleva cabo también elemento a elemento si los operandos 6272 son un escalr y una matriz o uma matriz y un escalar, pero no si 6273 los operandos son dos matrices. 6274 6275 El producto matricial se representa con el operador de 6276 multiplicación no conmutativa '.'. El correspondiente operador de 6277 exponenciación no conmutativa es '^^'. Dada la matriz '<A>', 6278 '<A>.<A> = <A>^^2' y '<A>^^-1' es la inversa de <A>, si existe. 6279 6280 Algunas variables controlan la simplificación de expresiones que 6281 incluyan estas operaciones: 'doallmxops', 'domxexpt', 'domxmxops', 6282 'doscmxops' y 'doscmxplus'. 6283 6284 Hay otras opciones adicionales relacionadas con matrices: 6285 'lmxchar', 'rmxchar', 'ratmx', 'listarith', 'detout', 6286 'scalarmatrix' y 'sparse'. 6287 6288 Hay también algunas funciones que admiten matrices como argumentos 6289 o que devuelven resultados matriciales: 'eigenvalues', 6290 'eigenvectors', 'determinant', 'charpoly', 'genmatrix', 'addcol', 6291 'addrow', 'copymatrix', 'transpose', 'echelon' y 'rank'. 6292 6293 Ejemplos: 6294 6295 * Construcción de matrices a partir de listas. 6296 (%i1) x: matrix ([17, 3], [-8, 11]); 6297 [ 17 3 ] 6298 (%o1) [ ] 6299 [ - 8 11 ] 6300 (%i2) y: matrix ([%pi, %e], [a, b]); 6301 [ %pi %e ] 6302 (%o2) [ ] 6303 [ a b ] 6304 * Suma elemento a elemento. 6305 (%i3) x + y; 6306 [ %pi + 17 %e + 3 ] 6307 (%o3) [ ] 6308 [ a - 8 b + 11 ] 6309 * Resta elemento a elemento. 6310 (%i4) x - y; 6311 [ 17 - %pi 3 - %e ] 6312 (%o4) [ ] 6313 [ - a - 8 11 - b ] 6314 * Multiplicación elemento a elemento. 6315 (%i5) x * y; 6316 [ 17 %pi 3 %e ] 6317 (%o5) [ ] 6318 [ - 8 a 11 b ] 6319 * División elemento a elemento. 6320 (%i6) x / y; 6321 [ 17 - 1 ] 6322 [ --- 3 %e ] 6323 [ %pi ] 6324 (%o6) [ ] 6325 [ 8 11 ] 6326 [ - - -- ] 6327 [ a b ] 6328 * Matriz elevada a un exponente escalar, operación elemento a 6329 elemento. 6330 (%i7) x ^ 3; 6331 [ 4913 27 ] 6332 (%o7) [ ] 6333 [ - 512 1331 ] 6334 * Base escalar y exponente matricial, operación elemento a 6335 elemento. 6336 (%i8) exp(y); 6337 [ %pi %e ] 6338 [ %e %e ] 6339 (%o8) [ ] 6340 [ a b ] 6341 [ %e %e ] 6342 * Base y exponente matriciales. Esta operación no se realiza 6343 elemento a elemento. 6344 (%i9) x ^ y; 6345 [ %pi %e ] 6346 [ ] 6347 [ a b ] 6348 [ 17 3 ] 6349 (%o9) [ ] 6350 [ - 8 11 ] 6351 * Multiplicación matricial no conmutativa. 6352 (%i10) x . y; 6353 [ 3 a + 17 %pi 3 b + 17 %e ] 6354 (%o10) [ ] 6355 [ 11 a - 8 %pi 11 b - 8 %e ] 6356 (%i11) y . x; 6357 [ 17 %pi - 8 %e 3 %pi + 11 %e ] 6358 (%o11) [ ] 6359 [ 17 a - 8 b 11 b + 3 a ] 6360 * Exponenciación matricial no conmutativa. Una base escalar <b> 6361 elevada a un exponente matricial <M> se lleva a cabo elemento 6362 a elemento y por lo tanto 'b^^m' equivale a 'b^m'. 6363 (%i12) x ^^ 3; 6364 [ 3833 1719 ] 6365 (%o12) [ ] 6366 [ - 4584 395 ] 6367 (%i13) %e ^^ y; 6368 [ %pi %e ] 6369 [ %e %e ] 6370 (%o13) [ ] 6371 [ a b ] 6372 [ %e %e ] 6373 * Una matriz elevada al exponente -1 con el operador de 6374 exponenciación no conmutativa equivale a la matriz inversa, si 6375 existe. 6376 (%i14) x ^^ -1; 6377 [ 11 3 ] 6378 [ --- - --- ] 6379 [ 211 211 ] 6380 (%o14) [ ] 6381 [ 8 17 ] 6382 [ --- --- ] 6383 [ 211 211 ] 6384 (%i15) x . (x ^^ -1); 6385 [ 1 0 ] 6386 (%o15) [ ] 6387 [ 0 1 ] 6388 6389 -- Función: matrixmap (<f>, <M>) 6390 Devuelve una matriz con el elemento 'i,j' igual a '<f>(<M>[i,j])'. 6391 6392 Véanse también 'map', 'fullmap', 'fullmapl' y 'apply'. 6393 6394 -- Función: matrixp (<expr>) 6395 Devuelve 'true' si <expr> es una matriz, en caso contrario 'false'. 6396 6397 -- Variable opcional: matrix_element_add 6398 Valor por defecto: '+' 6399 6400 La variable 'matrix_element_add' guarda el símbolo del operador a 6401 ejecutar en lugar de la suma en el producto matricial; a 6402 'matrix_element_add' se le puede asignar cualquier operador n-ario 6403 (esto es, una función que admite cualquier número de argumentos). 6404 El valor asignado puede ser el nombre de un operador encerrado 6405 entre apóstrofos, el nombre de una función o una expresión lambda. 6406 6407 Véanse también 'matrix_element_mult' y 'matrix_element_transpose'. 6408 6409 Ejemplo: 6410 6411 (%i1) matrix_element_add: "*"$ 6412 (%i2) matrix_element_mult: "^"$ 6413 (%i3) aa: matrix ([a, b, c], [d, e, f]); 6414 [ a b c ] 6415 (%o3) [ ] 6416 [ d e f ] 6417 (%i4) bb: matrix ([u, v, w], [x, y, z]); 6418 [ u v w ] 6419 (%o4) [ ] 6420 [ x y z ] 6421 (%i5) aa . transpose (bb); 6422 [ u v w x y z ] 6423 [ a b c a b c ] 6424 (%o5) [ ] 6425 [ u v w x y z ] 6426 [ d e f d e f ] 6427 6428 -- Variable opcional: matrix_element_mult 6429 Valor por defecto: '*' 6430 6431 La variable 'matrix_element_mult' guarda el símbolo del operador a 6432 ejecutar en lugar de la multiplicación en el producto matricial; a 6433 'matrix_element_mult' se le puede asignar cualquier operador 6434 binario. El valor asignado puede ser el nombre de un operador 6435 encerrado entre apóstrofos, el nombre de una función o una 6436 expresión lambda. 6437 6438 El operador '.' puede ser una opción útil en determinados 6439 contextos. 6440 6441 Véanse también 'matrix_element_add' y 'matrix_element_transpose'. 6442 6443 Ejemplo: 6444 6445 (%i1) matrix_element_add: lambda ([[x]], sqrt (apply ("+", x)))$ 6446 (%i2) matrix_element_mult: lambda ([x, y], (x - y)^2)$ 6447 (%i3) [a, b, c] . [x, y, z]; 6448 2 2 2 6449 (%o3) sqrt((c - z) + (b - y) + (a - x) ) 6450 (%i4) aa: matrix ([a, b, c], [d, e, f]); 6451 [ a b c ] 6452 (%o4) [ ] 6453 [ d e f ] 6454 (%i5) bb: matrix ([u, v, w], [x, y, z]); 6455 [ u v w ] 6456 (%o5) [ ] 6457 [ x y z ] 6458 (%i6) aa . transpose (bb); 6459 [ 2 2 2 ] 6460 [ sqrt((c - w) + (b - v) + (a - u) ) ] 6461 (%o6) Col 1 = [ ] 6462 [ 2 2 2 ] 6463 [ sqrt((f - w) + (e - v) + (d - u) ) ] 6464 6465 [ 2 2 2 ] 6466 [ sqrt((c - z) + (b - y) + (a - x) ) ] 6467 Col 2 = [ ] 6468 [ 2 2 2 ] 6469 [ sqrt((f - z) + (e - y) + (d - x) ) ] 6470 6471 -- Variable opcional: matrix_element_transpose 6472 Valor por defecto: 'false' 6473 6474 La variable 'matrix_element_transpose' es una operación que se 6475 aplica a cada elemento de una matriz a la que se le calcula la 6476 transpuesta. A 'matrix_element_mult' se le puede asignar cualquier 6477 operador unitario. El valor asignado puede ser el nombre de un 6478 operador encerrador entre apóstrofos, el nombre de una función o 6479 una expresión lambda. 6480 6481 Cuando 'matrix_element_transpose' es igual a 'transpose', la 6482 función 'transpose' se aplica a cada elemento. Cuando 6483 'matrix_element_transpose' es igual a 'nonscalars', la función 6484 'transpose' se aplica a todos los elementos no escalares. Si 6485 alguno de los elementos es un átomo, la opción 'nonscalars' se 6486 aplica 'transpose' sólo si el átomo se declara no escalar, mientras 6487 que la opción 'transpose' siempre aplica 'transpose'. 6488 6489 La opción por defecto, 'false', significa que no se aplica ninguna 6490 operación. 6491 6492 Véanse también 'matrix_element_add' y 'matrix_element_mult'. 6493 6494 Ejemplos: 6495 6496 (%i1) declare (a, nonscalar)$ 6497 (%i2) transpose ([a, b]); 6498 [ transpose(a) ] 6499 (%o2) [ ] 6500 [ b ] 6501 (%i3) matrix_element_transpose: nonscalars$ 6502 (%i4) transpose ([a, b]); 6503 [ transpose(a) ] 6504 (%o4) [ ] 6505 [ b ] 6506 (%i5) matrix_element_transpose: transpose$ 6507 (%i6) transpose ([a, b]); 6508 [ transpose(a) ] 6509 (%o6) [ ] 6510 [ transpose(b) ] 6511 (%i7) matrix_element_transpose: 6512 lambda ([x], realpart(x) - %i*imagpart(x))$ 6513 (%i8) m: matrix ([1 + 5*%i, 3 - 2*%i], [7*%i, 11]); 6514 [ 5 %i + 1 3 - 2 %i ] 6515 (%o8) [ ] 6516 [ 7 %i 11 ] 6517 (%i9) transpose (m); 6518 [ 1 - 5 %i - 7 %i ] 6519 (%o9) [ ] 6520 [ 2 %i + 3 11 ] 6521 6522 -- Función: mattrace (<M>) 6523 Devuelve la traza (esto es, la suma de los elementos de la diagonal 6524 principal) de la matriz cuadrada <M>. 6525 6526 Para disponer de esta función es necesario cargar el paquete 6527 haciendo 'load ("nchrpl")'. 6528 6529 -- Función: minor (<M>, <i>, <j>) 6530 Devuelve el menor '(<i>, <j>)' de la matriz <M>. Esto es, la 6531 propia matriz <M>, una vez extraídas la fila <i> y la columna <j>. 6532 6533 -- Función: ncharpoly (<M>, <x>) 6534 Devuelve el polinomio característico de la matriz <M> respecto de 6535 la variable <x>. Es una alternativa a la función 'charpoly' de 6536 Maxima. 6537 6538 La función 'ncharpoly' opera calculando trazas de las potencias de 6539 la matriz dada, que son iguales a las sumas de las potencias de las 6540 raíces del polinomio característico. A partir de estas cantidades 6541 se pueden calcular las funciones simétricas de las raíces, que no 6542 son otra cosa sino los coeficientes del polinomio característico. 6543 La función 'charpoly' opera calculando el determinante de by '<x> * 6544 ident [n] - a'. La función 'ncharpoly' es m'as eficiente en el 6545 caso de matrices grandes y densas. 6546 6547 Para disponer de esta función es necesario cargar el paquete 6548 haciendo 'load ("nchrpl")'. 6549 6550 -- Función: newdet (<M>) 6551 Calcula el determinante de la matriz <M> por el algoritmo del árbol 6552 menor de Johnson-Gentleman. El resultado devuelto por 'newdet' 6553 tiene formato CRE. 6554 6555 -- Función: permanent (<M>) 6556 Calcula la permanente de la matriz <M> por el algoritmo del árbol 6557 menor de Johnson-Gentleman. La permanente es como un determinante 6558 pero sin cambios de signo. El resultado devuelto por 'permanent' 6559 tiene formato CRE. 6560 6561 Véase también 'newdet'. 6562 6563 -- Función: rank (<M>) 6564 Calcula el rango de la matriz <M>. Esto es, el orden del mayor 6565 subdeterminante no singular de <M>. 6566 6567 La función <rango> puede retornar una respuesta errónea si no 6568 detecta que un elemento de la matriz equivalente a cero lo es. 6569 6570 -- Variable opcional: ratmx 6571 Valor por defecto: 'false' 6572 6573 Si 'ratmx' vale 'false', el determinante y la suma, resta y 6574 producto matriciales se calculan cuando las matrices se expresan en 6575 términos de sus elementos, pero no se calcula la inversión 6576 matricial en su representación general. 6577 6578 Si 'ratmx' vale 'true', las cuatro operaciones citadas más arriba 6579 se calculan en el formato CRE y el resultado de la matriz inversa 6580 también se da en formato CRE. Esto puede hacer que se expandan los 6581 elementos de la matriz, dependiendo del valor de 'ratfac', lo que 6582 quizás no sea siempre deseable. 6583 6584 -- Función: row (<M>, <i>) 6585 Devuelve la <i>-ésima fila de la matriz <M>. El valor que devuelve 6586 tiene formato de matriz. 6587 6588 -- Variable opcional: rmxchar 6589 Valor por defecto: ']' 6590 6591 La variable 'rmxchar' es el carácter que se dibuja al lado derecho 6592 de una matriz. 6593 6594 Véase también 'lmxchar'. 6595 6596 -- Variable opcional: scalarmatrixp 6597 Valor por defecto: 'true' 6598 6599 Si 'scalarmatrixp' vale 'true', entonces siempre que una matriz 1 x 6600 1 se produce como resultado del cálculo del producto no conmutativo 6601 de matrices se cambia al formato escalar. 6602 6603 Si 'scalarmatrixp' vale 'all', entonces todas las matrices 1 x 1 se 6604 simplifican a escalares. 6605 6606 Si 'scalarmatrixp' vale 'false', las matrices 1 x 1 no se 6607 convierten en escalares. 6608 6609 -- Función: setelmx (<x>, <i>, <j>, <M>) 6610 Asigna el valor <x> al (<i>, <j>)-ésimo elemento de la matriz <M> y 6611 devuelve la matriz actualizada. 6612 6613 La llamada '<M> [<i>, <j>]: <x>' hace lo mismo, pero devuelve <x> 6614 en lugar de <M>. 6615 6616 -- Función: similaritytransform (<M>) 6617 -- Función: simtran (<M>) 6618 La función 'similaritytransform' calcula la transformada de 6619 similitud de la matriz 'M'. Devuelve una lista que es la salida de 6620 la instrucción 'uniteigenvectors'. Además, si la variable 6621 'nondiagonalizable' vale 'false' entonces se calculan dos matrices 6622 globales 'leftmatrix' y 'rightmatrix'. Estas matrices tienen la 6623 propiedad de que 'leftmatrix . <M> . rightmatrix' es una matriz 6624 diagonal con los valores propios de <M> en su diagonal. Si 6625 'nondiagonalizable' vale 'true' entonces no se calculan estas 6626 matrices. 6627 6628 Si la variable 'hermitianmatrix' vale 'true' entonces 'leftmatrix' 6629 es el conjugado complejo de la transpuesta de 'rightmatrix'. En 6630 otro caso 'leftmatrix' es la inversa de 'rightmatrix'. 6631 6632 Las columnas de la matriz 'rightmatrix' son los vectores propios de 6633 <M>. Las otras variables (véanse 'eigenvalues' y 'eigenvectors') 6634 tienen el mismo efecto, puesto que 'similaritytransform' llama a 6635 las otras funciones del paquete para poder formar 'rightmatrix'. 6636 6637 Estas funciones se cargan con 'load ("eigen")'. 6638 6639 El nombre 'simtran' es sinónimo de 'similaritytransform'. 6640 6641 -- Variable opcional: sparse 6642 Valor por defecto: 'false' 6643 6644 Si 'sparse' vale 'true' y si 'ratmx' vale 'true', entonces 6645 'determinant' utilizará rutinas especiales para calcular 6646 determinantes dispersos. 6647 6648 -- Función: submatrix (<i_1>, ..., <i_m>, <M>, <j_1>, ..., <j_n>) 6649 -- Función: submatrix (<i_1>, ..., <i_m>, <M>) 6650 -- Función: submatrix (<M>, <j_1>, ..., <j_n>) 6651 Devuelve una nueva matriz formada a partir de la matriz <M> pero 6652 cuyas filas <i_1>, ..., <i_m> y columnas <j_1>, ..., <j_n> han sido 6653 eliminadas. 6654 6655 -- Función: transpose (<M>) 6656 Calcula la transpuesta de <M>. 6657 6658 Si <M> es una matriz, el valor devuelto es otra matriz <N> tal que 6659 'N[i,j] = M[j,i]'. 6660 6661 Si <M> es una lista, el valor devuelto es una matriz <N> de 'length 6662 (m)' filas y 1 columna, tal que 'N[i,1] = M[i]'. 6663 6664 En caso de no ser <M> ni matriz ni lista, se devuelve la expresión 6665 nominal ''transpose (<M>)'. 6666 6667 -- Función: triangularize (<M>) 6668 Devuelve la forma triangular superior de la matriz 'M', obtenida 6669 por eliminación gaussiana. El resultado es el mismo que el 6670 devuelto por 'echelon', con la salvedad de que el primer elemento 6671 no nulo de cada fila no se normaliza a 1. 6672 6673 Las funciones 'lu_factor' y 'cholesky' también triangularizan 6674 matrices. 6675 6676 (%i1) M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]); 6677 [ 3 7 aa bb ] 6678 [ ] 6679 (%o1) [ - 1 8 5 2 ] 6680 [ ] 6681 [ 9 2 11 4 ] 6682 (%i2) triangularize (M); 6683 [ - 1 8 5 2 ] 6684 [ ] 6685 (%o2) [ 0 - 74 - 56 - 22 ] 6686 [ ] 6687 [ 0 0 626 - 74 aa 238 - 74 bb ] 6688 6689 -- Función: uniteigenvectors (<M>) 6690 -- Función: ueivects (<M>) 6691 Calcula los vectores propios unitarios de la matriz <M>. El valor 6692 que devuelve es una lista de listas, la primera de las cuales es la 6693 salida de la función 'eigenvalues' y el resto de sublistas son los 6694 vectores propios unitarios de la matriz correspondiente a esos 6695 valores propios, respectivamente. 6696 6697 Las variables citadas en la descripción de la función 6698 'eigenvectors' tienen los mismos efectos en 'uniteigenvectors'. 6699 6700 Si 'knowneigvects' vale 'true', el paquete 'eigen' da por supuesto 6701 que el usuario conoce los vectores propios de la matriz y que están 6702 guardados en la variable global 'listeigvects', en tal caso el 6703 contenido de 'listeigvects' debe ser una lista de estructura 6704 similar a la que devuelve la función 'eigenvectors'. 6705 6706 Si 'knowneigvects' vale 'true' y la lista de vectores propios está 6707 en la variable 'listeigvects', el valor de la variable 6708 'nondiagonalizable' puede que no sea el correcto. Si tal es el 6709 caso, debe asignarsele el valor correcto. 6710 6711 Para utilizar esta fucnión es necesario cargarla haciendo 'load 6712 ("eigen")'. 6713 6714 El nombre 'ueivects' es sinónimo de 'uniteigenvectors'. 6715 6716 -- Función: unitvector (<x>) 6717 -- Función: uvect (<x>) 6718 Devuelve <x>/norm(<x>), esto es, el vector unitario de igual 6719 dirección y sentido que <x>. 6720 6721 'load ("eigen")' loads this function. 6722 6723 Para utilizar esta fucnión es necesario cargarla haciendo 'load 6724 ("eigen")'. 6725 6726 El nombre 'uvect' es sinónimo de 'unitvector'. 6727 6728 -- Función: vectorpotential (<givencurl>) 6729 Devuelve el vector potencial de un vector rotacional en el sistema 6730 de coordenadas actual. 'potentialzeroloc' tiene un rol similar al 6731 de 'potential', pero el orden del miembro izquierdo de las 6732 ecuaciones debe ser una permutación cíclica de las coordenadas. 6733 6734 -- Función: vectorsimp (<expr>) 6735 Realiza simplificaciones y expansiones de acuerdo con los valores 6736 de las siguientes variables globales: 6737 6738 'expandall', 'expanddot', 'expanddotplus', 'expandcross', 6739 'expandcrossplus', 'expandcrosscross', 'expandgrad', 6740 'expandgradplus', 'expandgradprod', 'expanddiv', 'expanddivplus', 6741 'expanddivprod', 'expandcurl', 'expandcurlplus', 'expandcurlcurl', 6742 'expandlaplacian', 'expandlaplacianplus' y 'expandlaplacianprod'. 6743 6744 Todas estas variables tienen por defecto el valor 'false'. El 6745 sufijo 'plus' se refiere al uso de la suma o la distributividad. 6746 El sufijo 'prod' se refiere a la expansión de operadores que 6747 realizan cualquier tipo de producto. 6748 6749 'expandcrosscross' 6750 Simplifica p ~ (q ~ r) en (p . r)*q - (p . q)*r. 6751 'expandcurlcurl' 6752 Simplifica curl curl p en grad div p + div grad p. 6753 'expandlaplaciantodivgrad' 6754 Simplifica laplacian p en div grad p. 6755 'expandcross' 6756 Activa 'expandcrossplus' y 'expandcrosscross'. 6757 'expandplus' 6758 Activa 'expanddotplus', 'expandcrossplus', 'expandgradplus', 6759 'expanddivplus', 'expandcurlplus' y 'expandlaplacianplus'. 6760 'expandprod' 6761 Activa 'expandgradprod', 'expanddivprod' y 6762 'expandlaplacianprod'. 6763 6764 Estas variables están declaradas como 'evflag'. 6765 6766 -- Función: zeromatrix (<m>, <n>) 6767 Devuelve una matriz rectangular <m> por <n> con todos sus elementos 6768 iguales a cero. 6769 6770 -- Símbolo especial: [ 6771 -- Símbolo especial: [ 6772 Los símbolos '[' y ']' marcan el comienzo y final, respectivamente, 6773 de una lista. 6774 6775 Los símbolos '[' y ']' también se utilizan para indicar los 6776 subíndices de los elementos de una lista, arreglo o función 6777 arreglo. 6778 6779 Ejemplos: 6780 6781 (%i1) x: [a, b, c]; 6782 (%o1) [a, b, c] 6783 (%i2) x[3]; 6784 (%o2) c 6785 (%i3) array (y, fixnum, 3); 6786 (%o3) y 6787 (%i4) y[2]: %pi; 6788 (%o4) %pi 6789 (%i5) y[2]; 6790 (%o5) %pi 6791 (%i6) z['foo]: 'bar; 6792 (%o6) bar 6793 (%i7) z['foo]; 6794 (%o7) bar 6795 (%i8) g[k] := 1/(k^2+1); 6796 1 6797 (%o8) g := ------ 6798 k 2 6799 k + 1 6800 (%i9) g[10]; 6801 1 6802 (%o9) --- 6803 101 6804 6805 6806File: maxima.info, Node: Afines, Next: itensor, Prev: Matrices y Álgebra Lineal, Up: Top 6807 680824 Afines 6809********* 6810 6811* Menu: 6812 6813* Funciones y variables para Afines:: 6814 6815 6816File: maxima.info, Node: Funciones y variables para Afines, Prev: Afines, Up: Afines 6817 681824.1 Funciones y variables para Afines 6819====================================== 6820 6821 -- Función: fast_linsolve ([<expr_1>, ..., <expr_m>], [<x_1>, ..., 6822 <x_n>]) 6823 Resuelve las ecuaciones lineales simultáneas <expr_1>, ..., 6824 <expr_m> para las variables <x_1>, ..., <x_n>. Cada <expr_i> puede 6825 ser una ecuación o una expresión general; en caso de tratarse de 6826 una expresión general, será tratada como una ecuación de la forma 6827 '<expr_i> = 0'. 6828 6829 El valor que devuelve es una lista de ecuaciones de la forma 6830 '[<x_1> = <a_1>, ..., <x_n> = <a_n>]' donde todas las <a_1>, ..., 6831 <a_n> están exentas de <x_1>, ..., <x_n>. 6832 6833 La función 'fast_linsolve' es más rápida que 'linsolve' para 6834 sistemas de ecuaciones con coeficientes dispersos. 6835 6836 Antes de utilizar esta función ejecútese 'load(affine)'. 6837 6838 -- Función: grobner_basis ([<expr_1>, ..., <expr_m>]) 6839 Devuelve una base de Groebner para las ecuaciones <expr_1>, ..., 6840 <expr_m>. La función 'polysimp' puede ser entonces utilizada para 6841 simplificar otras funciones relativas a las ecuaciones. 6842 6843 grobner_basis ([3*x^2+1, y*x])$ 6844 6845 polysimp (y^2*x + x^3*9 + 2) ==> -3*x + 2 6846 6847 'polysimp(f)' alcanza 0 si y sólo si <f> está en el ideal generado 6848 por <expr_1>, ..., <expr_m>, es decir, si y sólo si <f> es una 6849 combinación polinómica de los elementos de <expr_1>, ..., <expr_m>. 6850 6851 Antes de utilizar esta función ejecútese 'load(affine)'. 6852 6853 -- Función: set_up_dot_simplifications (<eqns>, <check_through_degree>) 6854 -- Función: set_up_dot_simplifications (<eqns>) 6855 6856 Las <eqns> son ecuaciones polinómicas de variables no conmutativas. 6857 El valor de 'current_variables' es la lista de variables utilizadas 6858 para el cálculo de los grados. Las ecuaciones deben ser 6859 homogéneas, al objeto de completar el procedimiento. 6860 6861 El grado es el devuelto por 'nc_degree'. Éste a su vez depende de 6862 los pesos de las variables individuales. 6863 6864 Antes de utilizar esta función ejecútese 'load(affine)'. 6865 6866 -- Función: declare_weights (<x_1>, <w_1>, ..., <x_n>, <w_n>) 6867 Asigna los pesos <w_1>, ..., <w_n> a <x_1>, ..., <x_n>, 6868 respectivamente. Estos pesos son los utilizados en el cálculo de 6869 'nc_degree'. 6870 6871 Antes de utilizar esta función ejecútese 'load(affine)'. 6872 6873 -- Función: nc_degree (<p>) 6874 Devuelve el grado de un polinomio no conmutativo <p>. Véase 6875 'declare_weights'. 6876 6877 Antes de utilizar esta función ejecútese 'load(affine)'. 6878 6879 -- Función: dotsimp (<f>) 6880 Devuelve 0 si y sólo si <f> está en el ideal generado por las 6881 ecuaciones, esto es, si y sólo si <f> es una combinación lineal de 6882 los elementos de las ecuaciones. 6883 6884 Antes de utilizar esta función ejecútese 'load(affine)'. 6885 6886 -- Función: fast_central_elements ([<x_1>, ..., <x_n>], <n>) 6887 Si se ha ejecutado 'set_up_dot_simplifications' con antelación, 6888 obtiene los polinomios centrales de grado <n> de variables <x_1>, 6889 ..., <x_n>. 6890 6891 Por ejemplo: 6892 set_up_dot_simplifications ([y.x + x.y], 3); 6893 fast_central_elements ([x, y], 2); 6894 [y.y, x.x]; 6895 6896 Antes de utilizar esta función ejecútese 'load(affine)'. 6897 6898 -- Función: check_overlaps (<n>, <add_to_simps>) 6899 Revisa la superposición hasta el grado <n>, asegurándose de que el 6900 usuario tiene suficientes reglas de simplificación en cada grado 6901 para que 'dotsimp' trabaje correctamente. Este proceso puede 6902 acelerarse si se conoce de antemano cuál es la dimensión del 6903 espacio de monomios. Si éste es de dimensión global finita, 6904 entonces debería usarse 'hilbert'. Si no se conoce la dimensiones 6905 de los monomios, no se debería especificar una 'rank_function'. Un 6906 tercer argumento opcional es 'reset'. 6907 6908 Antes de utilizar esta función ejecútese 'load(affine)'. 6909 6910 -- Función: mono ([<x_1>, ..., <x_n>], <n>) 6911 Devuelve la lista de monomios independientes. 6912 6913 Antes de utilizar esta función ejecútese 'load(affine)'. 6914 6915 -- Función: monomial_dimensions (<n>) 6916 Calcula el desarrollo de Hilbert de grado <n> para el algebra 6917 actual. 6918 6919 Antes de utilizar esta función ejecútese 'load(affine)'. 6920 6921 -- Función: extract_linear_equations ([<p_1>, ..., <p_n>], [<m_1>, ..., 6922 <m_n>]) 6923 Hace una lista de los coeficientes de los polinomios no 6924 conmutativos <p_1>, ..., <p_n> de los monomios no conmutativos 6925 <m_1>, ..., <m_n>. Los coeficientes deben escalares. Hágase uso 6926 de 'list_nc_monomials' para construir la lista de monomios. 6927 6928 Antes de utilizar esta función ejecútese 'load(affine)'. 6929 6930 -- Función: list_nc_monomials ([<p_1>, ..., <p_n>]) 6931 -- Función: list_nc_monomials (<p>) 6932 Devuelve una lista de los monomios no conmutativos que aparecen en 6933 el polinomio <p> o una lista de polinomios en <p_1>, ..., <p_n>. 6934 6935 Antes de utilizar esta función ejecútese 'load(affine)'. 6936 6937 -- Variable: all_dotsimp_denoms 6938 Valor por defecto: 'false' 6939 6940 Cuando 'all_dotsimp_denoms' es una lista, los denominadores 6941 encontrados por 'dotsimp' son añadidos a la lista. La variable 6942 'all_dotsimp_denoms' puede inicializarse como una lista vacía '[]' 6943 antes de llamar a 'dotsimp'. 6944 6945 Por defecto, 'dotsimp' no recolecta los denominadores. 6946 6947 6948File: maxima.info, Node: itensor, Next: ctensor, Prev: Afines, Up: Top 6949 695025 itensor 6951********** 6952 6953* Menu: 6954 6955* Introducción a itensor:: 6956* Funciones y variables para itensor:: 6957 6958 6959File: maxima.info, Node: Introducción a itensor, Next: Funciones y variables para itensor, Prev: itensor, Up: itensor 6960 696125.1 Introducción a itensor 6962=========================== 6963 6964Maxima implementa dos tipos diferentes de manipulación simbólica de 6965tensores: la manipulación de componentes (paquete 'ctensor') y la 6966manipulación indexada (paquete 'itensor'). 6967 6968Véase más abajo la nota sobre 'notación tensorial'. 6969 6970La manipulación de componentes significa que los objetos geométricos 6971tensoriales se representan como arreglos (arrays) o matrices. 6972Operaciones tensoriales como la contracción o la diferenciación 6973covariante se llevan a cabo sumando índices mudos con la sentencia 'do'. 6974Esto es, se realizan operaciones directamente con las componentes del 6975tensor almacenadas en un arreglo o matriz. 6976 6977La manipulación indexada de tensores se lleva a cabo mediante la 6978representación de los tensores como funciones de sus índices 6979covariantes, contravariantes y de derivadas. Operaciones tensoriales 6980como la contracción o la diferenciación covariante se realizan 6981manipulando directamente los índices, en lugar de sus componentes 6982asociadas. 6983 6984Estas dos técnicas para el tratamiento de los procesos diferenciales, 6985algebraicos y analíticos en el contexto de la geometría riemanniana 6986tienen varias ventajas y desventajas que surgen según la naturaleza y 6987dificultad del problema que está abordando el usuario. Sin embargo, se 6988deben tener presentes las siguientes características de estas dos 6989técnicas: 6990 6991La representación de los tensores y sus operaciones en términos de sus 6992componentes facilita el uso de paquete 'ctensor'. La especificación de 6993la métrica y el cálculo de los tensores inducidos e invariantes es 6994inmediato. Aunque toda la potencia de simplificación de Maxima se 6995encuentra siempre a mano, una métrica compleja con dependencias 6996funcionales y de coordenadas intrincada, puede conducir a expresiones de 6997gran tamaño en las que la estructura interna quede oculta. Además, 6998muchos cálculos requieren de expresiones intermedias que pueden provocar 6999la detención súbita de los programas antes de que se termine el cálculo. 7000Con la experiencia, el usuario podrá evitar muchas de estas 7001dificultades. 7002 7003Devido a la forma en que los tensores y sus operaciones se representan 7004en términos de operaciones simbólicas con sus índices, expresiones que 7005serían intratables en su representación por componentes pueden en 7006ocasiones simplificarse notablemente utilizando las rutinas especiales 7007para objetos simétricos del paquete 'itensor'. De esta manera, la 7008estructura de expresiones grandes puede hacerse más transparente. Por 7009otro lado, debido a la forma especial de la representación indexada de 7010tensores en 'itensor', en algunos casos el usuario encontrará 7011dificultades con la especificación de la métrica o la definición de 7012funciones. 7013 7014El paquete 'itensor' puede derivar respecto de una variable indexada, lo 7015que permite utilizar el paquete cuando se haga uso del formalismo de 7016lagrangiano y hamiltoniano. Puesto que es posible derivar un campo 7017lagrangiano respecto de una variable de campo indexada, se puede hacer 7018uso de Maxima para derivar las ecuaciones de Euler-Lagrange 7019correspondientes en forma indexada. Estas ecuaciones pueden traducirse 7020a componentes tensoriales ('ctensor') con la función 'ic_convert', lo 7021que permite resolver las ecuaciones de campo en cualquier sistema de 7022coordenadas, o obtener las ecuaciones de movimiento en forma 7023hamiltoniana. Véanse dos ejemplos en 'einhil.dem' y 'bradic.dem'; el 7024primero utiliza la acción de Einstein-Hilbert para derivar el campo 7025tensorial de Einstein en el caso homogéneo e isotrópico (ecuaciones de 7026Friedmann), así como en el caso esferosimétrico estático (solución de 7027Schwarzschild); el segundo demuestra cómo calcular las ecuaciones de 7028Friedmann a partir de la acción de la teoría de la gravedad de 7029Brans-Dicke, y también muestra cómo derivar el hamiltoniano asociado con 7030la teoría del campo escalar. 7031 703225.1.1 Notación tensorial 7033------------------------- 7034 7035Hasta ahora, el paquete 'itensor' de Maxima utilizaba una notación que 7036algunas veces llevaba a una ordenación incorrecta de los índices. Por 7037ejemplo: 7038 7039 (%i2) imetric(g); 7040 (%o2) done 7041 (%i3) ishow(g([],[j,k])*g([],[i,l])*a([i,j],[]))$ 7042 i l j k 7043 (%t3) g g a 7044 i j 7045 (%i4) ishow(contract(%))$ 7046 k l 7047 (%t4) a 7048 7049Este resultado no es correcto a menos que 'a' sea un tensor simétrico. 7050La razón por la que esto ocurre es que aunque 'itensor' mantenga 7051correctamente el orden dentro del conjunto de índices covariantes y 7052contravariantes, una vez un índice sea aumentado o disminuido, su 7053posición relativa al otro conjunto de índices se pierde. 7054 7055Para evitar este problema, se ha desarrollado una notación totalmente 7056compatible con la anterior.En esta notación, los índices contravariantes 7057se insertan en las posiciones correctas en la lista de índices 7058covariantes, pero precedidos del signo negativo. 7059 7060En esta notación, el ejemplo anterior da el resultado correcto: 7061 7062 (%i5) ishow(g([-j,-k],[])*g([-i,-l],[])*a([i,j],[]))$ 7063 i l j k 7064 (%t5) g a g 7065 i j 7066 (%i6) ishow(contract(%))$ 7067 l k 7068 (%t6) a 7069 7070El único código que hace uso de esta notación es la función 'lc2kdt'. 7071 7072Devido a que este código es nuevo, puede contener errores. 7073 707425.1.2 Manipulación indexada de tensores 7075---------------------------------------- 7076 7077El paquete 'itensor' se carga haciendo 'load(itensor)'. Para acceder a 7078las demos se hará 'demo(tensor)'. 7079 7080En el paquete 'itensor' un tensor se representa como un objeto indexado, 7081esto es, como una función de tres grupos de índices: los covariantes, 7082los contravariantes y los de derivadas. Los índices covariantes se 7083especifican mediante una lista que será el primer argumento del objeto 7084indexado, siendo los índices contravariantes otra lista que será el 7085segundo argumento del mismo objeto indexado. Si al objeto indexado le 7086falta cualquiera de estos grupos de índices, entonces se le asignará al 7087argumento correspondiente la lista vacía '[]'. Así, 'g([a,b],[c])' 7088representa un objeto indexado llamado 'g', el cual tiene dos índices 7089covariantes '(a,b)', un índice contravariante ('c') y no tiene índices 7090de derivadas. 7091 7092Los índices de derivadas, si están presentes, se añaden como argumentos 7093adicionales a la función simbólica que representa al tensor. Se pueden 7094especificar explícitamente por el usuario o pueden crearse durante el 7095proceso de diferenciación respecto de alguna coordenada. Puesto que la 7096diferenciación ordinaria es conmutativa, los índices de derivadas se 7097ordenan alfanuméricamente, a menos que la variable 'iframe_flag' valga 7098'true', indicando que se está utilizando una métrica del sistema de 7099referencia. Esta ordenación canónica hace posible que Maxima reconozca, 7100por ejemplo, que 't([a],[b],i,j)' es lo mismo que 't([a],[b],j,i)'. La 7101diferenciación de un objeto indexado con respecto de alguna coordenada 7102cuyo índice no aparece como argumento de dicho objeto indexado, dará 7103como resultado cero. Esto se debe a que Maxima no sabe si el tensor 7104representado por el objeto indexado depende implícitamente de la 7105coordenada correspondiente. Modificando la función 'diff' de Maxima en 7106'itensor', se da por hecho que todos los objetos indexados dependen de 7107cualquier variable de diferenciación, a menos que se indique lo 7108contrario. Esto hace posible que la convención sobre la sumación se 7109extienda a los índices de derivadas. El paquete 'itensor' trata a los 7110índices de derivadas como covariantes. 7111 7112Las siguientes funciones forman parte del paquete 'itensor' para la 7113manipulación indexada de vectores. En lo que respecta a las rutinas de 7114simplificación, no se considera en general que los objetos indexados 7115tengan propiedades simétricas. Esto puede cambiarse reasignando a la 7116variable 'allsym[false]' el valor 'true', con lo cual los objetos 7117indexados se considerarán simétricos tanto respecto de sus índices 7118covariantes como contravariantes. 7119 7120En general, el paquete 'itensor' trata a los tensores como objetos 7121opacos. Las ecuaciones tensoriales se manipulan en base a reglas 7122algebraicas, como la simetría y la contracción. Además, en el paquete 7123'itensor' hay funciones para la diferenciación covariante, la curvatura 7124y la torsión. Los cálculos se pueden realizar respecto de una métrica 7125del sistema de referencia móvil, dependiendo de las asignaciones dadas a 7126la variable 'iframe_flag'. 7127 7128La siguiente sesión de ejemplo demuestra cómo cargar el paquete 7129'itensor', especificar el nombre de la métrica y realizar algunos 7130cálculos sencillos. 7131 7132 (%i1) load(itensor); 7133 (%o1) /share/tensor/itensor.lisp 7134 (%i2) imetric(g); 7135 (%o2) done 7136 (%i3) components(g([i,j],[]),p([i,j],[])*e([],[]))$ 7137 (%i4) ishow(g([k,l],[]))$ 7138 (%t4) e p 7139 k l 7140 (%i5) ishow(diff(v([i],[]),t))$ 7141 (%t5) 0 7142 (%i6) depends(v,t); 7143 (%o6) [v(t)] 7144 (%i7) ishow(diff(v([i],[]),t))$ 7145 d 7146 (%t7) -- (v ) 7147 dt i 7148 (%i8) ishow(idiff(v([i],[]),j))$ 7149 (%t8) v 7150 i,j 7151 (%i9) ishow(extdiff(v([i],[]),j))$ 7152 (%t9) v - v 7153 j,i i,j 7154 ----------- 7155 2 7156 (%i10) ishow(liediff(v,w([i],[])))$ 7157 %3 %3 7158 (%t10) v w + v w 7159 i,%3 ,i %3 7160 (%i11) ishow(covdiff(v([i],[]),j))$ 7161 %4 7162 (%t11) v - v ichr2 7163 i,j %4 i j 7164 (%i12) ishow(ev(%,ichr2))$ 7165 %4 %5 7166 (%t12) v - (g v (e p + e p - e p - e p 7167 i,j %4 j %5,i ,i j %5 i j,%5 ,%5 i j 7168 7169 + e p + e p ))/2 7170 i %5,j ,j i %5 7171 (%i13) iframe_flag:true; 7172 (%o13) true 7173 (%i14) ishow(covdiff(v([i],[]),j))$ 7174 %6 7175 (%t14) v - v icc2 7176 i,j %6 i j 7177 (%i15) ishow(ev(%,icc2))$ 7178 %6 7179 (%t15) v - v ifc2 7180 i,j %6 i j 7181 (%i16) ishow(radcan(ev(%,ifc2,ifc1)))$ 7182 %6 %7 %6 %7 7183 (%t16) - (ifg v ifb + ifg v ifb - 2 v 7184 %6 j %7 i %6 i j %7 i,j 7185 7186 %6 %7 7187 - ifg v ifb )/2 7188 %6 %7 i j 7189 (%i17) ishow(canform(s([i,j],[])-s([j,i])))$ 7190 (%t17) s - s 7191 i j j i 7192 (%i18) decsym(s,2,0,[sym(all)],[]); 7193 (%o18) done 7194 (%i19) ishow(canform(s([i,j],[])-s([j,i])))$ 7195 (%t19) 0 7196 (%i20) ishow(canform(a([i,j],[])+a([j,i])))$ 7197 (%t20) a + a 7198 j i i j 7199 (%i21) decsym(a,2,0,[anti(all)],[]); 7200 (%o21) done 7201 (%i22) ishow(canform(a([i,j],[])+a([j,i])))$ 7202 (%t22) 0 7203 7204