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: Conjuntos, Next: Definición de Funciones, Prev: Reglas y patrones, Up: Top 13 1435 Conjuntos 15************ 16 17* Menu: 18 19* Introducción a los conjuntos:: 20* Funciones y variables para los conjuntos:: 21 22 23File: maxima.info, Node: Introducción a los conjuntos, Next: Funciones y variables para los conjuntos, Prev: Conjuntos, Up: Conjuntos 24 2535.1 Introducción a los conjuntos 26================================= 27 28Maxima dispone de funciones para realizar operaciones con conjuntos, 29como la intersección o la unión. Los conjuntos deben ser finitos y 30definidos por enumeración. Maxima trata a los conjuntos y a las listas 31como objectos de distinta naturaleza, lo que permite trabajar con 32conjuntos cuyos elementos puedan ser también conjuntos o listas. 33 34Además de funciones para operar con conjuntos finitos, Maxima dispone 35también de algunas funciones sobre combinatoria, como los números de 36Stirling de primera y segunda especie, números de Bell, coeficientes 37multinomiales, particiones de enteros no negativos y algunos otros. 38Maxima también define la función delta de Kronecker. 39 4035.1.1 Utilización 41------------------ 42 43Para construir un conjunto cuyos elementos sean 'a_1, ..., a_n', se 44utiliza la instrucción 'set(a_1, ..., a_n)' o '{a_1, ..., a_n}'; para 45formar un conjunto vacío, basta con hacer 'set()' o '{}'. Para 46introducir conjuntos en Maxima, 'set (...)' y '{ ... }' son 47equivalentes. Los conjuntos se muestran siempre con llave. 48 49Si un elemento se indica más de una vez, el proceso de simplificación 50elimina los elementos redundantes. 51 52 (%i1) set(); 53 (%o1) {} 54 (%i2) set(a, b, a); 55 (%o2) {a, b} 56 (%i3) set(a, set(b)); 57 (%o3) {a, {b}} 58 (%i4) set(a, [b]); 59 (%o4) {a, [b]} 60 (%i5) {}; 61 (%o5) {} 62 (%i6) {a, b, a}; 63 (%o6) {a, b} 64 (%i7) {a, {b}}; 65 (%o7) {a, {b}} 66 (%i8) {a, [b]}; 67 (%o8) {a, [b]} 68 69Dos elementos candidatos a formar parte de un conjunto, <x> e <y>, son 70redundantes, esto es, se consideran el mismo elemento a efectos de 71consruir el conjunto, si y sólo si 'is (<x> = <y>)' devuelve el valor 72'true'. Nótese que 'is (equal (<x>, <y>))' puede devolver 'true' y 'is 73(<x> = <y>)' retornar 'false'; en cuyo caso los elementos <x> e <y> se 74considerarían distintos. 75 76 (%i1) x: a/c + b/c; 77 b a 78 (%o1) - + - 79 c c 80 (%i2) y: a/c + b/c; 81 b a 82 (%o2) - + - 83 c c 84 (%i3) z: (a + b)/c; 85 b + a 86 (%o3) ----- 87 c 88 (%i4) is (x = y); 89 (%o4) true 90 (%i5) is (y = z); 91 (%o5) false 92 (%i6) is (equal (y, z)); 93 (%o6) true 94 (%i7) y - z; 95 b + a b a 96 (%o7) - ----- + - + - 97 c c c 98 (%i8) ratsimp (%); 99 (%o8) 0 100 (%i9) {x, y, z}; 101 b + a b a 102 (%o9) {-----, - + -} 103 c c c 104 105Para formar un conjunto a partir de los miembros de una lista úsese 106'setify'. 107 108 (%i1) setify([b, a]); 109 (%o1) {a, b} 110 111Los elementos 'x' e 'y' de un conjunto se consideran iguales si 'is(x = 112y)' devuelve el valor 'true'. Así, 'rat(x)' y 'x' se consideran el 113mismo elemento de un conjunto; consecuentemente, 114 115 (%i1) {x, rat(x)}; 116 (%o1) {x} 117 118Además, puesto que 'is((x-1)*(x+1) = x^2 - 1)' devuelve 'false', 119'(x-1)*(x+1)' y 'x^2-1' se consideran elementos diferentes; así 120 121 (%i1) {(x - 1)*(x + 1), x^2 - 1}; 122 2 123 (%o1) {(x - 1) (x + 1), x - 1} 124 125Para reducir este conjunto a otro unitario, aplicar 'rat' a cada 126elemento del conjunto: 127 128 (%i1) {(x - 1)*(x + 1), x^2 - 1}; 129 2 130 (%o1) {(x - 1) (x + 1), x - 1} 131 (%i2) map (rat, %); 132 2 133 (%o2)/R/ {x - 1} 134 135Para eliminar redundancias con otros conjuntos, será necesario utilizar 136otras funciones de simplificación. He aquí un ejemplo que utiliza 137'trigsimp': 138 139 (%i1) {1, cos(x)^2 + sin(x)^2}; 140 2 2 141 (%o1) {1, sin (x) + cos (x)} 142 (%i2) map (trigsimp, %); 143 (%o2) {1} 144 145Se entiende que un conjunto está simplificado cuando entre sus elementos 146no hay redundancias y se hayan ordenados. La versión actual de las 147funciones para conjuntos utiliza la función 'orderlessp' de Maxima para 148ordenar sus elementos; sin embargo, futuras versiones de las funciones 149para operar con conjuntos podrán utilizar otras funciones de ordenación. 150 151Algunas operaciones con conjuntos, tales como la sustitución, fuerzan 152automáticamente una re-simplificación; por ejemplo, 153 154 (%i1) s: {a, b, c}$ 155 (%i2) subst (c=a, s); 156 (%o2) {a, b} 157 (%i3) subst ([a=x, b=x, c=x], s); 158 (%o3) {x} 159 (%i4) map (lambda ([x], x^2), set (-1, 0, 1)); 160 (%o4) {0, 1} 161 162Maxima considera a las listas y conjuntos como objetos diferentes; 163funciones tales como 'union' y 'intersection' emitirán un error si 164alguno de sus argumentos no es un conjunto. Si se necesita aplicar una 165función de conjunto a una lista, se deberá utilizar la función 'setify' 166para convertirla previamente en conjunto. Así, 167 168 (%i1) union ([1, 2], {a, b}); 169 Function union expects a set, instead found [1,2] 170 -- an error. Quitting. To debug this try debugmode(true); 171 (%i2) union (setify ([1, 2]), {a, b}); 172 (%o2) {1, 2, a, b} 173 174Para extraer todos los elementos de un conjunto 's' que satisfagan un 175predicado 'f', úsese 'subset(s,f)'. (Un predicado es una función 176booleana.) Por ejemplo, para encontrar las ecuaciones en un conjunto 177dado que no dependan de la variable 'z', se hará 178 179 (%i1) subset ({x + y + z, x - y + 4, x + y - 5}, 180 lambda ([e], freeof (z, e))); 181 (%o1) {- y + x + 4, y + x - 5} 182 183La sección 'Funciones y variables para los conjuntos' incluye una lista 184completa de funciones para operar con conjuntos en Maxima. 185 18635.1.2 Iteraciones con elementos 187-------------------------------- 188 189Hay dos formas para operar iterativamente sobre los elementos de un 190conjunto. Una es utilizar 'map'; por ejemplo: 191 192 (%i1) map (f, {a, b, c}); 193 (%o1) {f(a), f(b), f(c)} 194 195La otra forma consiste en hacer uso de la construcción 'for <x> in <s> 196do' 197 198 (%i1) s: {a, b, c}; 199 (%o1) {a, b, c} 200 (%i2) for si in s do print (concat (si, 1)); 201 a1 202 b1 203 c1 204 (%o2) done 205 206Las funciones de Maxima 'first' y 'rest' funcionan también con 207conjuntos. En este caso, 'first' devuelve el primer elemento que se 208muestra del conjunto, el cual puede depender de la implementación del 209sistema. Si 's' es un conjunto, entonces 'rest(s)' equivale a 'disjoin 210(first(s), s)'. Hay otras funciones que trabajan correctamente con 211conjuntos. En próximas versiones de las funciones para operar con 212conjuntos es posible que 'first' y 'rest' trabajen de modo diferente o 213que ya no lo hagan en absoluto. 214 21535.1.3 Fallos 216------------- 217 218Las funciones para operar con conjuntos utilizan la función 'orderlessp' 219de Maxima para ordenar los elementos de los conjuntos, así como la 220función 'like' de Lisp para decidir sobre la igualdad de dichos 221elementos. Ambas funciones tienen fallos que son conocidos y que pueden 222aflorar si se trabaja con conjuntos que tengan elementos en formato de 223listas o matrices y que contengan expresiones racionales canónicas 224(CRE). Un ejemplo es 225 226 (%i1) {[x], [rat (x)]}; 227 Maxima encountered a Lisp error: 228 229 The value #:X1440 is not of type LIST. 230 231 Automatically continuing. 232 To reenable the Lisp debugger set *debugger-hook* to nil. 233 234Esta expresión provoca una parada de Maxima junto con la emisión de un 235mensaje de error, el cual dependerá de la versión de Lisp que utilice 236Maxima. Otro ejemplo es 237 238 (%i1) setify ([[rat(a)], [rat(b)]]); 239 Maxima encountered a Lisp error: 240 241 The value #:A1440 is not of type LIST. 242 243 Automatically continuing. 244 To reenable the Lisp debugger set *debugger-hook* to nil. 245 246Estos fallos son causados por fallos en 'orderlessp' y 'like', no por 247fallos cuyo origen se encuentre en las funciones para conjuntos. Para 248ilustrarlo, se pueden ejecutar las siguientes expresiones 249 250 (%i1) orderlessp ([rat(a)], [rat(b)]); 251 Maxima encountered a Lisp error: 252 253 The value #:B1441 is not of type LIST. 254 255 Automatically continuing. 256 To reenable the Lisp debugger set *debugger-hook* to nil. 257 (%i2) is ([rat(a)] = [rat(a)]); 258 (%o2) false 259 260Hasta que estos errores no se corrijan, no es aconsejable construir 261conjuntos que tengan por elementos listas o matrices que contengan 262expresiones en forma CRE; sin embargo, un conjunto con elementos de la 263forma CRE no deberían dar problemas: 264 265 (%i1) {x, rat (x)}; 266 (%o1) {x} 267 268La función 'orderlessp' de Maxima tiene otro fallo que puede causar 269problemas con las funciones para conjuntos, en concreto, que el 270predicado de ordenación 'orderlessp' no es transitivo. El ejemplo más 271simple que ilustra este punto es 272 273 (%i1) q: x^2$ 274 (%i2) r: (x + 1)^2$ 275 (%i3) s: x*(x + 2)$ 276 (%i4) orderlessp (q, r); 277 (%o4) true 278 (%i5) orderlessp (r, s); 279 (%o5) true 280 (%i6) orderlessp (q, s); 281 (%o6) false 282 283El fallo puede causar problemas con todas las funciones para conjuntos, 284así como también con otras funciones de Maxima. Es probable, pero no 285seguro, que este fallo se puede evitar si todos los elementos del 286conjunto están en la forma de expresión racional canónica (CRE) o han 287sido simplificados con 'ratsimp'. 288 289Los mecanismos 'orderless' y 'ordergreat' de Maxima son incompatibles 290con las funciones para conjuntos. Si se necesitan utilizar 'orderless' 291o 'ordergreat', hágase antes de construir los conjuntos y no se utilice 292la instrucción 'unorder'. 293 294Se ruega a todo usuario que crea haber encontrado un fallo en las 295funciones para conjuntos que lo comunique en la base de datos de Maxima. 296Véase 'bug_report'. 297 29835.1.4 Autores 299-------------- 300 301Stavros Macrakis de Cambridge, Massachusetts y Barton Willis de la 302University of Nebraska at Kearney (UNK). 303 304 305File: maxima.info, Node: Funciones y variables para los conjuntos, Prev: Introducción a los conjuntos, Up: Conjuntos 306 30735.2 Funciones y variables para los conjuntos 308============================================= 309 310 -- Función: adjoin (<x>, <a>) 311 312 Calcula la unión del conjunto <a> y '{<x>}'. 313 314 La función 'adjoin' emite un mensaje de error si <a> no es un 315 conjunto literal. 316 317 Las sentencias 'adjoin(<x>, <a>)' y 'union(set(<x>), <a>)' son 318 equivalentes, aunque 'adjoin' puede ser algo más rápida que 319 'union'. 320 321 Véase también 'disjoin'. 322 323 Ejemplos: 324 325 (%i1) adjoin (c, {a, b}); 326 (%o1) {a, b, c} 327 (%i2) adjoin (a, {a, b}); 328 (%o2) {a, b} 329 330 -- Función: belln (<n>) 331 332 Representa el n-ésimo número de Bell, de modo que 'belln(n)' es el 333 número de particiones de un conjunto de <n> elementos. 334 335 El argumento <n> debe ser un entero no negativo. 336 337 La función 'belln' se distribuye sobre ecuaciones, listas, matrices 338 y conjuntos. 339 340 Ejemplos: 341 342 'belln' se aplica a enteros no negativos, 343 344 (%i1) makelist (belln (i), i, 0, 6); 345 (%o1) [1, 1, 2, 5, 15, 52, 203] 346 (%i2) is (cardinality (set_partitions ({})) = belln (0)); 347 (%o2) true 348 (%i3) is (cardinality (set_partitions ({1, 2, 3, 4, 5, 6})) 349 = belln (6)); 350 (%o3) true 351 352 Si <n> no es un entero no negativo, la función 'belln(n)' no hace 353 cálculo alguno. 354 355 (%i1) [belln (x), belln (sqrt(3)), belln (-9)]; 356 (%o1) [belln(x), belln(sqrt(3)), belln(- 9)] 357 358 -- Función: cardinality (<a>) 359 360 Devuelve el número de elementos del conjunto <a>. 361 362 La función 'cardinality' ignora los elementos redundantes, incluso 363 cuando la simplificación está desabilitada. 364 365 Ejemplos: 366 367 (%i1) cardinality ({}); 368 (%o1) 0 369 (%i2) cardinality ({a, a, b, c}); 370 (%o2) 3 371 (%i3) simp : false; 372 (%o3) false 373 (%i4) cardinality ({a, a, b, c}); 374 (%o4) 3 375 376 -- Función: cartesian_product (<b_1>, ... , <b_n>) 377 378 Devuelve un conjunto formado por listas de la forma '[<x_1>, ..., 379 <x_n>]', siendo <x_1>, ..., <x_n> elementos de los conjuntos <b_1>, 380 ... , <b_n>, respectivamente. 381 382 La función 'cartesian_product' emite un mensaje de error si alguno 383 de sus argumentos no es un conjunto literal. 384 385 Ejemplos: 386 387 (%i1) cartesian_product ({0, 1}); 388 (%o1) {[0], [1]} 389 (%i2) cartesian_product ({0, 1}, {0, 1}); 390 (%o2) {[0, 0], [0, 1], [1, 0], [1, 1]} 391 (%i3) cartesian_product ({x}, {y}, {z}); 392 (%o3) {[x, y, z]} 393 (%i4) cartesian_product ({x}, {-1, 0, 1}); 394 (%o4) {[x, - 1], [x, 0], [x, 1]} 395 396 -- Función: disjoin (<x>, <a>) 397 398 Devuelve el conjunto <a> sin el elemento <x>. Si <x> no es 399 elemento de <a>, entonces el resultado es el propio <a>. 400 401 La función 'disjoin' emite un mensaje de error si <a> no es un 402 conjunto literal. 403 404 Las sentencias 'disjoin(<x>, <a>)', 'delete(<x>, <a>)' y 405 'setdifference(<a>, set(<x>))' son todas ellas equivalentes; pero 406 en general, 'disjoin' será más rápida que las otras. 407 408 Ejemplos: 409 410 (%i1) disjoin (a, {a, b, c, d}); 411 (%o1) {b, c, d} 412 (%i2) disjoin (a + b, {5, z, a + b, %pi}); 413 (%o2) {5, %pi, z} 414 (%i3) disjoin (a - b, {5, z, a + b, %pi}); 415 (%o3) {5, %pi, b + a, z} 416 417 -- Función: disjointp (<a>, <b>) 418 419 Devuelve 'true' si y sólo si los conjuntos <a> y <b> son disjuntos. 420 421 La función 'disjointp' emite un mensaje de error si <a> o <b> no 422 son conjuntos literales. 423 424 Ejemplos: 425 426 (%i1) disjointp ({a, b, c}, {1, 2, 3}); 427 (%o1) true 428 (%i2) disjointp ({a, b, 3}, {1, 2, 3}); 429 (%o2) false 430 431 -- Función: divisors (<n>) 432 433 Calcula el conjunto de divisores de <n>. 434 435 La sentencia 'divisors(<n>)' devuelve un conjunto de enteros si <n> 436 es un entero no nulo. El conjunto de divisores incluye los 437 elementos 1 y <n>. Los divisores de un entero negativo son los 438 divisores de su valor absoluto. 439 440 La función 'divisors' se distribuye sobre las ecuaciones, listas, 441 matrices y conjuntos. 442 443 Ejemplos: 444 445 Se puede comprobar que 28 es un número perfecto: la suma de sus 446 divisores (excepto él mismo) es 28. 447 448 (%i1) s: divisors(28); 449 (%o1) {1, 2, 4, 7, 14, 28} 450 (%i2) lreduce ("+", args(s)) - 28; 451 (%o2) 28 452 453 La función 'divisors' es simplificadora. Haciendo la sustitución 454 de 'a' por 8 en 'divisors(a)' devuelve los divisores sin tener que 455 reevaluar 'divisors(8)', 456 457 (%i1) divisors (a); 458 (%o1) divisors(a) 459 (%i2) subst (8, a, %); 460 (%o2) {1, 2, 4, 8} 461 462 La función 'divisors' se distribuye sobre ecuaciones, listas, 463 matrices y conjuntos. 464 465 (%i1) divisors (a = b); 466 (%o1) divisors(a) = divisors(b) 467 (%i2) divisors ([a, b, c]); 468 (%o2) [divisors(a), divisors(b), divisors(c)] 469 (%i3) divisors (matrix ([a, b], [c, d])); 470 [ divisors(a) divisors(b) ] 471 (%o3) [ ] 472 [ divisors(c) divisors(d) ] 473 (%i4) divisors ({a, b, c}); 474 (%o4) {divisors(a), divisors(b), divisors(c)} 475 476 -- Función: elementp (<x>, <a>) 477 478 Devuelve 'true' si y sólo si <x> es miembro del conjunto <a>. 479 480 La función 'elementp' emite un mensaje de error si <a> no es un 481 conjunto literal. 482 483 Ejemplos: 484 485 (%i1) elementp (sin(1), {sin(1), sin(2), sin(3)}); 486 (%o1) true 487 (%i2) elementp (sin(1), {cos(1), cos(2), cos(3)}); 488 (%o2) false 489 490 -- Función: emptyp (<a>) 491 Devuelve 'true' si y sólo si <a> es el conjunto vacío o la lista 492 vacía. 493 494 Ejemplos: 495 496 (%i1) map (emptyp, [{}, []]); 497 (%o1) [true, true] 498 (%i2) map (emptyp, [a + b, {{}}, %pi]); 499 (%o2) [false, false, false] 500 501 -- Función: equiv_classes (<s>, <F>) 502 503 Devuelve el conjunto de las clases de equivalencia del conjunto <s> 504 respecto de la relación de equivalencia <F>. 505 506 El argumento <F> es una función de dos variables definida sobre el 507 producto cartesiano <s> por <s>. El valor devuelto por <F> debe 508 ser 'true' o 'false', o bien una expresión <expr> tal que 509 'is(<expr>)' tome el valor 'true' o 'false'. 510 511 Si <F> no es una relación de equivalencia, 'equiv_classes' la 512 acepta sin emitir ningún mensaje de error, pero el resultado será 513 incorrecto en general. 514 515 Ejemplos: 516 517 La relación de equivalencia es una expresión lambda que devuelve 518 'true' o 'false', 519 520 (%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, 521 lambda ([x, y], is (equal (x, y)))); 522 (%o1) {{1, 1.0}, {2, 2.0}, {3, 3.0}} 523 524 La relación de equivalencia es el nombre de una función relacional 525 en la que 'is' evalúa a 'true' o 'false', 526 527 (%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, equal); 528 (%o1) {{1, 1.0}, {2, 2.0}, {3, 3.0}} 529 530 Las clases de equivalencia son números que difieren en un múltiplo 531 de 3. 532 533 (%i1) equiv_classes ({1, 2, 3, 4, 5, 6, 7}, 534 lambda ([x, y], remainder (x - y, 3) = 0)); 535 (%o1) {{1, 4, 7}, {2, 5}, {3, 6}} 536 537 -- Función: every (<f>, <s>) 538 -- Función: every (<f>, <L_1>, ..., <L_n>) 539 540 Devuelve 'true' si el predicado <f> vale 'true' para todos los 541 argumentos dados. 542 543 Dado un conjunto como segundo argumento, 'every(<f>, <s>)' devuelve 544 'true' si 'is(<f>(<a_i>))' devuelve 'true' para todos los <a_i> 545 pertenecientes <s>. La función 'every' puede evaluar o no <f> para 546 todos los <a_i> pertenecientes <s>. Puesto que los conjuntos no 547 están ordenados, 'every' puede evaluar '<f>(<a_i>)' en cualquier 548 orden. 549 550 Dada una o más listas como argumentos, 'every(<f>, <L_1>, ..., 551 <L_n>)' devuelve 'true' si 'is(<f>(<x_1>, ..., <x_n>))' devuelve 552 'true' para todo <x_1>, ..., <x_n> en <L_1>, ..., <L_n>, 553 respectivamente. La función 'every' puede evaluar o no <f> para 554 cualquier combinación de <x_1>, ..., <x_n>; además, 'every' evalúa 555 las listas en el orden creciente del índice. 556 557 Dado un conjunto vacío '{}' o lista vacía '[]' como argumentos, 558 'every' devuelve 'false'. 559 560 Si la variable global 'maperror' vale 'true', todas las listas 561 <L_1>, ..., <L_n> deben ser de igual longitud. Si 'maperror' vale 562 'false', los argumentos en forma de listas se truncan para igualar 563 sus longitudes a la de la lista más corta. 564 565 Los valores que devuelve el predicado <f> cuando toman (mediante 566 'is') un valor diferente a 'true' y 'false' se controlan con la 567 variable global 'prederror'. Si 'prederror' vale 'true', tales 568 valores se consideran como 'false' y la respuesta de 'every' es 569 'false'. Si 'prederror' vale 'false', tales valores se consideran 570 como desconocidos ('unknown') y la respuesta de 'every' es 571 'unknown'. 572 573 Ejemplos: 574 575 Se aplica 'every' a un único conjunto. El predicado es una función 576 de un argumento. 577 578 (%i1) every (integerp, {1, 2, 3, 4, 5, 6}); 579 (%o1) true 580 (%i2) every (atom, {1, 2, sin(3), 4, 5 + y, 6}); 581 (%o2) false 582 583 Se aplica 'every' a dos listas. El predicado es una función de dos 584 argumentos. 585 586 (%i1) every ("=", [a, b, c], [a, b, c]); 587 (%o1) true 588 (%i2) every ("#", [a, b, c], [a, b, c]); 589 (%o2) false 590 591 Las respuestas del predicado <f> que se evalúan a cualquier cosa 592 diferente de 'true' y 'false' están controlados por la variable 593 global 'prederror'. 594 595 (%i1) prederror : false; 596 (%o1) false 597 (%i2) map (lambda ([a, b], is (a < b)), [x, y, z], 598 [x^2, y^2, z^2]); 599 (%o2) [unknown, unknown, unknown] 600 (%i3) every ("<", [x, y, z], [x^2, y^2, z^2]); 601 (%o3) unknown 602 (%i4) prederror : true; 603 (%o4) true 604 (%i5) every ("<", [x, y, z], [x^2, y^2, z^2]); 605 (%o5) false 606 607 -- Función: extremal_subset (<s>, <f>, max) 608 -- Función: extremal_subset (<s>, <f>, min) 609 610 Calcula el subconjunto de <s> para el cual la función <f> toma sus 611 valores mayor y menor. 612 613 La sentencia 'extremal_subset(<s>, <f>, max)' devuelve el 614 subconjunto del conjunto o lista <s> para el cual la función real 615 <f> toma su valor máximo. 616 617 La sentencia 'extremal_subset(<s>, <f>, min)' devuelve el 618 subconjunto del conjunto o lista <s> para el cual la función real 619 <f> toma su valor mínimo. 620 621 Ejemplos 622 623 (%i1) extremal_subset ({-2, -1, 0, 1, 2}, abs, max); 624 (%o1) {- 2, 2} 625 (%i2) extremal_subset ({sqrt(2), 1.57, %pi/2}, sin, min); 626 (%o2) {sqrt(2)} 627 628 -- Función: flatten (<expr>) 629 630 Recoge los argumentos de subexpresiones con el mismo operador que 631 <expr> y construye con ellas otra expresión a partir de estos 632 argumentos. 633 634 Aquellas subexpresiones en las que el operador es diferente del 635 operador principal de 'expr' se copian sin modificarse, incluso 636 cuando ellas mismas contengan subexpresiones en las que el operador 637 sea el mismo que el de 'expr'. 638 639 Es posible que 'flatten' construya expresiones en las que el número 640 de argumentos difiera del número admitido por el operador, lo cual 641 hará que se emita un mensaje de error. La función 'flatten' no 642 intentará detectar estas situaciones. 643 644 Las expresiones que tengan representaciones especiales, por ejemplo 645 las racionales canónicas (CRE), no admiten que se aplique sobre 646 ellas la función 'flatten'; en tales casos se devuelve el argumento 647 sin modificación. 648 649 Ejemplos: 650 651 Aplicada a una lista, 'flatten' reune todos los elementos que son a 652 su vez listas. 653 654 (%i1) flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]); 655 (%o1) [a, b, c, d, e, f, g, h, i, j] 656 657 Aplicado a un conjunto, 'flatten' reune todos los elementos que son 658 a su vez conjuntos. 659 660 (%i1) flatten ({a, {b}, {{c}}}); 661 (%o1) {a, b, c} 662 (%i2) flatten ({a, {[a], {a}}}); 663 (%o2) {a, [a]} 664 665 La función 'flatten' es similar a la declaración del operador 666 principal como n-ario. Sin embargo, 'flatten' no tiene efecto 667 alguno sobre subexpresiones que tengan un operador diferente del 668 principal, mientras que sí lo tiene una declaración n-aria. 669 670 (%i1) expr: flatten (f (g (f (f (x))))); 671 (%o1) f(g(f(f(x)))) 672 (%i2) declare (f, nary); 673 (%o2) done 674 (%i3) ev (expr); 675 (%o3) f(g(f(x))) 676 677 La función 'flatten' trata las funciones subindicadas como a 678 cualquier otro operador. 679 680 (%i1) flatten (f[5] (f[5] (x, y), z)); 681 (%o1) f (x, y, z) 682 5 683 684 Es posible que 'flatten' construya expresiones en las que el número 685 de argumentos difiera del número admitido por el operador. 686 687 (%i1) 'mod (5, 'mod (7, 4)); 688 (%o1) mod(5, mod(7, 4)) 689 (%i2) flatten (%); 690 (%o2) mod(5, 7, 4) 691 (%i3) ''%, nouns; 692 Wrong number of arguments to mod 693 -- an error. Quitting. To debug this try debugmode(true); 694 695 -- Función: full_listify (<a>) 696 697 Sustituye los operadores de conjunto presentes en <a> por 698 operadores de listas, devolviendo el resultado. La función 699 'full_listify' sustituye operadores de conjuntos en subexpresiones 700 anidadas, incluso cuando el operador principal no es 'set'. 701 702 La función 'listify' sustituye únicamente el operador principal. 703 704 Ejemplos: 705 706 (%i1) full_listify ({a, b, {c, {d, e, f}, g}}); 707 (%o1) [a, b, [c, [d, e, f], g]] 708 (%i2) full_listify (F (G ({a, b, H({c, d, e})}))); 709 (%o2) F(G([a, b, H([c, d, e])])) 710 711 -- Función: fullsetify (<a>) 712 713 Si <a> es una lista, sustituye el operador de lista por el de 714 conjunto, aplicando posteriormente 'fullsetify' a todos los 715 elementos que son a su vez conjuntos. Si <a> no es una lista, se 716 devuelve sin cambio alguno. 717 718 La función 'setify' sustituye solamente el operador principal. 719 720 Ejemplos: 721 722 En la salida '(%o2)' el argumento de 'f' no se convierte en 723 conjunto porque el operador principal de 'f([b])' no es una lista. 724 725 (%i1) fullsetify ([a, [a]]); 726 (%o1) {a, {a}} 727 (%i2) fullsetify ([a, f([b])]); 728 (%o2) {a, f([b])} 729 730 -- Función: identity (<x>) 731 732 La función 'identity' devuelve su argumento cualquiera que sea 733 éste. 734 735 Ejemplos: 736 737 La función 'identity' puede utilizarse como predicado cuando los 738 argumentos ya son valores booleanos. 739 740 (%i1) every (identity, [true, true]); 741 (%o1) true 742 743 -- Función: integer_partitions (<n>) 744 -- Función: integer_partitions (<n>, <len>) 745 746 Devuelve particiones enteras de <n>, esto es, listas de enteros 747 cuyas sumas son <n>. 748 749 La sentencia 'integer_partitions(<n>)' devuelve el conjunto de 750 todas las particiones del entero <n>. Cada partición es una lista 751 ordenada de mayor a menor. 752 753 La sentencia 'integer_partitions(<n>, <len>)' devuelve todas las 754 particiones de longitud <len> o menor; en este caso, se añaden 755 ceros a cada partición con menos de <len> términos para que todas 756 ellas sean de longitud <len>. Las particiones son listas ordenadas 757 de mayor a menor. 758 759 Una lista [a_1, ..., a_m] es una partición de un entero no negativo 760 n si (1) cada a_i es entero no nulo y (2) a_1 + ... + a_m = n. Así, 761 0 no tiene particiones. 762 763 Ejemplos: 764 765 (%i1) integer_partitions (3); 766 (%o1) {[1, 1, 1], [2, 1], [3]} 767 (%i2) s: integer_partitions (25)$ 768 (%i3) cardinality (s); 769 (%o3) 1958 770 (%i4) map (lambda ([x], apply ("+", x)), s); 771 (%o4) {25} 772 (%i5) integer_partitions (5, 3); 773 (%o5) {[2, 2, 1], [3, 1, 1], [3, 2, 0], [4, 1, 0], [5, 0, 0]} 774 (%i6) integer_partitions (5, 2); 775 (%o6) {[3, 2], [4, 1], [5, 0]} 776 777 Para encontrar todas las particiones que satisfagan cierta 778 condición, utilícese la función 'subset'; he aquí un ejemplo que 779 encuentra todas las particiones de 10 formadas por números primos. 780 781 (%i1) s: integer_partitions (10)$ 782 (%i2) cardinality (s); 783 (%o2) 42 784 (%i3) xprimep(x) := integerp(x) and (x > 1) and primep(x)$ 785 (%i4) subset (s, lambda ([x], every (xprimep, x))); 786 (%o4) {[2, 2, 2, 2, 2], [3, 3, 2, 2], [5, 3, 2], [5, 5], [7, 3]} 787 788 -- Función: intersect (<a_1>, ..., <a_n>) 789 Es una forma abreviada de la función 'intersection'. 790 791 -- Función: intersection (<a_1>, ..., <a_n>) 792 793 Devuelve el conjunto de todos los elementos que son comunes a los 794 conjuntos <a_1> a <a_n>. 795 796 Emite un mensaje de error en caso de que cualquiera de los <a_i> no 797 sea un conjunto. 798 799 Ejemplos: 800 801 (%i1) S_1 : {a, b, c, d}; 802 (%o1) {a, b, c, d} 803 (%i2) S_2 : {d, e, f, g}; 804 (%o2) {d, e, f, g} 805 (%i3) S_3 : {c, d, e, f}; 806 (%o3) {c, d, e, f} 807 (%i4) S_4 : {u, v, w}; 808 (%o4) {u, v, w} 809 (%i5) intersection (S_1, S_2); 810 (%o5) {d} 811 (%i6) intersection (S_2, S_3); 812 (%o6) {d, e, f} 813 (%i7) intersection (S_1, S_2, S_3); 814 (%o7) {d} 815 (%i8) intersection (S_1, S_2, S_3, S_4); 816 (%o8) {} 817 818 -- Función: kron_delta (<x1>, <y1>, ..., <xp>, <yp>) 819 820 Es la función delta de Kronecker. 821 822 La función 'kron_delta' devuelve 1 cuando <xi> y <yi> son iguales 823 para todos los pares, devolviendo 0 si existe un par en el que <xi> 824 y <yi> no sean iguales. La igualdad se determina utilizando 825 'is(equal(xi,xj))' y la desigualdad con 'is(notequal(xi,xj))'. En 826 caso de un solo argumento, 'kron_delta' devuelve un mensaje de 827 error. 828 829 Ejemplos: 830 831 (%i1) kron_delta(a,a); 832 (%o1) 1 833 (%i2) kron_delta(a,b,a,b); 834 (%o2) kron_delta(a, b) 835 (%i3) kron_delta(a,a,b,a+1); 836 (%o3) 0 837 (%i4) assume(equal(x,y)); 838 (%o4) [equal(x, y)] 839 (%i5) kron_delta(x,y); 840 (%o5) 1 841 842 -- Función: listify (<a>) 843 844 Si <a> es un conjunto, devuelve una lista con los elementos de <a>; 845 si <a> no es un conjunto, devuelve <a>. 846 847 La función 'full_listify' sustituye todos los operadores de 848 conjunto en <a> por operadores de lista. 849 850 Ejemplos: 851 852 (%i1) listify ({a, b, c, d}); 853 (%o1) [a, b, c, d] 854 (%i2) listify (F ({a, b, c, d})); 855 (%o2) F({a, b, c, d}) 856 857 -- Función: lreduce (<f>, <s>) 858 -- Función: lreduce (<f>, <s>, <init>) 859 860 Amplía la función binaria <F> a n-aria mediante composición, siendo 861 <s> una lista. 862 863 La sentencia 'lreduce(<F>, <s>)' devuelve 'F(... F(F(s_1, s_2), 864 s_3), ... s_n)'. Si se incluye el argumento opcional <s_0>, el 865 resultado equivale a 'lreduce(<F>, cons(<s_0>, <s>))'. 866 867 La función <F> se aplica primero a los elementos del extremo 868 izquierdo de la lista, de ahí el nombre 'lreduce', (left reduce). 869 870 Véanse también 'rreduce', 'xreduce' y 'tree_reduce'. 871 872 Ejemplos: 873 874 La función 'lreduce' sin el argumento opcional, 875 876 (%i1) lreduce (f, [1, 2, 3]); 877 (%o1) f(f(1, 2), 3) 878 (%i2) lreduce (f, [1, 2, 3, 4]); 879 (%o2) f(f(f(1, 2), 3), 4) 880 881 La función 'lreduce' con el argumento opcional, 882 883 (%i1) lreduce (f, [1, 2, 3], 4); 884 (%o1) f(f(f(4, 1), 2), 3) 885 886 La función 'lreduce' aplicada a operadores binarios de Maxima. El 887 símbolo '/' es el operador división. 888 889 (%i1) lreduce ("^", args ({a, b, c, d})); 890 b c d 891 (%o1) ((a ) ) 892 (%i2) lreduce ("/", args ({a, b, c, d})); 893 a 894 (%o2) ----- 895 b c d 896 897 -- Función: makeset (<expr>, <x>, <s>) 898 899 Genera un conjunto cuyos miembros se generan a partir de la 900 expresión <expr>, siendo <x> una lista de variables de <expr> y <s> 901 un conjunto o lista de listas. Para generar los elementos del 902 conjunto, se evalúa <expr> asignando a las variables de <x> los 903 elementos de <s> en paralelo. 904 905 Los elementos de <s> deben tener la misma longitud que <x>. La 906 lista de variables <x> debe ser una lista de símbolos sin 907 subíndices. Cuando se trate de un único símbolo, <x> debe 908 expresarse como una lista de un elemento y cada elemento de <s> 909 debe ser una lista de un sólo elemento. 910 911 Véase también 'makelist'. 912 913 Ejemplos: 914 915 (%i1) makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]); 916 1 2 3 4 917 (%o1) {-, -, -, -} 918 a b c d 919 (%i2) S : {x, y, z}$ 920 (%i3) S3 : cartesian_product (S, S, S); 921 (%o3) {[x, x, x], [x, x, y], [x, x, z], [x, y, x], [x, y, y], 922 [x, y, z], [x, z, x], [x, z, y], [x, z, z], [y, x, x], 923 [y, x, y], [y, x, z], [y, y, x], [y, y, y], [y, y, z], 924 [y, z, x], [y, z, y], [y, z, z], [z, x, x], [z, x, y], 925 [z, x, z], [z, y, x], [z, y, y], [z, y, z], [z, z, x], 926 [z, z, y], [z, z, z]} 927 (%i4) makeset (i + j + k, [i, j, k], S3); 928 (%o4) {3 x, 3 y, y + 2 x, 2 y + x, 3 z, z + 2 x, z + y + x, 929 z + 2 y, 2 z + x, 2 z + y} 930 (%i5) makeset (sin(x), [x], {[1], [2], [3]}); 931 (%o5) {sin(1), sin(2), sin(3)} 932 933 -- Función: moebius (<n>) 934 935 Representa la función de Moebius. 936 937 Si <n> es el producto de k números primos diferentes, 938 'moebius(<n>)' devuelve (-1)^k, retornando 1 si <n> = 1 y 0 para 939 cualesquiera otros enteros positivos. 940 941 La función de Moebius se distribuye respecto de ecuaciones, listas, 942 matrices y conjuntos. 943 944 Ejemplos: 945 946 (%i1) moebius (1); 947 (%o1) 1 948 (%i2) moebius (2 * 3 * 5); 949 (%o2) - 1 950 (%i3) moebius (11 * 17 * 29 * 31); 951 (%o3) 1 952 (%i4) moebius (2^32); 953 (%o4) 0 954 (%i5) moebius (n); 955 (%o5) moebius(n) 956 (%i6) moebius (n = 12); 957 (%o6) moebius(n) = 0 958 (%i7) moebius ([11, 11 * 13, 11 * 13 * 15]); 959 (%o7) [- 1, 1, 1] 960 (%i8) moebius (matrix ([11, 12], [13, 14])); 961 [ - 1 0 ] 962 (%o8) [ ] 963 [ - 1 1 ] 964 (%i9) moebius ({21, 22, 23, 24}); 965 (%o9) {- 1, 0, 1} 966 967 -- Función: multinomial_coeff (<a_1>, ..., <a_n>) 968 -- Función: multinomial_coeff () 969 970 Calcula el coeficiente multinomial. 971 972 Si todos los <a_k> son enteros no negativos, el coeficiente 973 multinomial es el número de formas de colocar '<a_1> + ... + <a_n>' 974 objetos diferentes en n cajas con <a_k> elementos en la k-ésima 975 caja. En general, 'multinomial_coeff (<a_1>, ..., <a_n>)' calcula 976 '(<a_1> + ... + <a_n>)!/(<a_1>! ... <a_n>!)'. 977 978 Si no se dan argumentos, 'multinomial_coeff()' devuelve 1. 979 980 Se puede usar 'minfactorial' para simplificar el valor devuelto por 981 'multinomial_coeff'. 982 983 Ejemplos: 984 985 (%i1) multinomial_coeff (1, 2, x); 986 (x + 3)! 987 (%o1) -------- 988 2 x! 989 (%i2) minfactorial (%); 990 (x + 1) (x + 2) (x + 3) 991 (%o2) ----------------------- 992 2 993 (%i3) multinomial_coeff (-6, 2); 994 (- 4)! 995 (%o3) -------- 996 2 (- 6)! 997 (%i4) minfactorial (%); 998 (%o4) 10 999 1000 -- Función: num_distinct_partitions (<n>) 1001 -- Función: num_distinct_partitions (<n>, <list>) 1002 1003 Si <n> es un entero no negativo, devuelve el número de particiones 1004 enteras distintas de <n>, en caso contrario 1005 'num_distinct_partitions' devuelve una forma nominal. 1006 1007 La sentencia 'num_distinct_partitions(<n>, list)' devuelve una 1008 lista con el número de particiones distintas de 1, 2, 3, ..., <n>. 1009 1010 Una partición distinta de <n> es una lista de números enteros 1011 positivos distintos k_1, ..., k_m tales que <n> = k_1 + ... + k_m. 1012 1013 Ejemplos: 1014 1015 (%i1) num_distinct_partitions (12); 1016 (%o1) 15 1017 (%i2) num_distinct_partitions (12, list); 1018 (%o2) [1, 1, 1, 2, 2, 3, 4, 5, 6, 8, 10, 12, 15] 1019 (%i3) num_distinct_partitions (n); 1020 (%o3) num_distinct_partitions(n) 1021 1022 -- Función: num_partitions (<n>) 1023 -- Función: num_partitions (<n>, <list>) 1024 1025 Si <n> es un entero no negativo, devuelve el número de particiones 1026 enteras de <n>, en caso contrario 'num_partitions' devuelve una 1027 expresión nominal. 1028 1029 La sentencia 'num_partitions(<n>, list)' devuelve una lista con los 1030 números de particiones enteras de 1, 2, 3, ..., <n>. 1031 1032 Siendo <n> un entero no negativo, 'num_partitions(<n>)' es igual a 1033 'cardinality(integer_partitions(<n>))'; sin embargo, 1034 'num_partitions' no construye el conjunto de particiones, por lo 1035 que es más rápido. 1036 1037 Ejemplos: 1038 1039 (%i1) num_partitions (5) = cardinality (integer_partitions (5)); 1040 (%o1) 7 = 7 1041 (%i2) num_partitions (8, list); 1042 (%o2) [1, 1, 2, 3, 5, 7, 11, 15, 22] 1043 (%i3) num_partitions (n); 1044 (%o3) num_partitions(n) 1045 1046 -- Función: partition_set (<a>, <f>) 1047 1048 Particiona el conjunto <a> respecto del predicado <f>. 1049 1050 La función 'partition_set' devuelve una lista con dos conjuntos; el 1051 primer conjunto es el subconjunto de <a> para el cual el predicado 1052 <f> devuelve 'false' y el segundo contiene al resto de elementos de 1053 <a>. 1054 1055 La función 'partition_set' no aplica 'is' al valor devuelto por 1056 <f>. 1057 1058 La función 'partition_set' emite un mensaje de error si <a> no es 1059 un conjunto literal. 1060 1061 Véase también 'subset'. 1062 1063 Ejemplos: 1064 1065 (%i1) partition_set ({2, 7, 1, 8, 2, 8}, evenp); 1066 (%o1) [{1, 7}, {2, 8}] 1067 (%i2) partition_set ({x, rat(y), rat(y) + z, 1}, 1068 lambda ([x], ratp(x))); 1069 (%o2)/R/ [{1, x}, {y, y + z}] 1070 1071 -- Función: permutations (<a>) 1072 1073 Devuelve un conjunto con todas las permutaciones distintas de los 1074 miembros de la lista o conjunto <a>. Cada permutación es una 1075 lista, no un conjunto. 1076 1077 Si <a> es una lista, sus miembros duplicados no son eliminados 1078 antes de buscar sus permutaciones. 1079 1080 Si <a> no es una lista o conjunto, 'permutations' emite un mensaje 1081 de error. 1082 1083 Véase también 'random_permutation'. 1084 1085 Ejemplos: 1086 1087 (%i1) permutations ([a, a]); 1088 (%o1) {[a, a]} 1089 (%i2) permutations ([a, a, b]); 1090 (%o2) {[a, a, b], [a, b, a], [b, a, a]} 1091 1092 -- Función: powerset (<a>) 1093 -- Función: powerset (<a>, <n>) 1094 1095 Devuelve el conjunto de todos los subconjuntos del conjunto <a> o 1096 un sunconjunto de ellos. 1097 1098 La sentencia 'powerset(<a>)' devuelve el conjunto de todos los 1099 subconjuntos de <a>, que contendrá '2^cardinality(<a>)' elementos. 1100 1101 La sentencia 'powerset(<a>, <n>)' devuelve el conjunto de todos los 1102 subconjuntos de <a> de cardinalidad <n>. 1103 1104 La función 'powerset' emite un mensaje de error si <a> no es un 1105 conjunto literal o si <n> no es un entero no negativo. 1106 1107 Ejemplos: 1108 1109 (%i1) powerset ({a, b, c}); 1110 (%o1) {{}, {a}, {a, b}, {a, b, c}, {a, c}, {b}, {b, c}, {c}} 1111 (%i2) powerset ({w, x, y, z}, 4); 1112 (%o2) {{w, x, y, z}} 1113 (%i3) powerset ({w, x, y, z}, 3); 1114 (%o3) {{w, x, y}, {w, x, z}, {w, y, z}, {x, y, z}} 1115 (%i4) powerset ({w, x, y, z}, 2); 1116 (%o4) {{w, x}, {w, y}, {w, z}, {x, y}, {x, z}, {y, z}} 1117 (%i5) powerset ({w, x, y, z}, 1); 1118 (%o5) {{w}, {x}, {y}, {z}} 1119 (%i6) powerset ({w, x, y, z}, 0); 1120 (%o6) {{}} 1121 1122 -- Función: random_permutation (<a>) 1123 1124 Devuelve una permutación aleatoria del conjunto o lista <a>, 1125 siguiendo el algoritmo de Knuth. 1126 1127 El valor devuelto es una lista nueva distinta del argumento, 1128 incluso cuando todos los elementos son iguales. Sin embargo, los 1129 elementos del argumento no se copian. 1130 1131 Ejemplos: 1132 1133 (%i1) random_permutation ([a, b, c, 1, 2, 3]); 1134 (%o1) [c, 1, 2, 3, a, b] 1135 (%i2) random_permutation ([a, b, c, 1, 2, 3]); 1136 (%o2) [b, 3, 1, c, a, 2] 1137 (%i3) random_permutation ({x + 1, y + 2, z + 3}); 1138 (%o3) [y + 2, z + 3, x + 1] 1139 (%i4) random_permutation ({x + 1, y + 2, z + 3}); 1140 (%o4) [x + 1, y + 2, z + 3] 1141 1142 -- Función: rreduce (<f>, <s>) 1143 -- Función: rreduce (<f>, <s>, <init>) 1144 1145 Amplía la función binaria <F> a n-aria mediante composición, siendo 1146 <s> una lista. 1147 1148 La sentencia 'rreduce(<F>, <s>)' devuelve 'F(s_1, ... F(s_{n - 2}, 1149 F(s_{n - 1}, s_n)))'. Si se incluye el argumento opcional <s_{n + 1150 1}>, el resultado equivale a 'rreduce(<F>, endcons(<s_{n + 1}>, 1151 <s>))'. 1152 1153 La función <F> se aplica primero a los elementos del extremo 1154 derecho de la lista, de ahí el nombre 'rreduce', (right reduce). 1155 1156 Véanse también 'lreduce', 'xreduce' y 'tree_reduce'. 1157 1158 Ejemplos: 1159 1160 La función 'rreduce' sin el argumento opcional, 1161 1162 (%i1) rreduce (f, [1, 2, 3]); 1163 (%o1) f(1, f(2, 3)) 1164 (%i2) rreduce (f, [1, 2, 3, 4]); 1165 (%o2) f(1, f(2, f(3, 4))) 1166 1167 La función 'rreduce' con el argumento opcional, 1168 1169 (%i1) rreduce (f, [1, 2, 3], 4); 1170 (%o1) f(1, f(2, f(3, 4))) 1171 1172 La función 'rreduce' aplicada a operadores binarios de Maxima. El 1173 símbolo '/' es el operador división. 1174 1175 (%i1) rreduce ("^", args ({a, b, c, d})); 1176 d 1177 c 1178 b 1179 (%o1) a 1180 (%i2) rreduce ("/", args ({a, b, c, d})); 1181 a c 1182 (%o2) --- 1183 b d 1184 1185 -- Función: setdifference (<a>, <b>) 1186 1187 Devuelve el conjunto con los elementos del conjunto <a> que no 1188 pertenecen al conjunto <b>. 1189 1190 La función 'setdifference' emite un mensaje de error si <a> o <b> 1191 no son conjuntos. 1192 1193 Ejemplos: 1194 1195 (%i1) S_1 : {a, b, c, x, y, z}; 1196 (%o1) {a, b, c, x, y, z} 1197 (%i2) S_2 : {aa, bb, c, x, y, zz}; 1198 (%o2) {aa, bb, c, x, y, zz} 1199 (%i3) setdifference (S_1, S_2); 1200 (%o3) {a, b, z} 1201 (%i4) setdifference (S_2, S_1); 1202 (%o4) {aa, bb, zz} 1203 (%i5) setdifference (S_1, S_1); 1204 (%o5) {} 1205 (%i6) setdifference (S_1, {}); 1206 (%o6) {a, b, c, x, y, z} 1207 (%i7) setdifference ({}, S_1); 1208 (%o7) {} 1209 1210 -- Función: setequalp (<a>, <b>) 1211 1212 Devuelve 'true' si los conjuntos <a> y <b> tienen el mismo número 1213 de elementos y 'is (<x> = <y>)' vale 'true' para 'x' perteneciente 1214 a <a> e 'y' perteneciente a <b>, considerados en el orden que 1215 determina la función 'listify'. En caso contrario, 'setequalp' 1216 devuelve 'false'. 1217 1218 Ejemplos: 1219 1220 (%i1) setequalp ({1, 2, 3}, {1, 2, 3}); 1221 (%o1) true 1222 (%i2) setequalp ({a, b, c}, {1, 2, 3}); 1223 (%o2) false 1224 (%i3) setequalp ({x^2 - y^2}, {(x + y) * (x - y)}); 1225 (%o3) false 1226 1227 -- Función: setify (<a>) 1228 1229 Construye un conjunto con los miembros de la lista <a>. Los 1230 elementos duplicados de la lista <a> son borrados y ordenados de 1231 acuerdo con el predicado 'orderlessp'. 1232 1233 La función 'setify' emite un mensaje de error si <a> no es un 1234 conjunto literal. 1235 1236 Ejemplos: 1237 1238 (%i1) setify ([1, 2, 3, a, b, c]); 1239 (%o1) {1, 2, 3, a, b, c} 1240 (%i2) setify ([a, b, c, a, b, c]); 1241 (%o2) {a, b, c} 1242 (%i3) setify ([7, 13, 11, 1, 3, 9, 5]); 1243 (%o3) {1, 3, 5, 7, 9, 11, 13} 1244 1245 -- Función: setp (<a>) 1246 1247 Devuelve 'true' si y sólo si <a> es un conjunto de Maxima. 1248 1249 La función 'setp' devuelve 'true' tanto cuando el conjunto tiene 1250 como cuando no tiene elementos repetidos. 1251 1252 La función 'setp' is equivalent to the Maxima function 'setp(a) := 1253 not atom(a) and op(a) = 'set'. 1254 1255 Ejemplos: 1256 1257 (%i1) simp : false; 1258 (%o1) false 1259 (%i2) {a, a, a}; 1260 (%o2) {a, a, a} 1261 (%i3) setp (%); 1262 (%o3) true 1263 1264 -- Función: set_partitions (<a>) 1265 -- Función: set_partitions (<a>, <n>) 1266 1267 Devuelve el conjunto de todas las particiones de <a> o un 1268 subconjunto de ellas. 1269 1270 La sentencia 'set_partitions(<a>, <n>)' devuelve un conjunto con 1271 todas las descomposiciones de <a> en <n> conjuntos no vacíos 1272 disjuntos. 1273 1274 La sentencia 'set_partitions(<a>)' devuelve el conjunto de todas 1275 las particiones. 1276 1277 La función 'stirling2' devuelve la cardinalidad del conjunto de las 1278 particiones de un conjunto. 1279 1280 Se dice que un conjunto P es una partición del conjunto S si 1281 verifica 1282 1283 1. cada elemento de P es un conjunto no vacío, 1284 2. los elementos de P son disjuntos, 1285 3. la unión de los elementos de P es igual a S. 1286 1287 Ejemplos: 1288 1289 El conjunto vacío forma una partición de sí mismo, 1290 1291 (%i1) set_partitions ({}); 1292 (%o1) {{}} 1293 1294 La cardinalidad del conjunto de particiones de un conjunto puede 1295 calcularse con 'stirling2', 1296 1297 (%i1) s: {0, 1, 2, 3, 4, 5}$ 1298 (%i2) p: set_partitions (s, 3)$ 1299 (%i3) cardinality(p) = stirling2 (6, 3); 1300 (%o3) 90 = 90 1301 1302 Cada elemento de 'p' debería tener <n> = 3 miembros, 1303 1304 (%i1) s: {0, 1, 2, 3, 4, 5}$ 1305 (%i2) p: set_partitions (s, 3)$ 1306 (%i3) map (cardinality, p); 1307 (%o3) {3} 1308 1309 Por último, para cada miembro de 'p', la unión de sus elementos 1310 debe ser igual a 's', 1311 1312 (%i1) s: {0, 1, 2, 3, 4, 5}$ 1313 (%i2) p: set_partitions (s, 3)$ 1314 (%i3) map (lambda ([x], apply (union, listify (x))), p); 1315 (%o3) {{0, 1, 2, 3, 4, 5}} 1316 1317 -- Función: some (<f>, <a>) 1318 -- Función: some (<f>, <L_1>, ..., <L_n>) 1319 1320 Devuelve 'true' si el predicado <f> devuelve 'true' para al menos 1321 uno de sus argumentos. Si el segundo argumento es un conjunto, 1322 'some (<f>, <a>)' devuelve 'true' si '<f>(<a_i>)' devuelve también 1323 'true' para alguno de los <a_i> en <a>; puede ser que 'some' no 1324 evalúe <f> para todos los <a_i> de <s>. Puesto que los conjuntos 1325 no están ordenados, 'some' puede evaluar '<f>(<a_i>)' en cualquier 1326 orden. 1327 1328 Dada una o más listas como argumentos, 'some (<f>, <L_1>, ..., 1329 <L_n>)' devuelve 'true' si '<f>(<x_1>, ..., <x_n>)' devuelve 1330 también 'true' para al menos un <x_1>, ..., <x_n> de <L_1>, ..., 1331 <L_n>, respectivamente; puede ser que 'some' no evalúe <f> para 1332 todos las combinaciones <x_1>, ..., <x_n>. La función 'some' 1333 evalúa las listas en el orden creciente de su índice 1334 1335 Dado un conjunto vacío '{}' o una lista vacía como argumentos, 1336 'some' devuelve 'false'. 1337 1338 Si la variable global 'maperror' vale 'true', todas las listas 1339 <L_1>, ..., <L_n> deben tener igual número de elementos. Si 1340 'maperror' vale 'false', los argumentos se truncan para tener todos 1341 el número de elementos de la lista más corta. 1342 1343 Los valores que devuelve el predicado <f> cuando toman (mediante 1344 'is') un valor diferente a 'true' y 'false' se controlan con la 1345 variable global 'prederror'. Si 'prederror' vale 'true', tales 1346 valores se consideran como 'false'. Si 'prederror' vale 'false', 1347 tales valores se consideran como desconocidos ('unknown'). 1348 1349 Ejemplos: 1350 1351 La función 'some' aplicada a un único conjunto. El predicado es 1352 una función de un argumento, 1353 1354 (%i1) some (integerp, {1, 2, 3, 4, 5, 6}); 1355 (%o1) true 1356 (%i2) some (atom, {1, 2, sin(3), 4, 5 + y, 6}); 1357 (%o2) true 1358 1359 La función 'some' aplicada a dos listas. El predicado es una 1360 función de dos argumentos, 1361 1362 (%i1) some ("=", [a, b, c], [a, b, c]); 1363 (%o1) true 1364 (%i2) some ("#", [a, b, c], [a, b, c]); 1365 (%o2) false 1366 1367 Las respuestas del predicado <f> que se evalúan a cualquier cosa 1368 diferente de 'true' y 'false' están controlados por la variable 1369 global 'prederror'. 1370 1371 (%i1) prederror : false; 1372 (%o1) false 1373 (%i2) map (lambda ([a, b], is (a < b)), [x, y, z], 1374 [x^2, y^2, z^2]); 1375 (%o2) [unknown, unknown, unknown] 1376 (%i3) some ("<", [x, y, z], [x^2, y^2, z^2]); 1377 (%o3) unknown 1378 (%i4) some ("<", [x, y, z], [x^2, y^2, z + 1]); 1379 (%o4) true 1380 (%i5) prederror : true; 1381 (%o5) true 1382 (%i6) some ("<", [x, y, z], [x^2, y^2, z^2]); 1383 (%o6) false 1384 (%i7) some ("<", [x, y, z], [x^2, y^2, z + 1]); 1385 (%o7) true 1386 1387 -- Función: stirling1 (<n>, <m>) 1388 1389 Es el número de Stirling de primera especie. 1390 1391 Si tanto <n> como <m> son enteros no negativos, el valor que toma 1392 'stirling1 (<n>, <m>)' es el número de permutaciones de un conjunto 1393 de <n> elementos con <m> ciclos. Para más detalles, véase Graham, 1394 Knuth and Patashnik Concrete Mathematics. Maxima utiliza una 1395 relación recursiva para definir 'stirling1 (<n>, <m>)' para <m> 1396 menor que 0; no está definida para <n> menor que 0 ni para 1397 argumentos no enteros. 1398 1399 La función 'stirling1' es simplificadora. Maxima reconoce las 1400 siguientes identidades: 1401 1402 1. stirling1(0, n) = kron_delta(0, n) (Ref. [1]) 1403 2. stirling1(n, n) = 1 (Ref. [1]) 1404 3. stirling1(n, n - 1) = binomial(n, 2) (Ref. [1]) 1405 4. stirling1(n + 1, 0) = 0 (Ref. [1]) 1406 5. stirling1(n + 1, 1) = n! (Ref. [1]) 1407 6. stirling1(n + 1, 2) = 2^n - 1 (Ref. [1]) 1408 1409 Estas identidades se aplican cuando los argumentos son enteros 1410 literales o símbolos declarados como enteros y el primer argumento 1411 es no negativo. La función 'stirling1' no simplifica para 1412 argumentos no enteros. 1413 1414 Referencias: 1415 1416 [1] Donald Knuth, The Art of Computer Programming, Tercera Edición, 1417 Volumen 1, Sección 1.2.6, Ecuaciones 48, 49 y 50. 1418 1419 Ejemplos: 1420 1421 (%i1) declare (n, integer)$ 1422 (%i2) assume (n >= 0)$ 1423 (%i3) stirling1 (n, n); 1424 (%o3) 1 1425 1426 La función 'stirling1' no simplifica en caso de argumentos no 1427 enteros, 1428 1429 (%i1) stirling1 (sqrt(2), sqrt(2)); 1430 (%o1) stirling1(sqrt(2), sqrt(2)) 1431 1432 Maxima aplicas algunas identidades a 'stirling1', 1433 1434 (%i1) declare (n, integer)$ 1435 (%i2) assume (n >= 0)$ 1436 (%i3) stirling1 (n + 1, n); 1437 n (n + 1) 1438 (%o3) --------- 1439 2 1440 (%i4) stirling1 (n + 1, 1); 1441 (%o4) n! 1442 1443 -- Función: stirling2 (<n>, <m>) 1444 1445 Es el número de Stirling de segunda especie. 1446 1447 Si <n> y <m> son enteros no negativos, 'stirling2 (<n>, <m>)' es el 1448 número de formas en las que se puede particionar un conjunto de 1449 cardinal <n> en <m> subconjuntos disjuntos. Maxima utiliza una 1450 relación recursiva para definir 'stirling2 (<n>, <m>)' con <m> 1451 menor que 0; la función no está definida para <n> menor que 0 ni 1452 para argumentos no enteros. 1453 1454 La función 'stirling2' es simplificadora. Maxima reconoce las 1455 siguientes identidades: 1456 1457 1. stirling2(0, n) = kron_delta(0, n) (Ref. [1]) 1458 2. stirling2(n, n) = 1 (Ref. [1]) 1459 3. stirling2(n, n - 1) = binomial(n, 2) (Ref. [1]) 1460 4. stirling2(n + 1, 1) = 1 (Ref. [1]) 1461 5. stirling2(n + 1, 2) = 2^n - 1 (Ref. [1]) 1462 6. stirling2(n, 0) = kron_delta(n, 0) (Ref. [2]) 1463 7. stirling2(n, m) = 0 when m > n (Ref. [2]) 1464 8. stirling2(n, m) = sum((-1)^(m - k) binomial(m k) k^n,i,1,m) / 1465 m! si m y n son enteros y n no negativo. (Ref. [3]) 1466 1467 Estas identidades se aplican cuando los argumentos son enteros 1468 literales o símbolos declarados como enteros y el primer argumento 1469 es no negativo. La función 'stirling2' no simplifica para 1470 argumentos no enteros. 1471 1472 Referencias: 1473 1474 [1] Donald Knuth. The Art of Computer Programming, Tercera 1475 Edición, Volumen 1, Sección 1.2.6, Ecuaciones 48, 49 y 50. 1476 1477 [2] Graham, Knuth y Patashnik. Concrete Mathematics, Tabla 264. 1478 1479 [3] Abramowitz y Stegun. Handbook of Mathematical Functions, 1480 Sección 24.1.4. 1481 1482 Ejemplos: 1483 1484 (%i1) declare (n, integer)$ 1485 (%i2) assume (n >= 0)$ 1486 (%i3) stirling2 (n, n); 1487 (%o3) 1 1488 1489 La función 'stirling2' no simplifica en caso de argumentos no 1490 enteros, 1491 1492 (%i1) stirling2 (%pi, %pi); 1493 (%o1) stirling2(%pi, %pi) 1494 1495 Maxima aplicas algunas identidades a 'stirling2', 1496 1497 (%i1) declare (n, integer)$ 1498 (%i2) assume (n >= 0)$ 1499 (%i3) stirling2 (n + 9, n + 8); 1500 (n + 8) (n + 9) 1501 (%o3) --------------- 1502 2 1503 (%i4) stirling2 (n + 1, 2); 1504 n 1505 (%o4) 2 - 1 1506 1507 -- Función: subset (<a>, <f>) 1508 1509 Devuelve el subconjunto del conjunto <a> que satisface el predicado 1510 <f>. 1511 1512 La función 'subset' devuelve el conjunto que contiene a los 1513 elementos de <a> para los cuales <f> devuelve un resultado 1514 diferente de 'false'. La función 'subset' no aplica 'is' al valor 1515 retornado por <f>. 1516 1517 La función 'subset' emite un mensaje de error si <a> no es un 1518 conjunto literal. 1519 1520 Véase también 'partition_set'. 1521 1522 Ejemplos: 1523 1524 (%i1) subset ({1, 2, x, x + y, z, x + y + z}, atom); 1525 (%o1) {1, 2, x, z} 1526 (%i2) subset ({1, 2, 7, 8, 9, 14}, evenp); 1527 (%o2) {2, 8, 14} 1528 1529 -- Función: subsetp (<a>, <b>) 1530 1531 Devuelve 'true' si y sólo si el conjunto <a> es un subconjunto de 1532 <b>. 1533 1534 La función 'subsetp' emite un mensaje de error si cualesquiera <a> 1535 o <b> no es un conjunto literal. 1536 1537 Ejemplos: 1538 1539 (%i1) subsetp ({1, 2, 3}, {a, 1, b, 2, c, 3}); 1540 (%o1) true 1541 (%i2) subsetp ({a, 1, b, 2, c, 3}, {1, 2, 3}); 1542 (%o2) false 1543 1544 -- Función: symmdifference (<a_1>, ..., <a_n>) 1545 1546 Devuelve la diferencia simétrica de los conjuntos ' <a_1>, ..., 1547 <a_n>'. 1548 1549 Dados dos argumentos, 'symmdifference (<a>, <b>)' equivale a 'union 1550 (setdifference (<a>, <b>), setdifference (<b>, <a>))'. 1551 1552 La función 'symmdifference' emite un mensaje de error si alguno de 1553 su argumentos no es un conjunto literal. 1554 1555 Ejemplos: 1556 1557 (%i1) S_1 : {a, b, c}; 1558 (%o1) {a, b, c} 1559 (%i2) S_2 : {1, b, c}; 1560 (%o2) {1, b, c} 1561 (%i3) S_3 : {a, b, z}; 1562 (%o3) {a, b, z} 1563 (%i4) symmdifference (); 1564 (%o4) {} 1565 (%i5) symmdifference (S_1); 1566 (%o5) {a, b, c} 1567 (%i6) symmdifference (S_1, S_2); 1568 (%o6) {1, a} 1569 (%i7) symmdifference (S_1, S_2, S_3); 1570 (%o7) {1, b, z} 1571 (%i8) symmdifference ({}, S_1, S_2, S_3); 1572 (%o8) {1,b, z} 1573 1574 -- Función: tree_reduce (<F>, <s>) 1575 -- Función: tree_reduce (<F>, <s>, <s_0>) 1576 1577 Amplía la función binaria <F> a n-aria, siendo <s> una lista. 1578 1579 La función 'tree_reduce' equivale a lo suguiente: Aplicar <F> a 1580 pares sucesivos de elementos para formar una nueva lista 1581 '[<F>(<s_1>, <s_2>), <F>(<s_3>, <s_4>), ...]', llevando el elemento 1582 final sin cambiar si el número de elementos es impar; después 1583 repetir hasta que la lista se reduzca a un único elemento, que es 1584 el valor de retorno. 1585 1586 Cuando está presente el argumento opcional <s_0>, el resultado 1587 equivale a 'tree_reduce(<F>, cons(<s_0>, <s>)'. 1588 1589 Para la suma de números decimales en coma flotante, 'tree_reduce' 1590 puede devolver una suma que tenga un error de redondeo menor que el 1591 conseguido por 'rreduce' o 'lreduce'. 1592 1593 Los elementos de <s> y los resultados parciales pueden colocarse en 1594 un árbol binario de mínima profundidad, de ahí el nombre de 1595 tree_reduce. 1596 1597 Ejemplos: 1598 1599 La función 'tree_reduce' aplicada a una lista con un número par de 1600 elementos, 1601 1602 (%i1) tree_reduce (f, [a, b, c, d]); 1603 (%o1) f(f(a, b), f(c, d)) 1604 1605 La función 'tree_reduce' aplicada a una lista con un número impar 1606 de elementos, 1607 1608 (%i1) tree_reduce (f, [a, b, c, d, e]); 1609 (%o1) f(f(f(a, b), f(c, d)), e) 1610 1611 -- Function: union (<a_1>, ..., <a_n>) 1612 1613 Devuelve la unión de los conjuntos <a_1> hasta <a_n>. 1614 1615 La sentencia 'union()' (sin argumentos) devuelve el conjunto vacío. 1616 1617 La función 'union' emite un mensaje de error si alguno de sus 1618 argumentos no es un conjunto literal. 1619 1620 Ejemplos: 1621 1622 (%i1) S_1 : {a, b, c + d, %e}; 1623 (%o1) {%e, a, b, d + c} 1624 (%i2) S_2 : {%pi, %i, %e, c + d}; 1625 (%o2) {%e, %i, %pi, d + c} 1626 (%i3) S_3 : {17, 29, 1729, %pi, %i}; 1627 (%o3) {17, 29, 1729, %i, %pi} 1628 (%i4) union (); 1629 (%o4) {} 1630 (%i5) union (S_1); 1631 (%o5) {%e, a, b, d + c} 1632 (%i6) union (S_1, S_2); 1633 (%o6) {%e, %i, %pi, a, b, d + c} 1634 (%i7) union (S_1, S_2, S_3); 1635 (%o7) {17, 29, 1729, %e, %i, %pi, a, b, d + c} 1636 (%i8) union ({}, S_1, S_2, S_3); 1637 (%o8) {17, 29, 1729, %e, %i, %pi, a, b, d + c} 1638 1639 -- Función: xreduce (<F>, <s>) 1640 -- Función: xreduce (<F>, <s>, <s_0>) 1641 1642 Amplía la función <F> a n-aria mediante composición; si <F> ya es 1643 n-aria, aplica <F> a <s>. Si <F> no es n-aria, 'xreduce' equivale 1644 a 'lreduce'. El argumento <s> debe ser una lista. 1645 1646 Funciones n-arias reconocidas por Maxima son la suma '+', la 1647 multiplicación '*', 'and', 'or', 'max', 'min' y 'append'. Las 1648 funciones también se pueden declarar n-arias mediante 'declare(<F>, 1649 nary)'; para estas funciones, 'xreduce' será más rápida que 1650 'rreduce' o 'lreduce'. 1651 1652 Cuando está presente el argumento opcional <s_0>, el resultado 1653 equivale a 'xreduce(<s>, cons(<s_0>, <s>))'. 1654 1655 La suma de números decimales en coma flotante no es exactamente 1656 asociativa; aún así, 'xreduce' aplica la suma n-aria cuando <s> 1657 contiene números en coma flotante. 1658 1659 Ejemplos: 1660 1661 La función 'xreduce' aplicada a una función n-aria; 'F' es invocada 1662 una sóla vez, con todos sus argumentos, 1663 1664 (%i1) declare (F, nary); 1665 (%o1) done 1666 (%i2) F ([L]) := L; 1667 (%o2) F([L]) := L 1668 (%i3) xreduce (F, [a, b, c, d, e]); 1669 (%o3) [[[[[("[", simp), a], b], c], d], e] 1670 1671 La función 'xreduce' aplicada a una función que se desconoce si es 1672 n-aria; 'G' es invocada varias veces, con dos argumentos de cada 1673 vez, 1674 1675 (%i1) G ([L]) := L; 1676 (%o1) G([L]) := L 1677 (%i2) xreduce (G, [a, b, c, d, e]); 1678 (%o2) [[[[[("[", simp), a], b], c], d], e] 1679 (%i3) lreduce (G, [a, b, c, d, e]); 1680 (%o3) [[[[a, b], c], d], e] 1681 1682 1683File: maxima.info, Node: Definición de Funciones, Next: Programación, Prev: Conjuntos, Up: Top 1684 168536 Definición de Funciones 1686************************** 1687 1688* Menu: 1689 1690* Introducción a la definición de funciones:: 1691* Funciones:: 1692* Macros:: 1693* Funciones y variables para la definición de funciones:: 1694 1695 1696File: maxima.info, Node: Introducción a la definición de funciones, Next: Funciones, Prev: Definición de Funciones, Up: Definición de Funciones 1697 169836.1 Introducción a la definición de funciones 1699============================================== 1700 1701 1702File: maxima.info, Node: Funciones, Next: Macros, Prev: Introducción a la definición de funciones, Up: Definición de Funciones 1703 170436.2 Funciones 1705============== 1706 170736.2.1 Funciones ordinarias 1708--------------------------- 1709 1710Para definir una función en Maxima es necesario utilizar el operador 1711':='. 1712 1713Por ejemplo, 1714 1715 f(x) := sin(x) 1716 1717define una función 'f'. También se pueden definir funciones anónimas 1718utilizando 'lambda'; por ejemplo, 1719 1720 lambda ([i, j], ...) 1721 1722puede utilizarse en lugar de 'f' donde 1723 1724 f(i,j) := block ([], ...); 1725 map (lambda ([i], i+1), l) 1726 1727devolvería una lista con todos sus elementos aumentados en una unidad. 1728 1729También se puede definir una función con un número variable de 1730argumentos, sin más que añadir un argumento final al que se le asigna 1731una lista con todos los argumentos adicionales.: 1732 1733 (%i1) f ([u]) := u; 1734 (%o1) f([u]) := u 1735 (%i2) f (1, 2, 3, 4); 1736 (%o2) [1, 2, 3, 4] 1737 (%i3) f (a, b, [u]) := [a, b, u]; 1738 (%o3) f(a, b, [u]) := [a, b, u] 1739 (%i4) f (1, 2, 3, 4, 5, 6); 1740 (%o4) [1, 2, [3, 4, 5, 6]] 1741 1742El miembro derecho de una función debe ser una expresión. Así, si se 1743quiere una secuencia de expresiones, se debe hacer 1744 1745 f(x) := (expr1, expr2, ...., exprn); 1746 1747siendo el valor que alcance exprn el devuelto por la función. 1748 1749Si se quiere hacer un 'return' desde alguna de las expresiones de la 1750función, se debe utilizar la estructura 'block' junto con 'return'. Por 1751ejemplo, 1752 1753 block ([], expr1, ..., if (a > 10) then return(a), ..., exprn) 1754 1755es una expresión de pleno derecho, por lo que puede ocupar el lado 1756derecho de la definición de una función. Aquí puede ocurrir que el 1757retorno se produzca antes que se alcance la última expresión. 1758 1759Los primeros corchetes del bloque ('[]') pueden contener una lista de 1760variables junto con posibles asignaciones, tal como '[a: 3, b, c: []]', 1761lo que provocará que las tres variables 'a','b' y 'c' se consideren 1762locales y sean independientes de otras globales con el mismo nombre; las 1763variables locales sólo estarán activas mientras se ejecute el código que 1764está dentro de la estructura 'block', o dentro de funciones que son 1765llamadas desde dentro de 'block'. A esto se le llama asignación 1766dinámica, pues las variables sobreviven desde el inicio del bloque hasta 1767que éste deje de estar operativo. Una vez se salga del bloque los 1768valores originales de las variables, si es que los había, quedan 1769restaurados. Es recomendable proteger las variables de esta forma. Se 1770tendrá en cuenta que las asignaciones a las variables del bloque se 1771hacen en paralelo, lo que significa que si como en el ejemplo anterior 1772se hace 'c: a' en el momento de entrar en el bloque, el valor de 'c' 1773será el que tenía 'a' antes de entrar en el bloque, es decir, antes de 1774la asignación 'a: 3'. Así, haciendo lo siguiente 1775 1776 block ([a: a], expr1, ... a: a+3, ..., exprn) 1777 1778se prevendría de que el valor externo de 'a' fuese alterado, pero 1779permitiría acceder a él desde dentro del bloque. La parte derecha de 1780las asignaciones se evalúa dentro de su contexto antes de hacer efectiva 1781la asignación. Utilizando únicamente 'block([x],..' haría que 'x' se 1782tuviese a sí misma como valor, justo como si se acabase de iniciar una 1783nueva sesión de Maxima. 1784 1785Los valores de los argumentos de una funcón se tratan exactamente de la 1786misma forma que las variables de un bloque. Así, con 1787 1788 f(x) := (expr1, ..., exprn); 1789 1790y 1791 1792 f(1); 1793 1794se estaría en un contexto similar para la evaluación de las expresiones 1795como si se hubiera hecho 1796 1797 block ([x: 1], expr1, ..., exprn) 1798 1799Dentro de las funciones, cuando el lado derecho de la definición deba 1800ser evaluado será útil hacer uso de 'define' y posiblemente de 'buildq'. 1801 180236.2.2 Funciones array 1803---------------------- 1804 1805Una función array almacena el valor de la función la primera vez que es 1806invocada con un argumento dado, devolviendo el valor almacenado sin 1807recalcularlo cuando es llamada con ese mismo argumento. Estas funciones 1808reciben también el nombre de funciones memorizadoras. 1809 1810Los nombres de las funciones array son añadidos a la lista global 1811'arrays', no a la lista global 'functions'. La función 'arrayinfo' 1812devuelve la lista de argumentos para los que hay valores almacenados y 1813'listarray' devuelve precisamente estos valores almacenados. Las 1814funciones 'dispfun' y 'fundef' devuelven la definición de la función 1815array. 1816 1817La función 'arraymake' construye una llamada a una función array, de 1818forma similar a como lo hace 'funmake' para las funciones ordinarias. 1819Por otro lado, 'arrayapply' aplica una función array a sus argumentos, 1820tal como lo hace 'apply' con las funciones ordinarias. No existe para 1821las funciones array nada similar a 'map', aunque 'map(lambda([<x>], 1822<a>[<x>]), <L>)' o 'makelist(<a>[<x>], <x>, <L>)', siendo <L> una lista, 1823podrían suplantar esta carencia. 1824 1825La función 'remarray' borra la definición de una función array, así como 1826cualesquiera valores almacenados que tenga asociados, tal como 1827'remfunction' lo hace con las funciones ordinarias. 1828 1829La llamada 'kill(<a>[<x>])' borra el valor de la función array <a> 1830almacenado para el argumento <x>; la próxima vez que se llame a <a> con 1831el argumento <x>, se recalculará el valor correspondiente. Sin embargo, 1832no hay forma de borrar todos los valores almacenados de una sola vez, 1833excepto mediante 'kill(<a>)' o 'remarray(<a>)', con lo que se borra 1834también la definición de la propia función. 1835 1836 1837File: maxima.info, Node: Macros, Next: Funciones y variables para la definición de funciones, Prev: Funciones, Up: Definición de Funciones 1838 183936.3 Macros 1840=========== 1841 1842 -- Función: buildq (<L>, <expr>) 1843 Sustituye en paralelo las variables nombradas en la lista <L> en la 1844 expresión <expr>, sin evaluar ésta. La expresión resultante se 1845 simplifica pero no se evalúa hasta que 'buildq' termine de hacer 1846 las sustituciones. 1847 1848 Los elementos de <L> son símbolos o expresiones de asignación del 1849 tipo '<symbol>: <value>', evaluadas en paralelo. Esto es, el valor 1850 de una variable en la parte derecha de una asignación es el valor 1851 que toma dicha variable en el contexto desde el que se invoca a 1852 'buildq'. En caso de que a una variable de <L> no se le haga una 1853 signación explícita, su valor en 'buildq' es el mismo que tiene en 1854 el contexto desde el que se llama a 'buildq'. 1855 1856 Las variables referenciadas en <L> se sustituyen en <expr> en 1857 paralelo. Esto es, la sustitución para cada variable se determina 1858 antes de que se hagan las sustituciones, de forma que la 1859 sustitución de una variable no tiene efecto alguno sobre las otras. 1860 1861 Si alguna variable <x> aparece como 'splice (<x>)' en <expr>, 1862 entonces a <x> se le debe asignar una lista, la cual será 1863 interpolada en <expr> en lugar de hacer una simple sustitución; ver 1864 ejemplo más abajo. 1865 1866 Cualesquiera otras variables de <expr> que no aparezcan en <L> se 1867 traspasan al resultado tal cual, incluso cuando tienen asignados 1868 valores en el contexto desde el que se llama a 'buildq'. 1869 1870 Ejemplos: 1871 1872 'a' queda asociada explícitamente a 'x', mientras que 'b' tiene la 1873 misma asociación (29) que en el contexto de llamada y 'c' es 1874 traspasado al resultado sin ser sustituido. La expresión 1875 resultante no se evalúa hasta que no se le obligue a ello mediante 1876 la evaluación explícita '''%'. 1877 1878 (%i1) (a: 17, b: 29, c: 1729)$ 1879 (%i2) buildq ([a: x, b], a + b + c); 1880 (%o2) x + c + 29 1881 (%i3) ''%; 1882 (%o3) x + 1758 1883 1884 En este ejemplo, 'e' se asocia a una lista, la cual aparece como 1885 tal en los argumentos de 'foo' e interpolada en los argumentos de 1886 'bar'. 1887 1888 (%i1) buildq ([e: [a, b, c]], foo (x, e, y)); 1889 (%o1) foo(x, [a, b, c], y) 1890 (%i2) buildq ([e: [a, b, c]], bar (x, splice (e), y)); 1891 (%o2) bar(x, a, b, c, y) 1892 1893 Como se ve a continuación, el resultado se simplifica tras las 1894 sustituciones. Si la simplificación se realizase antes que las 1895 sustituciones, ambos resultados serían iguales. 1896 1897 (%i1) buildq ([e: [a, b, c]], splice (e) + splice (e)); 1898 (%o1) 2 c + 2 b + 2 a 1899 (%i2) buildq ([e: [a, b, c]], 2 * splice (e)); 1900 (%o2) 2 a b c 1901 1902 Las variables de <L> se asocian en paralelo; si se hiciese 1903 secuencialmente, el primer resultado sería 'foo (b, b)'. Las 1904 sustituciones se llevan a cabo en paralelo. Compárese el segundo 1905 resultado con el resultado de 'subst', que hace las sustituciones 1906 de forma secuencial. 1907 1908 (%i1) buildq ([a: b, b: a], foo (a, b)); 1909 (%o1) foo(b, a) 1910 (%i2) buildq ([u: v, v: w, w: x, x: y, y: z, z: u], 1911 bar (u, v, w, x, y, z)); 1912 (%o2) bar(v, w, x, y, z, u) 1913 (%i3) subst ([u=v, v=w, w=x, x=y, y=z, z=u], 1914 bar (u, v, w, x, y, z)); 1915 (%o3) bar(u, u, u, u, u, u) 1916 1917 Se construye a continuación un sistema de ecuaciones con algunas 1918 variables o expresiones en el lado izquierdo y sus valores en el 1919 derecho; 'macroexpand' muestra la expresión devuelta por 1920 'show_values'. 1921 1922 (%i1) show_values ([L]) ::= buildq ([L], map ("=", 'L, L)); 1923 (%o1) show_values([L]) ::= buildq([L], map("=", 'L, L)) 1924 (%i2) (a: 17, b: 29, c: 1729)$ 1925 (%i3) show_values (a, b, c - a - b); 1926 (%o3) [a = 17, b = 29, c - b - a = 1683] 1927 (%i4) macroexpand (show_values (a, b, c - a - b)); 1928 (%o4) map(=, '([a, b, c - b - a]), [a, b, c - b - a]) 1929 1930 Dada una función con varios argumentos, se crea otra función en la 1931 cual algunos argumentos son fijos. 1932 1933 (%i1) curry (f, [a]) := 1934 buildq ([f, a], lambda ([[x]], apply (f, append (a, x))))$ 1935 (%i2) by3 : curry ("*", 3); 1936 (%o2) lambda([[x]], apply(*, append([3], x))) 1937 (%i3) by3 (a + b); 1938 (%o3) 3 (b + a) 1939 1940 -- Función: macroexpand (<expr>) 1941 Devuelve la macroexpansión de <expr>, sin evaluarla, cuando 'expr' 1942 es una llamada a una función macro; en caso contrario, 1943 'macroexpand' devuelve <expr>. 1944 1945 Si la expansión de <expr> devuelve otra llamada a una función 1946 macro, esta llamada también se expande. 1947 1948 La función 'macroexpand' no evalúa su argumento. Sin embargo, si 1949 la expansión de una llamada a función macro tiene efectos 1950 laterales, éstos se ejecutan. 1951 1952 Véanse también '::=', 'macros' y 'macroexpand1'. 1953 1954 Ejemplos: 1955 1956 (%i1) g (x) ::= x / 99; 1957 x 1958 (%o1) g(x) ::= -- 1959 99 1960 (%i2) h (x) ::= buildq ([x], g (x - a)); 1961 (%o2) h(x) ::= buildq([x], g(x - a)) 1962 (%i3) a: 1234; 1963 (%o3) 1234 1964 (%i4) macroexpand (h (y)); 1965 y - a 1966 (%o4) ----- 1967 99 1968 (%i5) h (y); 1969 y - 1234 1970 (%o5) -------- 1971 99 1972 1973 -- Función: macroexpand1 (<expr>) 1974 Devuelve la macroexpansión de <expr>, sin evaluarla, cuando 'expr' 1975 es una llamada a una función macro; en caso contrario, 1976 'macroexpand1' devuelve <expr>. 1977 1978 La función 'macroexpand1' no evalúa su argumento. Sin embargo, si 1979 la expansión de una llamada a función macro tiene efectos 1980 laterales, éstos se ejecutan. 1981 1982 Si la expansión de <expr> devuelve otra llamada a una función 1983 macro, esta llamada no se expande. 1984 1985 Véanse también '::=', 'macros' y 'macroexpand'. 1986 1987 Ejemplos: 1988 1989 (%i1) g (x) ::= x / 99; 1990 x 1991 (%o1) g(x) ::= -- 1992 99 1993 (%i2) h (x) ::= buildq ([x], g (x - a)); 1994 (%o2) h(x) ::= buildq([x], g(x - a)) 1995 (%i3) a: 1234; 1996 (%o3) 1234 1997 (%i4) macroexpand1 (h (y)); 1998 (%o4) g(y - a) 1999 (%i5) h (y); 2000 y - 1234 2001 (%o5) -------- 2002 99 2003 2004 -- Variable global: macros 2005 Valor por defecto: '[]' 2006 2007 La variable 'macros' es la lista de las funciones macro definidas 2008 por el usuario. El operador de definición de funciones macro '::=' 2009 coloca la nueva función macro en esta lista, mientras que 'kill', 2010 'remove' y 'remfunction' eliminan las funciones macro de la lista. 2011 2012 Véase también 'infolists'. 2013 2014 -- Función: splice (<a>) 2015 2016 Interpola la lista nombrada por el átomo <a> dentro de una 2017 expresión, pero sólo si 'splice' aparece dentro de 'buildq'; en 2018 otro caso, 'splice' se considera una función no definida. Si <a> 2019 aparece dentro de 'buildq' sin 'splice', entonces queda sustituida 2020 por una lista dentro del resultado. El argumento de 'splice' debe 2021 ser un átomo, no pudiendo ser una lista literal ni una expresión 2022 que devuelva una lista. 2023 2024 Normalmente 'splice' suministra los argumentos para una función u 2025 operador. Para una función 'f', la expresión 'f (splice (<a>))' 2026 dentro de 'buildq' se convierte en 'f (<a>[1], <a>[2], <a>[3], 2027 ...)'. Dado un operador 'o', la expresión '"o" (splice (<a>)' 2028 dentro de 'buildq' se convierte en '"o" (<a>[1], <a>[2], <a>[3], 2029 ...)', donde 'o' puede ser cualquier tipo de operador, normalmente 2030 uno que admita varios argumentos. Nótese que el operador debe ir 2031 encerrado entre comillas dobles '"'. 2032 2033 Ejemplos: 2034 2035 (%i1) buildq ([x: [1, %pi, z - y]], foo (splice (x)) / length (x)); 2036 foo(1, %pi, z - y) 2037 (%o1) ----------------------- 2038 length([1, %pi, z - y]) 2039 (%i2) buildq ([x: [1, %pi]], "/" (splice (x))); 2040 1 2041 (%o2) --- 2042 %pi 2043 (%i3) matchfix ("<>", "<>"); 2044 (%o3) <> 2045 (%i4) buildq ([x: [1, %pi, z - y]], "<>" (splice (x))); 2046 (%o4) <>1, %pi, z - y<> 2047 2048 2049File: maxima.info, Node: Funciones y variables para la definición de funciones, Prev: Macros, Up: Definición de Funciones 2050 205136.4 Funciones y variables para la definición de funciones 2052========================================================== 2053 2054 -- Función: apply (<F>, [<x_1>, ..., <x_n>]) 2055 Construye y evalúa la expresión '<F>(<arg_1>, ..., <arg_n>)'. 2056 2057 La función 'apply' no hace distinciones entre funciones array y 2058 funciones ordinarias; cuando <F> es el nombre de una función array, 2059 'apply' evalúa '<F>(...)', esto es, hace una llamada con paréntesis 2060 en lugar de corchetes. La función 'arrayapply' evalúa una llamada 2061 a función con corchetes para estos casos. 2062 2063 Ejemplos: 2064 2065 La función 'apply' evalúa sus argumentos. En este ejemplo, 'min' 2066 se aplica al valor de 'L'. 2067 2068 (%i1) L : [1, 5, -10.2, 4, 3]; 2069 (%o1) [1, 5, - 10.2, 4, 3] 2070 (%i2) apply (min, L); 2071 (%o2) - 10.2 2072 2073 La función 'apply' evalúa sus argumentos, incluso cuando la función 2074 <F> no lo hace. 2075 2076 (%i1) F (x) := x / 1729; 2077 x 2078 (%o1) F(x) := ---- 2079 1729 2080 (%i2) fname : F; 2081 (%o2) F 2082 (%i3) dispfun (F); 2083 x 2084 (%t3) F(x) := ---- 2085 1729 2086 2087 (%o3) [%t3] 2088 (%i4) dispfun (fname); 2089 fname is not the name of a user function. 2090 -- an error. Quitting. To debug this try debugmode(true); 2091 (%i5) apply (dispfun, [fname]); 2092 x 2093 (%t5) F(x) := ---- 2094 1729 2095 2096 (%o5) [%t5] 2097 2098 La función 'apply' evalúa el nombre de función <F>. La comilla 2099 simple ''' evita la evaluación. El nombre 'demoivre' corresponde a 2100 una variable global y también a una función. 2101 2102 (%i1) demoivre; 2103 (%o1) false 2104 (%i2) demoivre (exp (%i * x)); 2105 (%o2) %i sin(x) + cos(x) 2106 (%i3) apply (demoivre, [exp (%i * x)]); 2107 demoivre evaluates to false 2108 Improper name or value in functional position. 2109 -- an error. Quitting. To debug this try debugmode(true); 2110 (%i4) apply ('demoivre, [exp (%i * x)]); 2111 (%o4) %i sin(x) + cos(x) 2112 2113 -- Función: block ([<v_1>, ..., <v_m>], <expr_1>, ..., <expr_n>) 2114 -- Función: block (<expr_1>, ..., <expr_n>) 2115 2116 La función 'block' evalúa <expr_1>, ..., <expr_n> secuencialmente y 2117 devuelve el valor de la última expresión evaluada. La secuencia 2118 puede alterarse con las funciones 'go', 'throw' y 'return'. La 2119 última expresión es <expr_n> a menos que 'return' o una expresión 2120 que contenga un 'throw' sea evaluada. Las variables <v_1>, ..., 2121 <v_m> son locales en el bloque; éstas se distiguen de las globales 2122 que tengan el mismo nombre. Si no se declaran variables locales 2123 entonces se puede omitir la lista. Dentro del bloque, cualquier 2124 otra variable distinta de <v_1>, ..., <v_m> se considera global. 2125 2126 La función 'block' guarda los valores actuales de las variables 2127 <v_1>, ..., <v_m>, si los tienen, a la entrada del bloque y luego 2128 las evalúa a sí mismas, es decir les saca el valor temporalmente. 2129 A las variables locales se les puede asignar cualquier valor dentro 2130 del bloque, pero al salir de éste, los valores inicialmente 2131 almacenados quedan restaurados, al tiempo que los asignados dentro 2132 del bloque se pierden. 2133 2134 La declaración 'local(<v_1>, ..., <v_m>)' dentro de un bloque 2135 almacena las propiedades asociadas a los símbolos <v_1>, ..., 2136 <v_m>, borra cualesquiera otras propiedades antes de evaluar las 2137 expresiones y restaura las propiedades guardadas antes de abandonar 2138 el bloque. Algunas declaraciones, como ':=', 'array', 2139 'dependencies', 'atvalue', 'matchdeclare', 'atomgrad', 'constant', 2140 'nonscalar', 'assume' y otras se implementan como propiedades de 2141 símbolos. El efecto producido por 'local' consiste en hacer que 2142 tales declaraciones tengan efecto sólo dentro del bloque, en otro 2143 caso las declaraciones dentro del bloque tendrían un efecto global 2144 que afectarían al exterior de 'block'. 2145 2146 Un 'block' puede aparecer dentro de otro 'block'. Las variables 2147 locales se inicializan cada vez que se entra dentro de un nuevo 2148 bloque. Las variables locales de un bloque se consideran globales 2149 dentro de otro anidado dentro del primero. Si una variable es no 2150 local dentro de un bloque, su valor es el que le corresponde en el 2151 bloque superior. Este criterio se conoce con el nombre de "alcance 2152 dinámico". 2153 2154 El valor del bloque es el de la última sentencia o el argumento de 2155 la función 'return', que puede utilizarse para salir del bloque. 2156 La función 'go' puede usarse para transferir el control a la 2157 sentencia del bloque que esté etiquetada con el argumento de 'go'. 2158 Para etiquetar una sentencia basta que vaya precedida de un 2159 argumento atómico como cualquier otra sentencia dentro del bloque. 2160 Por ejemplo, 'block ([x], x:1, tururu, x: x+1, ..., go(tururu), 2161 ...)'. El argumento de 'go' debe ser el nombre de una etiqueta 2162 colocada dentro del bloque. No se puede utilzar 'go' para 2163 trasladarse a una etiqueta de un bloque que no sea el que contenga 2164 a 'go'. 2165 2166 Normalmente los bloques aparecerán al lado derecho de las 2167 definiciones de funciones, pero también pueden utilizarse en otros 2168 contextos. 2169 2170 -- Función: break (<expr_1>, ..., <expr_n>) 2171 2172 Calcula e imprime <expr_1>, ..., <expr_n> para luego provocar la 2173 detención de Maxima, de modo que el usuario pueda examinar y 2174 cambiar el entorno de ejecución. Pulsando posteriormente 'exit;' 2175 el cálculo se reanuda. 2176 2177 -- Función: catch (<expr_1>, ..., <expr_n>) 2178 2179 Evalúa <expr_1>, ..., <expr_n> una a una; si alguna de ellas 2180 conlleva la evaluación de una expresión de la forma 'throw (arg)', 2181 entonces el valor de 'catch' es el de 'throw (arg)' y ya no se 2182 evalúan más expresiones. Esta respuesta pasa todos los niveles de 2183 anidamiento hasta el 'catch' más próximo. Si no hay ningún 'catch' 2184 que contenga un 'throw' se emite un mensaje de error. 2185 2186 Si la evaluación de los argumentos no conlleva la evaluación de 2187 ningún 'throw', entonces el valor de 'catch' es el devuelto por 2188 <expr_n>. 2189 2190 (%i1) lambda ([x], if x < 0 then throw(x) else f(x))$ 2191 (%i2) g(l) := catch (map (''%, l))$ 2192 (%i3) g ([1, 2, 3, 7]); 2193 (%o3) [f(1), f(2), f(3), f(7)] 2194 (%i4) g ([1, 2, -3, 7]); 2195 (%o4) - 3 2196 2197 La función 'g' devuelve las imágenes por 'f' de todos los elementos 2198 de la lista 'l' si ésta contiene únicamente números no negativos; 2199 si no es este el caso, entonces 'g' captura el primer negativo que 2200 encuentra y lo devuelve por medio del 'throw'. 2201 2202 -- Function: compfile (<filename>, <f_1>, ..., <f_n>) 2203 -- Function: compfile (<filename>, functions) 2204 -- Function: compfile (<filename>, all) 2205 2206 Traduce funciones de Maxima a código Lisp, guardándolo luego en el 2207 fichero <filename>. 2208 2209 Con la llamada 'compfile(<filename>, <f_1>, ..., <f_n>)' se 2210 traducen las funciones especificadas, mientras que 2211 'compfile(<filename>, functions)' y 'compfile(<filename>, all)' 2212 traducen las funciones definidas por el usuario. 2213 2214 El código Lisp traducido no se evalúa, ni el fichero de salida es 2215 procesado por el compilador de Lisp. La función 'translate' crea y 2216 evalúa las traducciones Lisp, mientras que 'compile_file' traduce 2217 primero de Maxima a Lisp y luego ejecuta el compilador Lisp. 2218 2219 Véanse también 'translate', 'translate_file' y 'compile_file'. 2220 2221 -- Función: compile (<f_1>, ..., <f_n>) 2222 -- Función: compile (functions) 2223 -- Función: compile (all) 2224 2225 Traduce las funciones de Maxima <f_1>, ..., <f_n> a Lisp, evaluando 2226 el código resultante, y llama a la función Lisp 'COMPILE' para cada 2227 función traducida. La función 'compile' devuelve una lista con los 2228 nombres de las funciones compiladas. 2229 2230 Las llamadas 'compile (all)' o 'compile (functions)' compilan todas 2231 las funciones definidas por el usuario. 2232 2233 La función 'compile' no evalúa sus argumentos, pero con el operador 2234 comilla-comilla ('''') sí lo hace. 2235 2236 -- Función: define (<f>(<x_1>, ..., <x_n>), <expr>) 2237 -- Función: define (<f>[<x_1>, ..., <x_n>], <expr>) 2238 -- Función: define (funmake (<f>, [<x_1>, ..., <x_n>]), <expr>) 2239 -- Función: define (arraymake (<f>, [<x_1>, ..., <x_n>]), <expr>) 2240 -- Función: define (ev (<expr_1>), <expr_2>) 2241 2242 Define una función de nombre <f> con argumentos <x_1>, ..., <x_n> y 2243 cuerpo <expr>. 'define' evalúa siempre su segundo argumento, a 2244 menos que se indique lo contrario con el operador de comilla 2245 simple. La función así definida puede ser una función ordinaria de 2246 Maxima (con sus argumentos encerrados entre paréntesis) o una 2247 función array (con sus argumentos encerrados entre corchetes). 2248 2249 Cuando el último o único argumento <x_n> es una lista de un solo 2250 elemento, la función definida por 'define' acepta un número 2251 variable de argumentos. Los valores de los argumentos se van 2252 asignando uno a uno a <x_1>, ..., <x_(n - 1)>, y los que queden, si 2253 los hay, se asignan a <x_n> en forma de lista. 2254 2255 Cuando el primer argumento de 'define' es una expresión de la forma 2256 '<f>(<x_1>, ..., <x_n>)' o '<f>[<x_1>, ..., <x_n>]', se evalúan los 2257 argumentos de la función, pero no <f>, incluso cuando se trate de 2258 una función o variable ya existente con ese nombre. 2259 2260 Cuando el primer argumento es una expresión con operador 'funmake', 2261 'arraymake' o 'ev', se evalúa este primer argumento, lo que permite 2262 calcular la función. 2263 2264 Todas las definiciones de funciones aparecen en el mismo espacio de 2265 nombres; definiendo una función 'f' dentro de otra función 'g' no 2266 limita automáticamente el alcance de 'f' a 'g'. Sin embargo, 2267 'local(f)' hace que la definición de la función 'f' sea efectiva 2268 sólo dentro del bloque o expresión compuesta en el que aparece 2269 'local'. 2270 2271 Si un argumento formal <x_k> es un símbolo afectado por el operador 2272 comilla simple (expresión nominal), la función definida por 2273 'define' no evalúa el correspondiente valor de argumento. En 2274 cualquier otro caso, los argumentos que se pasan son evaluados. 2275 2276 Véanse también ':=' y '::='. 2277 2278 Ejemplos: 2279 2280 'define' evalúa siempre su segundo argumento, a menos que se 2281 indique lo contrario con el operador de comilla simple. 2282 2283 (%i1) expr : cos(y) - sin(x); 2284 (%o1) cos(y) - sin(x) 2285 (%i2) define (F1 (x, y), expr); 2286 (%o2) F1(x, y) := cos(y) - sin(x) 2287 (%i3) F1 (a, b); 2288 (%o3) cos(b) - sin(a) 2289 (%i4) F2 (x, y) := expr; 2290 (%o4) F2(x, y) := expr 2291 (%i5) F2 (a, b); 2292 (%o5) cos(y) - sin(x) 2293 2294 La función así definida puede ser una función ordinaria de Maxima o 2295 una función array. 2296 2297 (%i1) define (G1 (x, y), x.y - y.x); 2298 (%o1) G1(x, y) := x . y - y . x 2299 (%i2) define (G2 [x, y], x.y - y.x); 2300 (%o2) G2 := x . y - y . x 2301 x, y 2302 2303 Cuando el último o único argumento <x_n> es una lista de un solo 2304 elemento, la función definida por 'define' acepta un número 2305 variable de argumentos. 2306 2307 (%i1) define (H ([L]), '(apply ("+", L))); 2308 (%o1) H([L]) := apply("+", L) 2309 (%i2) H (a, b, c); 2310 (%o2) c + b + a 2311 2312 Cuando el primer argumento es una expresión con operador 'funmake', 2313 'arraymake' o 'ev', se evalúa este primer argumento. 2314 2315 (%i1) [F : I, u : x]; 2316 (%o1) [I, x] 2317 (%i2) funmake (F, [u]); 2318 (%o2) I(x) 2319 (%i3) define (funmake (F, [u]), cos(u) + 1); 2320 (%o3) I(x) := cos(x) + 1 2321 (%i4) define (arraymake (F, [u]), cos(u) + 1); 2322 (%o4) I := cos(x) + 1 2323 x 2324 (%i5) define (foo (x, y), bar (y, x)); 2325 (%o5) foo(x, y) := bar(y, x) 2326 (%i6) define (ev (foo (x, y)), sin(x) - cos(y)); 2327 (%o6) bar(y, x) := sin(x) - cos(y) 2328 2329 -- Función: define_variable (<name>, <default_value>, <mode>) 2330 2331 Introduce una variable global en el entorno de Maxima. La función 2332 'define_variable' puede ser útil en los paquetes escritos por los 2333 usuarios que vayan a ser compilados o traducidos con frecuencia. 2334 2335 La función 'define_variable' ejecuta los siguientes pasos: 2336 2337 1. 'mode_declare (<name>, <mode>)' declara el modo de <name> al 2338 traductor. Véase 'mode_declare' para ver la lista de modos 2339 aceptables. 2340 2341 2. Si aún no tiene asignación, se le da a la variable 2342 <default_value> el valor <name>. 2343 2344 3. 'declare (<name>, special)' la declara como especial. 2345 2346 4. Asocia <name> a una función de comprobación para asegurar que 2347 a <name> sólo se le asignan valores del modo declarado. 2348 2349 La propiedad 'value_check' se puede asociar a cualquier variable 2350 que haya sido definida mediante 'define_variable' en cualquiera de 2351 los modos diferentes a 'any'. La propiedad 'value_check' puede ser 2352 una expresión lambda o una función de una variable, que será 2353 invocada al intentar asignar un valor a la variable; el argumento 2354 pasado a la función 'value_check' es el valor que se le quiere 2355 asignar a la variable. 2356 2357 La función 'define_variable' evalúa 'default_value' pero no 'name' 2358 ni 'mode'; el valor que devuelve es el valor actual de 'name', el 2359 cual es 'default_value' si a 'name' no se le ha aplicado ninguna 2360 asignación, o el valor de dicha asignación en caso contrario. 2361 2362 Ejemplos: 2363 2364 'foo' es una variable booleana con valor inicial 'true'. 2365 (%i1) define_variable (foo, true, boolean); 2366 (%o1) true 2367 (%i2) foo; 2368 (%o2) true 2369 (%i3) foo: false; 2370 (%o3) false 2371 (%i4) foo: %pi; 2372 Error: foo was declared mode boolean, has value: %pi 2373 -- an error. Quitting. To debug this try debugmode(true); 2374 (%i5) foo; 2375 (%o5) false 2376 2377 'bar' es una variable entera, cuyo valor habrá de ser primo. 2378 (%i1) define_variable (bar, 2, integer); 2379 (%o1) 2 2380 (%i2) qput (bar, prime_test, value_check); 2381 (%o2) prime_test 2382 (%i3) prime_test (y) := if not primep(y) then 2383 error (y, "is not prime."); 2384 (%o3) prime_test(y) := 2385 if not primep(y) then error(y, "is not prime.") 2386 (%i4) bar: 1439; 2387 (%o4) 1439 2388 (%i5) bar: 1440; 2389 1440 is not prime. 2390 #0: prime_test(y=1440) 2391 -- an error. Quitting. To debug this try debugmode(true); 2392 (%i6) bar; 2393 (%o6) 1439 2394 2395 'baz_quux' es una variable a la que no se le podrá asignar valor 2396 alguno. El modo 'any_check' es como 'any', pero 'any_check' activa 2397 el mecanismo 'value_check', cosa que 'any' no hace. 2398 (%i1) define_variable (baz_quux, 'baz_quux, any_check); 2399 (%o1) baz_quux 2400 (%i2) F: lambda ([y], if y # 'baz_quux then 2401 error ("Cannot assign to `baz_quux'.")); 2402 (%o2) lambda([y], if y # 'baz_quux 2403 then error(Cannot assign to `baz_quux'.)) 2404 (%i3) qput (baz_quux, ''F, value_check); 2405 (%o3) lambda([y], if y # 'baz_quux 2406 then error(Cannot assign to `baz_quux'.)) 2407 (%i4) baz_quux: 'baz_quux; 2408 (%o4) baz_quux 2409 (%i5) baz_quux: sqrt(2); 2410 Cannot assign to `baz_quux'. 2411 #0: lambda([y],if y # 'baz_quux then 2412 error("Cannot assign to `baz_quux'."))(y=sqrt(2)) 2413 -- an error. Quitting. To debug this try debugmode(true); 2414 (%i6) baz_quux; 2415 (%o6) baz_quux 2416 2417 -- Función: dispfun (<f_1>, ..., <f_n>) 2418 -- Función: dispfun (all) 2419 2420 Muestra la deficnión de las funciones de usuario <f_1>, ..., <f_n>. 2421 Cada argumento puede ser el nombre de una macro (definida mediante 2422 '::='), una función ordinaria (definida mediante ':=' o 'define'), 2423 una función arreglo (definida mediante ':=' o 'define', pero 2424 encerrando los argumentos dentro de corchetes '[ ]'), una función 2425 de subíndice (definida mediante ':=' o 'define', pero encerrando 2426 algunos argumentos entre corchetes y otros entre paréntesis '( )'), 2427 una función de subíndice seleccionada por un subíndice variable, o 2428 una función de subíndice definida con un subíndice constante. 2429 2430 La llamada 'dispfun (all)' muestra todas las funciones de usuario 2431 tal como las dan las listas 'functions', 'arrays' y 'macros', 2432 omitiendo las funciones con subíndices definidas con subíndices 2433 constantes. 2434 2435 La función 'dispfun' crea una etiqueta ('%t1', '%t2', etc.) para 2436 cada función mostrada, y asigna la definición de la función a la 2437 etiqueta. En contraste, 'fundef' devuelve las definiciones de las 2438 funciones. 2439 2440 La función 'dispfun' no evalúa sus argumentos; el operador de 2441 comilla-comilla '''' permite la evaluación. 2442 2443 La función 'dispfun' devuelve la lista de etiquetas de expresiones 2444 intermedias correspondientes a las funciones mostradas. 2445 2446 Ejemplos: 2447 2448 (%i1) m(x, y) ::= x^(-y); 2449 - y 2450 (%o1) m(x, y) ::= x 2451 (%i2) f(x, y) := x^(-y); 2452 - y 2453 (%o2) f(x, y) := x 2454 (%i3) g[x, y] := x^(-y); 2455 - y 2456 (%o3) g := x 2457 x, y 2458 (%i4) h[x](y) := x^(-y); 2459 - y 2460 (%o4) h (y) := x 2461 x 2462 (%i5) i[8](y) := 8^(-y); 2463 - y 2464 (%o5) i (y) := 8 2465 8 2466 (%i6) dispfun (m, f, g, h, h[5], h[10], i[8]); 2467 - y 2468 (%t6) m(x, y) ::= x 2469 2470 - y 2471 (%t7) f(x, y) := x 2472 2473 - y 2474 (%t8) g := x 2475 x, y 2476 2477 - y 2478 (%t9) h (y) := x 2479 x 2480 2481 1 2482 (%t10) h (y) := -- 2483 5 y 2484 5 2485 2486 1 2487 (%t11) h (y) := --- 2488 10 y 2489 10 2490 2491 - y 2492 (%t12) i (y) := 8 2493 8 2494 2495 (%o12) [%t6, %t7, %t8, %t9, %t10, %t11, %t12] 2496 (%i12) ''%; 2497 - y - y - y 2498 (%o12) [m(x, y) ::= x , f(x, y) := x , g := x , 2499 x, y 2500 - y 1 1 - y 2501 h (y) := x , h (y) := --, h (y) := ---, i (y) := 8 ] 2502 x 5 y 10 y 8 2503 5 10 2504 2505 -- Función: fullmap (<f>, <expr_1>, ...) 2506 Similar a 'map', pero conservará el mapeado descendente de todas 2507 las subexpresiones hasta que los operadores principales ya no sean 2508 los mismos. 2509 2510 La función 'fullmap' es utilizada por el simplificador de Maxima en 2511 algunas transformaciones matriciales, por lo que Maxima generará en 2512 algunas ocasiones mensajes de error relacionados con 'fullmap' 2513 aunque el usuario no haya invocado explícitamente esta función. 2514 2515 (%i1) a + b * c; 2516 (%o1) b c + a 2517 (%i2) fullmap (g, %); 2518 (%o2) g(b) g(c) + g(a) 2519 (%i3) map (g, %th(2)); 2520 (%o3) g(b c) + g(a) 2521 2522 -- Función: fullmapl (<f>, <list_1>, ...) 2523 Similar a 'fullmap', pero 'fullmapl' sólo hace mapeo sobre listas y 2524 matrices. 2525 2526 (%i1) fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]); 2527 (%o1) [[a + 3, 4], [4, 3.5]] 2528 2529 -- Variable del sistema: functions 2530 Valor por defecto: '[]' 2531 2532 La variable 'functions' es una lista que contiene los nombres de 2533 las funciones ordinarias de Maxima. Una función ordinaria es 2534 aquella que ha sido construida mediante cualquiera de los métodos 2535 'define' o ':=' y que es invocada utilizando paréntesis. Una 2536 función puede definirse durante una sesión de Maxima o en un 2537 fichero que posteriormente será cargado en memoria por 'load' o 2538 'batch'. 2539 2540 Las funciones array, que son invocadas con corchetes ('F[x]'), y 2541 las funciones subindicadas, que son las invocadas con corchetes y 2542 paréntesis ('F[x](y)') se registran en la variable global 'arrays', 2543 no en 'functions'. 2544 2545 Las funciones Lisp no se registran en ninguna lista. 2546 2547 Ejemplos: 2548 2549 (%i1) F_1 (x) := x - 100; 2550 (%o1) F_1(x) := x - 100 2551 (%i2) F_2 (x, y) := x / y; 2552 x 2553 (%o2) F_2(x, y) := - 2554 y 2555 (%i3) define (F_3 (x), sqrt (x)); 2556 (%o3) F_3(x) := sqrt(x) 2557 (%i4) G_1 [x] := x - 100; 2558 (%o4) G_1 := x - 100 2559 x 2560 (%i5) G_2 [x, y] := x / y; 2561 x 2562 (%o5) G_2 := - 2563 x, y y 2564 (%i6) define (G_3 [x], sqrt (x)); 2565 (%o6) G_3 := sqrt(x) 2566 x 2567 (%i7) H_1 [x] (y) := x^y; 2568 y 2569 (%o7) H_1 (y) := x 2570 x 2571 (%i8) functions; 2572 (%o8) [F_1(x), F_2(x, y), F_3(x)] 2573 (%i9) arrays; 2574 (%o9) [G_1, G_2, G_3, H_1] 2575 2576 -- Función: fundef (<f>) 2577 2578 Devuelve la definición de la función <f>. 2579 2580 Cada argumento puede ser el nombre de una macro (definida mediante 2581 '::='), una función ordinaria (definida mediante ':=' o 'define'), 2582 una función arreglo (definida mediante ':=' o 'define', pero 2583 encerrando los argumentos dentro de corchetes '[ ]'), una función 2584 de subíndice (definida mediante ':=' o 'define', pero encerrando 2585 algunos argumentos entre corchetes y otros entre paréntesis '( )'), 2586 una función de subíndice seleccionada por un subíndice variable, o 2587 una función de subíndice definida con un subíndice constante. 2588 2589 La función 'fundef' no evalúa sus argumentos; el operador 2590 comilla-comilla '''' permite la evaluación. 2591 2592 La llamada de función 'fundef (<f>)' devuelve la definición de <f>. 2593 Por el contrario, 'dispfun (<f>)' crea una etiqueta intermedia y le 2594 asigna la definición a la etiqueta. 2595 2596 -- Función: funmake (<F>, [<arg_1>, ..., <arg_n>]) 2597 2598 Devuelve una expresión '<F>(<arg_1>, ..., <arg_n>)'. El valor así 2599 retornado es simplificado pero no evaluado, de forma que la función 2600 <F> no es invocada, incluso cuando exista. 2601 2602 La función 'funmake' no hace distinciones entre funciones array y 2603 funciones ordinarias; cuando <F> es el nombre de una función array, 2604 'funmake' devuelve '<F>(...)', esto es, una llamada a función con 2605 paréntesis en lugar de corchetes. La función 'arraymake' devuelve 2606 una llamada a función con corchetes para estos casos. 2607 2608 La función 'funmake' evalúa sus argumentos. 2609 2610 Ejemplos: 2611 2612 La función 'funmake' aplicada a una función ordinaria de Maxima. 2613 2614 (%i1) F (x, y) := y^2 - x^2; 2615 2 2 2616 (%o1) F(x, y) := y - x 2617 (%i2) funmake (F, [a + 1, b + 1]); 2618 (%o2) F(a + 1, b + 1) 2619 (%i3) ''%; 2620 2 2 2621 (%o3) (b + 1) - (a + 1) 2622 2623 La función 'funmake' aplicada a una macro. 2624 2625 (%i1) G (x) ::= (x - 1)/2; 2626 x - 1 2627 (%o1) G(x) ::= ----- 2628 2 2629 (%i2) funmake (G, [u]); 2630 (%o2) G(u) 2631 (%i3) ''%; 2632 u - 1 2633 (%o3) ----- 2634 2 2635 2636 La función 'funmake' aplicada a una función subindicada. 2637 2638 (%i1) H [a] (x) := (x - 1)^a; 2639 a 2640 (%o1) H (x) := (x - 1) 2641 a 2642 (%i2) funmake (H [n], [%e]); 2643 n 2644 (%o2) lambda([x], (x - 1) )(%e) 2645 (%i3) ''%; 2646 n 2647 (%o3) (%e - 1) 2648 (%i4) funmake ('(H [n]), [%e]); 2649 (%o4) H (%e) 2650 n 2651 (%i5) ''%; 2652 n 2653 (%o5) (%e - 1) 2654 2655 La función 'funmake' aplicada a un símbolo que no está asociado a 2656 función alguna. 2657 2658 (%i1) funmake (A, [u]); 2659 (%o1) A(u) 2660 (%i2) ''%; 2661 (%o2) A(u) 2662 2663 La función 'funmake' evalúa sus argumentos, pero no el valor 2664 retornado. 2665 2666 (%i1) det(a,b,c) := b^2 -4*a*c; 2667 2 2668 (%o1) det(a, b, c) := b - 4 a c 2669 (%i2) (x : 8, y : 10, z : 12); 2670 (%o2) 12 2671 (%i3) f : det; 2672 (%o3) det 2673 (%i4) funmake (f, [x, y, z]); 2674 (%o4) det(8, 10, 12) 2675 (%i5) ''%; 2676 (%o5) - 284 2677 2678 Maxima simplifica el valor retornado de 'funmake'. 2679 2680 (%i1) funmake (sin, [%pi / 2]); 2681 (%o1) 1 2682 2683 -- Función: lambda ([<x_1>, ..., <x_m>], <expr_1>, ..., <expr_n>) 2684 -- Function: lambda ([[<L>]], <expr_1>, ..., <expr_n>) 2685 -- Function: lambda ([<x_1>, ..., <x_m>, [<L>]], <expr_1>, ..., 2686 <expr_n>) 2687 Define y devuelve una expresión lambda (es decir, una función 2688 anónima). La función puede tener argumentos <x_1>, ..., <x_m> y/o 2689 argumentos opcionales <L>, que aparecerán dentro del cuerpo de la 2690 función como una lista. El valor que devuelve la función es 2691 <expr_n>. Una expresión lambda puede asignarse a una variable y 2692 ser evaluada como si fuese una función ordinaria. Además, puede 2693 aparecer en algunos contextos en los que sea necesario un nombre de 2694 función. 2695 2696 Cuando se evalúa la función, se crean las variables <x_1>, ..., 2697 <x_m> sin asignación de valores. Una función 'lambda' puede 2698 aparecer dentro de un 'block' o de otra 'lambda'. Las variables 2699 locales se inicializan cada vez que se entra dentro de un nuevo 2700 bloque o de otra función 'lambda'. Las variables locales se 2701 consideran globales dentro de un bloque o función 'lambda' anidado 2702 dentro del primero. Si una variable es no local dentro de un 2703 bloque o función 'lambda', su valor es el que le corresponde en el 2704 bloque o función 'lambda' superior. Este criterio se conoce con el 2705 nombre de "alcance dinámico". 2706 2707 Una vez establecidas las variables locales <expr_1> a <expr_n> son 2708 secuencialmente evaluadas. La variable especial '%%' representa el 2709 valor de la expresión inmediata anterior. Las sentencias 'throw' y 2710 'catch' pueden aparecer también en la lista de expresiones. 2711 2712 La función 'return' no puede aparecer en una expresión 'lambda' a 2713 menos que se encuentre acotada dentro de un bloque ('block'), en 2714 cuyo caso 'return' establece el valor de retorno del bloque, pero 2715 no de la expresión 'lambda', a menos que el bloque resulte ser 2716 precisamente <expr_n>. De igual manera, 'go' no puede aparecer en 2717 una expresión 'lambda' si no es dentro de un 'block'. 2718 2719 Las funciones 'lambda' no evalúan sus argumentos; el operador 2720 comilla-comilla '''' permite su evaluación. 2721 2722 Ejemplo: 2723 2724 * Una función lambda puede asignarse a una variable y ser 2725 evaluada como si fuese una función ordinaria. 2726 (%i1) f: lambda ([x], x^2); 2727 2 2728 (%o1) lambda([x], x ) 2729 (%i2) f(a); 2730 2 2731 (%o2) a 2732 * Una expresión lambda puede aparecer en algunos contextos en 2733 los que sea necesario un nombre de función. 2734 (%i3) lambda ([x], x^2) (a); 2735 2 2736 (%o3) a 2737 (%i4) apply (lambda ([x], x^2), [a]); 2738 2 2739 (%o4) a 2740 (%i5) map (lambda ([x], x^2), [a, b, c, d, e]); 2741 2 2 2 2 2 2742 (%o5) [a , b , c , d , e ] 2743 * Los argumentos son variables locales. Otras variables se 2744 consideran globales. Las variables globales son evaluadas en 2745 el momento que lo es la expresión, a menos que la evaluación 2746 de las mismas sea forzada, como cuando se hace uso de ''''. 2747 (%i6) a: %pi$ 2748 (%i7) b: %e$ 2749 (%i8) g: lambda ([a], a*b); 2750 (%o8) lambda([a], a b) 2751 (%i9) b: %gamma$ 2752 (%i10) g(1/2); 2753 %gamma 2754 (%o10) ------ 2755 2 2756 (%i11) g2: lambda ([a], a*''b); 2757 (%o11) lambda([a], a %gamma) 2758 (%i12) b: %e$ 2759 (%i13) g2(1/2); 2760 %gamma 2761 (%o13) ------ 2762 2 2763 * Las expresiones lambda pueden anidarse. Las variables locales 2764 de expresiones lambda exteriores se consideran globales en 2765 expresiones internas, a menos que se enmascaren con variables 2766 locales de igual nombre. 2767 (%i14) h: lambda ([a, b], h2: lambda ([a], a*b), h2(1/2)); 2768 1 2769 (%o14) lambda([a, b], h2 : lambda([a], a b), h2(-)) 2770 2 2771 (%i15) h(%pi, %gamma); 2772 %gamma 2773 (%o15) ------ 2774 2 2775 * Puesto que 'lambda' no evalúa sus argumentos, la expresión 2776 lambda 'i' de más abajo no define una función del tipo 2777 "multiplicar por 'a'". Tal tipo de función se puede definir a 2778 través de 'buildq', como en la expresión lambda 'i2' de más 2779 abajo. 2780 (%i16) i: lambda ([a], lambda ([x], a*x)); 2781 (%o16) lambda([a], lambda([x], a x)) 2782 (%i17) i(1/2); 2783 (%o17) lambda([x], a x) 2784 (%i18) i2: lambda([a], buildq([a: a], lambda([x], a*x))); 2785 (%o18) lambda([a], buildq([a : a], lambda([x], a x))) 2786 (%i19) i2(1/2); 2787 x 2788 (%o19) lambda([x], -) 2789 2 2790 (%i20) i2(1/2)(%pi); 2791 %pi 2792 (%o20) --- 2793 2 2794 * Una expresión lambda puede tener un número variable de 2795 argumentos, los cuales se indican mediante '[<L>]', bien sea 2796 solo o como un último argumento. Estos argumentos aparecerán 2797 dentro del cuerpo de la función en forma de lista. 2798 (%i1) f : lambda ([aa, bb, [cc]], aa * cc + bb); 2799 (%o1) lambda([aa, bb, [cc]], aa cc + bb) 2800 (%i2) f (foo, %i, 17, 29, 256); 2801 (%o2) [17 foo + %i, 29 foo + %i, 256 foo + %i] 2802 (%i3) g : lambda ([[aa]], apply ("+", aa)); 2803 (%o3) lambda([[aa]], apply(+, aa)) 2804 (%i4) g (17, 29, x, y, z, %e); 2805 (%o4) z + y + x + %e + 46 2806 2807 -- Función: local (<v_1>, ..., <v_n>) 2808 2809 La declaración 'local(<v_1>, ..., <v_m>)' dentro de un bloque 2810 almacena las propiedades asociadas a los símbolos <v_1>, ..., 2811 <v_m>, borra cualesquiera otras propiedades antes de evaluar las 2812 expresiones y restaura las propiedades guardadas antes de abandonar 2813 el bloque. 2814 2815 Algunas declaraciones, como ':=', 'array', 'dependencies', 2816 'atvalue', 'matchdeclare', 'atomgrad', 'constant', 'nonscalar', 2817 'assume' y otras se implementan como propiedades de símbolos. El 2818 efecto producido por 'local' consiste en hacer que tales 2819 declaraciones tengan efecto sólo dentro del bloque, en otro caso 2820 las declaraciones dentro del bloque tendrían un efecto global que 2821 afectarían al exterior de 'block'. 2822 2823 La función 'local' sólo puede usarse dentro de un 'block', en el 2824 cuerpo de definición de funciones o de expresiones 'lambda' o en la 2825 función 'ev', siéndole permitido aparecer una sóla vez en cada una 2826 de ellas. 2827 2828 La función 'local' no evalúa sus argumentos y devuelve 'done'. 2829 2830 Ejemplo: 2831 2832 Definición local de una función. 2833 2834 (%i1) foo (x) := 1 - x; 2835 (%o1) foo(x) := 1 - x 2836 (%i2) foo (100); 2837 (%o2) - 99 2838 (%i3) block (local (foo), foo (x) := 2 * x, foo (100)); 2839 (%o3) 200 2840 (%i4) foo (100); 2841 (%o4) - 99 2842 2843 -- Variable opcional: macroexpansion 2844 Valor por defecto: 'false' 2845 2846 La variable 'macroexpansion' controla si la expansión (esto es, el 2847 valor de retorno) de una función macro se sustituye por la llamada 2848 a la función macro. Una sustitución puede acelerar futuras 2849 evaluaciones de la expresión, bajo el coste que implica tener que 2850 almacenar la expansión. 2851 2852 'false' 2853 La expansión de una función macro no se sustituye por la 2854 llamada a la función macro. 2855 'expand' 2856 La primera vez que se evalúa una llamada a función macro se 2857 almacena la expansión. De esta manera la expansión no se 2858 recalcula en llamadas posteriores; cualesquiera efectos 2859 laterales (como 'print' o asignaciones a variables globales) 2860 tan solo tienen lugar la primera vez que la función macro es 2861 evaluada. La expansión en una expresión no afecta a otras 2862 expresiones que llamen a la misma función macro. 2863 'displace' 2864 La primera vez que se evalúa una llamada a una función macro, 2865 la expansión se sustituye por la llamada, modificando así la 2866 expresión desde la que se hizo la llamada a la función macro. 2867 La expansión no se recalcula en llamadas posteriores; 2868 cualesquiera efectos laterales tan solo tienen lugar la 2869 primera vez que la función macro es evaluada. La expansión en 2870 una expresión no afecta a otras expresiones que llamen a la 2871 misma función macro. 2872 2873 Ejemplos: 2874 2875 Si 'macroexpansion' vale 'false', una función macro es llamada cada 2876 vez que la expresión de llamada es evaluada. 2877 2878 (%i1) f (x) := h (x) / g (x); 2879 h(x) 2880 (%o1) f(x) := ---- 2881 g(x) 2882 (%i2) g (x) ::= block (print ("x + 99 is equal to", x), 2883 return (x + 99)); 2884 (%o2) g(x) ::= block(print("x + 99 is equal to", x), 2885 return(x + 99)) 2886 (%i3) h (x) ::= block (print ("x - 99 is equal to", x), 2887 return (x - 99)); 2888 (%o3) h(x) ::= block(print("x - 99 is equal to", x), 2889 return(x - 99)) 2890 (%i4) macroexpansion: false; 2891 (%o4) false 2892 (%i5) f (a * b); 2893 x - 99 is equal to x 2894 x + 99 is equal to x 2895 a b - 99 2896 (%o5) -------- 2897 a b + 99 2898 (%i6) dispfun (f); 2899 h(x) 2900 (%t6) f(x) := ---- 2901 g(x) 2902 2903 (%o6) done 2904 (%i7) f (a * b); 2905 x - 99 is equal to x 2906 x + 99 is equal to x 2907 a b - 99 2908 (%o7) -------- 2909 a b + 99 2910 2911 Si 'macroexpansion' vale 'expand', una función macro tan solo es 2912 llamada una vez. 2913 2914 (%i1) f (x) := h (x) / g (x); 2915 h(x) 2916 (%o1) f(x) := ---- 2917 g(x) 2918 (%i2) g (x) ::= block (print ("x + 99 is equal to", x), 2919 return (x + 99)); 2920 (%o2) g(x) ::= block(print("x + 99 is equal to", x), 2921 return(x + 99)) 2922 (%i3) h (x) ::= block (print ("x - 99 is equal to", x), 2923 return (x - 99)); 2924 (%o3) h(x) ::= block(print("x - 99 is equal to", x), 2925 return(x - 99)) 2926 (%i4) macroexpansion: expand; 2927 (%o4) expand 2928 (%i5) f (a * b); 2929 x - 99 is equal to x 2930 x + 99 is equal to x 2931 a b - 99 2932 (%o5) -------- 2933 a b + 99 2934 (%i6) dispfun (f); 2935 h(x) 2936 (%t6) f(x) := ---- 2937 g(x) 2938 2939 (%o6) done 2940 (%i7) f (a * b); 2941 a b - 99 2942 (%o7) -------- 2943 a b + 99 2944 2945 Si 'macroexpansion' vale 'expand', una función macro es llamada una 2946 vez y la expresión de llamada se modifica. 2947 2948 (%i1) f (x) := h (x) / g (x); 2949 h(x) 2950 (%o1) f(x) := ---- 2951 g(x) 2952 (%i2) g (x) ::= block (print ("x + 99 is equal to", x), return (x + 99)); 2953 (%o2) g(x) ::= block(print("x + 99 is equal to", x), 2954 return(x + 99)) 2955 (%i3) h (x) ::= block (print ("x - 99 is equal to", x), return (x - 99)); 2956 (%o3) h(x) ::= block(print("x - 99 is equal to", x), 2957 return(x - 99)) 2958 (%i4) macroexpansion: displace; 2959 (%o4) displace 2960 (%i5) f (a * b); 2961 x - 99 is equal to x 2962 x + 99 is equal to x 2963 a b - 99 2964 (%o5) -------- 2965 a b + 99 2966 (%i6) dispfun (f); 2967 x - 99 2968 (%t6) f(x) := ------ 2969 x + 99 2970 2971 (%o6) done 2972 (%i7) f (a * b); 2973 a b - 99 2974 (%o7) -------- 2975 a b + 99 2976 2977 -- Variable opcional: mode_checkp 2978 Valor por defecto: 'true' 2979 2980 Cuando 'mode_checkp' vale 'true', 'mode_declare' chequea los modos 2981 de las variables con valores asignados. 2982 2983 -- Variable opcional: mode_check_errorp 2984 Valor por defecto: 'false' 2985 2986 Cuando 'mode_check_errorp' vale 'true', 'mode_declare' llama a 2987 error. 2988 2989 -- Variable opcional: mode_check_warnp 2990 Valor por defecto: 'true' 2991 2992 Cuando 'mode_check_warnp' vale 'true', se detallan los errores de 2993 modo. 2994 2995 -- Función: mode_declare (<y_1>, <modo_1>, ..., <y_n>, <modo_n>) 2996 2997 La función 'mode_declare' se utiliza para declarar los modos de 2998 variables y funciones para la ulterior traducción a Lisp o 2999 compilación de funciones. Se coloca habitualmente al comienzo de 3000 la definición de una función, de un script en Maxima o se ejecuta 3001 en tiempo real. 3002 3003 Los argumentos de 'mode_declare' son pares formados por una 3004 variable y un modo, el cual debe ser 'boolean', 'fixnum', 'number', 3005 'rational' o 'float'. Cada variable puede ser sustituida por una 3006 lista de variables, en cuyo caso todas ellas tendrán el mismo modo. 3007 3008 Código numérico que utilice arreglos puede ejecutarse más rápido 3009 declarando el tamaño que va a ocupar el arreglo, como en: 3010 3011 mode_declare (array (a [10, 10]), float) 3012 3013 para un arreglo de números en coma flotante de dimensiones 10 x 10. 3014 3015 Se puede declarar el modo del resultado de una función poniendo 3016 'function (f_1, f_2, ...)' como argumento; aquí 'f_1', 'f_2', ... 3017 son los nombres de las funciones. Por ejemplo, la expresión 3018 3019 mode_declare ([function (f_1, f_2, ...)], fixnum) 3020 3021 declara que el valor a devolver por 'f_1', 'f_2', ... son enteros 3022 de modo "single-word". 3023 3024 El nombre 'modedeclare' es sinónimo de 'mode_declare'. 3025 3026 -- Función: mode_identity (<arg_1>, <arg_2>) 3027 Es una forma especial usada con 'mode_declare' y 'macros' para 3028 declarar, por ejemplo, una lista de listas de números. 3029 3030 -- Función: remfunction (<f_1>, ..., <f_n>) 3031 -- Función: remfunction (all) 3032 Desliga las definiciones de función de sus símbolos <f_1>, ..., 3033 <f_n>. Los argumentos pueden ser nombres de funciones ordinarias 3034 (creadas con ':=' o 'define') o de funciones macro (creadas con 3035 '::='). 3036 3037 La instrucción 'remfunction (all)' desliga todas las definiciones 3038 de funciones. 3039 3040 La función 'remfunction' no evalúa sus argumentos. 3041 3042 La función 'remfunction' devuelve una lista con los símbolos para 3043 los que la definición de función fue desligada. Devuelve 'false' 3044 en el lugar de cualquier símbolo para el que no hay función 3045 definida. 3046 3047 La función 'remfunction' no se puede aplicar a arrays de funciones 3048 ni a funciones subindicadas. Sí es aplicable en tales casos la 3049 función 'remarray'. 3050 3051 -- Variable opcional: savedef 3052 Valor por defecto: 'true' 3053 3054 Si 'savedef' vale 'true', se mantiene la versión Maxima de una 3055 función definida por el usuario cuando ésta se traduce, lo que 3056 permite mostrar su código con 'dispfun' y que la función pueda ser 3057 editada. 3058 3059 Si 'savedef' vale 'false', los nombres de las funciones traducidas 3060 se eliminan de la lista 'functions'. 3061 3062 -- Variable opcional: transcompile 3063 Valor por defecto: 'true' 3064 3065 Si 'transcompile' vale 'true', 'translate' y 'translate_file' 3066 generan declaraciones para hacer el código traducido más apto para 3067 la compilación. 3068 3069 La función 'compfile' hace la asignación 'transcompile: true'. 3070 3071 -- Función: translate (<f_1>, ..., <f_n>) 3072 -- Función: translate (functions) 3073 -- Función: translate (all) 3074 3075 Traduce las funciones definidas por el usuario <f_1>, ..., <f_n> 3076 del lenguaje de Maxima a Lisp y evalúa las traducciones Lisp. 3077 Normalmente las funciones traducidas se ejecutan más rapidamente 3078 que las originales. 3079 3080 Las llamadas 'translate (all)' o 'translate (functions)' traducen 3081 todas las funciones de usuario. 3082 3083 Las funciones a ser traducidas deberían incluir una llamada a 3084 'mode_declare' al comienzo siempre que sea posible, a fin de 3085 producir código más eficiente. Por ejemplo: 3086 3087 f (x_1, x_2, ...) := block ([v_1, v_2, ...], 3088 mode_declare (v_1, modo_1, v_2, modo_2, ...), ...) 3089 3090 3091 donde <x_1>, <x_2>, ... son los parámetros que se pasan a la 3092 función y <v_1>, <v_2>, ... son las variables locales. 3093 3094 Los nombres de las funciones traducidas son eliminados de la lista 3095 'functions' si 'savedef' vale 'false' (ver más abajo) y son 3096 añadidos a las listas 'props'. 3097 3098 Las funciones no deberían ser traducidas hasta no estar 3099 completamente depuradas. 3100 3101 Se supone que las expresiones están simplificadas; en caso de no 3102 estarlo, se generará código correcto pero ineficiente. Así, el 3103 usuario no debería asignar a 'simp' el valor 'false', el cual 3104 inhibe la simplificación de la expresión a ser traducida. 3105 3106 Cuando la variable 'translate' vale 'true', se traducen 3107 automáticamente las funciones de usuario a Lisp. 3108 3109 Nótese que las funciones traducidas puede que no se ejecuten 3110 exactamente igual a como lo hacían antes de la traducción, debido a 3111 posibles incompatibilidades entre las versiones de Maxima y Lisp. 3112 En general, la función 'rat' con más de un argumento y la función 3113 'ratvars' no deberían utilizarse si algunas de las variables son 3114 declaradas como expresiones racionales canónicas (CRE) mediante 3115 'mode_declare'. Además, la asignación 'prederror: false' no 3116 traducirá. 3117 3118 Si 'savedef' vale 'true', entonces la versión de Maxima de una 3119 función de usuario permanecerá cuando la función sea traducida por 3120 'translate'. Con esto se hace posible que se muestre la definición 3121 llamando a 'dispfun' y que la función sea editada. 3122 3123 Si 'transrun' vale 'false' entonces las versiones interpretadas de 3124 todas las funciones serán ejecutadas en lugar de las versiones 3125 traducidas. 3126 3127 El resultado devuelto por 'translate' es una lista con los nombres 3128 de las funciones traducidas. 3129 3130 -- Función: translate_file (<nombre_fichero_maxima>) 3131 -- Función: translate_file (<nombre_fichero_maxima>, 3132 <nombre_fichero_lisp>) 3133 3134 Traduce un fichero en código Maxima a un fichero en código Lisp. 3135 La función 'translate_file' devuelve una lista con los nombres de 3136 tres ficheros: el nombre del ficheero en Maxima, el nombre del 3137 fichero en Lisp y el nombre del fichero que contiene información 3138 adicional sobre la traducción. La función 'translate_file' evalúa 3139 sus argumentos. 3140 3141 La llamada 'translate_file ("foo.mac"); load("foo.LISP")' es lo 3142 mismo que 'batch ("foo.mac")', excepto por la presencia de ciertas 3143 restricciones, como el uso de '''' y '%', por ejemplo. 3144 3145 La llamada 'translate_file (<nombre_fichero_maxima>)' traduce un 3146 fichero en Maxima, <nombre_fichero_maxima>, a otro en Lisp de 3147 nombre similar. Por ejemplo, 'foo.mac' se traduce en 'foo.LISP'. 3148 El nombre del fichero en Maxima puede incluir el nombre de un 3149 directorio, en cuyo caso el fichero de salida Lisp se guardará en 3150 el mismo directorio desde el que se leyó la fuente Maxima. 3151 3152 La llamada 'translate_file (<nombre_fichero_maxima>, 3153 <nombre_fichero_lisp>)' traduce el fichero Maxima 3154 <nombre_fichero_maxima> en el fichero Lisp <nombre_fichero_lisp>. 3155 La función 'translate_file' ignora la extensión del fichero, en 3156 caso de que exista, de 'nombre_fichero_lisp'; la extensión del 3157 fichero de salida Lisp será invariablemente 'LISP'. El nombre del 3158 fichero Lisp puede incluir la ruta del directorio, en cuyo caso se 3159 almacenará en el directorio especificado. 3160 3161 La función 'translate_file' también escribe un fichero de mensajes 3162 de avisos del traductor con diversos niveles de gravedad. La 3163 extensión de este fichero es 'UNLISP'. Este fichero puede contener 3164 información valiosa, aunque de difícil interpretación, para 3165 detectar fallos en el código traducido. El fichero 'UNLISP' se 3166 guarda siempre en el mismo directorio desde el que se leyó la 3167 fuente de Maxima. 3168 3169 La función 'translate_file' emite código Lisp que incluye algunas 3170 declaraciones y definiciones que entran en efecto tan pronto como 3171 el código Lisp es compilado. Véase 'compile_file' para más 3172 información sobre este particular. 3173 3174 Véanse también 'tr_array_as_ref', 'tr_bound_function_applyp', 3175 'tr_exponent', 'tr_file_tty_messagesp', 3176 'tr_float_can_branch_complex', 'tr_function_call_default', 3177 'tr_numer', 'tr_optimize_max_loop', 'tr_semicompile', 3178 'tr_state_vars', 'tr_warnings_get', 'tr_warn_bad_function_calls', 3179 'tr_warn_fexpr', 'tr_warn_meval', 'tr_warn_mode', 3180 'tr_warn_undeclared', y 'tr_warn_undefined_variable'. 3181 3182 -- Variable opcional: transrun 3183 Valor por defecto: 'true' 3184 3185 Si 'transrun' vale 'false' entonces se ejecutarán las versiones 3186 interpretadas de todas las funciones, en lugar de las versiones 3187 traducidas. 3188 3189 -- Variable opcional: tr_array_as_ref 3190 Valor por defecto: 'true' 3191 3192 Si 'translate_fast_arrays' vale 'false', referencias de arreglos en 3193 el código Lisp creadas por 'translate_file' se ven afectadas por 3194 'tr_array_as_ref'. 3195 3196 El valor de la variable 'tr_array_as_ref' no tiene ningún efecto 3197 cuando 'translate_fast_arrays' vale 'true'. 3198 3199 -- Variable opcional: tr_bound_function_applyp 3200 Valor por defecto: 'true' 3201 3202 Si 'tr_bound_function_applyp' vale 'true', Maxima envía un aviso si 3203 encuentra una variable con valor asignado que está siendo utilizada 3204 como una función. 'tr_bound_function_applyp' no influye en el 3205 código generado bajo estas circunstancias. 3206 3207 Por ejemplo, una expresión como 'g (f, x) := f (x+1)' provocará un 3208 mensaje de esta naturaleza. 3209 3210 -- Variable opcional: tr_file_tty_messagesp 3211 Valor por defecto: 'false' 3212 3213 Si 'tr_file_tty_messagesp' vale 'true', los mensajes generados por 3214 'translate_file' durante la traducción de un fichero se muestran en 3215 la consola y se insertan en el fichero UNLISP. Si vale 'false', los 3216 mensajes sobre la traducción del fichero sólo se incorporan al 3217 fichero UNLISP. 3218 3219 -- Variable opcional: tr_float_can_branch_complex 3220 Valor por defecto: 'true' 3221 3222 Le dice al traductor de Maxima a Lisp que las funciones 'acos', 3223 'asin', 'asec' y 'acsc' pueden devolver valores complejos. 3224 3225 -- Variable opcional: tr_function_call_default 3226 Valor por defecto: 'general' 3227 3228 El valor 'false' significa llama a 'meval', 'expr' significa que 3229 Lisp asignó los argumentos de la función, 'general', el valor por 3230 defecto, devuelve código apropiado para 'mexprs' y 'mlexprs' pero 3231 no para 'macros'. La opción 'general' asegura que las asignaciones 3232 de las variables son correctas en el código compilado. En modo 3233 'general', cuando se traduce F(X), si F es una variable con valor, 3234 entonces se entiende que se quiere calcular 'apply (f, [x])', y 3235 como tal se traduce, con el apropiado aviso. No es necesario 3236 desactivar esto. Con los valores por defecto la falta de mensajes 3237 de aviso implica compatibilidad completa entre el código traducido 3238 y compilado con el interpretado por Maxima. 3239 3240 -- Variable opcional: tr_numer 3241 Valor por defecto: 'false' 3242 3243 Si 'tr_numer' vale 'true' se utilizan las propiedades numéricas en 3244 aquellos átomos que las posean, como en '%pi'. 3245 3246 -- Variable opcional: tr_optimize_max_loop 3247 Valor por defecto: 100 3248 3249 El valor de 'tr_optimize_max_loop' es el número máximo de veces que 3250 el traductor repetirá la macro-expansión y la optimización en el 3251 tratamiento de una expresión. 3252 3253 -- Variable opcional: tr_semicompile 3254 Valor por defecto: 'false' 3255 3256 Si 'tr_semicompile' vale 'true', las salidas de 'translate_file' y 3257 'compfile' serán macro-expandidas pero no compiladas a código 3258 máquina por el compilador de Lisp. 3259 3260 -- Variable del sistema: tr_state_vars 3261 Valor por defecto: 3262 3263 [transcompile, tr_semicompile, tr_warn_undeclared, tr_warn_meval, 3264 tr_warn_fexpr, tr_warn_mode, tr_warn_undefined_variable, 3265 tr_function_call_default, tr_array_as_ref,tr_numer] 3266 3267 Es la lista de variables que afectan la forma en que se obtiene la 3268 salida del código traducido. Esta información es útil para 3269 desarrolladores que pretendan corregir posibles fallos del 3270 traductor. Comparando el código traducido con el que se debería 3271 obtener bajo unas ciertas condiciones, es posible hacer el 3272 seguimiento de los fallos. 3273 3274 -- Función: tr_warnings_get () 3275 3276 Devuelve una lista con los avisos dados por el traductor. 3277 3278 -- Variable opcional: tr_warn_bad_function_calls 3279 Valor por defecto: 'true' 3280 3281 Devuelve un aviso cuando se hacen llamadas a funciones que quizás 3282 no sean correctas debido a declaraciones inapropiadas realizadas 3283 durante la traducción. 3284 3285 -- Variable opcional: tr_warn_fexpr 3286 Valor por defecto: 'compfile' 3287 3288 Devuelve un aviso si se encuentra con alguna FEXPR. Las FEXPR no 3289 deberían aparecer en el código traducido. 3290 3291 -- Variable opcional: tr_warn_meval 3292 Valor por defecto: 'compfile' 3293 3294 Devuelve un aviso si la función 'meval' es llamada. Si 'meval' es 3295 invocada, es señal de la presencia de problemas en la traducción. 3296 3297 -- Variable opcional: tr_warn_mode 3298 Valor por defecto: 'all' 3299 3300 Devuelve un aviso cuando a las variables se les asignan valores 3301 incompatibles con su modo. 3302 3303 -- Variable opcional: tr_warn_undeclared 3304 Valor por defecto: 'compile' 3305 3306 Determina cuando enviar mensajes sobre variables no declaradas. 3307 3308 -- Variable opcional: tr_warn_undefined_variable 3309 Valor por defecto: 'all' 3310 3311 Devuelve un aviso cuando se detectan variables globales no 3312 definidas. 3313 3314 -- Función: compile_file (<nombre_fich>) 3315 -- Función: compile_file (<nombre_fich>, <nombre_fich_compilado>) 3316 -- Función: compile_file (<nombre_fich>, <nombre_fich_compilado>, 3317 <nombre_fich_lisp>) 3318 3319 Traduce el fichero Maxima <nombre_fich> a Lisp, ejecuta el 3320 compilador de Lisp y, en caso de ser exitosa la compilación, carga 3321 el código compilado en Maxima. 3322 3323 La función 'compile_file' devuelve una lista con los nombres de 3324 tres ficheros: el fichero original en Maxima, la traducción Lisp, 3325 notas sobre la traducción y el código compilado. Si la compilación 3326 falla, el cuarto elemento es 'false'. 3327 3328 Algunas declaraciones y definiciones entran en efecto tan pronto 3329 como el código Lisp es compilado (sin cargar el código compilado). 3330 Éstas incluyen funciones definidas con el operador ':=', macros 3331 definidas con el operador '::=', 'alias', 'declare', 3332 'define_variable', 'mode_declare' y 'infix', 'matchfix', 'nofix', 3333 'postfix', 'prefix' y 'compfile'. 3334 3335 Asignaciones y llamadas a funciones no se evalúan hasta que el 3336 código compilado es cargado. En particular, dentro del fichero 3337 Maxima, asignaciones a los controles ("flags") de traducción 3338 ('tr_numer', etc.) no tienen efecto durante la traducción. 3339 3340 El <nombre_fich> no puede contener sentencias del tipo ':lisp'. 3341 3342 La función 'compile_file' evalúa sus argumentos. 3343 3344 -- Función: declare_translated (<f_1>, <f_2>, ...) 3345 3346 Cuando se traduce un fichero de código Maxima a Lisp, es importante 3347 para el traductor saber qué funciones de las que están en el 3348 fichero van a ser llamadas como traducidas o compiladas, y cuáles 3349 son simplemente funciones Maxima o que no están definidas. Se 3350 genera el código '(MFUNCTION-CALL fn arg1 arg2 ...)' cuando el 3351 traductor no sabe si 'fn' va a ser una función lisp. 3352 3353 3354File: maxima.info, Node: Programación, Next: Depurado, Prev: Definición de Funciones, Up: Top 3355 335637 Programación 3357*************** 3358 3359* Menu: 3360 3361* Lisp y Maxima:: 3362* Recolector de basura:: 3363* Introducción a la programación:: 3364* Funciones y variables para la programación:: 3365 3366 3367File: maxima.info, Node: Lisp y Maxima, Next: Recolector de basura, Prev: Programación, Up: Programación 3368 336937.1 Lisp y Maxima 3370================== 3371 3372Maxima fue escrito en Lisp, y es muy fácil tener acceso a funciones y 3373variables Lisp desde Maxima y viceversa. Los símbolos Lisp y los 3374símblos Maxima están claramente diferenciados por medio de una 3375convención de nombres. Un símblo Lisp el cual comienza con un signo 3376pesos '$' corresponde a un símbolo Maxima sin el signo pesos. Un 3377símbolo Maxima el cual comienza con un signo de cierre de interrogación 3378'?' corresponde a un símbolo Lisp sin dicho signo. Por ejemplo, el 3379símbolo Maxima 'foo' corresponde a el símbolo Lisp '$FOO', mientras que 3380el símbolo Maxima '?foo' corresponde a el símbolo Lisp 'FOO', tenga en 3381cuenta que '?foo' esta escrito sin espacio entre '?' y 'foo'; de otra 3382manera se estaría invocando a 'describe ("foo")'. 3383 3384El guión '-', asterisco '*', u otros carácteres especiales en símbolos 3385Lisp deben ser escritos mediante un backslash '\' si aparecen en código 3386Maxima. Por ejemplo, el identificador Lisp '*foo-bar*' se debe escribir 3387'?\*foo\-bar\*' en Maxima. 3388 3389Se puede ejecutar código Lisp desde una sesión de Maxima. Una línea 3390Lisp (que contenga una o más formas) puede ser ejecutada por medio de un 3391comando especial ':lisp'. Por ejemplo, 3392 3393 (%i1) :lisp (foo $x $y) 3394 3395se llama a la función Lisp 'foo' con variables Maxima 'x' y 'y' como 3396argumentos. La instrucción ':lisp' puede aparecer en el prompt 3397interactivo o en un archivo que sea procesado por 'batch' o 'demo', pero 3398no en un archivo que sea procesado por 'load', 'batchload', 3399'translate_file' o 'compile_file'. 3400 3401La función 'to_lisp()' abre una sesión interactiva con el interprete 3402Lisp. Escribiendo '(to-maxima)' se cierra la sesión con Lisp y se 3403retorna a Maxima. 3404 3405Las funciones y variables Lisp las cuales esten para ser visibles en 3406Maxima como funciones y variables con nombres oridinarios (sin una 3407puntuación especial), deben tener nombres tipo Lisp que comiencen con el 3408signo pesos '$'. 3409 3410Maxima distingue entre letras minúsculas y mayúsculas en 3411identificadores. Existen algunas reglas que gobiernan la traducción de 3412nombres entre Lisp y Maxima. 3413 3414 1. Un identificador Lisp que no se encuentra encerrado en barras 3415 verticales corresponde a un identificador Maxima en minúscula. Que 3416 el idenficador Lisp esté en mayúscula, minúscula o una combinación 3417 de ambas, no afecta en nada. Por ejemplo, los identificadores Lisp 3418 '$foo', '$FOO', y '$Foo', todos corresponden al identificador 3419 Maxima 'foo'. Esto es así porque '$foo', '$FOO' y '$Foo' se 3420 convierten por defecto al símbolo '$FOO' de Lisp. 3421 3422 2. Un identificador Lisp el cual se encuentre todo en mayúscula o todo 3423 en minúscula y encerrado entre barras verticales corresponde a un 3424 identicador Maxima con el caso contrario. Esto es, de mayúsculas 3425 cambia a minúsculas y de minúsculas cambia a mayúsculas. E.g., el 3426 identificador Lisp '|$FOO|' y '|$foo|' corresponden los 3427 identificadores Maxima 'foo' y 'FOO', respectivamente. 3428 3. Un identificador Lisp el cual esta escrito mezclando letras 3429 mayúsculas y minúsculas y se encuentra entre barras verticales 3430 corresponde a un identificador Maxima con la misma escritura. 3431 E.g., el identificador Lisp '|$Foo|' corresponde a el identificador 3432 Maxima 'Foo'. 3433 3434La macro Lisp '#$' permite el uso de expresiones Maxima dentro de código 3435Lisp. '#$<expr>$' extiende a una expresión Lisp equivalente a la 3436expresión Maxima <expr>. 3437 3438 (msetq $foo #$[x, y]$) 3439 3440Esto tiene el mismo efecto que: 3441 3442 (%i1) foo: [x, y]; 3443 3444La función Lisp 'displa' imprime una expresión en formato Maxima. 3445 3446 (%i1) :lisp #$[x, y, z]$ 3447 ((MLIST SIMP) $X $Y $Z) 3448 (%i1) :lisp (displa '((MLIST SIMP) $X $Y $Z)) 3449 [x, y, z] 3450 NIL 3451 3452Las funciones definidas en Maxima no son funciones Lisp ordinarias. La 3453función Lisp 'mfuncall' llama a una función Maxima. Por ejemplo: 3454 3455 (%i1) foo(x,y) := x*y$ 3456 (%i2) :lisp (mfuncall '$foo 'a 'b) 3457 ((MTIMES SIMP) A B) 3458 3459Algunas funciones Lisp son compartidas en el paquete Maxima, las cuales 3460se listan a continuación: 3461 3462'complement', 'continue', '//', 'float', 'functionp', 'array', 'exp', 3463'listen', 'signum', 'atan', 'asin', 'acos', 'asinh', 'acosh', 'atanh', 3464'tanh', 'cosh', 'sinh', 'tan', 'break', y 'gcd'. 3465 3466 3467File: maxima.info, Node: Recolector de basura, Next: Introducción a la programación, Prev: Lisp y Maxima, Up: Programación 3468 346937.2 Recolector de basura 3470========================= 3471 3472La computación simbólica tiende a crear una buena cantidad de basura 3473(resultados temporales que ya no serán utilizados), y un manejo efectivo 3474de esto puede ser crucial para el término exitoso de algunos programas. 3475 3476Bajo GCL (GNU Common Lisp), en aquellos sistemas UNIX donde la llamada 3477al sistema mprotect está disponible (incluyendo SUN OS 4.0 y algunas 3478variantes de BSD) se dispone de un recolector de basura estratificado. 3479Véase la documentación de GCL para ALLOCATE y GBC. A nivel Lisp, 3480ejecutando (setq si::*notify-gbc* t) pemitirá determinar qué áreas 3481necesitan más espacio. 3482 3483En cuanto al resto de Lisps bajo los que funciona Maxima, se remite al 3484lector a la documentación correspondiente para controlar la recolección 3485de basura. 3486 3487 3488File: maxima.info, Node: Introducción a la programación, Next: Funciones y variables para la programación, Prev: Recolector de basura, Up: Programación 3489 349037.3 Introducción a la programación 3491=================================== 3492 3493Maxima dispone de los bucles 'do' para hacer iteraciones, así como 3494estructuras más primitivas del estilo de 'go'. 3495 3496 3497File: maxima.info, Node: Funciones y variables para la programación, Prev: Introducción a la programación, Up: Programación 3498 349937.4 Funciones y variables para la programación 3500=============================================== 3501 3502 -- Función: backtrace () 3503 -- Función: backtrace (<n>) 3504 Devuelve la pila de llamadas, esto es, la lista de funciones que 3505 han llamado a la función actualmente activa. 3506 3507 La llamada a 'backtrace()' devuelve la pila completa de llamadas. 3508 3509 Ejemplos: 3510 3511 (%i1) h(x) := g(x/7)$ 3512 (%i2) g(x) := f(x-11)$ 3513 (%i3) f(x) := e(x^2)$ 3514 (%i4) e(x) := (backtrace(), 2*x + 13)$ 3515 (%i5) h(10); 3516 #0: e(x=4489/49) 3517 #1: f(x=-67/7) 3518 #2: g(x=10/7) 3519 #3: h(x=10) 3520 9615 3521 (%o5) ---- 3522 49 3523 3524 La llamada 'backtrace (<n>)' devuelve las <n> funciones más 3525 recientes, incluyendo a la función actualmente activa. 3526 3527 Ejemplos: 3528 3529 (%i1) h(x) := (backtrace(1), g(x/7))$ 3530 (%i2) g(x) := (backtrace(1), f(x-11))$ 3531 (%i3) f(x) := (backtrace(1), e(x^2))$ 3532 (%i4) e(x) := (backtrace(1), 2*x + 13)$ 3533 (%i5) h(10); 3534 #0: h(x=10) 3535 #0: g(x=10/7) 3536 #0: f(x=-67/7) 3537 #0: e(x=4489/49) 3538 9615 3539 (%o5) ---- 3540 49 3541 3542 -- Operador especial: do 3543 La sentencia 'do' se utiliza para realizar iteraciones. Debido a 3544 su generalidad la sentencia 'do' se describirá en dos partes. En 3545 primer lugar se mostrará su forma más usual, análoga a la de otros 3546 lenguajes de programación (Fortran, Algol, PL/I, etc.); después se 3547 mencionarán otras formas de uso. 3548 3549 Hay tres variantes de esta sentencia que se diferencian entre sí 3550 únicamente por las condiciones de fin de bucle. Son las 3551 siguientes: 3552 3553 * 'for <variable>: <valor_inicial> step <incremento> thru 3554 <límite> do <cuerpo>' 3555 * 'for <variable>: <valor_inicial> step <incremento> while 3556 <condición> do <cuerpo>' 3557 * 'for <variable>: <valor_inicial> step <incremento> unless 3558 <condición> do <cuerpo>' 3559 3560 El <valor_inicial>, el <incremento>, el <límite> y el <cuerpo> 3561 pueden ser cualquier tipo de expresión válida de Maxima. Si el 3562 incremento es igual a la unidad (1) entonces "'step 1'" puede 3563 omitirse. 3564 3565 La ejecución de la sentencia 'do' se realiza asignando el 3566 valor_inicial a la variable (llamada de aquí en adelante 3567 variable-control). A continuación: (1) si la variable-control ha 3568 excedido el límite de la especificación dada por un 'thru', o si la 3569 condición impuesta por 'unless' es verdadera ('true'), o si la 3570 condición dada por 'while' es falsa ('false') entonces la iteración 3571 'do' termina. (2) El cuerpo se evalúa. (3) El incremento es 3572 sumado a la variable-control. El proceso de (1) a (3) se repite 3573 hasta que la condición de fin de iteración se satisfaga. También 3574 es posible especificar varias condiciones de terminación del bucle, 3575 en cuyo caso 'do' terminará cuando se satisfaga alguna de ellas. 3576 3577 En general la condición 'thru' se satisfará cuando la 3578 variable-control sea mayor que el límite si el incremento es no 3579 negativo, o cuando la variable-control sea menor que el límite 3580 cuando el incremento es negativo. El incremento y el límite pueden 3581 ser expresiones no numéricas, tanto en cuanto esta desigualdad 3582 pueda quedar determinada. Sin embargo, a menos que el incremento 3583 sea un número negativo en el momento de comenzar el cómputo de 3584 'do', Maxima supondrá que se evaluará a una cantidad positiva. En 3585 caso de no ser efectivamente positivo, la sentencia 'do' puede dar 3586 un resultado inesperado. 3587 3588 Nótese que el límite, el incremento y la condición de terminación 3589 se evalúan en cada iteración del bucle. Así, si alguna de 3590 expresiones necesitan de muchos cálculos y devuelven un resultado 3591 que no va a cambiar durante toda la ejecución del cuerpo, será más 3592 eficiente dar este valor a una variable antes de comenzar la 3593 sentencia 'do' y utilizarla luego durante su ejecución. 3594 3595 El valor que habitualmente devuelva la sentencia 'do' será el átomo 3596 'done'. Sin embargo, la función 'return' puede usarse dentro del 3597 cuerpo para salir de 'do' de forma prematura retornando un valor 3598 determinado. Nótese no obstante que un 'return' dentro de un 'do' 3599 que está dentro de un bloque ('block') provocará una salida de 'do' 3600 pero no de 'block'. Repárese también en que la función 'go' no 3601 puede usarse para salir de 'do' e ir a algún lugar de 'block'. 3602 3603 La variable-control es siempre local respecto de 'do', por lo que 3604 se puede utilizar cualquier nombre de variable sin afectar el valor 3605 de cualquier otra variable externa a 'do' y que tenga el mismo 3606 nombre. La variable-control no tendrá asignado ningún valor una 3607 vez se haya concluido el 'do'. 3608 3609 (%i1) for a:-3 thru 26 step 7 do display(a)$ 3610 a = - 3 3611 3612 a = 4 3613 3614 a = 11 3615 3616 a = 18 3617 3618 a = 25 3619 3620 (%i1) s: 0$ 3621 (%i2) for i: 1 while i <= 10 do s: s+i; 3622 (%o2) done 3623 (%i3) s; 3624 (%o3) 55 3625 3626 Nótese que la condición 'while i <= 10' es equivalente a 'unless i 3627 > 10' y a 'thru 10'. 3628 3629 (%i1) series: 1$ 3630 (%i2) term: exp (sin (x))$ 3631 (%i3) for p: 1 unless p > 7 do 3632 (term: diff (term, x)/p, 3633 series: series + subst (x=0, term)*x^p)$ 3634 (%i4) series; 3635 7 6 5 4 2 3636 x x x x x 3637 (%o4) -- - --- - -- - -- + -- + x + 1 3638 90 240 15 8 2 3639 3640 lo que da ocho términos del desarrollo de Taylor de la función 3641 'e^sin(x)'. 3642 3643 (%i1) poly: 0$ 3644 (%i2) for i: 1 thru 5 do 3645 for j: i step -1 thru 1 do 3646 poly: poly + i*x^j$ 3647 (%i3) poly; 3648 5 4 3 2 3649 (%o3) 5 x + 9 x + 12 x + 14 x + 15 x 3650 (%i4) guess: -3.0$ 3651 (%i5) for i: 1 thru 10 do 3652 (guess: subst (guess, x, 0.5*(x + 10/x)), 3653 if abs (guess^2 - 10) < 0.00005 then return (guess)); 3654 (%o5) - 3.162280701754386 3655 3656 Este ejemplo calcula la raíz cuadrada negativa de 10 haciendo 10 3657 iteraciones del método de Newton-Raphson. De no haberse alcanzado 3658 el criterio de convergencia el valor devuelto hubiese sido 'done'. 3659 3660 En lugar de añadir siempre una cantidad a la variable-control a 3661 veces se puede querer que cambie en cada iteración siguiendo algún 3662 otro criterio. En tal caso se puede hacer uso de 'next 3663 <expresión>' en lugar de 'step <incremento>'. Esto hará que a la 3664 variable-control se le asigne el resultado de evaluar la expresión 3665 en cada iteración del bucle. 3666 3667 (%i6) for count: 2 next 3*count thru 20 do display (count)$ 3668 count = 2 3669 3670 count = 6 3671 3672 count = 18 3673 3674 En ocasiones puede interesar realizar una iteración en la que la 3675 variable-control no se utilice nunca. Se podrá entonces dar 3676 únicamente las condiciones de terminación del bucle omitiendo la 3677 inicialización y actualizando la información, tal como se hace en 3678 el siguiente ejemplo para calcular la raíz cuadrada de 5 utilizando 3679 un valor inicial alejado de la solución. 3680 3681 (%i1) x: 1000$ 3682 (%i2) thru 20 do x: 0.5*(x + 5.0/x)$ 3683 (%i3) x; 3684 (%o3) 2.23606797749979 3685 (%i4) sqrt(5), numer; 3686 (%o4) 2.23606797749979 3687 3688 Si así se quiere, incluso es posible omitir las condiciones de 3689 terminación completamente y escribir únicamente 'do <body>', lo que 3690 provocará entrar en un bucle infinito. En tal caso, debería usarse 3691 la función 'return' a fin de terminar con la ejecución de 'do'. 3692 3693 (%i1) newton (f, x):= ([y, df, dfx], df: diff (f ('x), 'x), 3694 do (y: ev(df), x: x - f(x)/y, 3695 if abs (f (x)) < 5e-6 then return (x)))$ 3696 (%i2) sqr (x) := x^2 - 5.0$ 3697 (%i3) newton (sqr, 1000); 3698 (%o3) 2.236068027062195 3699 3700 (En este ejemplo, cuando se ejecuta 'return' obliga a que sea 'x' 3701 el valor devuelto por 'do'. Al salirse del bloque, 'x' es también 3702 el valor que devuelve 'block' por ser 'do' la última sentencia del 3703 bloque.) 3704 3705 Hay todavía otra forma de 'do' en Maxima. Su sintaxis es: 3706 3707 for <variable> in <lista> <test_de_parada> do <cuerpo> 3708 3709 Los elementos de <list> son cualesquiera expresiones que se irán 3710 asignando sucesivamente a la variable en cada repetición del 3711 cuerpo. El test de parada <end_tests> (que es opcional) puede 3712 usarse para terminar la ejecución de 'do'; de otro modo las 3713 iteraciones se pararán cuando la lista se haya agotado o cuando se 3714 ejecute un 'return' dentro del cuerpo. (De hecho, la lista puede 3715 ser cualquier expresión no atómica, de la cual se irán extrayendo 3716 de forma sucesiva sus diferentes partes.) 3717 3718 (%i1) for f in [log, rho, atan] do ldisp(f(1))$ 3719 (%t1) 0 3720 (%t2) rho(1) 3721 %pi 3722 (%t3) --- 3723 4 3724 (%i4) ev(%t3,numer); 3725 (%o4) 0.78539816 3726 3727 -- Función: errcatch (<expr_1>, ..., <expr_n>) 3728 Evalúa las expresiones <expr_1>, ..., <expr_n> una a una y devuelve 3729 '[<expr_n>]' (una lista) en caso de que no ocurra ningún error. En 3730 caso de aparecer algún error durante el cálculo de alguno de los 3731 argumentos, 'errcatch' evita que el error se propague y devuelve la 3732 lista vacía '[]' sin evaluar más argumentos. 3733 3734 La función 'errcatch' es útil en ficheros 'batch' donde se sospeche 3735 que pueda aparecer algún error, el cual provocaría la terminación 3736 de la ejecución del 'batch' de no ser previamente detectado. 3737 3738 -- Función: error (<expr_1>, ..., <expr_n>) 3739 -- Variable del sistema: error 3740 Calcula y devuelve <expr_1>, ..., <expr_n>, enviando posteriormente 3741 una seãl de error a Maxima o al 'errcatch' más cercano. 3742 3743 A la variable 'error' se le asigna una lista con la descripción del 3744 error. El primer elemento de 'error' es una cadena de formato, la 3745 cual une todas las cadenas de los argumentos <expr_1>, ..., 3746 <expr_n>, siendo los demás elementos de la lista los valores de los 3747 argumentos que no son cadenas. 3748 3749 La llamada a 'errormsg()' formatea e imprime 'error'. Se reimprime 3750 así el mensaje de error más reciente. 3751 3752 -- Variable opcional: error_size 3753 Valor por defecto: 10 3754 3755 La variable 'error_size' modifica los mensajes de error de acuerdo 3756 con el tamaño de las expresiones que aparecen en él. Si el tamaño 3757 de una expresión (tal como lo determina la función Lisp 3758 'ERROR-SIZE') es mayor que 'error_size', la expresión se reemplaza 3759 en el mensaje por un símbolo, asignándole a éste una expresión. 3760 Los símbolos se toman de la lista 'error_syms'. 3761 3762 En caso contrario, si la expresión es menor que 'error_size', la 3763 expresión se muestra en el propio mensaje. 3764 3765 Véanse también 'error' y 'error_syms'. 3766 3767 Ejemplo: 3768 3769 El tamaño de 'U', tal como lo determina 'ERROR-SIZE', es 24. 3770 3771 (%i1) U: (C^D^E + B + A)/(cos(X-1) + 1)$ 3772 3773 (%i2) error_size: 20$ 3774 3775 (%i3) error ("Example expression is", U); 3776 3777 Example expression is errexp1 3778 -- an error. Quitting. To debug this try debugmode(true); 3779 (%i4) errexp1; 3780 E 3781 D 3782 C + B + A 3783 (%o4) -------------- 3784 cos(X - 1) + 1 3785 (%i5) error_size: 30$ 3786 3787 (%i6) error ("Example expression is", U); 3788 3789 E 3790 D 3791 C + B + A 3792 Example expression is -------------- 3793 cos(X - 1) + 1 3794 -- an error. Quitting. To debug this try debugmode(true); 3795 3796 -- Variable opcional: error_syms 3797 Valor por defecto: '[errexp1, errexp2, errexp3]' 3798 3799 En los mensajes de error, las expresiones mayores que 'error_size' 3800 son reemplazadas por símbolos a los cuales se les asignas estas 3801 expresiones. Los símbolos se toman de la lista 'error_syms'. La 3802 primera expresión que resulte ser demasiado larga se reemplaza por 3803 'error_syms[1]', la segunda por 'error_syms[2]' y así 3804 sucesivamente. 3805 3806 Si hay más expresiones largas que elementos en 'error_syms', los 3807 símbolos se construyen automáticamente, siendo el <n>-ésimo símbolo 3808 equivalente a 'concat ('errexp, <n>)'. 3809 3810 Véanse también 'error' y 'error_size'. 3811 3812 -- Función: errormsg () 3813 3814 Reimprime el mensaje de error más reciente. La variable 'error' 3815 guarda el mensaje y 'errormsg' lo formatea e imprime. 3816 3817 -- Variable opcional: errormsg 3818 Valor por defecto: 'true' 3819 3820 Cuando 'errormsg' vale 'false' se suprimen los contenidos de los 3821 mensajes de error. 3822 3823 La variable 'errormsg' no se puede asignar a un valor local dentro 3824 de un bloque. El valor global de 'errormsg' está siempre presente. 3825 3826 Ejemplos: 3827 3828 (%i1) errormsg; 3829 (%o1) true 3830 (%i2) sin(a,b); 3831 Wrong number of arguments to sin 3832 -- an error. To debug this try: debugmode(true); 3833 (%i3) errormsg:false; 3834 (%o3) false 3835 (%i4) sin(a,b); 3836 3837 -- an error. To debug this try: debugmode(true); 3838 3839 La variable 'errormsg' no se puede asignar a un valor local dentro 3840 de un bloque. 3841 3842 (%i1) f(bool):=block([errormsg:bool], 3843 print ("value of errormsg is",errormsg))$ 3844 (%i2) errormsg:true; 3845 (%o2) true 3846 (%i3) f(false); 3847 value of errormsg is true 3848 (%o3) true 3849 (%i4) errormsg:false; 3850 (%o4) false 3851 (%i5) f(true); 3852 value of errormsg is false 3853 (%o5) false 3854 3855 -- Operador especial: for 3856 Utilizado en las iteraciones. Véase 'do' para una descripción de 3857 las técnicas de iteración en Maxima. 3858 3859 -- Función: go (<etiqueta>) 3860 Se utiliza dentro de un bloque ('block') para transferir el control 3861 a la sentencia del bloque que esté etiquetada con el argumento de 3862 'go'. Una sentencia queda etiquetada cuando está precedida por un 3863 argumento de tipo átomo como cualquier otra sentencia de 'block'. 3864 Por ejemplo: 3865 3866 block ([x], x:1, tururu, x+1, ..., go(tururu), ...) 3867 3868 El argumento de 'go' debe ser el nombre de una etiqueta que 3869 aparezca en el mismo bloque ('block'). No se puede utilizar 'go' 3870 para transferir el control a un bloque que no sea aquel que 3871 contenga la sentencia 'go'. 3872 3873 -- Operador especial: if 3874 Evaluación condicionada. Se reconocen varias formas de expresiones 3875 'if'. 3876 3877 La expresión 'if <cond_1> then <expr_1> else <expr_0>' devuelve 3878 <expr_1> si <cond_1> vale 'true', en caso contrario la respuesta es 3879 'expr_0'. 3880 3881 La expresión 'if <cond_1> then <expr_1> elseif <cond_2> then 3882 <expr_2> elseif ... else <expr_0>' devuelve <expr_k> si <cond_k> 3883 vale 'true' y todas las condiciones anteriores toman el valor 3884 'false'. Si ninguna de las condiciones vale 'true', la respuesta 3885 es 'expr_0'. 3886 3887 La falta de un 'else' final se interpreta como un 'else false'; 3888 esto es, la expresión 'if <cond_1> then <expr_1>' equivale a 'if 3889 <cond_1> then <expr_1> else false', y 'if <cond_1> then <expr_1> 3890 elseif ... elseif <cond_n> then <expr_n>' equivale a su vez a 'if 3891 <cond_1> then <expr_1> elseif ... elseif <cond_n> then <expr_n> 3892 else false'. 3893 3894 Las alternativas <expr_0>, ..., <expr_n> pueden ser expresiones 3895 válidas de Maxima, incluidas expresiones 'if' anidadas. Las 3896 alternativas ni se simplifican ni se evalúan, a menos que su 3897 condición asociada valga 'true'. 3898 3899 Las condiciones <cond_1>, ..., <cond_n> deben ser expresiones 3900 capaces de dar como resultado 'true' o 'false' al ser evaluadas. 3901 Si en un momento dado una condición no da como resultado un valor 3902 de verdad ('true' o 'false'), el comportamiento de 'if' se controla 3903 con la variable global 'prederror'. Si 'prederror' vale 'true', se 3904 considera un error que la condición evaluada no dé como resultado 3905 un valor de verdad; en caso contrario, las condiciones que no den 3906 como resultado un valor de verdad se aceptan, dándose el resultado 3907 como una expresión condicional. 3908 3909 Las condiciones pueden contener operadores lógicos y relacionales, 3910 así como otros elementos, tal como se indica a continuación: 3911 3912 Operación Símbolo Tipo 3913 3914 menor que < operador relacional infijo 3915 menor o igual que <= operador relacional infijo 3916 igualdad (sintáctica) = operador relacional infijo 3917 negación de = # operador relacional infijo 3918 igualdad (por valor) equal operador relacional infijo 3919 negación de equal notequal operador relacional infijo 3920 mayor o igual que >= operador relacional infijo 3921 mayor que > operador relacional infijo 3922 y and operador lógico infijo 3923 o or operador lógico infijo 3924 no not operador lógico prefijo 3925 3926 -- Función: map (<f>, <expr_1>, ..., <expr_n>) 3927 Devuelve una expresión cuyo operador principal es el mismo que 3928 aparece en las expresiones <expr_1>, ..., <expr_n> pero cuyas 3929 subpartes son los resultados de aplicar <f> a cada una de las 3930 subpartes de las expresiones; <f> puede ser tanto el nombre de una 3931 función de n argumentos como una expresión 'lambda' de n 3932 argumentos. 3933 3934 Uno de los usos que tiene 'map' es la de aplicar (o mapear) una 3935 función (por ejemplo, 'partfrac') sobre cada término de una 3936 expresión extensa en la que normalmente no se podría utilizar la 3937 función debido a insuficiencias en el espacio de almacenamiento 3938 durante el curso de un cálculo. 3939 3940 (%i1) map(f,x+a*y+b*z); 3941 (%o1) f(b z) + f(a y) + f(x) 3942 (%i2) map(lambda([u],partfrac(u,x)),x+1/(x^3+4*x^2+5*x+2)); 3943 1 1 1 3944 (%o2) ----- - ----- + -------- + x 3945 x + 2 x + 1 2 3946 (x + 1) 3947 (%i3) map(ratsimp, x/(x^2+x)+(y^2+y)/y); 3948 1 3949 (%o3) y + ----- + 1 3950 x + 1 3951 (%i4) map("=",[a,b],[-0.5,3]); 3952 (%o4) [a = - 0.5, b = 3] 3953 3954 Véase también 'maperror' . 3955 3956 -- Función: mapatom (<expr>) 3957 Devuelve 'true' si y sólo <expr> es tratado por las rutinas de 3958 mapeo como un átomo. 3959 3960 -- Variable opcional: maperror 3961 Valor por defecto: 'true' 3962 3963 Cuando 'maperror' toma el valor 'false', hace que todas las 3964 funciones de mapeo, como por ejemplo 3965 3966 map (f, <expr_1>, <expr_2>, ...) 3967 3968 (1) paren cuando hayan terminado de procesar la <expr_i> más corta, 3969 a menos que todas ellas sean del mismo tamaño y (2) apliquen 'f' a 3970 '[expr_1, expr_2, ...]' si es el caso que las 'expr_i' no son todas 3971 del mismo tipo de objeto. 3972 3973 Cuando 'maperror' toma el valor 'true' entonces se emite un mensaje 3974 de error cuando se presenta cualquiera de los dos casos anteriores. 3975 3976 -- Variable opcional: mapprint 3977 Valor por defecto: 'true' 3978 3979 Si 'mapprint' vale 'true', se producirán ciertos mensajes por parte 3980 de las funciones 'map', 'mapl' y 'fullmap' en determinadas 3981 situaciones, como cuando 'map' hace uso de 'apply'. 3982 3983 Si 'mapprint' vale 'false', no se emitirán tales mensajes. 3984 3985 -- Función: maplist (<f>, <expr_1>, ..., <expr_n>) 3986 Devuelve una lista con las aplicaciones de <f> a las partes de las 3987 expresiones <expr_1>, ..., <expr_n>; <f> es el nombre de una 3988 función ou una expresión lambda. 3989 3990 La función 'maplist' difiere de 'map (<f>, <expr_1>, ..., 3991 <expr_n>)', la cual devuelve una expresión con el mismo operador 3992 principal que tenga <expr_i>, excepto en simplificaciones y en el 3993 caso en el que 'map' hace un 'apply'. 3994 3995 -- Variable opcional: prederror 3996 Valor por defecto: 'false' 3997 3998 Cuando 'prederror' toma el valor 'true', se emite un mensaje de 3999 error siempre que el predicado de una sentencia 'if' o de una 4000 función 'is' no se pueda evaluar ni a verdadero ('true') ni a falso 4001 ('false'). 4002 4003 Si toma el valor 'false', se devuelve bajo las mismas 4004 circunstancias anteriores el valor 'unknown'. El modo 'prederror: 4005 false' no está soportado en el código traducido; sin embargo, 4006 'maybe' está soportado en código traducido. 4007 4008 Véanse también 'is' y 'maybe'. 4009 4010 -- Función: return (valor) 4011 Puede utilizarse para salir de un bloque, devolviendo su argumento. 4012 Véase 'block' para más información. 4013 4014 -- Función: scanmap (<f>, <expr>) 4015 -- Función: scanmap (<f>, <expr>, bottomup) 4016 Aplica recursivamente <f> sobre <expr>, de arriba hacia abajo. 4017 Esto es más útil cuando se busca una factorización completa, por 4018 ejemplo: 4019 4020 (%i1) exp:(a^2+2*a+1)*y + x^2$ 4021 (%i2) scanmap(factor,exp); 4022 2 2 4023 (%o2) (a + 1) y + x 4024 4025 Nótese que cómo 'scanmap' aplica la función dada 'factor' a las 4026 subexpresiones que forman a <expr>; si se presenta otra forma de 4027 <expr> a 'scanmap' entonces el resultado puede ser diferente. Así, 4028 '%o2' no se restaura cuando 'scanmap' se aplica a la forma 4029 expandida de exp: 4030 4031 (%i3) scanmap(factor,expand(exp)); 4032 2 2 4033 (%o3) a y + 2 a y + y + x 4034 4035 Aquí hay otro ejemplo de la forma en que 'scanmap' aplica 4036 recursivamente una función dada a todas las subexpresiones, 4037 incluyendo exponentes: 4038 4039 (%i4) expr : u*v^(a*x+b) + c$ 4040 (%i5) scanmap('f, expr); 4041 f(f(f(a) f(x)) + f(b)) 4042 (%o5) f(f(f(u) f(f(v) )) + f(c)) 4043 4044 'scanmap (<f>, <expr>, bottomup)' aplica <f> a <expr> de abajo 4045 hacia arriba. Por ejemplo, para 'f' no definida, 4046 4047 scanmap(f,a*x+b) -> 4048 f(a*x+b) -> f(f(a*x)+f(b)) -> f(f(f(a)*f(x))+f(b)) 4049 scanmap(f,a*x+b,bottomup) -> f(a)*f(x)+f(b) 4050 -> f(f(a)*f(x))+f(b) -> 4051 f(f(f(a)*f(x))+f(b)) 4052 4053 En este caso se obtiene la misma respuesta por cualquiera de los 4054 dos métodos. 4055 4056 -- Función: throw (<expr>) 4057 Evalúa <expr> y devuelve el valor del 'catch' más reciente. La 4058 función 'throw' se utiliza junto con 'catch' como un mecanismo de 4059 retorno no local. 4060 4061 -- Operador especial: while 4062 -- Operador especial: unless 4063 4064 Véase 'do'. 4065 4066 -- Función: outermap (<f>, <a_1>, ..., <a_n>) 4067 Aplica la función <f> a cada uno de los elementos del producto 4068 vectorial <a_1> por <a_2> ... por <a_n>. 4069 4070 El argumento <f> debe ser el nombre de una función de n argumentos, 4071 o una expresión lambda de n argumentos. Cada uno de los argumentos 4072 <a_k> puede ser una lista, una lista anidada, una matriz o 4073 cualquier otro tipo de expresión. 4074 4075 El valor devuelto por 'outermap' es una estructura anidada. Si <x> 4076 es la respuesta dada por 'outermap', entonces tiene la misma 4077 estructura que la primera lista, lista anidada o matriz, 4078 '<x>[i_1]...[i_m]' tiene la misma estructura que la segunda lista, 4079 lista anidada o matriz, '<x>[i_1]...[i_m][j_1]...[j_n]' tiene la 4080 misma estructura que la tercera lista, lista anidada o matriz, y 4081 así sucesivamente, siendo <m>, <n>, ... los números índice 4082 necesarios para acceder a los elementos de cada argumento: uno para 4083 las listas, dos para las matrices y uno o más para las listas 4084 anidadas. Aquellos argumentos que no sean listas ni matrices no 4085 tienen efecto alguno sobre la estructura del valor retornado. 4086 4087 Nótese que el efecto producido por 'outermap' es diferente del que 4088 se obtiene al aplicar <f> a cada uno de los elementos del producto 4089 devuelto por 'cartesian_product'. La función 'outermap' mantiene 4090 la estructura de los argumentos en la respuesta, miemtras que 4091 'cartesian_product' no lo hace. 4092 4093 La función 'outermap' evalúa sus argumentos. 4094 4095 Véanse también 'map', 'maplist' y 'apply'. 4096 4097 Ejemplos: 4098 4099 Ejemplos elementales de uso de 'outermap'. Con el fin de mostrar 4100 con mayor claridad las combinaciones del argumento, se mantiene sin 4101 definir 'F'. 4102 4103 (%i1) outermap (F, [a, b, c], [1, 2, 3]); 4104 (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)], 4105 [F(c, 1), F(c, 2), F(c, 3)]] 4106 (%i2) outermap (F, matrix ([a, b], [c, d]), matrix ([1, 2], [3, 4])); 4107 [ [ F(a, 1) F(a, 2) ] [ F(b, 1) F(b, 2) ] ] 4108 [ [ ] [ ] ] 4109 [ [ F(a, 3) F(a, 4) ] [ F(b, 3) F(b, 4) ] ] 4110 (%o2) [ ] 4111 [ [ F(c, 1) F(c, 2) ] [ F(d, 1) F(d, 2) ] ] 4112 [ [ ] [ ] ] 4113 [ [ F(c, 3) F(c, 4) ] [ F(d, 3) F(d, 4) ] ] 4114 (%i3) outermap (F, [a, b], x, matrix ([1, 2], [3, 4])); 4115 [ F(a, x, 1) F(a, x, 2) ] [ F(b, x, 1) F(b, x, 2) ] 4116 (%o3) [[ ], [ ]] 4117 [ F(a, x, 3) F(a, x, 4) ] [ F(b, x, 3) F(b, x, 4) ] 4118 (%i4) outermap (F, [a, b], matrix ([1, 2]), matrix ([x], [y])); 4119 [ [ F(a, 1, x) ] [ F(a, 2, x) ] ] 4120 (%o4) [[ [ ] [ ] ], 4121 [ [ F(a, 1, y) ] [ F(a, 2, y) ] ] 4122 [ [ F(b, 1, x) ] [ F(b, 2, x) ] ] 4123 [ [ ] [ ] ]] 4124 [ [ F(b, 1, y) ] [ F(b, 2, y) ] ] 4125 (%i5) outermap ("+", [a, b, c], [1, 2, 3]); 4126 (%o5) [[a + 1, a + 2, a + 3], [b + 1, b + 2, b + 3], 4127 [c + 1, c + 2, c + 3]] 4128 4129 El siguiente ejemplo permite hacer un análisis más profundo del 4130 valor retornado por 'outermap'. Los tres primeros argumentos son 4131 una matriz, una lista y otra matriz, en este orden. El valor 4132 devuelto es una matriz, cuyos elementos son listas y cada elemento 4133 de cada una de estas listas es a su vez una matriz. 4134 4135 (%i1) arg_1 : matrix ([a, b], [c, d]); 4136 [ a b ] 4137 (%o1) [ ] 4138 [ c d ] 4139 (%i2) arg_2 : [11, 22]; 4140 (%o2) [11, 22] 4141 (%i3) arg_3 : matrix ([xx, yy]); 4142 (%o3) [ xx yy ] 4143 (%i4) xx_0 : outermap(lambda([x, y, z], x / y + z), arg_1, 4144 arg_2, arg_3); 4145 [ [ a a ] [ a a ] ] 4146 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ] 4147 [ [ 11 11 ] [ 22 22 ] ] 4148 (%o4) Col 1 = [ ] 4149 [ [ c c ] [ c c ] ] 4150 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ] 4151 [ [ 11 11 ] [ 22 22 ] ] 4152 [ [ b b ] [ b b ] ] 4153 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ] 4154 [ [ 11 11 ] [ 22 22 ] ] 4155 Col 2 = [ ] 4156 [ [ d d ] [ d d ] ] 4157 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ] 4158 [ [ 11 11 ] [ 22 22 ] ] 4159 (%i5) xx_1 : xx_0 [1][1]; 4160 [ a a ] [ a a ] 4161 (%o5) [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] 4162 [ 11 11 ] [ 22 22 ] 4163 (%i6) xx_2 : xx_0 [1][1] [1]; 4164 [ a a ] 4165 (%o6) [ xx + -- yy + -- ] 4166 [ 11 11 ] 4167 (%i7) xx_3 : xx_0 [1][1] [1] [1][1]; 4168 a 4169 (%o7) xx + -- 4170 11 4171 (%i8) [op (arg_1), op (arg_2), op (arg_3)]; 4172 (%o8) [matrix, [, matrix] 4173 (%i9) [op (xx_0), op (xx_1), op (xx_2)]; 4174 (%o9) [matrix, [, matrix] 4175 4176 La función 'outermap' mantiene la estructura de los argumentos en 4177 su respuesta, mientras que 'cartesian_product' no lo hace. 4178 4179 (%i1) outermap (F, [a, b, c], [1, 2, 3]); 4180 (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)], 4181 [F(c, 1), F(c, 2), F(c, 3)]] 4182 (%i2) setify (flatten (%)); 4183 (%o2) {F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3), 4184 F(c, 1), F(c, 2), F(c, 3)} 4185 (%i3) map (lambda ([L], apply (F, L)), cartesian_product ({a, b, c}, {1, 2, 3})); 4186 (%o3) {F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3), 4187 F(c, 1), F(c, 2), F(c, 3)} 4188 (%i4) is (equal (%, %th (2))); 4189 (%o4) true 4190 4191 4192File: maxima.info, Node: Depurado, Next: augmented_lagrangian, Prev: Programación, Up: Top 4193 419438 Depurado 4195*********** 4196 4197* Menu: 4198 4199* Depuración del código fuente:: 4200* Claves de depuración:: 4201* Funciones y variables para depurado:: 4202 4203 4204File: maxima.info, Node: Depuración del código fuente, Next: Claves de depuración, Up: Depurado 4205 420638.1 Depuración del código fuente 4207================================= 4208 4209Maxima es capaz de dar asistencia en la depuración del código fuente. 4210Un usuario puede establecer un punto de referencia dentro del código de 4211una función a partir del cual se siga la ejecución línea a línea. La 4212compliación puede ser posteriormente examinada, conjuntamente con los 4213valores que se han ido asignando a las variables. 4214 4215La instrucción ':help', o ':h', muestra la lista de comandos para la 4216depuración. (En general, los comandos pueden abreviarse; en algunos 4217casos la lista de alternativas podrá ser listada.) Dentro del 4218depurador, el usuario podrá examinar también cualquier función propia de 4219Maxima, definirla y manipular variables y expresiones. 4220 4221El punto de referencia se establecerá con la instrucción ':br'. Ya 4222dentro del depurador, el usuario podrá avanzar una línea de cada vez 4223utilizando la instrucción ':n' (de "next", en inglés). La orden ':bt' 4224(de "backtrace") muestra la lista de la pila. Finalmente, con el 4225comando ':r' ("resume") se abandona el depurador continuando con la 4226ejecución. El uso de estas instrucciones se muestra en el siguiente 4227ejemplo. 4228 4229 (%i1) load ("/tmp/foobar.mac"); 4230 4231 (%o1) /tmp/foobar.mac 4232 4233 (%i2) :br foo 4234 Turning on debugging debugmode(true) 4235 Bkpt 0 for foo (in /tmp/foobar.mac line 1) 4236 4237 (%i2) bar (2,3); 4238 Bkpt 0:(foobar.mac 1) 4239 /tmp/foobar.mac:1:: 4240 4241 (dbm:1) :bt <-- pulsando :bt se retrocede 4242 #0: foo(y=5)(foobar.mac line 1) 4243 #1: bar(x=2,y=3)(foobar.mac line 9) 4244 4245 (dbm:1) :n <-- pulsando :n se avanza una línea 4246 (foobar.mac 2) 4247 /tmp/foobar.mac:2:: 4248 4249 (dbm:1) :n <-- pulsando :n se avanza otra línea 4250 (foobar.mac 3) 4251 /tmp/foobar.mac:3:: 4252 4253 (dbm:1) u; <-- se pide el valor de u 4254 28 4255 4256 (dbm:1) u: 33; <-- se cambia el valor de u a 33 4257 33 4258 4259 (dbm:1) :r <-- pulsando :r se termina la depuración 4260 4261 (%o2) 1094 4262 4263El fichero '/tmp/foobar.mac' contiene lo siguiente: 4264 4265 foo(y) := block ([u:y^2], 4266 u: u+3, 4267 u: u^2, 4268 u); 4269 4270 bar(x,y) := ( 4271 x: x+2, 4272 y: y+2, 4273 x: foo(y), 4274 x+y); 4275 4276USO DEL DEPURADOR EN EMACS 4277 4278Si el usuario está corriendo el código bajo GNU emacs en un entorno de 4279texto (dbl shell), o está ejecutando el entorno gráfico 'xmaxima', 4280entonces cuando una función pare en el punto de referencia, podrá 4281observar su posición actual en el archivo fuente, el cual será mostrado 4282en la otra mitad de la ventana, bien resaltada en rojo, o con una 4283pequeña flecha apuntando a la línea correcta. El usuario puede avanzar 4284líneas simples tecleando M-n (Alt-n). 4285 4286Bajo Emacs se debe ejecutar el programa en una ventana de texto 'dbl', 4287la cual requiere el archivo 'dbl.el' que está en el directorio elisp. 4288El usuario debe instalar los archivos elisp o agregar el directorio 4289elisp de Maxima a la ruta de búsqueda: por ejemplo, se puede añadir lo 4290siguiente al archivo '.emacs' o al 'site-init.el' 4291 4292 (setq load-path (cons "/usr/share/maxima/5.9.1/emacs" load-path)) 4293 (autoload 'dbl "dbl") 4294 4295entonces en emacs 4296 4297 M-x dbl 4298 4299debería abrir una ventana del sistema en la cual se pueden ejecutar 4300programas, por ejemplo Maxima, gcl, gdb, etc. En esta ventana también 4301se puede ejecutar el depurador, mostrando el código fuente en la otra 4302ventana. 4303 4304El usuario puede colocar un punto de referencia en una línea determinada 4305sin más que teclear 'C-x space'. Con esto se le hace saber al depurador 4306en qué función está el cursor y en qué línea del mismo. Si el cursor 4307está en la línea 2 de 'foo', entonces insertará en la otra ventana la 4308instrucción "':br foo 2'", a fin de detener 'foo' justo en la segunda 4309línea. Para tener esto operativo, el usuario debe tener activo 4310maxima-mode.el (modo-maxima.el) en la ventana en la que está 4311'foobar.mac'. Hay otros comandos disponibles en la ventana, como 4312evaluar la función dentro de Maxima tecleando 'Alt-Control-x'. 4313 4314 4315File: maxima.info, Node: Claves de depuración, Next: Funciones y variables para depurado, Prev: Depuración del código fuente, Up: Depurado 4316 431738.2 Claves de depuración 4318========================= 4319 4320Las claves de depuración son palabras que no son interpretadas como 4321expresiones de Maxima. Una clave de depuración puede introducirse 4322dentro de Maxima o del depurador. Las claves de depuración comienzan 4323con dos puntos, ':'. Por ejemplo, para evaluar una expresión Lisp, se 4324puede teclear ':lisp' seguido de la expresión a ser evaluada. 4325 4326 (%i1) :lisp (+ 2 3) 4327 5 4328 4329El número de argumentos depende del comando en particular. Además, 4330tampoco es necesario teclear el nombre completo de la instrucción, tan 4331solo lo justo para diferenciarla de las otras instrucciones. Así, ':br' 4332sería suficiente para ':break'. 4333 4334Las claves de depuración se listan a continuación. 4335 4336':break F n' 4337 Establece un punto de referencia en la función 'F' en la línea 'n' 4338 contando a partir del comienzo de la función. Si 'F' es una 4339 cadena, entonces se entiende que se trata de un fichero, siendo 4340 entonces 'n' el número de línea a partir del comienzo del fichero. 4341 El valor 'n' es opcional; en caso de no ser suministrado, se 4342 entenderá que vale cero (primera línea de la función o fichero). 4343':bt' 4344 Retrocede en la pila. 4345':continue' 4346 Continua el cómputo de la función. 4347':delete' 4348 Borra los punto de referencia especificados, o todos si no se 4349 especifica ninguno. 4350':disable' 4351 Deshabilita los puntos de referencia especificados, o todos si no 4352 se especifica ninguno. 4353':enable' 4354 Habilita los puntos de referencia especificados, o todos si no se 4355 especifica ninguno. 4356':frame n' 4357 Imprime el elemento 'n' de la pila, o el actualmente activo si no 4358 se especifica ninguno. 4359':help' 4360 Imprime la ayuda sobre un comando del depurador, o de todos los 4361 comandos si no se especifica ninguno. 4362':info' 4363 Imprime información sobre un elemento. 4364':lisp expresión' 4365 Evalúa la 'expresión' Lisp. 4366':lisp-quiet expresión' 4367 Evalúa la 'expresión' Lisp sin devolver el resultado. 4368':next' 4369 Como ':step', excepto que ':next' se salta las llamadas a 4370 funciones. 4371':quit' 4372 Sale del nivel actual del depurador sin completar el cómputo. 4373':resume' 4374 Continúa con el cómputo. 4375':step' 4376 Sigue con el cómputo de la función o fichero hasta que alcance una 4377 nueva línea fuente. 4378':top' 4379 Retorna a Maxima desde cualquier nivel del depurador sin completar 4380 el cómputo. 4381 4382 4383File: maxima.info, Node: Funciones y variables para depurado, Prev: Claves de depuración, Up: Depurado 4384 438538.3 Funciones y variables para depurado 4386======================================== 4387 4388 -- Variable opcional: debugmode 4389 Valor por defecto: 'false' 4390 4391 Cuando en Maxima ocurre un error, Maxima inicializará el depurador 4392 si 'debugmode' tiene el valor 'true'. El usuario puede ingresar 4393 comandos para examinar la pila de llamadas, los puntos de 4394 interrupción; en pocas palabras ir a través del código de Maxima. 4395 Vea 'debugging' para una lista de los comandos del depurador. 4396 4397 Habilitando 'debugmode' no se capturarán los errores tipo Lisp. 4398 4399 -- Variable opcional: refcheck 4400 Valor por defecto: 'false' 4401 4402 Cuando 'refcheck' vale 'true', Maxima imprime un mensaje cada vez 4403 que una variable es utilizada por vez primera en un cálculo. 4404 4405 -- Variable opcional: setcheck 4406 Valor por defecto: 'false' 4407 4408 Cuando el valor de 'setcheck' es una lista de variables (se admite 4409 que tengan subíndices) Maxima devuelve un mensaje indicando si los 4410 valores que han sido asignados a las variables lo han sido con el 4411 operador ordinario ':', o con el operador de asignación '::' o como 4412 resultado de haberse realizado una llamada de función, pero en 4413 ningún caso cuando la asignación haya sido hecha mediante los 4414 operadores ':=' o '::='. El mensaje contiene el nombre de la 4415 variable y su valor. 4416 4417 La variable 'setcheck' admite también los valores 'all' o 'true' 4418 con lo que el informe incluirá todas las variables. 4419 4420 Cada nueva asignación de 'setcheck' establece una nueva lista de 4421 variables a ser monitorizada, de forma que cualquier otra variable 4422 previamente asignada a 'setcheck' es olvidada. 4423 4424 Los nombres asignados a 'setcheck' deben estar precedidos del 4425 apóstrofo ''' a fin de evitar que las variables sean evaluadas 4426 antes de ser almacenadas en 'setcheck'. Por ejemplo, si 'x', 'y' y 4427 'z' ya guardan algún valor entoces se hará 4428 4429 setcheck: ['x, 'y, 'z]$ 4430 4431 para colocarlas en la lista de variables a monitorizar. 4432 4433 No se generará ninguna salida cuando una variable de la lista 4434 'setcheck' sea asignada a ella misma, como en 'X: 'X'. 4435 4436 -- Variable opcional: setcheckbreak 4437 Valor por defecto: 'false' 4438 4439 Si 'setcheckbreak' es igual 'true', Maxima se detendrá siempre que 4440 a una variable de la lista 'setcheck' se le asigne un nuevo valor. 4441 La detención tendrá lugar justo antes de hacerse la asignación. En 4442 ese momento 'setval' guarda el valor que se le va a dar a la 4443 variable. Entonces el usuario podrá darle un valor diferente 4444 pasándoselo a la variable 'setval'. 4445 4446 Véanse también 'setcheck' y 'setval'. 4447 4448 -- Variable del sistema: setval 4449 4450 Guarda el valor que va a ser asignado a una variable cuando 4451 'setcheckbreak' realiza una detención. Entonces se podrá asignarle 4452 otro valor pasándoselo previamente a 'setval'. 4453 4454 Véanse también 'setcheck' y 'setcheckbreak'. 4455 4456 -- Función: timer (<f_1>, ..., <f_n>) 4457 -- Función: timer (all) 4458 -- Función: timer () 4459 Dadas las funciones <f_1>, ..., <f_n>, 'timer' coloca cada una de 4460 ellas en la lista de funciones para las cuales se generarán 4461 estadísticas relativas al tiempo de cómputo. Así, 'timer(f)$ 4462 timer(g)$' coloca a 'f' y luego a 'g' en dicha lista de forma 4463 acumulativa. 4464 4465 La sentencia 'timer(all)' coloca todas las funciones de usuario 4466 (las referenciadas por la variable global 'functions') en la lista 4467 de funciones cuyos tiempos de ejecución se quieren monitorizar. 4468 4469 Si no se le pasan argumentos a 'timer' se obtendrá la lista de 4470 funciones cuyos tiempos de ejecución se quieren monitorizar. 4471 4472 Maxima almacena la duración del cómputo de cada función de la 4473 lista, de forma que 'timer_info' devolverá las estadísticas 4474 correspondientes, incluyendo el tiempo medio de cada llamada a la 4475 función, el número de llamadas realizadas y el tiempo total 4476 transcurrido. La instrucción 'untimer' borra las funciones de la 4477 lista. 4478 4479 La función 'timer' no evalúa sus argumentos, de forma que 'f(x) := 4480 x^2$ g:f$ timer(g)$' no coloca a 'f' en la lista. 4481 4482 Si 'trace(f)' está activada, entonces 'timer(f)' está desactivada; 4483 'trace' y 'timer' no pueden estar operativas al mismo tiempo. 4484 4485 Véase también 'timer_devalue'. 4486 4487 -- Función: untimer (<f_1>, ..., <f_n>) 4488 -- Función: untimer () 4489 Dadas las funciones <f_1>, ..., <f_n>, 'untimer' las elimina de la 4490 lista de funciones cuyos tiempos de ejecución se quiere 4491 monitorizar. 4492 4493 Si no se le suministran argumentos, 'untimer' borra completamente 4494 la lista. 4495 4496 Tras la ejecución de 'untimer (f)', 'timer_info (f)' aún devuelve 4497 las estadísticas de tiempo previamente registradas, pero 4498 'timer_info()' (sin argumentos) no devuelve información sobre 4499 aquellas funciones que ya no están en la lista. La ejecución de 4500 'timer (f)' inicializa todas las estadísticas a cero y coloca 'f' 4501 nuevamente en la lista. 4502 4503 -- Variable opcional: timer_devalue 4504 Valor por defecto: 'false' 4505 4506 Si 'timer_devalue' es igual a 'true', Maxima le resta a cada 4507 función cuyos tiempos de ejecución se quiere monitorizar el tiempo 4508 gastado en llamadas a otras funciones presentes también en la lista 4509 de monitorización. En caso contrario, los tiempos que se obtienen 4510 para cada función incluyen también los consumidos en otras 4511 funciones. Nótese que el tiempo consumido en llamadas a otras 4512 funciones que no están en la lista de monitorización no se resta 4513 del tiempo total. 4514 4515 Véanse también 'timer' y 'timer_info'. 4516 4517 -- Función: timer_info (<f_1>, ..., <f_n>) 4518 -- Función: timer_info () 4519 Dadas las funciones <f_1>, ..., <f_n>, 'timer_info' devuelve una 4520 matriz con información relativa a los tiempos de ejecución de cada 4521 una de estas funciones. Sin argumentos, 'timer_info' devuelve la 4522 información asociada a todas las funciones cuyos tiempos de 4523 ejecución se quiere monitorizar. 4524 4525 La matriz devuelta por 'timer_info' incluye los nombres de las 4526 funciones, tiempo de ejecución en cada llamada, número de veces que 4527 ha sido llamada, tiempo total de ejecución y tiempo consumido en la 4528 recolección de basura, 'gctime' (del inglés, "garbage collection 4529 time") en la versión original de Macsyma, aunque ahora toma el 4530 valor constante cero. 4531 4532 Los datos con los que 'timer_info' construye su respuesta pueden 4533 obtenerse también con la función 'get': 4534 4535 get(f, 'calls); get(f, 'runtime); get(f, 'gctime); 4536 4537 Véase también 'timer'. 4538 4539 -- Función: trace (<f_1>, ..., <f_n>) 4540 -- Función: trace (all) 4541 -- Función: trace () 4542 4543 Dadas las funciones <f_1>, ..., <f_n>, 'trace' imprime información 4544 sobre depuración cada vez que estas funciones son llamadas; 4545 'trace(f)$ trace(g)$' coloca de forma acumulativa a 'f' y luego a 4546 'g' en la lista de funciones a ser rastradas. 4547 4548 La sentencia 'trace(all)' coloca todas las funciones de usuario 4549 (las referenciadas por la variable global 'functions') en la lista 4550 de funciones a ser rastreadas. 4551 4552 Si no se suministran argumentos, 'trace' devuelve una lista con 4553 todas las funciones a ser rastreadas. 4554 4555 La función 'untrace' desactiva el rastreo. Véase también 4556 'trace_options'. 4557 4558 La función 'trace' no evalúa sus argumentos, de forma que 'f(x) := 4559 x^2$ g:f$ trace(g)$' no coloca a 'f' en la lista de rastreo. 4560 4561 Cuando una función se redefine es eliminada de la lista de rastreo. 4562 Así, tras 'timer(f)$ f(x) := x^2$', la función 'f' dejará de estar 4563 en dicha lista. 4564 4565 Si 'timer (f)' está activado, entonces 'trace (f)' está 4566 desactivado, ya que 'trace' y 'timer' no pueden estar ambos activos 4567 para la misma función. 4568 4569 -- Función: trace_options (<f>, <option_1>, ..., <option_n>) 4570 -- Función: trace_options (<f>) 4571 4572 Establece las opciones de rastreo para la función <f>. Cualquier 4573 otra opción previamente especificada queda reemplazada por las 4574 nuevas. La ejecución de 'trace_options (<f>, ...)' no tiene ningún 4575 efecto, a menos que se haya invocado previamente a 'trace (<f>)' 4576 (es indiferente que esta invocación sea anterior o posterior a 4577 'trace_options'). 4578 4579 'trace_options (<f>)' inicializa todas las opciones a sus valores 4580 por defecto. 4581 4582 Las claves de opciones son: 4583 4584 * 'noprint': No se imprime mensaje alguno ni a la entrada ni a 4585 la salida de la función. 4586 * 'break': Coloca un punto de referencia antes de que la función 4587 comience a ejecutarse y otro después de que termine su 4588 ejecución. Véase 'break'. 4589 * 'lisp_print': Muestra los argumentos y valores retornados como 4590 objetos de Lisp. 4591 * 'info': Imprime '-> true' tanto a la entrada como a la salida 4592 de la función. 4593 * 'errorcatch': Detecta errores, otorgando la posibilidad de 4594 marcar un error, reintentar la llamada a la función o 4595 especificar un valor de retorno. 4596 4597 Las opciones de rastreo se especifican de dos formas. La única 4598 presencia de la clave de opción ya activa la opción. (Nótese que 4599 la opción <foo> no se activa mediante '<foo>: true' u otra forma 4600 similar; se tendrá en cuenta también que las claves no necesitan ir 4601 precedidas del apóstrofo.) Especificando la clave de opción junto 4602 con una función de predicado se hace que la opción quede 4603 condicionada al predicado. 4604 4605 La lista de argumentos para las funciones de predicado es siempre 4606 '[level, direction, function, item]' donde 'level' es el nivel de 4607 recursión para la función, 'direction' puede ser tanto 'enter' como 4608 'exit', 'function' es el nombre de la función y 'item' es la lista 4609 de argumentos (a la entrada) o el valor de retorno (a la salida). 4610 4611 A continuación un ejemplo de opciones de rastreo no condicionales: 4612 4613 (%i1) ff(n) := if equal(n, 0) then 1 else n * ff(n - 1)$ 4614 4615 (%i2) trace (ff)$ 4616 4617 (%i3) trace_options (ff, lisp_print, break)$ 4618 4619 (%i4) ff(3); 4620 4621 Para la misma función, con la opción 'break' condicionada a un 4622 predicado: 4623 4624 (%i5) trace_options (ff, break(pp))$ 4625 4626 (%i6) pp (level, direction, function, item) := block (print (item), 4627 return (function = 'ff and level = 3 and direction = exit))$ 4628 4629 (%i7) ff(6); 4630 4631 -- Función: untrace (<f_1>, ..., <f_n>) 4632 -- Función: untrace () 4633 Dadas las funciones <f_1>, ..., <f_n>, 'untrace' desactiva el 4634 rastreo previamente activado por la función 'trace'. Si no se 4635 aportan argumentos, 'untrace' desactiva el rastreo de todas las 4636 funciones. 4637 4638 La llamada a 'untrace' devuelve una lista con las funciones para 4639 las que el rastreo se ha desactivado. 4640 4641 4642File: maxima.info, Node: augmented_lagrangian, Next: Bernstein, Prev: Depurado, Up: Top 4643 464439 augmented_lagrangian 4645*********************** 4646 4647* Menu: 4648 4649* Funciones y variables para augmented_lagrangian:: 4650 4651 4652File: maxima.info, Node: Funciones y variables para augmented_lagrangian, Prev: augmented_lagrangian, Up: augmented_lagrangian 4653 465439.1 Funciones y variables para augmented_lagrangian 4655==================================================== 4656 4657 -- Función: augmented_lagrangian_method (<FOM>, <xx>, <C>, <yy>) 4658 -- Función: augmented_lagrangian_method (<FOM>, <xx>, <C>, <yy>, 4659 optional_args) 4660 -- Función: augmented_lagrangian_method ([<FOM>, <grad>], <xx>, <C>, 4661 <yy>) 4662 -- Función: augmented_lagrangian_method ([<FOM>, <grad>], <xx>, <C>, 4663 <yy>, optional_args) 4664 4665 Devuelve una aproximación del valor mínimo de la expresión <FOM> 4666 respecto de las variables <xx>, manteniendo las restricciones <C> 4667 igual a cero. La lista <yy> contiene las soluciones iniciales para 4668 <xx>. El algoritmo que se utiliza es el método del lagrangiano 4669 aumentado (ver referencias [1] y [2]). 4670 4671 Si <grad> está presente en la llamada a la función, se interpreta 4672 como el gradiente de <FOM> respecto de <xx>, representado como una 4673 lista de tantas expresiones como variables tenga <xx>. Si el 4674 argumento <grad> no está, se calculará de forma automática. 4675 4676 Tanto <FOM> como cada uno de los elementos de <grad>, si se da como 4677 argumento, deben ser expresiones ordinarias; no admitiéndose ni 4678 nombres de funciones ni expresiones lambda. 4679 4680 El argumento 'optional_args' hace referencia a otros argumentos 4681 adicionales, los cuales se especifican de la forma '<symbol> = 4682 <value>'. Los argumentos opcionales reconocidos son: 4683 4684 'niter' 4685 Número de iteraciones del algoritmo. 4686 'lbfgs_tolerance' 4687 Tolerancia que se pasa a LBFGS. 4688 'iprint' 4689 Parámetro IPRINT (lista de dos enteros que controlan la 4690 frecuencia de mensajes) que se pasa a LBFGS. 4691 '%lambda' 4692 Valor inicial de '%lambda' que será utilizado para calcular el 4693 lagrangiano aumentado. 4694 4695 Esta función minimiza el lagrangiano aumentado haciendo uso del 4696 algoritmo LBFGS, que es un método de los llamados quasi-Newton. 4697 4698 Antes de hacer uso de esta función ejecútense 4699 'load("augmented_lagrangian")'. 4700 4701 Véase también 'lbfgs'. 4702 4703 Referencias: 4704 4705 [1] 4706 <http://www-fp.mcs.anl.gov/otc/Guide/OptWeb/continuous/constrained/nonlinearcon/auglag.html> 4707 4708 [2] <http://www.cs.ubc.ca/spider/ascher/542/chap10.pdf> 4709 4710 Ejemplos: 4711 4712 (%i1) load (lbfgs); 4713 (%o1) /maxima/share/lbfgs/lbfgs.mac 4714 (%i2) load (augmented_lagrangian); 4715 (%o2) 4716 /maxima/share/contrib/augmented_lagrangian.mac 4717 (%i3) FOM: x^2 + 2*y^2; 4718 2 2 4719 (%o3) 2 y + x 4720 (%i4) xx: [x, y]; 4721 (%o4) [x, y] 4722 (%i5) C: [x + y - 1]; 4723 (%o5) [y + x - 1] 4724 (%i6) yy: [1, 1]; 4725 (%o6) [1, 1] 4726 (%i7) augmented_lagrangian_method(FOM, xx, C, yy, iprint=[-1,0]); 4727 (%o7) [[x = 0.66665984108002, y = 0.33334027245545], 4728 %lambda = [- 1.333337940892525]] 4729 4730 Mismo ejemplo que en el caso anterior, pero ahora el gradiente se 4731 suministra como argumento. 4732 4733 (%i1) load (lbfgs)$ 4734 (%i2) load (augmented_lagrangian)$ 4735 (%i3) FOM: x^2 + 2*y^2; 4736 2 2 4737 (%o3) 2 y + x 4738 (%i4) FOM: x^2 + 2*y^2; 4739 2 2 4740 (%o4) 2 y + x 4741 (%i5) xx: [x, y]; 4742 (%o5) [x, y] 4743 (%i6) grad : [2*x, 4*y]; 4744 (%o6) [2 x, 4 y] 4745 (%i7) C: [x + y - 1]; 4746 (%o7) [y + x - 1] 4747 (%i8) yy: [1, 1]; 4748 (%o8) [1, 1] 4749 (%i9) augmented_lagrangian_method ([FOM, grad], xx, C, yy, 4750 iprint = [-1, 0]); 4751 (%o9) [[x = 0.666659841080025, y = .3333402724554462], 4752 %lambda = [- 1.333337940892543]] 4753 4754 4755File: maxima.info, Node: Bernstein, Next: bode, Prev: augmented_lagrangian, Up: Top 4756 475740 Bernstein 4758************ 4759 4760* Menu: 4761 4762* Funciones y variables para Bernstein:: 4763 4764 4765File: maxima.info, Node: Funciones y variables para Bernstein, Prev: Bernstein, Up: Bernstein 4766 476740.1 Funciones y variables para Bernstein 4768========================================= 4769 4770 -- Función: bernstein_poly (<k>, <n>, <x>) 4771 4772 Si 'k' no es un entero negativo, los polinomios de Bernstein se 4773 definen como 'bernstein_poly(k,n,x) = binomial(n,k) x^k 4774 (1-x)^(n-k)'; en cambio, si 'k' es un entero negativo, el polinomio 4775 de Bernstein 'bernstein_poly(k,n,x)' se anula. Cuando o bien 'k' o 4776 'n' no son enteros, la variable opcional 'bernstein_explicit' 4777 controla la expansión de los polinomios de Bernstein a su forma 4778 explícita. 4779 4780 Ejemplo: 4781 4782 (%i1) load(bernstein)$ 4783 4784 (%i2) bernstein_poly(k,n,x); 4785 (%o2) bernstein_poly(k, n, x) 4786 (%i3) bernstein_poly(k,n,x), bernstein_explicit : true; 4787 n - k k 4788 (%o3) binomial(n, k) (1 - x) x 4789 4790 Los polinomios de Bernstein tienen definidas su derivada e 4791 integral: 4792 4793 (%i4) diff(bernstein_poly(k,n,x),x); 4794 (%o4) (bernstein_poly(k - 1, n - 1, x) 4795 - bernstein_poly(k, n - 1, x)) n 4796 (%i5) integrate(bernstein_poly(k,n,x),x); 4797 (%o5) 4798 k + 1 4799 hypergeometric([k + 1, k - n], [k + 2], x) binomial(n, k) x 4800 ---------------------------------------------------------------- 4801 k + 1 4802 4803 Cuando los argumentos contienen números decimales en coma flotante, 4804 los polinomios de Bernstein también devuelven resultados decimales. 4805 4806 (%i6) bernstein_poly(5,9, 1/2 + %i); 4807 39375 %i 39375 4808 (%o6) -------- + ----- 4809 128 256 4810 (%i7) bernstein_poly(5,9, 0.5b0 + %i); 4811 (%o7) 3.076171875b2 %i + 1.5380859375b2 4812 4813 Para hacer uso de 'bernstein_poly', ejecútese primero 4814 'load("bernstein")'. 4815 4816 -- Variable opcional: bernstein_explicit 4817 Valor por defecto: 'false' 4818 4819 Cuando o bien 'k' o 'n' no son enteros, la variable opcional 4820 'bernstein_explicit' controla la expansión de los polinomios de 4821 Bernstein a su forma explícita. 4822 4823 Ejemplo: 4824 4825 (%i1) bernstein_poly(k,n,x); 4826 (%o1) bernstein_poly(k, n, x) 4827 (%i2) bernstein_poly(k,n,x), bernstein_explicit : true; 4828 n - k k 4829 (%o2) binomial(n, k) (1 - x) x 4830 4831 Cuando tanto 'k' como 'n' son enteros, 'bernstein(k,n,x)' se 4832 expande siempre a su forma explícita. 4833 4834 -- Función: multibernstein_poly (<[k1,k2,...,kp]>,<[n1,n2,..., 4835 np]>,<[x1,x2,..., xp]>) 4836 4837 La sentencia 'multibernstein_poly (<[k1,k2,...,kp]>,<[n1,n2,..., 4838 np]>,<[x1,x2,..., xp]>)' es el producto de polinomios de Bernstein 4839 'bernstein_poly(k1,n1,x1) bernstein_poly(k2,n2,x2) ... 4840 bernstein_poly(kp,np,xp)'. 4841 4842 Para hacer uso de 'multibernstein_poly', ejecútese primero 4843 'load("bernstein")'. 4844 4845 -- Función: bernstein_approx (<f>,<[x1,x1,...,xn]>,n) 4846 4847 Devuelve el polinomio de Bernstein uniforme de 'n'-ésimo orden que 4848 aproxima la función '(x1,x2,..xn) |--> f'. 4849 4850 Ejemplos: 4851 4852 (%i1) bernstein_approx(f(x),[x], 2); 4853 2 1 2 4854 (%o1) f(1) x + 2 f(-) (1 - x) x + f(0) (1 - x) 4855 2 4856 (%i2) bernstein_approx(f(x,y),[x,y], 2); 4857 2 2 1 2 2 2 4858 (%o2) f(1, 1) x y + 2 f(-, 1) (1 - x) x y + f(0, 1) (1 - x) y 4859 2 4860 1 2 1 1 4861 + 2 f(1, -) x (1 - y) y + 4 f(-, -) (1 - x) x (1 - y) y 4862 2 2 2 4863 1 2 2 2 4864 + 2 f(0, -) (1 - x) (1 - y) y + f(1, 0) x (1 - y) 4865 2 4866 1 2 2 2 4867 + 2 f(-, 0) (1 - x) x (1 - y) + f(0, 0) (1 - x) (1 - y) 4868 2 4869 4870 Para hacer uso de 'bernstein_approx', ejecútese primero 4871 'load("bernstein")'. 4872 4873 -- Función: bernstein_expand (<e>, <[x1,x1,...,xn]>) 4874 4875 Expresa el polinomio 'e' como una combinación lineal de polinomios 4876 de Bernstein multivariantes. 4877 4878 (%i1) bernstein_expand(x*y+1,[x,y]); 4879 (%o1) 2 x y + (1 - x) y + x (1 - y) + (1 - x) (1 - y) 4880 (%i2) expand(%); 4881 (%o2) x y + 1 4882 4883 Maxima devuelve un error si el primer argumento no es un polinomio. 4884 4885 Para hacer uso de 'bernstein_expand', ejecútese primero 4886 'load("bernstein")'. 4887 4888 4889File: maxima.info, Node: bode, Next: cobyla, Prev: Bernstein, Up: Top 4890 489141 bode 4892******* 4893 4894* Menu: 4895 4896* Funciones y variables para bode:: 4897 4898 4899File: maxima.info, Node: Funciones y variables para bode, Prev: bode, Up: bode 4900 490141.1 Funciones y variables para bode 4902==================================== 4903 4904 -- Función: bode_gain (<H>, <range>, ...<plot_opts>...) 4905 Función para dibujar el gráfico de ganancia de Bode. 4906 4907 Ejemplos (1 a 7 de 4908 <http://www.swarthmore.edu/NatSci/echeeve1/Ref/Bode/BodeHow.html>, 4909 8 de Ron Crummett): 4910 (%i1) load("bode")$ 4911 4912 (%i2) H1 (s) := 100 * (1 + s) / ((s + 10) * (s + 100))$ 4913 4914 (%i3) bode_gain (H1 (s), [w, 1/1000, 1000])$ 4915 4916 (%i4) H2 (s) := 1 / (1 + s/omega0)$ 4917 4918 (%i5) bode_gain (H2 (s), [w, 1/1000, 1000]), omega0 = 10$ 4919 4920 (%i6) H3 (s) := 1 / (1 + s/omega0)^2$ 4921 4922 (%i7) bode_gain (H3 (s), [w, 1/1000, 1000]), omega0 = 10$ 4923 4924 (%i8) H4 (s) := 1 + s/omega0$ 4925 4926 (%i9) bode_gain (H4 (s), [w, 1/1000, 1000]), omega0 = 10$ 4927 4928 (%i10) H5 (s) := 1/s$ 4929 4930 (%i11) bode_gain (H5 (s), [w, 1/1000, 1000])$ 4931 4932 (%i12) H6 (s) := 1/((s/omega0)^2 + 2 * zeta * (s/omega0) + 1)$ 4933 4934 (%i13) bode_gain (H6 (s), [w, 1/1000, 1000]), 4935 omega0 = 10, zeta = 1/10$ 4936 4937 (%i14) H7 (s) := (s/omega0)^2 + 2 * zeta * (s/omega0) + 1$ 4938 4939 (%i15) bode_gain (H7 (s), [w, 1/1000, 1000]), 4940 omega0 = 10, zeta = 1/10$ 4941 4942 (%i16) H8 (s) := 0.5 / (0.0001 * s^3 + 0.002 * s^2 + 0.01 * s)$ 4943 4944 (%i17) bode_gain (H8 (s), [w, 1/1000, 1000])$ 4945 4946 Antes de hacer uso de esta función ejecútese 'load("bode")'. Véase 4947 también 'bode_phase'. 4948 4949 -- Función: bode_phase (<H>, <range>, ...<plot_opts>...) 4950 Función para dibujar el gráfico de fase de Bode. 4951 4952 Ejemplos (1 a 7 de 4953 <http://www.swarthmore.edu/NatSci/echeeve1/Ref/Bode/BodeHow.html>, 4954 8 de Ron Crummett): 4955 (%i1) load("bode")$ 4956 4957 (%i2) H1 (s) := 100 * (1 + s) / ((s + 10) * (s + 100))$ 4958 4959 (%i3) bode_phase (H1 (s), [w, 1/1000, 1000])$ 4960 4961 (%i4) H2 (s) := 1 / (1 + s/omega0)$ 4962 4963 (%i5) bode_phase (H2 (s), [w, 1/1000, 1000]), omega0 = 10$ 4964 4965 (%i6) H3 (s) := 1 / (1 + s/omega0)^2$ 4966 4967 (%i7) bode_phase (H3 (s), [w, 1/1000, 1000]), omega0 = 10$ 4968 4969 (%i8) H4 (s) := 1 + s/omega0$ 4970 4971 (%i9) bode_phase (H4 (s), [w, 1/1000, 1000]), omega0 = 10$ 4972 4973 (%i10) H5 (s) := 1/s$ 4974 4975 (%i11) bode_phase (H5 (s), [w, 1/1000, 1000])$ 4976 4977 (%i12) H6 (s) := 1/((s/omega0)^2 + 2 * zeta * (s/omega0) + 1)$ 4978 4979 (%i13) bode_phase (H6 (s), [w, 1/1000, 1000]), 4980 omega0 = 10, zeta = 1/10$ 4981 4982 (%i14) H7 (s) := (s/omega0)^2 + 2 * zeta * (s/omega0) + 1$ 4983 4984 (%i15) bode_phase (H7 (s), [w, 1/1000, 1000]), 4985 omega0 = 10, zeta = 1/10$ 4986 4987 (%i16) H8 (s) := 0.5 / (0.0001 * s^3 + 0.002 * s^2 + 0.01 * s)$ 4988 4989 (%i17) bode_phase (H8 (s), [w, 1/1000, 1000])$ 4990 4991 (%i18) block ([bode_phase_unwrap : false], 4992 bode_phase (H8 (s), [w, 1/1000, 1000])); 4993 4994 (%i19) block ([bode_phase_unwrap : true], 4995 bode_phase (H8 (s), [w, 1/1000, 1000])); 4996 4997 Antes de hacer uso de esta función ejecútese 'load("bode")'. Véase 4998 también 'bode_gain'. 4999 5000 5001File: maxima.info, Node: cobyla, Next: contrib_ode, Prev: bode, Up: Top 5002 500342 cobyla 5004********* 5005 5006* Menu: 5007 5008* Introducción a cobyla:: 5009* Funciones y variables para cobyla:: 5010* Ejemplos para cobyla:: 5011 5012 5013File: maxima.info, Node: Introducción a cobyla, Next: Funciones y variables para cobyla, Prev: cobyla, Up: cobyla 5014 501542.1 Introducción a cobyla 5016========================== 5017 5018'fmin_cobyla' es una traducción a Common Lisp hecha con el programa 5019'f2cl' de la rutina Fortran COBYLA, (Powell, [1][2][3]), para 5020optimización con restricciones. 5021 5022COBYLA minimiza una función objetivo F(X) sujeta a M restricciones con 5023desigualdades de la forma g(X) >= 0 sobre X, siendo X un vector de 5024variables de N componentes. 5025 5026Las restricciones en forma de igualdades se pueden implementar por pares 5027de desigualdades de la forma g(X)>=0 y -g(X)>= 0. El interfaz Maxima 5028para COBYLA admite restricciones de igualdad, transformándolas luego 5029internamente a pares de desigualdades. 5030 5031El algoritmo hace uso de aproximaciones lineales, tanto de la función 5032objetivo como de las funciones de restricción; tales aproximaciones se 5033hacen mediante interpolación lineal de N+1 puntos en el espacio de 5034variables. Los puntos de interpolación se consideran vértices de un 5035simplejo o símplex. El parámetro RHO controla el tamaño del simplejo y 5036se reduce automáticamente de RHOBEG a RHOEND. Para cada RHO la subrutina 5037intenta alcanzar un buen vector de variables para el tamaño actual, 5038reduciéndose entonces RHO hasta alcanzar el valor de RHOEND. Por eso, 5039tanto a RHOBEG como a RHOEND se les deben asignar valores razonables, lo 5040que requiere cierto trabajo empírico previo. La rutina trata cada 5041restricción individualmente cuando se calcula un en las variables. El 5042nombre de la rutina se deriva de la frase Constrained Optimization BY 5043Linear Approximations. 5044 5045Referecias: 5046 5047[1] Código Fortran procede de 5048<http://plato.asu.edu/sub/nlores.html#general> 5049 5050[2] M. J. D. Powell, "A direct search optimization method that models 5051the objective and constraint functions by linear interpolation," en 5052Advances in Optimization and Numerical Analysis, eds. S. Gomez and 5053J.-P. Hennart (Kluwer Academic: Dordrecht, 1994), p. 51-67. 5054 5055[3] M. J. D. Powell, "Direct search algorithms for optimization 5056calculations," Acta Numerica 7, 287-336 (1998). Also available as 5057University of Cambridge, Department of Applied Mathematics and 5058Theoretical Physics, Numerical Analysis Group, Report NA1998/04 from 5059<http://www.damtp.cam.ac.uk/user/na/reports.html> 5060 5061 5062File: maxima.info, Node: Funciones y variables para cobyla, Next: Ejemplos para cobyla, Prev: Introducción a cobyla, Up: cobyla 5063 506442.2 Funciones y variables para cobyla 5065====================================== 5066 5067 -- Función: fmin_cobyla (<F>, <X>, <Y>) 5068 -- Función: fmin_cobyla (<F>, <X>, <Y>, optional_args) 5069 5070 Devuelve una aproximación del valor mínimo de la expresión <F> 5071 respecto de las variables <X>, sujeta a un conjunto opcional de 5072 restricciones. <Y> es una lista que contiene una solución semilla 5073 inicial en <X>. 5074 5075 <F> debe ser una expresión ordinaria, no valen nombres de funciones 5076 ni expresiones lambda. 5077 5078 'optional_args' hace referencia a argumentos adicionales, que se 5079 especifican de la forma '<symbol> = <value>'. Los argumentos 5080 opcionales que se reconocen son: 5081 5082 'constraints' 5083 Lista de restricciones en forma de desigualdades e igualdades 5084 que debe satisfacer <X>. Las desigualdades deben ser de la 5085 forma 'g(<X>) >= h(<X>)' o 'g(<X>) <= h(<X>)'. Las 5086 restricciones de igualdad deben ser de la forma 'g(<X>) = 5087 h(<X>)'. 5088 'rhobeg' 5089 Valor inicial de la variable interna RHO, que controla el 5090 tamaño del simplejo. Su valor por defecto es 1.0. 5091 'rhoend' 5092 El valor final deseado para el parámetro RHO. Es 5093 aproximadamente la precisión de las variables. Su valor por 5094 defecto es 1d-6. 5095 'iprint' 5096 Nivel de información de salida. Su valor por defecto es 0. 5097 * 0 - Sin información de salida 5098 * 1 - Sumario al final de los cálculos 5099 * 2 - Se van mostrando los nuevos valores de RHO y SIGMA, 5100 incluyendo el vector de variables. 5101 * 3 - Como en 2, pero la información se muestra cuando se 5102 calcula F(X). 5103 'maxfun' 5104 Número máximo de evaluaciones de la función. Su valor por 5105 defecto es 1000. 5106 5107 El resultado devuelto es un vector: 5108 1. Los valores de las variables con las que se alcanza el valor 5109 mínimo. Es una lista de elementos de la forma '<var> = 5110 <value>' para cada una de las variables listadas en <X>. 5111 2. El valor mínimo de la función objetivo. 5112 3. El número de evaluaciones de la función. 5113 4. Código de retorno con los siguientes significados: 5114 1. 0 - No ha habido errores. 5115 2. 1 - Alcanzado el máximo número permitido de evaluaciones 5116 de la función. 5117 3. 2 - Errores de redondeo han impedido el avance del 5118 proceso. 5119 5120 El código 'load(fmin_cobyla)' carga en memoria esta función.. 5121 5122 -- Función: bf_fmin_cobyla (<F>, <X>, <Y>) 5123 -- Función: bf_fmin_cobyla (<F>, <X>, <Y>, optional_args) 5124 5125 Esta función es idéntica a 'fmin_cobyla', excepto por el hecho de 5126 que utiliza aritmética de precisión arbitraria (bigfloat) y que el 5127 valor por defecto de <rhoend> es '10^(fpprec/2)'. 5128 5129 Véase 'fmin_cobyla'. 5130 5131 El código 'load(fmin_cobyla)' carga en memoria esta función.. 5132 5133 5134File: maxima.info, Node: Ejemplos para cobyla, Prev: Funciones y variables para cobyla, Up: cobyla 5135 513642.3 Ejemplos para cobyla 5137========================= 5138 5139Minimizar x1*x2 bajo la condición 1-x1^2-x2^2 >= 0. La solución teórica 5140es x1 = 1/sqrt(2), x2 = -1/sqrt(2). 5141 5142 (%i1) load(fmin_cobyla)$ 5143 5144 (%i2) fmin_cobyla(x1*x2, [x1, x2], [1,1], constraints = [x1^2+x2^2<=1], iprint=1); 5145 5146 Normal return from subroutine COBYLA 5147 5148 NFVALS = 66 F =-5.000000E-01 MAXCV = 1.999845E-12 5149 X = 7.071058E-01 -7.071077E-01 5150 (%o2) [[x1 = 0.70710584934848, x2 = - 0.7071077130248], - 0.49999999999926, 5151 [[-1.999955756559757e-12],[]], 66] 5152 5153Hay más ejemplos en el directorio 'share/cobyla/ex'. 5154 5155 5156File: maxima.info, Node: contrib_ode, Next: descriptive, Prev: cobyla, Up: Top 5157 515843 contrib_ode 5159************** 5160 5161* Menu: 5162 5163* Introducción a contrib_ode:: 5164* Funciones y variables para contrib_ode:: 5165* Posibles mejoras a contrib_ode:: 5166* Pruebas realizadas con contrib_ode:: 5167* Referencias para contrib_ode:: 5168 5169 5170File: maxima.info, Node: Introducción a contrib_ode, Next: Funciones y variables para contrib_ode, Prev: contrib_ode, Up: contrib_ode 5171 517243.1 Introducción a contrib_ode 5173=============================== 5174 5175La función 'ode2' de Maxima resuelve ecuaciones diferenciales ordinarias 5176(EDO) simples de primer y segundo orden. La función 'contrib_ode' 5177extiende las posibilidades de 'ode2' con métodos adicionales para ODEs 5178lineales y no lineales de primer orden y homogéneas lineales de segundo 5179orden. El código se encuentra en estado de desarrollo y la syntaxis 5180puede cambiar en futuras versiones. Una vez el código se haya 5181estabilizado podrá pasar a integrarse dentro de Maxima. 5182 5183El paquete debe cargarse con la instrucción 'load('contrib_ode)' antes 5184de utilizarlo. 5185 5186La sintaxis de 'contrib_ode' es similar a la de 'ode2'. Necesita tres 5187argumentos: una EDO (sólo se necesita el miembro izquierdo si el derecho 5188es igual cero), la variable dependiente y la independiente. Si 5189encuentra la solución, devolverá una lista de resultados. 5190 5191La forma de los resultados devueltos es diferente de la utilizada por 5192'ode2'. Puesto que las ecuaciones no lineales pueden tener múltiples 5193soluciones, 'contrib_ode' devuelve una lista de soluciones. Las 5194soluciones pueden tener diferentes formatos: 5195 * una función explícita para la variable dependiente, 5196 5197 * una función implícita para la variable dependiente, 5198 5199 * una solución paramétrica en términos de la variable '%t' o 5200 5201 * una transformación en otra EDO de variable '%u'. 5202 5203'%c' hace referencia a la constante de integración en las ecuaciones de 5204primer orden. '%k1' y '%k2' son las constantes para las ecuaciones de 5205segundo orden. Si por cualquier razón contrib_ode no pudiese encontrar 5206una solución, devolverá 'false', quizás después de mostrar un mensaje de 5207error. 5208 5209Ejemplos: 5210 5211En ocasiones es necesario devolver una lista de soluciones, pues algunas 5212EDOs pueden tener múltiples soluciones: 5213 5214 (%i1) load('contrib_ode)$ 5215 5216 (%i2) eqn:x*'diff(y,x)^2-(1+x*y)*'diff(y,x)+y=0; 5217 5218 dy 2 dy 5219 (%o2) x (--) - (x y + 1) -- + y = 0 5220 dx dx 5221 (%i3) contrib_ode(eqn,y,x); 5222 5223 x 5224 (%o3) [y = log(x) + %c, y = %c %e ] 5225 (%i4) method; 5226 5227 (%o4) factor 5228 5229Las EDOs no lineales pueden tener soluciones singulares sin constantes 5230de integración, como en la segunda solución del ejemplo siguiente: 5231 5232 (%i1) load('contrib_ode)$ 5233 5234 (%i2) eqn:'diff(y,x)^2+x*'diff(y,x)-y=0; 5235 5236 dy 2 dy 5237 (%o2) (--) + x -- - y = 0 5238 dx dx 5239 (%i3) contrib_ode(eqn,y,x); 5240 5241 2 5242 2 x 5243 (%o3) [y = %c x + %c , y = - --] 5244 4 5245 (%i4) method; 5246 5247 (%o4) clairault 5248 5249La siguiente ODE tiene dos soluciones paramétricas en términos de la 5250variable '%t'. En este caso, las soluciones paramétricas se pueden 5251manipular para dar soluciones explícitas. 5252 5253 (%i1) load('contrib_ode)$ 5254 5255 (%i2) eqn:'diff(y,x)=(x+y)^2; 5256 5257 dy 2 5258 (%o2) -- = (y + x) 5259 dx 5260 (%i3) contrib_ode(eqn,y,x); 5261 5262 (%o3) [[x = %c - atan(sqrt(%t)), y = - x - sqrt(%t)], 5263 [x = atan(sqrt(%t)) + %c, y = sqrt(%t) - x]] 5264 (%i4) method; 5265 5266 (%o4) lagrange 5267 5268En el siguiente ejemplo (Kamke 1.112) se obtiene una solución implícita. 5269 5270 (%i1) load('contrib_ode)$ 5271 5272 (%i2) assume(x>0,y>0); 5273 5274 (%o2) [x > 0, y > 0] 5275 (%i3) eqn:x*'diff(y,x)-x*sqrt(y^2+x^2)-y; 5276 5277 dy 2 2 5278 (%o3) x -- - x sqrt(y + x ) - y 5279 dx 5280 (%i4) contrib_ode(eqn,y,x); 5281 5282 y 5283 (%o4) [x - asinh(-) = %c] 5284 x 5285 (%i5) method; 5286 5287 (%o5) lie 5288 5289La siguiente ecuación de Riccati se transforma en una EDO lineal de 5290segundo orden de variable '%u'. Maxima es incapaz de resolver la nueva 5291EDO, por lo que la devuelve si resolver: 5292 5293 (%i1) load('contrib_ode)$ 5294 5295 (%i2) eqn:x^2*'diff(y,x)=a+b*x^n+c*x^2*y^2; 5296 5297 2 dy 2 2 n 5298 (%o2) x -- = c x y + b x + a 5299 dx 5300 (%i3) contrib_ode(eqn,y,x); 5301 5302 d%u 5303 --- 2 5304 dx 2 n - 2 a d %u 5305 (%o3) [[y = - ----, %u c (b x + --) + ---- c = 0]] 5306 %u c 2 2 5307 x dx 5308 (%i4) method; 5309 5310 (%o4) riccati 5311 5312Para EDOs de primer orden, 'contrib_ode' llama a 'ode2'. Entonces trata 5313de aplicar los siguientes métodos: factorización, Clairault, Lagrange, 5314Riccati, Abel y Lie. El método de Lie no se intenta aplicar a las 5315ecuaciones de Abel si el propio método de Abel no obtiene solución, pero 5316sí se utiliza si el método de Riccati devuelve una EDO de segundo orden 5317sin resolver. 5318 5319Para EDOs de segundo orden, 'contrib_ode' llama a 'ode2' y luego a 5320'odelin'. 5321 5322Se mostrarán mensajes de depurado si se ejecuta la sentencia 5323'put('contrib_ode,true,'verbose)'. 5324 5325 5326File: maxima.info, Node: Funciones y variables para contrib_ode, Next: Posibles mejoras a contrib_ode, Prev: Introducción a contrib_ode, Up: contrib_ode 5327 532843.2 Funciones y variables para contrib_ode 5329=========================================== 5330 5331 -- Función: contrib_ode (<eqn>, <y>, <x>) 5332 5333 Devuelve la lista de soluciones de la ecuación diferencia ordinaria 5334 (EDO) <eqn> de variable independiente <x> y variable dependiente 5335 <y>. 5336 5337 -- Función: odelin (<eqn>, <y>, <x>) 5338 5339 La función 'odelin' resulve EDOs homogéneas lineales de primer y 5340 segundo orden con variable independiente <x> y variable dependiente 5341 <y>. Devuelve un conjunto fundamental de soluciones de la EDO. 5342 5343 Para EDOs de segundo orden, 'odelin' utiliza un método desarrollado 5344 por Bronstein y Lafaille, que busca las soluciones en términos de 5345 funciones especiales dadas. 5346 5347 (%i1) load('contrib_ode); 5348 5349 (%i2) odelin(x*(x+1)*'diff(y,x,2)+(x+5)*'diff(y,x,1)+(-4)*y,y,x); 5350 ...trying factor method 5351 ...solving 7 equations in 4 variables 5352 ...trying the Bessel solver 5353 ...solving 1 equations in 2 variables 5354 ...trying the F01 solver 5355 ...solving 1 equations in 3 variables 5356 ...trying the spherodial wave solver 5357 ...solving 1 equations in 4 variables 5358 ...trying the square root Bessel solver 5359 ...solving 1 equations in 2 variables 5360 ...trying the 2F1 solver 5361 ...solving 9 equations in 5 variables 5362 gauss_a(- 6, - 2, - 3, - x) gauss_b(- 6, - 2, - 3, - x) 5363 (%o2) {---------------------------, ---------------------------} 5364 4 4 5365 x x 5366 5367 5368 -- Función: ode_check (<eqn>, <soln>) 5369 5370 Devuelve el valor de la ecuación diferencia ordinaria (EDO) <eqn> 5371 después de sustituir una posible solución <soln>. El valor es cero 5372 si <soln> es una solución de <eqn>. 5373 5374 (%i1) load('contrib_ode)$ 5375 5376 (%i2) eqn:'diff(y,x,2)+(a*x+b)*y; 5377 5378 2 5379 d y 5380 (%o2) --- + (a x + b) y 5381 2 5382 dx 5383 (%i3) ans:[y = bessel_y(1/3,2*(a*x+b)^(3/2)/(3*a))*%k2*sqrt(a*x+b) 5384 +bessel_j(1/3,2*(a*x+b)^(3/2)/(3*a))*%k1*sqrt(a*x+b)]; 5385 5386 3/2 5387 1 2 (a x + b) 5388 (%o3) [y = bessel_y(-, --------------) %k2 sqrt(a x + b) 5389 3 3 a 5390 3/2 5391 1 2 (a x + b) 5392 + bessel_j(-, --------------) %k1 sqrt(a x + b)] 5393 3 3 a 5394 (%i4) ode_check(eqn,ans[1]); 5395 5396 (%o4) 0 5397 5398 -- Variable opcional: 'method' 5399 5400 A la variable 'method' se le asigna el método aplicado. 5401 5402 -- Variable: '%c' 5403 5404 '%c' es la constante de integración para EDOs de primer orden. 5405 5406 -- Variable: '%k1' 5407 5408 '%k1' es la primera constante de integración para EDOs de segundo 5409 orden. 5410 5411 -- Variable: '%k2' 5412 5413 '%k2' es la segunda constante de integración para EDOs de segundo 5414 orden. 5415 5416 -- Función: gauss_a (<a>, <b>, <c>, <x>) 5417 5418 'gauss_a(a,b,c,x)' y 'gauss_b(a,b,c,x)' son funciones geométricas 5419 2F1 . Representan dos soluciones independientes cualesquiera de la 5420 ecuación diferencial hipergeométrica 'x(1-x) diff(y,x,2) + 5421 [c-(a+b+1)x] diff(y,x) - aby = 0' (A&S 15.5.1). 5422 5423 El único uso que se hace de estas funciones es en las soluciones de 5424 EDOs que devuelven 'odelin' y 'contrib_ode'. La definición y 5425 utilización de estas funciones puede cambiar en futuras 5426 distribuciones de Maxima. 5427 5428 Véanse también 'gauss_b', 'dgauss_a' y 'gauss_b'. 5429 5430 -- Función: gauss_b (<a>, <b>, <c>, <x>) 5431 Véase también 'gauss_a'. 5432 5433 -- Función: dgauss_a (<a>, <b>, <c>, <x>) 5434 The derivative with respect to x of 'gauss_a(a,b,c,x)'. 5435 5436 -- Función: dgauss_b (<a>, <b>, <c>, <x>) 5437 Derivada de 'gauss_b(<a>,<b>,<c>,<x>)' respecto de <x>. 5438 5439 -- Función: kummer_m (<a>, <b>, <x>) 5440 5441 Función M de Kummer, tal como la definen Abramowitz y Stegun, 5442 Handbook of Mathematical Functions, Sección 13.1.2. 5443 5444 El único uso que se hace de esta función es en las soluciones de 5445 EDOs que devuelven 'odelin' y 'contrib_ode'. La definición y 5446 utilización de estas funciones puede cambiar en futuras 5447 distribuciones de Maxima. 5448 5449 Véanse también 'kummer_u', 'dkummer_m' y 'dkummer_u'. 5450 5451 -- Función: kummer_u (<a>, <b>, <x>) 5452 5453 Función U de Kummer, tal como la definen Abramowitz y Stegun, 5454 Handbook of Mathematical Functions, Sección 13.1.3. 5455 5456 Véase también 'kummer_m'. 5457 5458 -- Función: dkummer_m (<a>, <b>, <x>) 5459 Derivada de 'kummer_m(<a>,<b>,<x>)' respecto de <x>. 5460 5461 -- Función: dkummer_u (<a>, <b>, <x>) 5462 Derivada de 'kummer_u(<a>,<b>,<x>)' respecto de <x>. 5463 5464 5465File: maxima.info, Node: Posibles mejoras a contrib_ode, Next: Pruebas realizadas con contrib_ode, Prev: Funciones y variables para contrib_ode, Up: contrib_ode 5466 546743.3 Posibles mejoras a contrib_ode 5468=================================== 5469 5470Este paquete aún se encuentra en fase de desarrollo. Aspectos 5471pendientes: 5472 5473 * Extender el método FACTOR 'ode1_factor' para que trabaje con raíces 5474 múltiples. 5475 5476 * Extender el método FACTOR 'ode1_factor' para que intente resolver 5477 factores de orden superior. En este momento sólo intenta resolver 5478 factores lineales. 5479 5480 * Modificar la rutina LAGRANGE 'ode1_lagrange' para que prefiera 5481 raíces reales a las complejas. 5482 5483 * Añadir más métodos para las ecuaciones de RIccati. 5484 5485 * Mejorar la identificación de las ecuaciones de Abel de segunda 5486 especie. El procedimiento actual no es muy bueno. 5487 5488 * Trabajar la rutina del grupo simétrico de Lie 'ode1_lie'. Existen 5489 algunos problemas: algunas partes no están implementadas, algunos 5490 ejemplos no terminan de ejecutarse, otros producen errors, otros 5491 devuelven respuestas muy complejas. 5492 5493 * Hacer más pruebas. 5494 5495 5496File: maxima.info, Node: Pruebas realizadas con contrib_ode, Next: Referencias para contrib_ode, Prev: Posibles mejoras a contrib_ode, Up: contrib_ode 5497 549843.4 Pruebas realizadas con contrib_ode 5499======================================= 5500 5501Los procedimientos fueron probados con cerca de mil ecuaciones tomadas 5502de Murphy, Kamke, Zwillinger y otros. Éstas se encuentran en el 5503directorio de pruebas. 5504 5505 * La rutina de Clairault 'ode1_clairault' encuentra todas las 5506 soluciones conocidas, incluídas las singulares, de las ecuaciones 5507 de Clairault en Murphy y Kamke. 5508 5509 * Las otras rutinas a veces devuelven una sola solución cuando 5510 existen más. 5511 5512 * Algunas de las soluciones devueltas por 'ode1_lie' son demasiado 5513 complejas e imposibles de interpretar. 5514 5515 * A veces se producen detenciones imprevistas del procedimiento. 5516 5517 5518File: maxima.info, Node: Referencias para contrib_ode, Prev: Pruebas realizadas con contrib_ode, Up: contrib_ode 5519 552043.5 Referencias para contrib_ode 5521================================= 5522 5523 1. E. Kamke, Differentialgleichungen Losungsmethoden und Losungen, Vol 5524 1, Geest & Portig, Leipzig, 1961 5525 5526 2. G. M. Murphy, Ordinary Differential Equations and Their Solutions, 5527 Van Nostrand, New York, 1960 5528 5529 3. D. Zwillinger, Handbook of Differential Equations, 3rd edition, 5530 Academic Press, 1998 5531 5532 4. F. Schwarz, Symmetry Analysis of Abel's Equation, Studies in 5533 Applied Mathematics, 100:269-294 (1998) 5534 5535 5. F. Schwarz, Algorithmic Solution of Abel's Equation, Computing 61, 5536 39-49 (1998) 5537 5538 6. E. S. Cheb-Terrab, A. D. Roche, Symmetries and First Order ODE 5539 Patterns, Computer Physics Communications 113 (1998), p 239. 5540 (<http://lie.uwaterloo.ca/papers/ode_vii.pdf>) 5541 5542 7. E. S. Cheb-Terrab, T. Kolokolnikov, First Order ODEs, Symmetries 5543 and Linear Transformations, European Journal of Applied 5544 Mathematics, Vol. 14, No. 2, pp. 231-246 (2003). 5545 (<http://arxiv.org/abs/math-ph/0007023>, 5546 <http://lie.uwaterloo.ca/papers/ode_iv.pdf>) 5547 5548 8. G. W. Bluman, S. C. Anco, Symmetry and Integration Methods for 5549 Differential Equations, Springer, (2002) 5550 5551 9. M Bronstein, S Lafaille, Solutions of linear ordinary differential 5552 equations in terms of special functions, Proceedings of ISSAC 2002, 5553 Lille, ACM Press, 23-28. 5554 (<http://www-sop.inria.fr/cafe/Manuel.Bronstein/publications/issac2002.pdf>) 5555 5556 5557File: maxima.info, Node: descriptive, Next: diag, Prev: contrib_ode, Up: Top 5558 555944 descriptive 5560************** 5561 5562* Menu: 5563 5564* Introducción a descriptive:: 5565* Funciones y variables para el tratamiento de datos:: 5566* Funciones y variables de parámetros descriptivos:: 5567* Funciones y variables para gráficos estadísticos:: 5568 5569 5570File: maxima.info, Node: Introducción a descriptive, Next: Funciones y variables para el tratamiento de datos, Prev: descriptive, Up: descriptive 5571 557244.1 Introducción a descriptive 5573=============================== 5574 5575El paquete 'descriptive' contiene funciones para realizar cl'culos y 5576gráficos estadísticos descriptivos. Junto con el código fuente se 5577distribuyen tres conjuntos de datos: 'pidigits.data', 'wind.data' y 5578'biomed.data'. 5579 5580Cualquier manual de estadística se puede utilizar como referencia al 5581paquete 'descriptive'. 5582 5583Para comentarios, fallos y sugerencias, por favor contactar con 5584<'riotorto AT yahoo DOT com'>. 5585 5586Aquí un sencillo ejemplo sobre cómo operan las funciones de 5587'descriptive', dependiendo de la naturaleza de sus argumentos, listas o 5588matrices, 5589 5590 (%i1) load (descriptive)$ 5591 (%i2) /* muestra univariate */ mean ([a, b, c]); 5592 c + b + a 5593 (%o2) --------- 5594 3 5595 (%i3) matrix ([a, b], [c, d], [e, f]); 5596 [ a b ] 5597 [ ] 5598 (%o3) [ c d ] 5599 [ ] 5600 [ e f ] 5601 (%i4) /* muestra multivariante */ mean (%); 5602 e + c + a f + d + b 5603 (%o4) [---------, ---------] 5604 3 3 5605 5606Nótese que en las muestras multivariantes la media se calcula para cada 5607columna. 5608 5609En caso de varias muestras de diferente tamaño, la función 'map' de 5610Maxima puede utilizarse para obtener los resultados deseados para cada 5611muestra, 5612 5613 (%i1) load (descriptive)$ 5614 (%i2) map (mean, [[a, b, c], [d, e]]); 5615 c + b + a e + d 5616 (%o2) [---------, -----] 5617 3 2 5618 5619En este caso, dos muestras de tamaños 3 y 2 han sido almacenadas en una 5620lista. 5621 5622Muestras univariantes deben guardarse en listas como en 5623 5624 (%i1) s1 : [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]; 5625 (%o1) [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] 5626 5627y muestras multivariantes en matrices como las del siguiente ejemplo 5628 5629 (%i1) s2 : matrix ([13.17, 9.29], [14.71, 16.88], [18.50, 16.88], 5630 [10.58, 6.63], [13.33, 13.25], [13.21, 8.12]); 5631 [ 13.17 9.29 ] 5632 [ ] 5633 [ 14.71 16.88 ] 5634 [ ] 5635 [ 18.5 16.88 ] 5636 (%o1) [ ] 5637 [ 10.58 6.63 ] 5638 [ ] 5639 [ 13.33 13.25 ] 5640 [ ] 5641 [ 13.21 8.12 ] 5642 5643En este caso, el número de columnas es igual al de la dimensión de la 5644variable aleatoria y el número de filas coincide con el tamaño muestral. 5645 5646Los datos pueden suministrarse manualmente, pero las muestras grandes se 5647suelen almacenar en ficheros de texto. Por ejemplo, el fichero 5648'pidigits.data' contiene los 100 primeros dígitos del número '%pi': 5649 3 5650 1 5651 4 5652 1 5653 5 5654 9 5655 2 5656 6 5657 5 5658 3 ... 5659 5660A fin de leer estos dígitos desde Maxima, 5661 5662 (%i1) s1 : read_list (file_search ("pidigits.data"))$ 5663 (%i2) length (s1); 5664 (%o2) 100 5665 5666Por otro lado, el archivo 'wind.data' contiene los promedios diarios de 5667la velocidad del viento en cinco estaciones meteorológicas en Irlanda 5668(esta muestra es parte de un conjunto de datos correspondientes a 12 5669estaciones meteorológicas. El fichero original se puede descargar 5670libremente del 'StatLib Data Repository' y se analiza en Haslett, J., 5671Raftery, A. E. (1989) <Space-time Modelling with Long-memory Dependence: 5672Assessing Ireland's Wind Power Resource, with Discussion>. Applied 5673Statistics 38, 1-50). Así se leen los datos: 5674 5675 (%i1) s2 : read_matrix (file_search ("wind.data"))$ 5676 (%i2) length (s2); 5677 (%o2) 100 5678 (%i3) s2 [%]; /* last record */ 5679 (%o3) [3.58, 6.0, 4.58, 7.62, 11.25] 5680 5681Algunas muestras contienen datos no numéricos. Como ejemplo, el archivo 5682'biomed.data' (el cual es parte de otro mayor descargado también del 5683'StatLib Data Repository') contiene cuatro mediciones sanguíneas tomadas 5684a dos grupos de pacientes, 'A' y 'B', de diferentes edades, 5685 5686 (%i1) s3 : read_matrix (file_search ("biomed.data"))$ 5687 (%i2) length (s3); 5688 (%o2) 100 5689 (%i3) s3 [1]; /* first record */ 5690 (%o3) [A, 30, 167.0, 89.0, 25.6, 364] 5691 5692El primer individuo pertenece al grupo 'A', tiene 30 años de edad y sus 5693medidas sanguíneas fueron 167.0, 89.0, 25.6 y 364. 5694 5695Debe tenerse cuidado cuando se trabaje con datos categóricos. En el 5696siguiente ejemplo, se asigna al símbolo 'a' cierto valor en algún 5697momento previo y luego se toma una muestra con el valor categórico 'a', 5698 5699 (%i1) a : 1$ 5700 (%i2) matrix ([a, 3], [b, 5]); 5701 [ 1 3 ] 5702 (%o2) [ ] 5703 [ b 5 ] 5704 5705 5706File: maxima.info, Node: Funciones y variables para el tratamiento de datos, Next: Funciones y variables de parámetros descriptivos, Prev: Introducción a descriptive, Up: descriptive 5707 570844.2 Funciones y variables para el tratamiento de datos 5709======================================================= 5710 5711 -- Función: build_sample (<list>) 5712 -- Función: build_sample (<matrix>) 5713 Construye una muestra a partir de una tabla de frecuencias 5714 absolutas. La tabla de entrada puede ser una una matriz o una 5715 lista de listas, todas ellas de igual tamaño. El número de 5716 columnas o la longitud de las listas debe ser mayor que la unidad. 5717 El último elemento de cada fila o lista se interpreta como la 5718 frecuencia absoluta. El resultado se devuelve siempre en formato 5719 de matriz. 5720 5721 Ejemplos: 5722 5723 Tabla de frecuencias univariante. 5724 5725 (%i1) load (descriptive)$ 5726 (%i2) sam1: build_sample([[6,1], [j,2], [2,1]]); 5727 [ 6 ] 5728 [ ] 5729 [ j ] 5730 (%o2) [ ] 5731 [ j ] 5732 [ ] 5733 [ 2 ] 5734 (%i3) mean(sam1); 5735 2 j + 8 5736 (%o3) [-------] 5737 4 5738 (%i4) barsplot(sam1) $ 5739 5740 Tabla de frecuencias multivariante. 5741 5742 (%i1) load (descriptive)$ 5743 (%i2) sam2: build_sample([[6,3,1], [5,6,2], [u,2,1],[6,8,2]]) ; 5744 [ 6 3 ] 5745 [ ] 5746 [ 5 6 ] 5747 [ ] 5748 [ 5 6 ] 5749 (%o2) [ ] 5750 [ u 2 ] 5751 [ ] 5752 [ 6 8 ] 5753 [ ] 5754 [ 6 8 ] 5755 (%i3) cov(sam2); 5756 [ 2 2 ] 5757 [ u + 158 (u + 28) 2 u + 174 11 (u + 28) ] 5758 [ -------- - --------- --------- - ----------- ] 5759 (%o3) [ 6 36 6 12 ] 5760 [ ] 5761 [ 2 u + 174 11 (u + 28) 21 ] 5762 [ --------- - ----------- -- ] 5763 [ 6 12 4 ] 5764 (%i4) barsplot(sam2, grouping=stacked) $ 5765 5766 -- Función: continuous_freq (<list>) 5767 -- Función: continuous_freq (<list>, <m>) 5768 El argumento de 'continuous_freq' debe ser una lista de números. 5769 Divide el rango en intervalos y cuenta cuántos valores hay en 5770 ellos. El segundo argumento es opcional y puede ser el número de 5771 clases deseado, 10 por defecto, o una lista que contenga los 5772 límites de las clases y el número de éstas, o una lista que 5773 contenga únicamente los límites. Si los valores muestrales son 5774 todos iguales, esta función devuelve solamente una clase de 5775 amplitud 2. 5776 5777 Ejemplos: 5778 5779 El argumento opcional indica el número de clases deseadas. La 5780 primera lista de la respuesta contiene los límites de los 5781 intervalos y la segunda los totales correspondientes: hay 16 5782 dígitos en el intervalo '[0, 1.8]', 24 en '(1.8, 3.6]' y así 5783 sucesivamente. 5784 5785 (%i1) load (descriptive)$ 5786 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 5787 (%i3) continuous_freq (s1, 5); 5788 (%o3) [[0, 1.8, 3.6, 5.4, 7.2, 9.0], [16, 24, 18, 17, 25]] 5789 5790 El argumento opcional indica que queremos 7 clases con límites -2 y 5791 12: 5792 5793 (%i1) load (descriptive)$ 5794 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 5795 (%i3) continuous_freq (s1, [-2,12,7]); 5796 (%o3) [[- 2, 0, 2, 4, 6, 8, 10, 12], [8, 20, 22, 17, 20, 13, 0]] 5797 5798 El argumento opcional indica que queremos el número por defecto de 5799 clases y límites -2 y 12: 5800 5801 (%i1) load (descriptive)$ 5802 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 5803 (%i3) continuous_freq (s1, [-2,12]); 5804 3 4 11 18 32 39 46 53 5805 (%o3) [[- 2, - -, -, --, --, 5, --, --, --, --, 12], 5806 5 5 5 5 5 5 5 5 5807 [0, 8, 20, 12, 18, 9, 8, 25, 0, 0]] 5808 5809 -- Función: discrete_freq (<list>) 5810 Calcula las frecuencias absolutas en muestras discretas, tanto 5811 numéricas como categóricas. Su único argumento debe ser una lista. 5812 5813 (%i1) load (descriptive)$ 5814 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 5815 (%i3) discrete_freq (s1); 5816 (%o3) [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 5817 [8, 8, 12, 12, 10, 8, 9, 8, 12, 13]] 5818 5819 La primera lista son los valores de la muestra y la segunda sus 5820 frecuencias absolutas. Las instrucciones '? col' y '? transpose' 5821 pueden ayudar a comprender la última entrada. 5822 5823 -- Función: standardize (<list>) 5824 -- Función: standardize (<matrix>) 5825 5826 Resta a cada elemento de la lista la media muestral y luego divide 5827 el resultado por la desviación típica. Si la entrada es una 5828 matriz, 'standardize' resta a cada fila la media multivariante y 5829 luego divide cada componente por la desviación típica 5830 correspondiente. 5831 5832 -- Función: subsample (<data_matrix>, <predicate_function>) 5833 -- Función: subsample (<data_matrix>, <predicate_function>, <col_num>, 5834 <col_num>, ...) 5835 Esta es una variante de la función 'submatrix' de Maxima. El 5836 primer argumento es una matriz de datos, el segundo es una función 5837 de predicado y el resto de argumentos opcionales son los números de 5838 las columnas a tomar en consideración. 5839 5840 Estos son los registros multivariantes en los que la velocidad del 5841 viento en la primera estación meteorológica fue menor de 18 nudos. 5842 Véase cómo en la expresión lambda la <i>-ésima componente se la 5843 referencia como 'v[i]'. 5844 (%i1) load (descriptive)$ 5845 (%i2) s2 : read_matrix (file_search ("wind.data"))$ 5846 (%i3) subsample (s2, lambda([v], v[1] > 18)); 5847 [ 19.38 15.37 15.12 23.09 25.25 ] 5848 [ ] 5849 [ 18.29 18.66 19.08 26.08 27.63 ] 5850 (%o3) [ ] 5851 [ 20.25 21.46 19.95 27.71 23.38 ] 5852 [ ] 5853 [ 18.79 18.96 14.46 26.38 21.84 ] 5854 5855 En el siguiente ejemplo, se solicitan únicamente la primera, 5856 segunda y quinta componentes de aquellos registros con velocidades 5857 del viento mayores o iguales que 16 nudos en la estación número 1 y 5858 menores que 25 nudos en la estación número 4. La muestra sólo 5859 contiene los datos referidos a las estaciones 1, 2 y 5. En este 5860 caso, la función de predicado se define por medio de una función de 5861 Maxima ordinaria. 5862 (%i1) load (descriptive)$ 5863 (%i2) s2 : read_matrix (file_search ("wind.data"))$ 5864 (%i3) g(x):= x[1] >= 16 and x[4] < 25$ 5865 (%i4) subsample (s2, g, 1, 2, 5); 5866 [ 19.38 15.37 25.25 ] 5867 [ ] 5868 [ 17.33 14.67 19.58 ] 5869 (%o4) [ ] 5870 [ 16.92 13.21 21.21 ] 5871 [ ] 5872 [ 17.25 18.46 23.87 ] 5873 5874 He aquí un ejemplo con las variables categóricas de 'biomed.data'. 5875 Se piden los registros correspondientes a aquellos pacientes del 5876 grupo 'B' mayores de 38 anños, 5877 (%i1) load (descriptive)$ 5878 (%i2) s3 : read_matrix (file_search ("biomed.data"))$ 5879 (%i3) h(u):= u[1] = B and u[2] > 38 $ 5880 (%i4) subsample (s3, h); 5881 [ B 39 28.0 102.3 17.1 146 ] 5882 [ ] 5883 [ B 39 21.0 92.4 10.3 197 ] 5884 [ ] 5885 [ B 39 23.0 111.5 10.0 133 ] 5886 [ ] 5887 [ B 39 26.0 92.6 12.3 196 ] 5888 (%o4) [ ] 5889 [ B 39 25.0 98.7 10.0 174 ] 5890 [ ] 5891 [ B 39 21.0 93.2 5.9 181 ] 5892 [ ] 5893 [ B 39 18.0 95.0 11.3 66 ] 5894 [ ] 5895 [ B 39 39.0 88.5 7.6 168 ] 5896 5897 Es probable que el análisis estadístico requiera únicamente de las 5898 medidas sanguíneas. 5899 (%i1) load (descriptive)$ 5900 (%i2) s3 : read_matrix (file_search ("biomed.data"))$ 5901 (%i3) subsample (s3, lambda([v], v[1] = B and v[2] > 38), 5902 3, 4, 5, 6); 5903 [ 28.0 102.3 17.1 146 ] 5904 [ ] 5905 [ 21.0 92.4 10.3 197 ] 5906 [ ] 5907 [ 23.0 111.5 10.0 133 ] 5908 [ ] 5909 [ 26.0 92.6 12.3 196 ] 5910 (%o3) [ ] 5911 [ 25.0 98.7 10.0 174 ] 5912 [ ] 5913 [ 21.0 93.2 5.9 181 ] 5914 [ ] 5915 [ 18.0 95.0 11.3 66 ] 5916 [ ] 5917 [ 39.0 88.5 7.6 168 ] 5918 5919 Esta es la media multivariante de 's3'. 5920 (%i1) load (descriptive)$ 5921 (%i2) s3 : read_matrix (file_search ("biomed.data"))$ 5922 (%i3) mean (s3); 5923 65 B + 35 A 317 6 NA + 8145.0 5924 (%o3) [-----------, ---, 87.178, -------------, 18.123, 5925 100 10 100 5926 3 NA + 19587 5927 ------------] 5928 100 5929 5930 Aquí la primera componente carece de significado, ya que tanto 'A' 5931 como 'B' son categóricas, la segunda componente es la edad media de 5932 los individuos en forma racional, al tiempo que los valores cuarto 5933 y quinto muestran cierto comportamiento extraño; lo cual se debe a 5934 que el símbolo 'NA' se utiliza para indicar datos no disponibles, 5935 por lo que ambas medias no tienen sentido. Una posible solución 5936 puede ser extraer de la matriz aquellas filas con símbolos 'NA', lo 5937 que acarrearía cierta pérdida de información. 5938 (%i1) load (descriptive)$ 5939 (%i2) s3 : read_matrix (file_search ("biomed.data"))$ 5940 (%i3) g(v):= v[4] # NA and v[6] # NA $ 5941 (%i4) mean (subsample (s3, g, 3, 4, 5, 6)); 5942 (%o4) [79.4923076923077, 86.2032967032967, 16.93186813186813, 5943 2514 5944 ----] 5945 13 5946 5947 -- Función: transform_sample (<matriz>, <varlist>, <exprlist>) 5948 5949 Transforma la <matriz> de datos, en la que a cada columna se le 5950 asigna un nombre de acuerdo con la lista <varlist>, según las 5951 expresiones de <exprlist>. 5952 5953 Ejemplos: 5954 5955 El segundo argumento asigna nombres a las tres columnas, con ellos 5956 la lista de expresiones define la transformación de la muestra. 5957 5958 (%i1) load (descriptive)$ 5959 (%i2) data: matrix([3,2,7],[3,7,2],[8,2,4],[5,2,4]) $ 5960 (%i3) transform_sample(data, [a,b,c], [c, a*b, log(a)]); 5961 [ 7 6 log(3) ] 5962 [ ] 5963 [ 2 21 log(3) ] 5964 (%o3) [ ] 5965 [ 4 16 log(8) ] 5966 [ ] 5967 [ 4 10 log(5) ] 5968 5969 Añade una columna constante y elimina la tercera variable. 5970 5971 (%i1) load (descriptive)$ 5972 (%i2) data: matrix([3,2,7],[3,7,2],[8,2,4],[5,2,4]) $ 5973 (%i3) transform_sample(data, [a,b,c], [makelist(1,k,length(data)),a,b]); 5974 [ 1 3 2 ] 5975 [ ] 5976 [ 1 3 7 ] 5977 (%o3) [ ] 5978 [ 1 8 2 ] 5979 [ ] 5980 [ 1 5 2 ] 5981 5982 5983File: maxima.info, Node: Funciones y variables de parámetros descriptivos, Next: Funciones y variables para gráficos estadísticos, Prev: Funciones y variables para el tratamiento de datos, Up: descriptive 5984 598544.3 Funciones y variables de parámetros descriptivos 5986===================================================== 5987 5988 -- Función: mean (<list>) 5989 -- Función: mean (<matrix>) 5990 Es la media muestral, definida como 5991 n 5992 ==== 5993 _ 1 \ 5994 x = - > x 5995 n / i 5996 ==== 5997 i = 1 5998 5999 Ejemplo: 6000 6001 (%i1) load (descriptive)$ 6002 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6003 (%i3) mean (s1); 6004 471 6005 (%o3) --- 6006 100 6007 (%i4) %, numer; 6008 (%o4) 4.71 6009 (%i5) s2 : read_matrix (file_search ("wind.data"))$ 6010 (%i6) mean (s2); 6011 (%o6) [9.9485, 10.1607, 10.8685, 15.7166, 14.8441] 6012 6013 -- Función: var (<list>) 6014 -- Función: var (<matrix>) 6015 Es la varianza muestral, definida como 6016 n 6017 ==== 6018 2 1 \ _ 2 6019 s = - > (x - x) 6020 n / i 6021 ==== 6022 i = 1 6023 6024 Ejemplo: 6025 6026 (%i1) load (descriptive)$ 6027 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6028 (%i3) var (s1), numer; 6029 (%o3) 8.425899999999999 6030 6031 Véase también 'var1'. 6032 6033 -- Función: var1 (<list>) 6034 -- Función: var1 (<matrix>) 6035 Es la cuasivarianza muestral, definida como 6036 n 6037 ==== 6038 1 \ _ 2 6039 --- > (x - x) 6040 n-1 / i 6041 ==== 6042 i = 1 6043 6044 Ejemplo: 6045 6046 (%i1) load (descriptive)$ 6047 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6048 (%i3) var1 (s1), numer; 6049 (%o3) 8.5110101010101 6050 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6051 (%i5) var1 (s2); 6052 (%o5) [17.39586540404041, 15.13912778787879, 15.63204924242424, 6053 32.50152569696971, 24.66977392929294] 6054 6055 Véase también 'var'. 6056 6057 -- Función: std (<list>) 6058 -- Función: std (<matrix>) 6059 Es la desviación típica muestral, raíz cuadrada de 'var'. 6060 6061 Ejemplo: 6062 6063 (%i1) load (descriptive)$ 6064 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6065 (%i3) std (s1), numer; 6066 (%o3) 2.902740084816414 6067 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6068 (%i5) std (s2); 6069 (%o5) [4.149928523480858, 3.871399812729241, 3.933920277534866, 6070 5.672434260526957, 4.941970881136392] 6071 6072 Véanse también 'var' y 'std1'. 6073 6074 -- Función: std1 (<list>) 6075 -- Función: std1 (<matrix>) 6076 Es la cuasidesviación típica muestral, raíz cuadrada de 'var1'. 6077 6078 Ejemplo: 6079 6080 (%i1) load (descriptive)$ 6081 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6082 (%i3) std1 (s1), numer; 6083 (%o3) 2.917363553109228 6084 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6085 (%i5) std1 (s2); 6086 (%o5) [4.17083509672109, 3.89090320978032, 3.953738641137555, 6087 5.701010936401517, 4.966867617451963] 6088 6089 Véanse también 'var1' y 'std'. 6090 6091 -- Función: noncentral_moment (<list>, <k>) 6092 -- Función: noncentral_moment (<matrix>, <k>) 6093 Es el momento no central de orden k, definido como 6094 n 6095 ==== 6096 1 \ k 6097 - > x 6098 n / i 6099 ==== 6100 i = 1 6101 6102 Ejemplo: 6103 6104 (%i1) load (descriptive)$ 6105 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6106 (%i3) noncentral_moment (s1, 1), numer; /* the mean */ 6107 (%o3) 4.71 6108 (%i5) s2 : read_matrix (file_search ("wind.data"))$ 6109 (%o5) [319793.8724761506, 320532.1923892463, 391249.5621381556, 6110 2502278.205988911, 1691881.797742255] 6111 (%i6) noncentral_moment (s2, 5); 6112 6113 Véase también 'central_moment'. 6114 6115 -- Función: central_moment (<list>, <k>) 6116 -- Función: central_moment (<matrix>, <k>) 6117 Es el momento central de orden k, definido como 6118 n 6119 ==== 6120 1 \ _ k 6121 - > (x - x) 6122 n / i 6123 ==== 6124 i = 1 6125 6126 Ejemplo: 6127 6128 (%i1) load (descriptive)$ 6129 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6130 (%i3) central_moment (s1, 2), numer; /* the variance */ 6131 (%o3) 8.425899999999999 6132 (%i5) s2 : read_matrix (file_search ("wind.data"))$ 6133 (%o5) [11.29584771375004, 16.97988248298583, 5.626661952750102, 6134 37.5986572057918, 25.85981904394192] 6135 (%i6) central_moment (s2, 3); 6136 6137 Véanse también 'central_moment' y 'mean'. 6138 6139 -- Función: cv (<list>) 6140 -- Función: cv (<matrix>) 6141 Es el coeficiente de variación, o cociente entre la desviación 6142 típica muestral ('std') y la media ('mean'), 6143 6144 (%i1) load (descriptive)$ 6145 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6146 (%i3) cv (s1), numer; 6147 (%o3) .6193977819764815 6148 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6149 (%i5) cv (s2); 6150 (%o5) [.4192426091090204, .3829365309260502, 0.363779605385983, 6151 .3627381836021478, .3346021393989506] 6152 6153 Véanse también 'std' y 'mean'. 6154 6155 -- Función: smin (<list>) 6156 -- Función: smin (<matrix>) 6157 Es el valor mínimo de la muestra <list>. Cuando el argumento es 6158 una matriz, 'smin' devuelve una lista con los valores mínimos de 6159 las columnas, las cuales están asociadas a variables estadísticas. 6160 6161 (%i1) load (descriptive)$ 6162 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6163 (%i3) smin (s1); 6164 (%o3) 0 6165 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6166 (%i5) smin (s2); 6167 (%o5) [0.58, 0.5, 2.67, 5.25, 5.17] 6168 6169 Véase también 'smax'. 6170 6171 -- Función: smax (<list>) 6172 -- Función: smax (<matrix>) 6173 Es el valor máximo de la muestra <list>. Cuando el argumento es 6174 una matriz, 'smax' devuelve una lista con los valores máximos de 6175 las columnas, las cuales están asociadas a variables estadísticas. 6176 6177 (%i1) load (descriptive)$ 6178 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6179 (%i3) smax (s1); 6180 (%o3) 9 6181 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6182 (%i5) smax (s2); 6183 (%o5) [20.25, 21.46, 20.04, 29.63, 27.63] 6184 6185 Véase también 'smin'. 6186 6187 -- Función: range (<list>) 6188 -- Función: range (<matrix>) 6189 Es la diferencia entre los valores extremos. 6190 6191 Ejemplo: 6192 6193 (%i1) load (descriptive)$ 6194 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6195 (%i3) range (s1); 6196 (%o3) 9 6197 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6198 (%i5) range (s2); 6199 (%o5) [19.67, 20.96, 17.37, 24.38, 22.46] 6200 6201 -- Función: quantile (<list>, <p>) 6202 -- Función: quantile (<matrix>, <p>) 6203 Es el <p>-cuantil, siendo <p> un número del intervalo [0, 1], de la 6204 muestra <list>. Aunque existen varias definiciones para el cuantil 6205 muestral (Hyndman, R. J., Fan, Y. (1996) <Sample quantiles in 6206 statistical packages>. American Statistician, 50, 361-365), la 6207 programada en el paquete 'descriptive' es la basada en la 6208 interpolación lineal. 6209 6210 Ejemplo: 6211 6212 (%i1) load (descriptive)$ 6213 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6214 (%i3) /* 1st and 3rd quartiles */ 6215 [quantile (s1, 1/4), quantile (s1, 3/4)], numer; 6216 (%o3) [2.0, 7.25] 6217 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6218 (%i5) quantile (s2, 1/4); 6219 (%o5) [7.2575, 7.477500000000001, 7.82, 11.28, 11.48] 6220 6221 -- Función: median (<list>) 6222 -- Función: median (<matrix>) 6223 Una vez ordenada una muestra, si el tamaño muestral es impar la 6224 mediana es el valor central, en caso contrario será la media de los 6225 dos valores centrales. 6226 6227 Ejemplo: 6228 6229 (%i1) load (descriptive)$ 6230 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6231 (%i3) median (s1); 6232 9 6233 (%o3) - 6234 2 6235 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6236 (%i5) median (s2); 6237 (%o5) [10.06, 9.855, 10.73, 15.48, 14.105] 6238 6239 La mediana es el cuantil 1/2. 6240 6241 Véase también 'quantile'. 6242 6243 -- Función: qrange (<list>) 6244 -- Función: qrange (<matrix>) 6245 El rango intercuartílico es la diferencia entre el tercer y primer 6246 cuartil, 'quantile(<list>,3/4) - quantile(<list>,1/4)', 6247 6248 (%i1) load (descriptive)$ 6249 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6250 (%i3) qrange (s1); 6251 21 6252 (%o3) -- 6253 4 6254 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6255 (%i5) qrange (s2); 6256 (%o5) [5.385, 5.572499999999998, 6.0225, 8.729999999999999, 6257 6.650000000000002] 6258 6259 Véase también 'quantile'. 6260 6261 -- Función: mean_deviation (<list>) 6262 -- Función: mean_deviation (<matrix>) 6263 Es la desviación media, definida como 6264 n 6265 ==== 6266 1 \ _ 6267 - > |x - x| 6268 n / i 6269 ==== 6270 i = 1 6271 6272 Ejemplo: 6273 6274 (%i1) load (descriptive)$ 6275 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6276 (%i3) mean_deviation (s1); 6277 51 6278 (%o3) -- 6279 20 6280 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6281 (%i5) mean_deviation (s2); 6282 (%o5) [3.287959999999999, 3.075342, 3.23907, 4.715664000000001, 6283 4.028546000000002] 6284 6285 Véase también 'mean'. 6286 6287 -- Función: median_deviation (<list>) 6288 -- Función: median_deviation (<matrix>) 6289 Es la desviación mediana, definida como 6290 n 6291 ==== 6292 1 \ 6293 - > |x - med| 6294 n / i 6295 ==== 6296 i = 1 6297 6298 siendo 'med' la mediana de <list>. 6299 6300 Ejemplo: 6301 6302 (%i1) load (descriptive)$ 6303 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6304 (%i3) median_deviation (s1); 6305 5 6306 (%o3) - 6307 2 6308 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6309 (%i5) median_deviation (s2); 6310 (%o5) [2.75, 2.755, 3.08, 4.315, 3.31] 6311 6312 Véase también 'mean'. 6313 6314 -- Función: harmonic_mean (<list>) 6315 -- Función: harmonic_mean (<matrix>) 6316 Es la media armónica, definida como 6317 n 6318 -------- 6319 n 6320 ==== 6321 \ 1 6322 > -- 6323 / x 6324 ==== i 6325 i = 1 6326 6327 Ejemplo: 6328 6329 (%i1) load (descriptive)$ 6330 (%i2) y : [5, 7, 2, 5, 9, 5, 6, 4, 9, 2, 4, 2, 5]$ 6331 (%i3) harmonic_mean (y), numer; 6332 (%o3) 3.901858027632205 6333 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6334 (%i5) harmonic_mean (s2); 6335 (%o5) [6.948015590052786, 7.391967752360356, 9.055658197151745, 6336 13.44199028193692, 13.01439145898509] 6337 6338 Véanse también 'mean' y 'geometric_mean'. 6339 6340 -- Función: geometric_mean (<list>) 6341 -- Función: geometric_mean (<matrix>) 6342 Es la media geométrica, definida como 6343 / n \ 1/n 6344 | /===\ | 6345 | ! ! | 6346 | ! ! x | 6347 | ! ! i| 6348 | i = 1 | 6349 \ / 6350 6351 Ejemplo: 6352 6353 (%i1) load (descriptive)$ 6354 (%i2) y : [5, 7, 2, 5, 9, 5, 6, 4, 9, 2, 4, 2, 5]$ 6355 (%i3) geometric_mean (y), numer; 6356 (%o3) 4.454845412337012 6357 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6358 (%i5) geometric_mean (s2); 6359 (%o5) [8.82476274347979, 9.22652604739361, 10.0442675714889, 6360 14.61274126349021, 13.96184163444275] 6361 6362 Véanse también 'mean' y 'harmonic_mean'. 6363 6364 -- Función: kurtosis (<list>) 6365 -- Función: kurtosis (<matrix>) 6366 Es el coeficiente de curtosis, definido como 6367 n 6368 ==== 6369 1 \ _ 4 6370 ---- > (x - x) - 3 6371 4 / i 6372 n s ==== 6373 i = 1 6374 6375 Ejemplo: 6376 6377 (%i1) load (descriptive)$ 6378 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6379 (%i3) kurtosis (s1), numer; 6380 (%o3) - 1.273247946514421 6381 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6382 (%i5) kurtosis (s2); 6383 (%o5) [- .2715445622195385, 0.119998784429451, 6384 - .4275233490482866, - .6405361979019522, - .4952382132352935] 6385 6386 Véanse también 'mean', 'var' y 'skewness'. 6387 6388 -- Función: skewness (<list>) 6389 -- Función: skewness (<matrix>) 6390 Es el coeficiente de asimetría, definido como 6391 n 6392 ==== 6393 1 \ _ 3 6394 ---- > (x - x) 6395 3 / i 6396 n s ==== 6397 i = 1 6398 6399 Ejemplo: 6400 6401 (%i1) load (descriptive)$ 6402 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6403 (%i3) skewness (s1), numer; 6404 (%o3) .009196180476450306 6405 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6406 (%i5) skewness (s2); 6407 (%o5) [.1580509020000979, .2926379232061854, .09242174416107717, 6408 .2059984348148687, .2142520248890832] 6409 6410 Véanse también 'mean', 'var' y 'kurtosis'. 6411 6412 -- Función: pearson_skewness (<list>) 6413 -- Función: pearson_skewness (<matrix>) 6414 Es el coeficiente de asimetría de Pearson, definido como 6415 _ 6416 3 (x - med) 6417 ----------- 6418 s 6419 6420 siendo <med> la mediana de <list>. 6421 6422 Ejemplo: 6423 6424 (%i1) load (descriptive)$ 6425 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6426 (%i3) pearson_skewness (s1), numer; 6427 (%o3) .2159484029093895 6428 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6429 (%i5) pearson_skewness (s2); 6430 (%o5) [- .08019976629211892, .2357036272952649, 6431 .1050904062491204, .1245042340592368, .4464181795804519] 6432 6433 Véanse también 'mean', 'var' y 'median'. 6434 6435 -- Función: quartile_skewness (<list>) 6436 -- Función: quartile_skewness (<matrix>) 6437 Es el coeficiente de asimetría cuartílico, definido como 6438 c - 2 c + c 6439 3/4 1/2 1/4 6440 -------------------- 6441 c - c 6442 3/4 1/4 6443 6444 siendo c_p el <p>-cuantil de la muestra <list>. 6445 6446 Ejemplo: 6447 6448 (%i1) load (descriptive)$ 6449 (%i2) s1 : read_list (file_search ("pidigits.data"))$ 6450 (%i3) quartile_skewness (s1), numer; 6451 (%o3) .04761904761904762 6452 (%i4) s2 : read_matrix (file_search ("wind.data"))$ 6453 (%i5) quartile_skewness (s2); 6454 (%o5) [- 0.0408542246982353, .1467025572005382, 6455 0.0336239103362392, .03780068728522298, 0.210526315789474] 6456 6457 Véase también 'quantile'. 6458 6459 -- Función: km (<list>, <option> ...) 6460 -- Función: km (<matrix>, <option> ...) 6461 6462 Estimador Kaplan-Meier de la función de supervivencia o fiabilidad 6463 S(x)=1-F(x). 6464 6465 Los datos se pueden introducir como una lista de pares de números o 6466 como una matriz de dos columnas. La primera componente es el 6467 tiempo observado y la segunda componente es el índice de censura (1 6468 = no censurado, 0 = censurado por la derecha). 6469 6470 El argumento opcional es el nombre de la variable en la expresión 6471 devuelta, la cual es <x> por defecto. 6472 6473 Ejemplos: 6474 6475 Muestra como una lista de pares. 6476 6477 (%i1) load (descriptive)$ 6478 (%i2) S: km([[2,1], [3,1], [5,0], [8,1]]); 6479 charfun((3 <= x) and (x < 8)) 6480 (%o2) charfun(x < 0) + ----------------------------- 6481 2 6482 3 charfun((2 <= x) and (x < 3)) 6483 + ------------------------------- 6484 4 6485 + charfun((0 <= x) and (x < 2)) 6486 (%i3) load (draw)$ 6487 (%i4) draw2d( 6488 line_width = 3, grid = true, 6489 explicit(S, x, -0.1, 10))$ 6490 6491 Estimación de probabilidades de supervivencia. 6492 6493 (%i1) load (descriptive)$ 6494 (%i2) S(t):= ''(km([[2,1], [3,1], [5,0], [8,1]], t)) $ 6495 (%i3) S(6); 6496 1 6497 (%o3) - 6498 2 6499 6500 -- Función: cdf_empirical (<list>, <option> ...) 6501 -- Función: cdf_empirical (<matrix>, <option> ...) 6502 6503 Función de distribución empírica F(x). 6504 6505 Los datos se pueden introducir como una lista de números o como una 6506 matriz columna. 6507 6508 El argumento opcional es el nombre de la variable en la expresión 6509 devuelta, la cual es <x> por defecto. 6510 6511 Ejemplo: 6512 6513 Función de distribución empírica. 6514 6515 (%i1) load (descriptive)$ 6516 (%i2) F(x):= ''(cdf_empirical([1,3,3,5,7,7,7,8,9])); 6517 (%o2) F(x) := (charfun(x >= 9) + charfun(x >= 8) 6518 + 3 charfun(x >= 7) + charfun(x >= 5) 6519 + 2 charfun(x >= 3) + charfun(x >= 1))/9 6520 (%i3) F(6); 6521 4 6522 (%o3) - 6523 9 6524 (%i4) load(draw)$ 6525 (%i5) draw2d( 6526 line_width = 3, 6527 grid = true, 6528 explicit(F(z), z, -2, 12)) $ 6529 6530 -- Función: cov (<matrix>) 6531 Es la matriz de covarianzas de una muestra multivariante, definida 6532 como 6533 n 6534 ==== 6535 1 \ _ _ 6536 S = - > (X - X) (X - X)' 6537 n / j j 6538 ==== 6539 j = 1 6540 6541 siendo X_j la j-ésima fila de la matriz muestral. 6542 6543 Ejemplo: 6544 6545 (%i1) load (descriptive)$ 6546 (%i2) s2 : read_matrix (file_search ("wind.data"))$ 6547 (%i3) fpprintprec : 7$ /* change precision for pretty output */ 6548 [ 17.22191 13.61811 14.37217 19.39624 15.42162 ] 6549 [ ] 6550 [ 13.61811 14.98774 13.30448 15.15834 14.9711 ] 6551 [ ] 6552 (%o4) [ 14.37217 13.30448 15.47573 17.32544 16.18171 ] 6553 [ ] 6554 [ 19.39624 15.15834 17.32544 32.17651 20.44685 ] 6555 [ ] 6556 [ 15.42162 14.9711 16.18171 20.44685 24.42308 ] 6557 (%i5) cov (s2); 6558 6559 Véase también 'cov1'. 6560 6561 -- Función: cov1 (<matrix>) 6562 Es la matriz de cuasivarianzas de una muestra multivariante, 6563 definida como 6564 n 6565 ==== 6566 1 \ _ _ 6567 S = --- > (X - X) (X - X)' 6568 1 n-1 / j j 6569 ==== 6570 j = 1 6571 6572 siendo X_j la j-ésima fila de la matriz muestral. 6573 6574 Ejemplo: 6575 6576 (%i1) load (descriptive)$ 6577 (%i2) s2 : read_matrix (file_search ("wind.data"))$ 6578 (%i3) fpprintprec : 7$ /* change precision for pretty output */ 6579 [ 17.39587 13.75567 14.51734 19.59216 15.5774 ] 6580 [ ] 6581 [ 13.75567 15.13913 13.43887 15.31145 15.12232 ] 6582 [ ] 6583 (%o4) [ 14.51734 13.43887 15.63205 17.50044 16.34516 ] 6584 [ ] 6585 [ 19.59216 15.31145 17.50044 32.50153 20.65338 ] 6586 [ ] 6587 [ 15.5774 15.12232 16.34516 20.65338 24.66977 ] 6588 (%i5) cov1 (s2); 6589 6590 Véase también 'cov'. 6591 6592 -- Función: global_variances (<matrix>) 6593 -- Función: global_variances (<matrix>, <options> ...) 6594 La función 'global_variances' devuelve una lista de medidas 6595 globales de variabilidad: 6596 6597 * <varianza total>: 'trace(S_1)', 6598 * <varianza media>: 'trace(S_1)/p', 6599 * <varianza generalizada>: 'determinant(S_1)', 6600 * <desviación típica generalizada>: 'sqrt(determinant(S_1))', 6601 * <varianza efectiva> 'determinant(S_1)^(1/p)', (definida en: 6602 Peña, D. (2002) <Análisis de datos multivariantes>; 6603 McGraw-Hill, Madrid.) 6604 * <desviación típica efectiva>: 'determinant(S_1)^(1/(2*p))'. 6605 donde <p> es la dimensión de la variable aleatoria multivariante y 6606 S_1 la matriz de covarianzas devuelta por la función 'cov1'. 6607 6608 Opción: 6609 6610 * ''data', por defecto ''true', indica si la matriz de entrada 6611 contiene los datos muestrales, en cuyo caso la matriz de 6612 covarianzas 'cov1' debe ser calculada; en caso contrario, se 6613 le debe pasar ésta a la función como matriz simétrica en lugar 6614 de los datos. 6615 6616 Ejemplo: 6617 6618 (%i1) load (descriptive)$ 6619 (%i2) s2 : read_matrix (file_search ("wind.data"))$ 6620 (%i3) global_variances (s2); 6621 (%o3) [105.338342060606, 21.06766841212119, 12874.34690469686, 6622 113.4651792608502, 6.636590811800794, 2.576158149609762] 6623 6624 Cálculo de 'global_variances' a partir de la matriz de covarianzas. 6625 6626 (%i1) load (descriptive)$ 6627 (%i2) s2 : read_matrix (file_search ("wind.data"))$ 6628 (%i3) s : cov1 (s2)$ 6629 (%i4) global_variances (s, data=false); 6630 (%o4) [105.338342060606, 21.06766841212119, 12874.34690469686, 6631 113.4651792608502, 6.636590811800794, 2.576158149609762] 6632 6633 Véanse también 'cov' y 'cov1'. 6634 6635 -- Función: cor (<matrix>) 6636 -- Función: cor (<matrix>, <options> ...) 6637 Es la matriz de correlaciones de la muestra multivariante. 6638 6639 Opción: 6640 6641 * ''data', por defecto ''true', indica si la matriz de entrada 6642 contiene los datos muestrales, en cuyo caso la matriz de 6643 covarianzas 'cov1' debe ser calculada; en caso contrario, se 6644 le debe pasar ésta a la función como matriz simétrica en lugar 6645 de los datos. 6646 6647 Ejemplo: 6648 6649 (%i1) load (descriptive)$ 6650 (%i2) fpprintprec:7$ 6651 (%i3) s2 : read_matrix (file_search ("wind.data"))$ 6652 (%i4) cor (s2); 6653 [ 1.0 .8476339 .8803515 .8239624 .7519506 ] 6654 [ ] 6655 [ .8476339 1.0 .8735834 .6902622 0.782502 ] 6656 [ ] 6657 (%o4) [ .8803515 .8735834 1.0 .7764065 .8323358 ] 6658 [ ] 6659 [ .8239624 .6902622 .7764065 1.0 .7293848 ] 6660 [ ] 6661 [ .7519506 0.782502 .8323358 .7293848 1.0 ] 6662 6663 Cálculo de la matriz de correlaciones a partir de la matriz de 6664 covarianzas. 6665 6666 (%i1) load (descriptive)$ 6667 (%i2) fpprintprec : 7 $ 6668 (%i3) s2 : read_matrix (file_search ("wind.data"))$ 6669 (%i4) s : cov1 (s2)$ 6670 (%i5) cor (s, data=false); /* this is faster */ 6671 [ 1.0 .8476339 .8803515 .8239624 .7519506 ] 6672 [ ] 6673 [ .8476339 1.0 .8735834 .6902622 0.782502 ] 6674 [ ] 6675 (%o5) [ .8803515 .8735834 1.0 .7764065 .8323358 ] 6676 [ ] 6677 [ .8239624 .6902622 .7764065 1.0 .7293848 ] 6678 [ ] 6679 [ .7519506 0.782502 .8323358 .7293848 1.0 ] 6680 6681 Véanse también 'cov' y 'cov1'. 6682 6683 -- Función: list_correlations (<matrix>) 6684 -- Función: list_correlations (<matrix>, <options> ...) 6685 La función 'list_correlations' devuelve una lista con medidas de 6686 correlación: 6687 6688 * <matriz de precisión>: es la inversa de la matriz de 6689 covarianzas S_1, 6690 -1 ij 6691 S = (s ) 6692 1 i,j = 1,2,...,p 6693 6694 * <multiple correlation vector>: (R_1^2, R_2^2, ..., R_p^2), 6695 with 6696 2 1 6697 R = 1 - ------- 6698 i ii 6699 s s 6700 ii 6701 es un indicador de la bondad de ajuste del modelo de regresión 6702 lineal multivariante de X_i cuando el resto de variables se 6703 utilizan como regresores. 6704 6705 * <matriz de correlaciones parciales>: en la que el elemento (i, 6706 j) es 6707 ij 6708 s 6709 r = - ------------ 6710 ij.rest / ii jj\ 1/2 6711 |s s | 6712 \ / 6713 6714 Opción: 6715 6716 * ''data', por defecto ''true', indica si la matriz de entrada 6717 contiene los datos muestrales, en cuyo caso la matriz de 6718 covarianzas 'cov1' debe ser calculada; en caso contrario, se 6719 le debe pasar ésta a la función como matriz simétrica en lugar 6720 de los datos. 6721 6722 Ejemplo: 6723 6724 (%i1) load (descriptive)$ 6725 (%i2) s2 : read_matrix (file_search ("wind.data"))$ 6726 (%i3) z : list_correlations (s2)$ 6727 (%i4) fpprintprec : 5$ /* for pretty output */ 6728 [ .38486 - .13856 - .15626 - .10239 .031179 ] 6729 [ ] 6730 [ - .13856 .34107 - .15233 .038447 - .052842 ] 6731 [ ] 6732 (%o5) [ - .15626 - .15233 .47296 - .024816 - .10054 ] 6733 [ ] 6734 [ - .10239 .038447 - .024816 .10937 - .034033 ] 6735 [ ] 6736 [ .031179 - .052842 - .10054 - .034033 .14834 ] 6737 (%o6) [.85063, .80634, .86474, .71867, .72675] 6738 [ - 1.0 .38244 .36627 .49908 - .13049 ] 6739 [ ] 6740 [ .38244 - 1.0 .37927 - .19907 .23492 ] 6741 [ ] 6742 (%o7) [ .36627 .37927 - 1.0 .10911 .37956 ] 6743 [ ] 6744 [ .49908 - .19907 .10911 - 1.0 .26719 ] 6745 [ ] 6746 [ - .13049 .23492 .37956 .26719 - 1.0 ] 6747 6748 Véanse también 'cov' y 'cov1'. 6749 6750 -- Función: principal_components (<matrix>) 6751 -- Función: principal_components (<matrix>, <options> ...) 6752 Calcula las componentes principales de una muestra multivariante. 6753 Las componentes principales se utilizan en el análisis estadístico 6754 multivariante para reducir la dimensionalidad de la muestra. 6755 6756 Opción: 6757 6758 * ''data', por defecto ''true', indica si la matriz de entrada 6759 contiene los datos muestrales, en cuyo caso la matriz de 6760 covarianzas 'cov1' debe ser calculada; en caso contrario, se 6761 le debe pasar ésta a la función como matriz simétrica en lugar 6762 de los datos. 6763 6764 La salida de la función 'principal_components' es una lista con los 6765 siguientes resultados: 6766 6767 * varianzas de las componentes principales, 6768 * porcentajes de variación total explicada por cada componente 6769 principal, 6770 * matriz de rotación. 6771 6772 Ejemplos: 6773 6774 En este ejemplo, la primera componente explica el 83.13 por ciento 6775 de la varianza total. 6776 6777 (%i1) load (descriptive)$ 6778 (%i2) s2 : read_matrix (file_search ("wind.data"))$ 6779 (%i3) fpprintprec:4 $ 6780 (%i4) res: principal_components(s2); 6781 0 errors, 0 warnings 6782 (%o4) [[87.57, 8.753, 5.515, 1.889, 1.613], 6783 [83.13, 8.31, 5.235, 1.793, 1.531], 6784 [ .4149 .03379 - .4757 - 0.581 - .5126 ] 6785 [ ] 6786 [ 0.369 - .3657 - .4298 .7237 - .1469 ] 6787 [ ] 6788 [ .3959 - .2178 - .2181 - .2749 .8201 ]] 6789 [ ] 6790 [ .5548 .7744 .1857 .2319 .06498 ] 6791 [ ] 6792 [ .4765 - .4669 0.712 - .09605 - .1969 ] 6793 (%i5) /* porcentajes acumulados */ 6794 block([ap: copy(res[2])], 6795 for k:2 thru length(ap) do ap[k]: ap[k]+ap[k-1], 6796 ap); 6797 (%o5) [83.13, 91.44, 96.68, 98.47, 100.0] 6798 (%i6) /* dimension de la muestra */ 6799 p: length(first(res)); 6800 (%o6) 5 6801 (%i7) /* dibuja porcentajes para seleccionar el numero de 6802 componentes principales para el analisis ulterior */ 6803 draw2d( 6804 fill_density = 0.2, 6805 apply(bars, makelist([k, res[2][k], 1/2], k, p)), 6806 points_joined = true, 6807 point_type = filled_circle, 6808 point_size = 3, 6809 points(makelist([k, res[2][k]], k, p)), 6810 xlabel = "Variances", 6811 ylabel = "Percentages", 6812 xtics = setify(makelist([concat("PC",k),k], k, p))) $ 6813 6814 En caso de que la matriz de covarianzas sea conocida, se le puede 6815 pasar a la función, pero debe utilizarse la opción 'data=false'. 6816 6817 (%i1) load (descriptive)$ 6818 (%i2) S: matrix([1,-2,0],[-2,5,0],[0,0,2]); 6819 [ 1 - 2 0 ] 6820 [ ] 6821 (%o2) [ - 2 5 0 ] 6822 [ ] 6823 [ 0 0 2 ] 6824 (%i3) fpprintprec:4 $ 6825 (%i4) /* el argumento es una matriz de covarianzas */ 6826 res: principal_components(S, data=false); 6827 0 errors, 0 warnings 6828 [ - .3827 0.0 .9239 ] 6829 [ ] 6830 (%o4) [[5.828, 2.0, .1716], [72.86, 25.0, 2.145], [ .9239 0.0 .3827 ]] 6831 [ ] 6832 [ 0.0 1.0 0.0 ] 6833 (%i5) /* transformacion para obtener las componentes principales a 6834 partir de los registros originales */ 6835 matrix([a1,b2,c3],[a2,b2,c2]).last(res); 6836 [ .9239 b2 - .3827 a1 1.0 c3 .3827 b2 + .9239 a1 ] 6837 (%o5) [ ] 6838 [ .9239 b2 - .3827 a2 1.0 c2 .3827 b2 + .9239 a2 ] 6839 6840