doc/info/es/nset.es.texi

   1 @c english version 2011-07-8
   2 @menu
   3 * Introducción a los conjuntos::
   4 * Funciones y variables para los conjuntos::
   5 @end menu
   6
   7 @node Introducción a los conjuntos, Funciones y variables para los conjuntos, Conjuntos, Conjuntos
   8 @section Introducción a los conjuntos
   9
  10 Maxima dispone de funciones para realizar operaciones con conjuntos, como la intersección o la unión. Los conjuntos deben ser finitos y definidos por enumeración. Maxima trata a los conjuntos y a las listas como objectos de distinta naturaleza, lo que permite trabajar con conjuntos cuyos elementos puedan ser también conjuntos o listas.
  11
  12 Además de funciones para operar con conjuntos finitos, Maxima dispone también de algunas funciones sobre combinatoria, como los números de Stirling de primera y segunda especie, números de Bell, coeficientes multinomiales, particiones de enteros no negativos y algunos otros. Maxima también define la función delta de Kronecker.
  13
  14
  15 @subsection Utilización
  16
  17 Para construir un conjunto cuyos elementos sean @code{a_1, ..., a_n}, se utiliza la instrucción  @code{set(a_1, ..., a_n)} o @code{@{a_1, ..., a_n@}}; para formar un conjunto vacío, basta con hacer @code{set()} o @code{@{@}}. Para introducir conjuntos en Maxima, @code{set (...)} y @code{@{ ... @}} son equivalentes. Los conjuntos se muestran siempre con llave.
  18
  19 Si un elemento se indica más de una vez, el proceso
  20 de simplificación elimina los elementos redundantes.
  21
  22 @c ===beg===
  23 @c set();
  24 @c set(a, b, a);
  25 @c set(a, set(b));
  26 @c set(a, [b]);
  27 @c {};
  28 @c {a, b, a};
  29 @c {a, {b}};
  30 @c {a, [b]};
  31 @c ===end===
  32 @example
  33 (%i1) set();
  34 (%o1)                          @{@}
  35 (%i2) set(a, b, a);
  36 (%o2)                        @{a, b@}
  37 (%i3) set(a, set(b));
  38 (%o3)                       @{a, @{b@}@}
  39 (%i4) set(a, [b]);
  40 (%o4)                       @{a, [b]@}
  41 (%i5) @{@};
  42 (%o5)                          @{@}
  43 (%i6) @{a, b, a@};
  44 (%o6)                        @{a, b@}
  45 (%i7) @{a, @{b@}@};
  46 (%o7)                       @{a, @{b@}@}
  47 (%i8) @{a, [b]@};
  48 (%o8)                       @{a, [b]@}
  49 @end example
  50
  51
  52 Dos elementos candidatos a formar parte de un conjunto, @var{x} e @var{y},
  53 son redundantes, esto es, se consideran el mismo elemento a
  54 efectos de consruir el conjunto, si y sólo si @code{is (@var{x} = @var{y})}
  55 devuelve el valor @code{true}. Nótese que @code{is (equal (@var{x}, @var{y}))}
  56 puede devolver @code{true} y @code{is (@var{x} = @var{y})} retornar
  57 @code{false}; en cuyo caso los elementos @var{x} e @var{y} se
  58 considerarían distintos.
  59
  60 @c ===beg===
  61 @c x: a/c + b/c;
  62 @c y: a/c + b/c;
  63 @c z: (a + b)/c;
  64 @c is (x = y);
  65 @c is (y = z);
  66 @c is (equal (y, z));
  67 @c y - z;
  68 @c ratsimp (%);
  69 @c {x, y, z};
  70 @c ===end===
  71 @example
  72 (%i1) x: a/c + b/c;
  73                               b   a
  74 (%o1)                         - + -
  75                               c   c
  76 (%i2) y: a/c + b/c;
  77                               b   a
  78 (%o2)                         - + -
  79                               c   c
  80 (%i3) z: (a + b)/c;
  81                               b + a
  82 (%o3)                         -----
  83                                 c
  84 (%i4) is (x = y);
  85 (%o4)                         true
  86 (%i5) is (y = z);
  87 (%o5)                         false
  88 (%i6) is (equal (y, z));
  89 (%o6)                         true
  90 (%i7) y - z;
  91                            b + a   b   a
  92 (%o7)                    - ----- + - + -
  93                              c     c   c
  94 (%i8) ratsimp (%);
  95 (%o8)                           0
  96 (%i9) @{x, y, z@};
  97                           b + a  b   a
  98 (%o9)                    @{-----, - + -@}
  99                             c    c   c
 100 @end example
 101
 102
 103 Para formar un conjunto a partir de los miembros de una lista úsese @code{setify}.
 104
 105 @c ===beg===
 106 @c setify([b, a]);
 107 @c ===end===
 108 @example
 109 (%i1) setify([b, a]);
 110 (%o1)                        @{a, b@}
 111 @end example
 112
 113 Los elementos @code{x} e @code{y} de un conjunto se consideran iguales si @code{is(x = y)} devuelve el valor @code{true}. Así, @code{rat(x)} y @code{x} se consideran el mismo elemento de un conjunto; consecuentemente,
 114
 115 @c ===beg===
 116 @c {x, rat(x)};
 117 @c ===end===
 118 @example
 119 (%i1) @{x, rat(x)@};
 120 (%o1)                          @{x@}
 121 @end example
 122
 123 Además, puesto que  @code{is((x-1)*(x+1) = x^2 - 1)} devuelve @code{false},  @code{(x-1)*(x+1)} y @code{x^2-1} se consideran elementos diferentes; así
 124
 125 @c ===beg===
 126 @c {(x - 1)*(x + 1), x^2 - 1};
 127 @c ===end===
 128 @example
 129 (%i1) @{(x - 1)*(x + 1), x^2 - 1@};
 130                                        2
 131 (%o1)               @{(x - 1) (x + 1), x  - 1@}
 132 @end example
 133
 134 Para reducir este conjunto a otro unitario, aplicar @code{rat} a cada elemento del conjunto:
 135
 136 @c ===beg===
 137 @c {(x - 1)*(x + 1), x^2 - 1};
 138 @c map (rat, %);
 139 @c ===end===
 140 @example
 141 (%i1) @{(x - 1)*(x + 1), x^2 - 1@};
 142                                        2
 143 (%o1)               @{(x - 1) (x + 1), x  - 1@}
 144 (%i2) map (rat, %);
 145                               2
 146 (%o2)/R/                    @{x  - 1@}
 147 @end example
 148
 149 Para eliminar redundancias con otros conjuntos, será necesario utilizar otras funciones de simplificación. He aquí un ejemplo que utiliza  @code{trigsimp}:
 150
 151 @c ===beg===
 152 @c {1, cos(x)^2 + sin(x)^2};
 153 @c map (trigsimp, %);
 154 @c ===end===
 155 @example
 156 (%i1) @{1, cos(x)^2 + sin(x)^2@};
 157                             2         2
 158 (%o1)                @{1, sin (x) + cos (x)@}
 159 (%i2) map (trigsimp, %);
 160 (%o2)                          @{1@}
 161 @end example
 162
 163 Se entiende que un conjunto está simplificado cuando entre sus elementos no hay redundancias y se hayan ordenados. La versión actual de las funciones para conjuntos utiliza la función @code{orderlessp} de Maxima para ordenar sus elementos; sin embargo, @i{futuras versiones de las funciones para operar con conjuntos podrán utilizar otras funciones de ordenación}.
 164
 165 Algunas operaciones con conjuntos, tales como la sustitución, fuerzan automáticamente una re-simplificación; por ejemplo,
 166
 167 @c ===beg===
 168 @c s: {a, b, c}$
 169 @c subst (c=a, s);
 170 @c subst ([a=x, b=x, c=x], s);
 171 @c map (lambda ([x], x^2), set (-1, 0, 1));
 172 @c ===end===
 173 @example
 174 (%i1) s: @{a, b, c@}$
 175 (%i2) subst (c=a, s);
 176 (%o2)                        @{a, b@}
 177 (%i3) subst ([a=x, b=x, c=x], s);
 178 (%o3)                          @{x@}
 179 (%i4) map (lambda ([x], x^2), set (-1, 0, 1));
 180 (%o4)                        @{0, 1@}
 181 @end example
 182
 183 Maxima considera a las listas y conjuntos como objetos diferentes;
 184 funciones tales como @code{union} y @code{intersection} emitirán
 185 un error si alguno de sus argumentos no es un conjunto. Si se
 186 necesita aplicar una función de conjunto a una lista, se deberá
 187 utilizar la función @code{setify} para convertirla previamente en conjunto.
 188 Así,
 189
 190 @c ===beg===
 191 @c union ([1, 2], {a, b});
 192 @c union (setify ([1, 2]), {a, b});
 193 @c ===end===
 194 @example
 195 (%i1) union ([1, 2], @{a, b@});
 196 Function union expects a set, instead found [1,2]
 197  -- an error.  Quitting.  To debug this try debugmode(true);
 198 (%i2) union (setify ([1, 2]), @{a, b@});
 199 (%o2)                     @{1, 2, a, b@}
 200 @end example
 201
 202 Para extraer todos los elementos de un conjunto @code{s} que satisfagan un predicado @code{f}, úsese @code{subset(s,f)}. (Un @i{predicado} es una función booleana.) Por ejemplo, para encontrar las ecuaciones en un conjunto dado que no dependan de la variable @code{z}, se hará
 203
 204 @c ===beg===
 205 @c subset ({x + y + z, x - y + 4, x + y - 5},
 206 @c         lambda ([e], freeof (z, e)));
 207 @c ===end===
 208 @example
 209 (%i1) subset (@{x + y + z, x - y + 4, x + y - 5@},
 210               lambda ([e], freeof (z, e)));
 211 (%o1)               @{- y + x + 4, y + x - 5@}
 212 @end example
 213
 214 La sección @code{Funciones y variables para los conjuntos} incluye una lista completa de funciones para operar con conjuntos en  Maxima.
 215
 216 @subsection Iteraciones con elementos
 217
 218 Hay dos formas para operar iterativamente sobre los elementos de un conjunto. Una es utilizar @code{map}; por ejemplo:
 219
 220 @c ===beg===
 221 @c map (f, {a, b, c});
 222 @c ===end===
 223 @example
 224 (%i1) map (f, @{a, b, c@});
 225 (%o1)                  @{f(a), f(b), f(c)@}
 226 @end example
 227
 228 La otra forma consiste en hacer uso de la construcción @code{for @var{x} in @var{s} do}
 229
 230 @c ===beg===
 231 @c s: {a, b, c};
 232 @c for si in s do print (concat (si, 1));
 233 @c ===end===
 234 @example
 235 (%i1) s: @{a, b, c@};
 236 (%o1)                       @{a, b, c@}
 237 (%i2) for si in s do print (concat (si, 1));
 238 a1
 239 b1
 240 c1
 241 (%o2)                         done
 242 @end example
 243
 244 Las funciones de Maxima  @code{first} y @code{rest} funcionan también con conjuntos.  En este caso, @code{first} devuelve el primer elemento que se muestra del conjunto, el cual puede depender de la implementación del sistema. Si @code{s} es un conjunto, entonces @code{rest(s)} equivale a @code{disjoin (first(s), s)}. Hay otras funciones que trabajan correctamente con conjuntos. En próximas versiones de las funciones para operar con conjuntos es posible que @code{first} y @code{rest} trabajen de modo diferente o que ya no lo hagan en absoluto.
 245
 246 @subsection Fallos
 247
 248 Las funciones para operar con conjuntos utilizan la función @code{orderlessp}
 249 de Maxima para ordenar los elementos de los conjuntos, así
 250 como la función @code{like} de Lisp para decidir sobre la igualdad de dichos
 251 elementos. Ambas funciones tienen fallos que son conocidos y que pueden
 252 aflorar si se trabaja con conjuntos que tengan elementos en formato de
 253 listas o matrices y que contengan expresiones racionales canónicas (CRE).
 254 Un ejemplo es
 255
 256 @c ===beg===
 257 @c {[x], [rat (x)]};
 258 @c ===end===
 259 @example
 260 (%i1) @{[x], [rat (x)]@};
 261 Maxima encountered a Lisp error:
 262
 263   The value #:X1440 is not of type LIST.
 264
 265 Automatically continuing.
 266 To reenable the Lisp debugger set *debugger-hook* to nil.
 267 @end example
 268
 269 Esta expresión provoca una parada de Maxima junto con la
 270 emisión de un mensaje de error, el cual dependerá de
 271 la versión de Lisp que utilice Maxima. Otro ejemplo es
 272
 273 @c ===beg===
 274 @c setify ([[rat(a)], [rat(b)]]);
 275 @c ===end===
 276 @example
 277 (%i1) setify ([[rat(a)], [rat(b)]]);
 278 Maxima encountered a Lisp error:
 279
 280   The value #:A1440 is not of type LIST.
 281
 282 Automatically continuing.
 283 To reenable the Lisp debugger set *debugger-hook* to nil.
 284 @end example
 285
 286 Estos fallos son causados por fallos en  @code{orderlessp} y @code{like},
 287 no por fallos cuyo origen se encuentre en las funciones para conjuntos.
 288 Para ilustrarlo, se pueden ejecutar las siguientes expresiones
 289
 290 @c ===beg===
 291 @c orderlessp ([rat(a)], [rat(b)]);
 292 @c is ([rat(a)] = [rat(a)]);
 293 @c ===end===
 294 @example
 295 (%i1) orderlessp ([rat(a)], [rat(b)]);
 296 Maxima encountered a Lisp error:
 297
 298   The value #:B1441 is not of type LIST.
 299
 300 Automatically continuing.
 301 To reenable the Lisp debugger set *debugger-hook* to nil.
 302 (%i2) is ([rat(a)] = [rat(a)]);
 303 (%o2)                         false
 304 @end example
 305
 306 Hasta que estos errores no se corrijan, no es aconsejable construir conjuntos que tengan por elementos listas o matrices que contengan expresiones en forma CRE; sin embargo, un conjunto con elementos de la forma CRE no deberían dar problemas:
 307
 308 @c ===beg===
 309 @c {x, rat (x)};
 310 @c ===end===
 311 @example
 312 (%i1) @{x, rat (x)@};
 313 (%o1)                          @{x@}
 314 @end example
 315
 316 La función @code{orderlessp} de Maxima tiene otro fallo que puede causar problemas con las funciones para conjuntos, en concreto, que el predicado de ordenación @code{orderlessp} no es transitivo. El ejemplo más simple que ilustra este punto es
 317
 318 @c ===beg===
 319 @c q: x^2$
 320 @c r: (x + 1)^2$
 321 @c s: x*(x + 2)$
 322 @c orderlessp (q, r);
 323 @c orderlessp (r, s);
 324 @c orderlessp (q, s);
 325 @c ===end===
 326 @example
 327 (%i1) q: x^2$
 328 (%i2) r: (x + 1)^2$
 329 (%i3) s: x*(x + 2)$
 330 (%i4) orderlessp (q, r);
 331 (%o4)                         true
 332 (%i5) orderlessp (r, s);
 333 (%o5)                         true
 334 (%i6) orderlessp (q, s);
 335 (%o6)                         false
 336 @end example
 337
 338 El fallo puede causar problemas con todas las funciones para conjuntos,
 339 así como también con otras funciones de Maxima.
 340 Es probable, pero no seguro, que este fallo se puede evitar si todos
 341 los elementos del conjunto están en la forma de expresión racional
 342 canónica (CRE) o han sido simplificados con @code{ratsimp}.
 343
 344 @c WHAT EXACTLY IS THE EFFECT OF ordergreat AND orderless ON THE SET FUNCTIONS ??
 345 Los mecanismos @code{orderless} y @code{ordergreat} de Maxima son incompatibles
 346 con las funciones para conjuntos. Si se necesitan utilizar @code{orderless} o
 347 @code{ordergreat}, hágase antes de construir los conjuntos y no se utilice
 348 la instrucción @code{unorder}.
 349
 350 Se ruega a todo usuario que crea haber encontrado un fallo en las funciones para conjuntos que lo comunique en la base de datos de Maxima. Véase @code{bug_report}.
 351
 352 @subsection Autores
 353
 354 Stavros Macrakis de Cambridge, Massachusetts y Barton Willis de la University of Nebraska at Kearney (UNK).
 355
 356 @node Funciones y variables para los conjuntos,  , Introducción a los conjuntos, Conjuntos
 357 @section Funciones y variables para los conjuntos
 358
 359
 360 @deffn {Función} adjoin (@var{x}, @var{a})
 361
 362 Calcula la unión del conjunto @var{a} y @code{@{@var{x}@}}.
 363
 364 La función @code{adjoin} emite un mensaje de error si @var{a}
 365 no es un conjunto literal.
 366
 367 Las sentencias @code{adjoin(@var{x}, @var{a})} y
 368 @code{union(set(@var{x}), @var{a})} son equivalentes, aunque
 369 @code{adjoin} puede ser algo más rápida que @code{union}.
 370
 371 Véase también @code{disjoin}.
 372
 373 Ejemplos:
 374
 375 @c ===beg===
 376 @c adjoin (c, {a, b});
 377 @c adjoin (a, {a, b});
 378 @c ===end===
 379 @example
 380 (%i1) adjoin (c, @{a, b@});
 381 (%o1)                       @{a, b, c@}
 382 (%i2) adjoin (a, @{a, b@});
 383 (%o2)                        @{a, b@}
 384 @end example
 385
 386 @end deffn
 387
 388
 389 @deffn {Función} belln (@var{n})
 390
 391 Representa el @math{n}-ésimo número de Bell, de
 392 modo que @code{belln(n)} es el número de particiones de un conjunto de
 393 @var{n} elementos.
 394
 395 El argumento @var{n} debe ser un entero no negativo.
 396
 397 La función @code{belln} se distribuye sobre ecuaciones, listas,
 398 matrices y conjuntos.
 399
 400 Ejemplos:
 401
 402 @code{belln} se aplica a enteros no negativos,
 403
 404 @c ===beg===
 405 @c makelist (belln (i), i, 0, 6);
 406 @c is (cardinality (set_partitions ({})) = belln (0));
 407 @c is (cardinality (set_partitions ({1, 2, 3, 4, 5, 6}))
 408 @c                          = belln (6));
 409 @c ===end===
 410 @example
 411 (%i1) makelist (belln (i), i, 0, 6);
 412 (%o1)               [1, 1, 2, 5, 15, 52, 203]
 413 (%i2) is (cardinality (set_partitions (@{@})) = belln (0));
 414 (%o2)                         true
 415 (%i3) is (cardinality (set_partitions (@{1, 2, 3, 4, 5, 6@}))
 416                             = belln (6));
 417 (%o3)                         true
 418 @end example
 419
 420 Si @var{n} no es un entero no negativo, la función @code{belln(n)} no hace cálculo alguno.
 421
 422 @c ===beg===
 423 @c [belln (x), belln (sqrt(3)), belln (-9)];
 424 @c ===end===
 425 @example
 426 (%i1) [belln (x), belln (sqrt(3)), belln (-9)];
 427 (%o1)        [belln(x), belln(sqrt(3)), belln(- 9)]
 428 @end example
 429 @end deffn
 430
 431
 432 @deffn {Función} cardinality (@var{a})
 433
 434 Devuelve el número de elementos del conjunto @var{a}.
 435
 436 La función @code{cardinality} ignora los elementos
 437 redundantes, incluso cuando la simplificación está
 438 desabilitada.
 439
 440 Ejemplos:
 441
 442 @c ===beg===
 443 @c cardinality ({});
 444 @c cardinality ({a, a, b, c});
 445 @c simp : false;
 446 @c cardinality ({a, a, b, c});
 447 @c ===end===
 448 @example
 449 (%i1) cardinality (@{@});
 450 (%o1)                           0
 451 (%i2) cardinality (@{a, a, b, c@});
 452 (%o2)                           3
 453 (%i3) simp : false;
 454 (%o3)                         false
 455 (%i4) cardinality (@{a, a, b, c@});
 456 (%o4)                           3
 457 @end example
 458 @end deffn
 459
 460
 461 @deffn {Función} cartesian_product (@var{b_1}, ... , @var{b_n})
 462
 463 Devuelve un conjunto formado por listas de la forma @code{[@var{x_1}, ..., @var{x_n}]},
 464 siendo @var{x_1}, ..., @var{x_n} elementos de los conjuntos @var{b_1}, ... , @var{b_n},
 465 respectivamente.
 466
 467 La función @code{cartesian_product} emite un mensaje de error si alguno
 468 de sus argumentos no es un conjunto literal.
 469
 470 Ejemplos:
 471
 472 @c ===beg===
 473 @c cartesian_product ({0, 1});
 474 @c cartesian_product ({0, 1}, {0, 1});
 475 @c cartesian_product ({x}, {y}, {z});
 476 @c cartesian_product ({x}, {-1, 0, 1});
 477 @c ===end===
 478 @example
 479 (%i1) cartesian_product (@{0, 1@});
 480 (%o1)                      @{[0], [1]@}
 481 (%i2) cartesian_product (@{0, 1@}, @{0, 1@});
 482 (%o2)           @{[0, 0], [0, 1], [1, 0], [1, 1]@}
 483 (%i3) cartesian_product (@{x@}, @{y@}, @{z@});
 484 (%o3)                      @{[x, y, z]@}
 485 (%i4) cartesian_product (@{x@}, @{-1, 0, 1@});
 486 (%o4)              @{[x, - 1], [x, 0], [x, 1]@}
 487 @end example
 488 @end deffn
 489
 490
 491 @deffn {Función} disjoin (@var{x}, @var{a})
 492
 493 Devuelve el conjunto @var{a} sin el elemento @var{x}.
 494 Si @var{x} no es elemento de @var{a}, entonces el
 495 resultado es el propio @var{a}.
 496
 497 La función @code{disjoin} emite un mensaje de error si
 498 @var{a} no es un conjunto literal.
 499
 500 Las sentencias @code{disjoin(@var{x}, @var{a})}, @code{delete(@var{x}, @var{a})}
 501 y @code{setdifference(@var{a}, set(@var{x}))} son todas ellas equivalentes;
 502 pero en general, @code{disjoin} será más rápida que las otras.
 503
 504 Ejemplos:
 505
 506 @c ===beg===
 507 @c disjoin (a, {a, b, c, d});
 508 @c disjoin (a + b, {5, z, a + b, %pi});
 509 @c disjoin (a - b, {5, z, a + b, %pi});
 510 @c ===end===
 511 @example
 512 (%i1) disjoin (a, @{a, b, c, d@});
 513 (%o1)                       @{b, c, d@}
 514 (%i2) disjoin (a + b, @{5, z, a + b, %pi@});
 515 (%o2)                      @{5, %pi, z@}
 516 (%i3) disjoin (a - b, @{5, z, a + b, %pi@});
 517 (%o3)                  @{5, %pi, b + a, z@}
 518 @end example
 519 @end deffn
 520
 521
 522 @deffn {Función} disjointp (@var{a}, @var{b})
 523
 524 Devuelve @code{true} si y sólo si los conjuntos  @var{a} y @var{b}
 525 son disjuntos.
 526
 527 La función @code{disjointp} emite un mensaje de error si
 528 @var{a} o @var{b} no son conjuntos literales.
 529
 530 Ejemplos:
 531
 532 @c ===beg===
 533 @c disjointp ({a, b, c}, {1, 2, 3});
 534 @c disjointp ({a, b, 3}, {1, 2, 3});
 535 @c ===end===
 536 @example
 537 (%i1) disjointp (@{a, b, c@}, @{1, 2, 3@});
 538 (%o1)                         true
 539 (%i2) disjointp (@{a, b, 3@}, @{1, 2, 3@});
 540 (%o2)                         false
 541 @end example
 542 @end deffn
 543
 544
 545 @deffn {Función} divisors (@var{n})
 546
 547 Calcula el conjunto de divisores de @var{n}.
 548
 549 La sentencia @code{divisors(@var{n})} devuelve un conjunto
 550 de enteros si @var{n} es un entero no nulo.
 551 El conjunto de divisores incluye los elementos 1 y @var{n}.
 552 Los divisores de un entero negativo son los divisores de su
 553 valor absoluto.
 554
 555 La función @code{divisors} se distribuye sobre las ecuaciones,
 556 listas, matrices y conjuntos.
 557
 558 Ejemplos:
 559
 560 Se puede comprobar que 28 es un número perfecto:
 561 la suma de sus divisores (excepto él mismo) es 28.
 562
 563 @c ===beg===
 564 @c s: divisors(28);
 565 @c lreduce ("+", args(s)) - 28;
 566 @c ===end===
 567 @example
 568 (%i1) s: divisors(28);
 569 (%o1)                 @{1, 2, 4, 7, 14, 28@}
 570 (%i2) lreduce ("+", args(s)) - 28;
 571 (%o2)                          28
 572 @end example
 573
 574 La función @code{divisors} es simplificadora.
 575 Haciendo la sustitución de @code{a} por 8 en @code{divisors(a)}
 576 devuelve los divisores sin tener que reevaluar @code{divisors(8)},
 577
 578 @c ===beg===
 579 @c divisors (a);
 580 @c subst (8, a, %);
 581 @c ===end===
 582 @example
 583 (%i1) divisors (a);
 584 (%o1)                      divisors(a)
 585 (%i2) subst (8, a, %);
 586 (%o2)                     @{1, 2, 4, 8@}
 587 @end example
 588
 589 La función @code{divisors} se distribuye sobre ecuaciones, listas,
 590 matrices y conjuntos.
 591
 592 @c ===beg===
 593 @c divisors (a = b);
 594 @c divisors ([a, b, c]);
 595 @c divisors (matrix ([a, b], [c, d]));
 596 @c divisors ({a, b, c});
 597 @c ===end===
 598 @example
 599 (%i1) divisors (a = b);
 600 (%o1)               divisors(a) = divisors(b)
 601 (%i2) divisors ([a, b, c]);
 602 (%o2)        [divisors(a), divisors(b), divisors(c)]
 603 (%i3) divisors (matrix ([a, b], [c, d]));
 604                   [ divisors(a)  divisors(b) ]
 605 (%o3)             [                          ]
 606                   [ divisors(c)  divisors(d) ]
 607 (%i4) divisors (@{a, b, c@});
 608 (%o4)        @{divisors(a), divisors(b), divisors(c)@}
 609 @end example
 610 @end deffn
 611
 612
 613 @deffn {Función} elementp (@var{x}, @var{a})
 614
 615 Devuelve @code{true} si y sólo si @var{x} es miembro del
 616 conjunto @var{a}.
 617
 618 La función @code{elementp} emite un mensaje de error si
 619 @var{a} no es un conjunto literal.
 620
 621 Ejemplos:
 622
 623 @c ===beg===
 624 @c elementp (sin(1), {sin(1), sin(2), sin(3)});
 625 @c elementp (sin(1), {cos(1), cos(2), cos(3)});
 626 @c ===end===
 627 @example
 628 (%i1) elementp (sin(1), @{sin(1), sin(2), sin(3)@});
 629 (%o1)                         true
 630 (%i2) elementp (sin(1), @{cos(1), cos(2), cos(3)@});
 631 (%o2)                         false
 632 @end example
 633 @end deffn
 634
 635
 636 @deffn {Función} emptyp (@var{a})
 637 Devuelve @code{true} si y sólo si @var{a} es el conjunto vacío o la lista vacía.
 638
 639 Ejemplos:
 640
 641 @c ===beg===
 642 @c map (emptyp, [{}, []]);
 643 @c map (emptyp, [a + b, {{}}, %pi]);
 644 @c ===end===
 645 @example
 646 (%i1) map (emptyp, [@{@}, []]);
 647 (%o1)                     [true, true]
 648 (%i2) map (emptyp, [a + b, @{@{@}@}, %pi]);
 649 (%o2)                 [false, false, false]
 650 @end example
 651 @end deffn
 652
 653
 654 @deffn {Función} equiv_classes (@var{s}, @var{F})
 655
 656 Devuelve el conjunto de las clases de equivalencia del conjunto @var{s}
 657 respecto de la relación de equivalencia @var{F}.
 658
 659 El argumento @var{F} es una función de dos variables definida sobre
 660 el producto cartesiano @var{s} por @var{s}.
 661 El valor devuelto por @var{F} debe ser @code{true} o @code{false},
 662 o bien una expresión @var{expr} tal que @code{is(@var{expr})}
 663 tome el valor @code{true} o @code{false}.
 664
 665 Si @var{F} no es una relación de equivalencia, @code{equiv_classes}
 666 la acepta sin emitir ningún mensaje de error, pero el resultado
 667 será incorrecto en general.
 668
 669 Ejemplos:
 670
 671 La relación de equivalencia es una expresión lambda que devuelve
 672 @code{true} o @code{false},
 673
 674 @c ===beg===
 675 @c equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0},
 676 @c                 lambda ([x, y], is (equal (x, y))));
 677 @c ===end===
 678 @example
 679 (%i1) equiv_classes (@{1, 1.0, 2, 2.0, 3, 3.0@},
 680                       lambda ([x, y], is (equal (x, y))));
 681 (%o1)            @{@{1, 1.0@}, @{2, 2.0@}, @{3, 3.0@}@}
 682 @end example
 683
 684 La relación de equivalencia es el nombre de una función relacional
 685 en la que @code{is} evalúa a @code{true} o @code{false},
 686
 687 @c ===beg===
 688 @c equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, equal);
 689 @c ===end===
 690 @example
 691 (%i1) equiv_classes (@{1, 1.0, 2, 2.0, 3, 3.0@}, equal);
 692 (%o1)            @{@{1, 1.0@}, @{2, 2.0@}, @{3, 3.0@}@}
 693 @end example
 694
 695 Las clases de equivalencia son números que difieren en un múltiplo de 3.
 696
 697 @c ===beg===
 698 @c equiv_classes ({1, 2, 3, 4, 5, 6, 7},
 699 @c             lambda ([x, y], remainder (x - y, 3) = 0));
 700 @c ===end===
 701 @example
 702 (%i1) equiv_classes (@{1, 2, 3, 4, 5, 6, 7@},
 703               lambda ([x, y], remainder (x - y, 3) = 0));
 704 (%o1)              @{@{1, 4, 7@}, @{2, 5@}, @{3, 6@}@}
 705 @end example
 706 @end deffn
 707
 708
 709 @deffn {Función} every (@var{f}, @var{s})
 710 @deffnx {Función} every (@var{f}, @var{L_1}, ..., @var{L_n})
 711
 712 Devuelve @code{true} si el predicado @var{f} vale @code{true}
 713 para todos los argumentos dados.
 714
 715 Dado un conjunto como segundo argumento,
 716 @code{every(@var{f}, @var{s})} devuelve @code{true}
 717 si @code{is(@var{f}(@var{a_i}))} devuelve @code{true} para todos los
 718 @var{a_i} pertenecientes @var{s}.
 719 La función @code{every} puede evaluar o no @var{f} para todos los
 720 @var{a_i} pertenecientes @var{s}.
 721 Puesto que los conjuntos no están ordenados, @code{every}
 722 puede evaluar @code{@var{f}(@var{a_i})} en cualquier orden.
 723
 724 Dada una o más listas como argumentos,
 725 @code{every(@var{f}, @var{L_1}, ..., @var{L_n})} devuelve @code{true}
 726 si @code{is(@var{f}(@var{x_1}, ..., @var{x_n}))} devuelve @code{true}
 727 para todo @var{x_1}, ..., @var{x_n} en @var{L_1}, ..., @var{L_n}, respectivamente.
 728 La función @code{every} puede evaluar o no
 729 @var{f} para cualquier combinación de @var{x_1}, ..., @var{x_n}; además,
 730 @code{every} evalúa las listas en el orden creciente del índice.
 731
 732 Dado un conjunto vacío @code{@{@}} o lista vacía
 733 @code{[]} como argumentos, @code{every} devuelve @code{false}.
 734
 735 Si la variable global @code{maperror} vale @code{true}, todas las listas
 736 @var{L_1}, ..., @var{L_n} deben ser de igual longitud.
 737 Si @code{maperror} vale @code{false}, los argumentos en forma de listas
 738 se truncan para igualar sus longitudes a la de la lista más corta.
 739
 740 Los valores que devuelve el predicado @var{f} cuando toman
 741 (mediante @code{is}) un valor diferente a @code{true} y @code{false}
 742 se controlan con la variable global @code{prederror}.
 743 Si @code{prederror} vale @code{true}, tales valores se
 744 consideran como @code{false} y la respuesta de @code{every} es @code{false}.
 745 Si @code{prederror} vale @code{false}, tales valores se
 746 consideran como desconocidos (@code{unknown}) y la respuesta de
 747 @code{every} es @code{unknown}.
 748
 749 Ejemplos:
 750
 751 Se aplica @code{every} a un único conjunto.
 752 El predicado es una función de un argumento.
 753
 754 @c ===beg===
 755 @c every (integerp, {1, 2, 3, 4, 5, 6});
 756 @c every (atom, {1, 2, sin(3), 4, 5 + y, 6});
 757 @c ===end===
 758 @example
 759 (%i1) every (integerp, @{1, 2, 3, 4, 5, 6@});
 760 (%o1)                         true
 761 (%i2) every (atom, @{1, 2, sin(3), 4, 5 + y, 6@});
 762 (%o2)                         false
 763 @end example
 764
 765 Se aplica @code{every} a dos listas.
 766 El predicado es una función de dos argumentos.
 767
 768 @c ===beg===
 769 @c every ("=", [a, b, c], [a, b, c]);
 770 @c every ("#", [a, b, c], [a, b, c]);
 771 @c ===end===
 772 @example
 773 (%i1) every ("=", [a, b, c], [a, b, c]);
 774 (%o1)                         true
 775 (%i2) every ("#", [a, b, c], [a, b, c]);
 776 (%o2)                         false
 777 @end example
 778
 779 Las respuestas del predicado @var{f} que se evalúan
 780 a cualquier cosa diferente de @code{true} y @code{false}
 781 están controlados por la variable global @code{prederror}.
 782
 783 @c ===beg===
 784 @c prederror : false;
 785 @c map (lambda ([a, b], is (a < b)), [x, y, z],
 786 @c                [x^2, y^2, z^2]);
 787 @c every ("<", [x, y, z], [x^2, y^2, z^2]);
 788 @c prederror : true;
 789 @c every ("<", [x, y, z], [x^2, y^2, z^2]);
 790 @c ===end===
 791 @example
 792 (%i1) prederror : false;
 793 (%o1)                         false
 794 (%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
 795                    [x^2, y^2, z^2]);
 796 (%o2)              [unknown, unknown, unknown]
 797 (%i3) every ("<", [x, y, z], [x^2, y^2, z^2]);
 798 (%o3)                        unknown
 799 (%i4) prederror : true;
 800 (%o4)                         true
 801 (%i5) every ("<", [x, y, z], [x^2, y^2, z^2]);
 802 (%o5)                         false
 803 @end example
 804 @end deffn
 805
 806
 807 @deffn {Función} extremal_subset (@var{s}, @var{f}, max)
 808 @deffnx {Función} extremal_subset (@var{s}, @var{f}, min)
 809
 810 Calcula el subconjunto de @var{s} para el cual la función @var{f}
 811 toma sus valores mayor y menor.
 812
 813 La sentencia @code{extremal_subset(@var{s}, @var{f}, max)}
 814 devuelve el subconjunto del conjunto o lista @var{s} para el cual
 815 la función real @var{f} toma su valor máximo.
 816
 817 La sentencia @code{extremal_subset(@var{s}, @var{f}, min)}
 818 devuelve el subconjunto del conjunto o lista @var{s} para el cual
 819 la función real @var{f} toma su valor mínimo.
 820
 821 Ejemplos
 822
 823 @c ===beg===
 824 @c extremal_subset ({-2, -1, 0, 1, 2}, abs, max);
 825 @c extremal_subset ({sqrt(2), 1.57, %pi/2}, sin, min);
 826 @c ===end===
 827 @example
 828 (%i1) extremal_subset (@{-2, -1, 0, 1, 2@}, abs, max);
 829 (%o1)                       @{- 2, 2@}
 830 (%i2) extremal_subset (@{sqrt(2), 1.57, %pi/2@}, sin, min);
 831 (%o2)                       @{sqrt(2)@}
 832 @end example
 833 @end deffn
 834
 835
 836 @deffn {Función} flatten (@var{expr})
 837
 838 Recoge los argumentos de subexpresiones con el mismo operador que @var{expr}
 839 y construye con ellas otra expresión a partir de estos argumentos.
 840
 841 Aquellas subexpresiones en las que el operador es diferente del operador
 842 principal de @code{expr} se copian sin modificarse, incluso cuando ellas
 843 mismas contengan subexpresiones en las que el operador sea el mismo
 844 que el de @code{expr}.
 845
 846 Es posible que @code{flatten} construya expresiones en las que el número
 847 de argumentos difiera del número admitido por el operador, lo cual
 848 hará que se emita un mensaje de error. La función @code{flatten}
 849 no intentará detectar estas situaciones.
 850
 851 Las expresiones que tengan representaciones especiales, por ejemplo las racionales
 852 canónicas (CRE), no admiten que se aplique sobre ellas la función @code{flatten};
 853 en tales casos se devuelve el argumento sin modificación.
 854
 855 Ejemplos:
 856
 857 Aplicada a una lista, @code{flatten} reune todos los elementos que son a su vez listas.
 858
 859 @c ===beg===
 860 @c flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]);
 861 @c ===end===
 862 @example
 863 (%i1) flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]);
 864 (%o1)            [a, b, c, d, e, f, g, h, i, j]
 865 @end example
 866
 867 Aplicado a un conjunto, @code{flatten} reune todos los elementos que son a su vez conjuntos.
 868
 869 @c ===beg===
 870 @c flatten ({a, {b}, {{c}}});
 871 @c flatten ({a, {[a], {a}}});
 872 @c ===end===
 873 @example
 874 (%i1) flatten (@{a, @{b@}, @{@{c@}@}@});
 875 (%o1)                       @{a, b, c@}
 876 (%i2) flatten (@{a, @{[a], @{a@}@}@});
 877 (%o2)                       @{a, [a]@}
 878 @end example
 879
 880 La función @code{flatten} es similar a la declaración del operador
 881 principal como n-ario. Sin embargo, @code{flatten} no tiene efecto alguno
 882 sobre subexpresiones que tengan un operador diferente del principal, mientras
 883 que sí lo tiene una declaración n-aria.
 884
 885
 886 @c ===beg===
 887 @c expr: flatten (f (g (f (f (x)))));
 888 @c declare (f, nary);
 889 @c ev (expr);
 890 @c ===end===
 891 @example
 892 (%i1) expr: flatten (f (g (f (f (x)))));
 893 (%o1)                     f(g(f(f(x))))
 894 (%i2) declare (f, nary);
 895 (%o2)                         done
 896 (%i3) ev (expr);
 897 (%o3)                      f(g(f(x)))
 898 @end example
 899
 900 La función @code{flatten} trata las funciones subindicadas como
 901 a cualquier otro operador.
 902
 903 @c ===beg===
 904 @c flatten (f[5] (f[5] (x, y), z));
 905 @c ===end===
 906 @example
 907 (%i1) flatten (f[5] (f[5] (x, y), z));
 908 (%o1)                      f (x, y, z)
 909                             5
 910 @end example
 911
 912 Es posible que @code{flatten} construya expresiones en las que el número
 913 de argumentos difiera del número admitido por el operador.
 914
 915 @c ===beg===
 916 @c 'mod (5, 'mod (7, 4));
 917 @c flatten (%);
 918 @c ''%, nouns;
 919 @c ===end===
 920 @example
 921 (%i1) 'mod (5, 'mod (7, 4));
 922 (%o1)                   mod(5, mod(7, 4))
 923 (%i2) flatten (%);
 924 (%o2)                     mod(5, 7, 4)
 925 (%i3) ''%, nouns;
 926 Wrong number of arguments to mod
 927  -- an error.  Quitting.  To debug this try debugmode(true);
 928 @end example
 929 @end deffn
 930
 931
 932 @deffn {Función} full_listify (@var{a})
 933
 934 Sustituye los operadores de conjunto presentes en @var{a}
 935 por operadores de listas, devolviendo el resultado.
 936 La función @code{full_listify} sustituye operadores de
 937 conjuntos en subexpresiones anidadas, incluso cuando
 938 el operador principal no es @code{set}.
 939
 940 La función @code{listify} sustituye únicamente el
 941 operador principal.
 942
 943 Ejemplos:
 944
 945 @c ===beg===
 946 @c full_listify ({a, b, {c, {d, e, f}, g}});
 947 @c full_listify (F (G ({a, b, H({c, d, e})})));
 948 @c ===end===
 949 @example
 950 (%i1) full_listify (@{a, b, @{c, @{d, e, f@}, g@}@});
 951 (%o1)               [a, b, [c, [d, e, f], g]]
 952 (%i2) full_listify (F (G (@{a, b, H(@{c, d, e@})@})));
 953 (%o2)              F(G([a, b, H([c, d, e])]))
 954 @end example
 955 @end deffn
 956
 957
 958 @deffn {Función} fullsetify (@var{a})
 959
 960 Si @var{a} es una lista, sustituye el operador de lista por el
 961 de conjunto, aplicando posteriormente @code{fullsetify} a todos
 962 los elementos que son a su vez conjuntos.
 963 Si @var{a} no es una lista, se devuelve sin cambio alguno.
 964
 965 La función @code{setify} sustituye solamente el operador principal.
 966
 967 Ejemplos:
 968
 969 En la salida @code{(%o2)} el argumento de @code{f} no se convierte en
 970 conjunto porque el operador principal de @code{f([b])} no es una lista.
 971
 972 @c ===beg===
 973 @c fullsetify ([a, [a]]);
 974 @c fullsetify ([a, f([b])]);
 975 @c ===end===
 976 @example
 977 (%i1) fullsetify ([a, [a]]);
 978 (%o1)                       @{a, @{a@}@}
 979 (%i2) fullsetify ([a, f([b])]);
 980 (%o2)                      @{a, f([b])@}
 981 @end example
 982 @end deffn
 983
 984
 985 @deffn {Función} identity (@var{x})
 986
 987 La función @code{identity} devuelve su argumento cualquiera que sea éste.
 988
 989 Ejemplos:
 990
 991 La función @code{identity} puede utilizarse como predicado cuando
 992 los argumentos ya son valores booleanos.
 993
 994 @c ===beg===
 995 @c every (identity, [true, true]);
 996 @c ===end===
 997 @example
 998 (%i1) every (identity, [true, true]);
 999 (%o1)                         true
1000 @end example
1001 @end deffn
1002
1003
1004 @deffn {Función} integer_partitions (@var{n})
1005 @deffnx {Función} integer_partitions (@var{n}, @var{len})
1006
1007 Devuelve particiones enteras de @var{n}, esto es,
1008 listas de enteros cuyas sumas son @var{n}.
1009
1010 La sentencia @code{integer_partitions(@var{n})}
1011 devuelve el conjunto de todas las particiones del entero @var{n}.
1012 Cada partición es una lista ordenada de mayor a menor.
1013
1014 La sentencia @code{integer_partitions(@var{n}, @var{len})}
1015 devuelve todas las particiones de longitud @var{len} o menor;
1016 en este caso, se añaden ceros a cada partición con menos
1017 de @var{len} términos para que todas ellas sean de longitud
1018 @var{len}. Las particiones son listas ordenadas de mayor a menor.
1019
1020 Una lista @math{[a_1, ..., a_m]} es una partición de un entero no
1021 negativo @math{n} si (1) cada @math{a_i} es entero no nulo y (2)
1022 @math{a_1 + ... + a_m = n.} Así, 0 no tiene particiones.
1023
1024 Ejemplos:
1025
1026 @c ===beg===
1027 @c integer_partitions (3);
1028 @c s: integer_partitions (25)$
1029 @c cardinality (s);
1030 @c map (lambda ([x], apply ("+", x)), s);
1031 @c integer_partitions (5, 3);
1032 @c integer_partitions (5, 2);
1033 @c ===end===
1034 @example
1035 (%i1) integer_partitions (3);
1036 (%o1)               @{[1, 1, 1], [2, 1], [3]@}
1037 (%i2) s: integer_partitions (25)$
1038 (%i3) cardinality (s);
1039 (%o3)                         1958
1040 (%i4) map (lambda ([x], apply ("+", x)), s);
1041 (%o4)                         @{25@}
1042 (%i5) integer_partitions (5, 3);
1043 (%o5) @{[2, 2, 1], [3, 1, 1], [3, 2, 0], [4, 1, 0], [5, 0, 0]@}
1044 (%i6) integer_partitions (5, 2);
1045 (%o6)               @{[3, 2], [4, 1], [5, 0]@}
1046 @end example
1047
1048 Para encontrar todas las particiones que satisfagan cierta
1049 condición, utilícese la función @code{subset};
1050 he aquí un ejemplo que encuentra todas las
1051 particiones de 10 formadas por números primos.
1052
1053 @c ===beg===
1054 @c s: integer_partitions (10)$
1055 @c cardinality (s);
1056 @c xprimep(x) := integerp(x) and (x > 1) and primep(x)$
1057 @c subset (s, lambda ([x], every (xprimep, x)));
1058 @c ===end===
1059 @example
1060 (%i1) s: integer_partitions (10)$
1061 (%i2) cardinality (s);
1062 (%o2)                          42
1063 (%i3) xprimep(x) := integerp(x) and (x > 1) and primep(x)$
1064 (%i4) subset (s, lambda ([x], every (xprimep, x)));
1065 (%o4) @{[2, 2, 2, 2, 2], [3, 3, 2, 2], [5, 3, 2], [5, 5], [7, 3]@}
1066 @end example
1067 @end deffn
1068
1069
1070 @deffn {Función} intersect (@var{a_1}, ..., @var{a_n})
1071 Es una forma abreviada de la función @code{intersection}.
1072 @end deffn
1073
1074
1075 @deffn {Función} intersection (@var{a_1}, ..., @var{a_n})
1076
1077 Devuelve el conjunto de todos los elementos que son
1078 comunes a los conjuntos  @var{a_1} a @var{a_n}.
1079
1080 Emite un mensaje de error en caso de que cualquiera de los
1081 @var{a_i} no sea un conjunto.
1082
1083 Ejemplos:
1084
1085 @c ===beg===
1086 @c S_1 : {a, b, c, d};
1087 @c S_2 : {d, e, f, g};
1088 @c S_3 : {c, d, e, f};
1089 @c S_4 : {u, v, w};
1090 @c intersection (S_1, S_2);
1091 @c intersection (S_2, S_3);
1092 @c intersection (S_1, S_2, S_3);
1093 @c intersection (S_1, S_2, S_3, S_4);
1094 @c ===end===
1095 @example
1096 (%i1) S_1 : @{a, b, c, d@};
1097 (%o1)                     @{a, b, c, d@}
1098 (%i2) S_2 : @{d, e, f, g@};
1099 (%o2)                     @{d, e, f, g@}
1100 (%i3) S_3 : @{c, d, e, f@};
1101 (%o3)                     @{c, d, e, f@}
1102 (%i4) S_4 : @{u, v, w@};
1103 (%o4)                       @{u, v, w@}
1104 (%i5) intersection (S_1, S_2);
1105 (%o5)                          @{d@}
1106 (%i6) intersection (S_2, S_3);
1107 (%o6)                       @{d, e, f@}
1108 (%i7) intersection (S_1, S_2, S_3);
1109 (%o7)                          @{d@}
1110 (%i8) intersection (S_1, S_2, S_3, S_4);
1111 (%o8)                          @{@}
1112 @end example
1113 @end deffn
1114
1115 @deffn {Función} kron_delta (@var{x1}, @var{y1}, @dots{}, @var{xp}, @var{yp})
1116
1117 Es la función delta de Kronecker.
1118
1119 La función @code{kron_delta} devuelve 1 cuando @var{xi} y
1120 @var{yi} son iguales para todos los pares, devolviendo 0 si existe
1121 un par en el que @var{xi} y @var{yi} no sean iguales. La igualdad
1122 se determina utilizando @code{is(equal(xi,xj))} y la desigualdad
1123 con @code{is(notequal(xi,xj))}. En caso de un solo argumento,
1124 @code{kron_delta} devuelve un mensaje de error.
1125
1126 Ejemplos:
1127
1128 @c ===beg===
1129 @c kron_delta(a,a);
1130 @c kron_delta(a,b,a,b);
1131 @c kron_delta(a,a,b,a+1);
1132 @c assume(equal(x,y));
1133 @c kron_delta(x,y);
1134 @c ===end===
1135 @example
1136 (%i1) kron_delta(a,a);
1137 (%o1)                                  1
1138 (%i2) kron_delta(a,b,a,b);
1139 (%o2)                          kron_delta(a, b)
1140 (%i3) kron_delta(a,a,b,a+1);
1141 (%o3)                                  0
1142 (%i4) assume(equal(x,y));
1143 (%o4)                            [equal(x, y)]
1144 (%i5) kron_delta(x,y);
1145 (%o5)                                  1
1146 @end example
1147 @end deffn
1148
1149
1150 @deffn {Función} listify (@var{a})
1151
1152 Si @var{a} es un conjunto, devuelve una lista con los elementos de @var{a};
1153 si  @var{a} no es un conjunto, devuelve @var{a}.
1154
1155 La función @code{full_listify} sustituye todos los operadores
1156 de conjunto en @var{a} por operadores de lista.
1157
1158 Ejemplos:
1159
1160 @c ===beg===
1161 @c listify ({a, b, c, d});
1162 @c listify (F ({a, b, c, d}));
1163 @c ===end===
1164 @example
1165 (%i1) listify (@{a, b, c, d@});
1166 (%o1)                     [a, b, c, d]
1167 (%i2) listify (F (@{a, b, c, d@}));
1168 (%o2)                    F(@{a, b, c, d@})
1169 @end example
1170 @end deffn
1171
1172
1173 @deffn {Función} lreduce (@var{f}, @var{s})
1174 @deffnx {Función} lreduce (@var{f}, @var{s}, @var{init})
1175
1176 Amplía la función binaria @var{F} a n-aria mediante
1177 composición, siendo @var{s} una lista.
1178
1179 La sentencia  @code{lreduce(@var{F}, @var{s})} devuelve
1180 @code{F(... F(F(s_1, s_2), s_3), ... s_n)}.
1181 Si se incluye el argumento opcional @var{s_0},
1182 el resultado equivale a @code{lreduce(@var{F}, cons(@var{s_0}, @var{s}))}.
1183
1184 La función @var{F} se aplica primero a los elementos del
1185 extremo izquierdo de la lista, de ahí el nombre
1186 @code{lreduce}, (@i{left reduce}).
1187
1188 Véanse también @code{rreduce}, @code{xreduce} y @code{tree_reduce}.
1189
1190 Ejemplos:
1191
1192 La función @code{lreduce} sin el argumento opcional,
1193
1194 @c ===beg===
1195 @c lreduce (f, [1, 2, 3]);
1196 @c lreduce (f, [1, 2, 3, 4]);
1197 @c ===end===
1198 @example
1199 (%i1) lreduce (f, [1, 2, 3]);
1200 (%o1)                     f(f(1, 2), 3)
1201 (%i2) lreduce (f, [1, 2, 3, 4]);
1202 (%o2)                  f(f(f(1, 2), 3), 4)
1203 @end example
1204
1205 La función @code{lreduce} con el argumento opcional,
1206
1207 @c ===beg===
1208 @c lreduce (f, [1, 2, 3], 4);
1209 @c ===end===
1210 @example
1211 (%i1) lreduce (f, [1, 2, 3], 4);
1212 (%o1)                  f(f(f(4, 1), 2), 3)
1213 @end example
1214
1215 La función @code{lreduce} aplicada a operadores binarios de Maxima.
1216 El símbolo @code{/} es el operador división.
1217
1218 @c ===beg===
1219 @c lreduce ("^", args ({a, b, c, d}));
1220 @c lreduce ("/", args ({a, b, c, d}));
1221 @c ===end===
1222 @example
1223 (%i1) lreduce ("^", args (@{a, b, c, d@}));
1224                                b c d
1225 (%o1)                       ((a ) )
1226 (%i2) lreduce ("/", args (@{a, b, c, d@}));
1227                                 a
1228 (%o2)                         -----
1229                               b c d
1230 @end example
1231
1232 @end deffn
1233
1234
1235 @deffn {Función} makeset (@var{expr}, @var{x}, @var{s})
1236
1237 Genera un conjunto cuyos miembros se generan a partir de la
1238 expresión @var{expr}, siendo @var{x} una lista de variables de
1239 @var{expr} y @var{s} un conjunto o lista de listas.
1240 Para generar los elementos del conjunto, se evalúa @var{expr}
1241 asignando a las variables de @var{x} los elementos de @var{s}
1242 en paralelo.
1243
1244 Los elementos de @var{s} deben tener la misma longitud que @var{x}.
1245 La lista de variables @var{x} debe ser una lista de símbolos
1246 sin subíndices. Cuando se trate de un único símbolo,
1247 @var{x} debe expresarse como una lista de un elemento y cada elemento de @var{s}
1248 debe ser una lista de un sólo elemento.
1249
1250 @c FOLLOWING EQUIVALENT EXPRESSION IS REALLY TOO COMPLICATED, JUST SKIP IT FOR NOW
1251 @c @code{makeset(@var{expr}, @var{x}, @var{s})} returns the same result as
1252 @c @code{setify(map(lambda([L], sublis(map("=", ''@var{x}, L), ''@var{expr})), args(@var{s})))}.
1253
1254 Véase también @code{makelist}.
1255
1256 Ejemplos:
1257
1258 @c ===beg===
1259 @c makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]);
1260 @c S : {x, y, z}$
1261 @c S3 : cartesian_product (S, S, S);
1262 @c makeset (i + j + k, [i, j, k], S3);
1263 @c makeset (sin(x), [x], {[1], [2], [3]});
1264 @c ===end===
1265 @example
1266 (%i1) makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]);
1267                            1  2  3  4
1268 (%o1)                     @{-, -, -, -@}
1269                            a  b  c  d
1270 (%i2) S : @{x, y, z@}$
1271 (%i3) S3 : cartesian_product (S, S, S);
1272 (%o3) @{[x, x, x], [x, x, y], [x, x, z], [x, y, x], [x, y, y],
1273 [x, y, z], [x, z, x], [x, z, y], [x, z, z], [y, x, x],
1274 [y, x, y], [y, x, z], [y, y, x], [y, y, y], [y, y, z],
1275 [y, z, x], [y, z, y], [y, z, z], [z, x, x], [z, x, y],
1276 [z, x, z], [z, y, x], [z, y, y], [z, y, z], [z, z, x],
1277 [z, z, y], [z, z, z]@}
1278 (%i4) makeset (i + j + k, [i, j, k], S3);
1279 (%o4) @{3 x, 3 y, y + 2 x, 2 y + x, 3 z, z + 2 x, z + y + x,
1280                                        z + 2 y, 2 z + x, 2 z + y@}
1281 (%i5) makeset (sin(x), [x], @{[1], [2], [3]@});
1282 (%o5)               @{sin(1), sin(2), sin(3)@}
1283 @end example
1284 @end deffn
1285
1286
1287 @deffn {Función} moebius (@var{n})
1288
1289 Representa la función de Moebius.
1290
1291 Si @var{n} es el producto de @math{k} números primos diferentes,
1292 @code{moebius(@var{n})} devuelve @math{(-1)^k}, retornando 1 si
1293 @math{@var{n} = 1} y 0 para cualesquiera otros enteros positivos.
1294
1295
1296 La función de Moebius se distribuye respecto de ecuaciones,
1297 listas, matrices y conjuntos.
1298
1299 Ejemplos:
1300
1301 @c ===beg===
1302 @c moebius (1);
1303 @c moebius (2 * 3 * 5);
1304 @c moebius (11 * 17 * 29 * 31);
1305 @c moebius (2^32);
1306 @c moebius (n);
1307 @c moebius (n = 12);
1308 @c moebius ([11, 11 * 13, 11 * 13 * 15]);
1309 @c moebius (matrix ([11, 12], [13, 14]));
1310 @c moebius ({21, 22, 23, 24});
1311 @c ===end===
1312 @example
1313 (%i1) moebius (1);
1314 (%o1)                           1
1315 (%i2) moebius (2 * 3 * 5);
1316 (%o2)                          - 1
1317 (%i3) moebius (11 * 17 * 29 * 31);
1318 (%o3)                           1
1319 (%i4) moebius (2^32);
1320 (%o4)                           0
1321 (%i5) moebius (n);
1322 (%o5)                      moebius(n)
1323 (%i6) moebius (n = 12);
1324 (%o6)                    moebius(n) = 0
1325 (%i7) moebius ([11, 11 * 13, 11 * 13 * 15]);
1326 (%o7)                      [- 1, 1, 1]
1327 (%i8) moebius (matrix ([11, 12], [13, 14]));
1328                            [ - 1  0 ]
1329 (%o8)                      [        ]
1330                            [ - 1  1 ]
1331 (%i9) moebius (@{21, 22, 23, 24@});
1332 (%o9)                      @{- 1, 0, 1@}
1333 @end example
1334 @end deffn
1335
1336
1337 @deffn {Función} multinomial_coeff (@var{a_1}, ..., @var{a_n})
1338 @deffnx {Función} multinomial_coeff ()
1339
1340 Calcula el coeficiente multinomial.
1341
1342 Si todos los @var{a_k} son enteros no negativos, el coeficiente multinomial
1343 es el número de formas de colocar  @code{@var{a_1} + ... + @var{a_n}}
1344 objetos diferentes en  @math{n} cajas con @var{a_k} elementos en la
1345 @math{k}-ésima caja. En general,
1346 @code{multinomial_coeff (@var{a_1}, ..., @var{a_n})} calcula
1347 @code{(@var{a_1} + ... + @var{a_n})!/(@var{a_1}! ... @var{a_n}!)}.
1348
1349 Si no se dan argumentos, @code{multinomial_coeff()} devuelve 1.
1350
1351 Se puede usar @code{minfactorial} para simplificar el valor
1352 devuelto por @code{multinomial_coeff}.
1353
1354 Ejemplos:
1355
1356 @c ===beg===
1357 @c multinomial_coeff (1, 2, x);
1358 @c minfactorial (%);
1359 @c multinomial_coeff (-6, 2);
1360 @c minfactorial (%);
1361 @c ===end===
1362 @example
1363 (%i1) multinomial_coeff (1, 2, x);
1364                             (x + 3)!
1365 (%o1)                       --------
1366                               2 x!
1367 (%i2) minfactorial (%);
1368                      (x + 1) (x + 2) (x + 3)
1369 (%o2)                -----------------------
1370                                 2
1371 (%i3) multinomial_coeff (-6, 2);
1372                              (- 4)!
1373 (%o3)                       --------
1374                             2 (- 6)!
1375 (%i4) minfactorial (%);
1376 (%o4)                          10
1377 @end example
1378 @end deffn
1379
1380
1381 @deffn {Función} num_distinct_partitions (@var{n})
1382 @deffnx {Función} num_distinct_partitions (@var{n}, @var{list})
1383
1384 Si @var{n} es un entero no negativo, devuelve el número de
1385 particiones enteras distintas de @var{n}, en caso contrario
1386 @code{num_distinct_partitions} devuelve una forma nominal.
1387
1388 La sentencia @code{num_distinct_partitions(@var{n}, list)}
1389 devuelve una lista con el número de particiones distintas
1390 de 1, 2, 3, ..., @var{n}.
1391
1392 Una partición distinta de @var{n} es una lista de números
1393 enteros positivos distintos @math{k_1}, ..., @math{k_m}
1394 tales que @math{@var{n} = k_1 + ... + k_m}.
1395
1396 Ejemplos:
1397
1398 @c ===beg===
1399 @c num_distinct_partitions (12);
1400 @c num_distinct_partitions (12, list);
1401 @c num_distinct_partitions (n);
1402 @c ===end===
1403 @example
1404 (%i1) num_distinct_partitions (12);
1405 (%o1)                          15
1406 (%i2) num_distinct_partitions (12, list);
1407 (%o2)      [1, 1, 1, 2, 2, 3, 4, 5, 6, 8, 10, 12, 15]
1408 (%i3) num_distinct_partitions (n);
1409 (%o3)              num_distinct_partitions(n)
1410 @end example
1411 @end deffn
1412
1413
1414 @deffn {Función} num_partitions (@var{n})
1415 @deffnx {Función} num_partitions (@var{n}, @var{list})
1416
1417 Si @var{n} es un entero no negativo, devuelve el número de
1418 particiones enteras de @var{n}, en caso contrario @code{num_partitions}
1419 devuelve una expresión nominal.
1420
1421 La sentencia @code{num_partitions(@var{n}, list)} devuelve una lista
1422 con los números de particiones enteras de 1, 2, 3, ..., @var{n}.
1423
1424 Siendo @var{n} un entero no negativo, @code{num_partitions(@var{n})}
1425 es igual a @code{cardinality(integer_partitions(@var{n}))}; sin
1426 embargo, @code{num_partitions} no construye el conjunto de
1427 particiones, por lo que es más rápido.
1428
1429 Ejemplos:
1430
1431 @c ===beg===
1432 @c num_partitions (5) = cardinality (integer_partitions (5));
1433 @c num_partitions (8, list);
1434 @c num_partitions (n);
1435 @c ===end===
1436 @example
1437 (%i1) num_partitions (5) = cardinality (integer_partitions (5));
1438 (%o1)                         7 = 7
1439 (%i2) num_partitions (8, list);
1440 (%o2)            [1, 1, 2, 3, 5, 7, 11, 15, 22]
1441 (%i3) num_partitions (n);
1442 (%o3)                   num_partitions(n)
1443 @end example
1444 @end deffn
1445
1446
1447 @deffn {Función} partition_set (@var{a}, @var{f})
1448
1449 Particiona el conjunto @var{a} respecto del predicado @var{f}.
1450
1451 La función @code{partition_set} devuelve una lista con dos conjuntos;
1452 el primer conjunto es el subconjunto de @var{a} para el cual el predicado
1453 @var{f} devuelve @code{false} y el segundo contiene al resto de elementos de @var{a}.
1454
1455 La función @code{partition_set} no aplica @code{is} al valor devuelto
1456 por @var{f}.
1457
1458 La función @code{partition_set} emite un mensaje de error si @var{a}
1459 no es un conjunto literal.
1460
1461 Véase también @code{subset}.
1462
1463 Ejemplos:
1464
1465 @c ===beg===
1466 @c partition_set ({2, 7, 1, 8, 2, 8}, evenp);
1467 @c partition_set ({x, rat(y), rat(y) + z, 1},
1468 @c                 lambda ([x], ratp(x)));
1469 @c ===end===
1470 @example
1471 (%i1) partition_set (@{2, 7, 1, 8, 2, 8@}, evenp);
1472 (%o1)                   [@{1, 7@}, @{2, 8@}]
1473 (%i2) partition_set (@{x, rat(y), rat(y) + z, 1@},
1474                   lambda ([x], ratp(x)));
1475 (%o2)/R/              [@{1, x@}, @{y, y + z@}]
1476 @end example
1477 @end deffn
1478
1479
1480 @deffn {Función} permutations (@var{a})
1481
1482 Devuelve un conjunto con todas las permutaciones distintas
1483 de los miembros de la lista o conjunto  @var{a}. Cada permutación
1484 es una lista, no un conjunto.
1485
1486 Si @var{a} es una lista, sus miembros duplicados no son eliminados
1487 antes de buscar sus permutaciones.
1488
1489 Si @var{a} no es una lista o conjunto, @code{permutations} emite
1490 un mensaje de error.
1491
1492 Véase también @code{random_permutation}.
1493
1494 Ejemplos:
1495
1496 @c ===beg===
1497 @c permutations ([a, a]);
1498 @c permutations ([a, a, b]);
1499 @c ===end===
1500 @example
1501 (%i1) permutations ([a, a]);
1502 (%o1)                       @{[a, a]@}
1503 (%i2) permutations ([a, a, b]);
1504 (%o2)           @{[a, a, b], [a, b, a], [b, a, a]@}
1505 @end example
1506 @end deffn
1507
1508
1509 @deffn {Función} powerset (@var{a})
1510 @deffnx {Función} powerset (@var{a}, @var{n})
1511
1512 Devuelve el conjunto de todos los subconjuntos del conjunto @var{a}
1513 o un sunconjunto de ellos.
1514
1515 La sentencia @code{powerset(@var{a})} devuelve el conjunto de todos
1516 los subconjuntos de @var{a}, que contendrá @code{2^cardinality(@var{a})}
1517 elementos.
1518
1519 La sentencia @code{powerset(@var{a}, @var{n})} devuelve el conjunto de todos
1520 los subconjuntos de @var{a} de cardinalidad @var{n}.
1521
1522 La función @code{powerset} emite un mensaje de error si @var{a} no
1523 es un conjunto literal o si @var{n} no es un entero no negativo.
1524
1525 Ejemplos:
1526
1527 @c ===beg===
1528 @c powerset ({a, b, c});
1529 @c powerset ({w, x, y, z}, 4);
1530 @c powerset ({w, x, y, z}, 3);
1531 @c powerset ({w, x, y, z}, 2);
1532 @c powerset ({w, x, y, z}, 1);
1533 @c powerset ({w, x, y, z}, 0);
1534 @c ===end===
1535 @example
1536 (%i1) powerset (@{a, b, c@});
1537 (%o1) @{@{@}, @{a@}, @{a, b@}, @{a, b, c@}, @{a, c@}, @{b@}, @{b, c@}, @{c@}@}
1538 (%i2) powerset (@{w, x, y, z@}, 4);
1539 (%o2)                    @{@{w, x, y, z@}@}
1540 (%i3) powerset (@{w, x, y, z@}, 3);
1541 (%o3)     @{@{w, x, y@}, @{w, x, z@}, @{w, y, z@}, @{x, y, z@}@}
1542 (%i4) powerset (@{w, x, y, z@}, 2);
1543 (%o4)   @{@{w, x@}, @{w, y@}, @{w, z@}, @{x, y@}, @{x, z@}, @{y, z@}@}
1544 (%i5) powerset (@{w, x, y, z@}, 1);
1545 (%o5)                 @{@{w@}, @{x@}, @{y@}, @{z@}@}
1546 (%i6) powerset (@{w, x, y, z@}, 0);
1547 (%o6)                         @{@{@}@}
1548 @end example
1549 @end deffn
1550
1551
1552
1553 @deffn {Función} random_permutation (@var{a})
1554
1555 Devuelve una permutación aleatoria del conjunto o lista
1556 @var{a}, siguiendo el algoritmo de Knuth.
1557
1558 El valor devuelto es una lista nueva distinta del argumento,
1559 incluso cuando todos los elementos son iguales. Sin embargo,
1560 los elementos del argumento no se copian.
1561
1562 Ejemplos:
1563
1564 @c ===beg===
1565 @c random_permutation ([a, b, c, 1, 2, 3]);
1566 @c random_permutation ([a, b, c, 1, 2, 3]);
1567 @c random_permutation ({x + 1, y + 2, z + 3});
1568 @c random_permutation ({x + 1, y + 2, z + 3});
1569 @c ===end===
1570 @example
1571 (%i1) random_permutation ([a, b, c, 1, 2, 3]);
1572 (%o1)                  [c, 1, 2, 3, a, b]
1573 (%i2) random_permutation ([a, b, c, 1, 2, 3]);
1574 (%o2)                  [b, 3, 1, c, a, 2]
1575 (%i3) random_permutation (@{x + 1, y + 2, z + 3@});
1576 (%o3)                 [y + 2, z + 3, x + 1]
1577 (%i4) random_permutation (@{x + 1, y + 2, z + 3@});
1578 (%o4)                 [x + 1, y + 2, z + 3]
1579 @end example
1580
1581 @end deffn
1582
1583
1584
1585
1586 @deffn {Función} rreduce (@var{f}, @var{s})
1587 @deffnx {Función} rreduce (@var{f}, @var{s}, @var{init})
1588
1589 Amplía la función binaria @var{F} a n-aria mediante
1590 composición, siendo @var{s} una lista.
1591
1592 La sentencia  @code{rreduce(@var{F}, @var{s})} devuelve
1593 @code{F(s_1, ... F(s_@{n - 2@}, F(s_@{n - 1@}, s_n)))}.
1594 Si se incluye el argumento opcional @var{s_@{n + 1@}},
1595 el resultado equivale a @code{rreduce(@var{F}, endcons(@var{s_@{n + 1@}}, @var{s}))}.
1596
1597 La función @var{F} se aplica primero a los elementos del
1598 extremo derecho de la lista, de ahí el nombre
1599 @code{rreduce}, (@i{right reduce}).
1600
1601 Véanse también @code{lreduce}, @code{xreduce} y @code{tree_reduce}.
1602
1603 Ejemplos:
1604
1605 La función @code{rreduce} sin el argumento opcional,
1606
1607 @c ===beg===
1608 @c rreduce (f, [1, 2, 3]);
1609 @c rreduce (f, [1, 2, 3, 4]);
1610 @c ===end===
1611 @example
1612 (%i1) rreduce (f, [1, 2, 3]);
1613 (%o1)                     f(1, f(2, 3))
1614 (%i2) rreduce (f, [1, 2, 3, 4]);
1615 (%o2)                  f(1, f(2, f(3, 4)))
1616 @end example
1617
1618 La función @code{rreduce} con el argumento opcional,
1619
1620 @c ===beg===
1621 @c rreduce (f, [1, 2, 3], 4);
1622 @c ===end===
1623 @example
1624 (%i1) rreduce (f, [1, 2, 3], 4);
1625 (%o1)                  f(1, f(2, f(3, 4)))
1626 @end example
1627
1628 La función @code{rreduce} aplicada a operadores binarios de Maxima.
1629 El símbolo @code{/} es el operador división.
1630
1631 @c ===beg===
1632 @c rreduce ("^", args ({a, b, c, d}));
1633 @c rreduce ("/", args ({a, b, c, d}));
1634 @c ===end===
1635 @example
1636 (%i1) rreduce ("^", args (@{a, b, c, d@}));
1637                                  d
1638                                 c
1639                                b
1640 (%o1)                         a
1641 (%i2) rreduce ("/", args (@{a, b, c, d@}));
1642                                a c
1643 (%o2)                          ---
1644                                b d
1645 @end example
1646 @end deffn
1647
1648
1649 @deffn {Función}  setdifference (@var{a}, @var{b})
1650
1651 Devuelve el conjunto con los elementos del conjunto @var{a} que
1652 no pertenecen al conjunto @var{b}.
1653
1654 La función @code{setdifference} emite un mensaje de error si
1655 @var{a} o @var{b} no son conjuntos.
1656
1657 Ejemplos:
1658
1659 @c ===beg===
1660 @c S_1 : {a, b, c, x, y, z};
1661 @c S_2 : {aa, bb, c, x, y, zz};
1662 @c setdifference (S_1, S_2);
1663 @c setdifference (S_2, S_1);
1664 @c setdifference (S_1, S_1);
1665 @c setdifference (S_1, {});
1666 @c setdifference ({}, S_1);
1667 @c ===end===
1668 @example
1669 (%i1) S_1 : @{a, b, c, x, y, z@};
1670 (%o1)                  @{a, b, c, x, y, z@}
1671 (%i2) S_2 : @{aa, bb, c, x, y, zz@};
1672 (%o2)                 @{aa, bb, c, x, y, zz@}
1673 (%i3) setdifference (S_1, S_2);
1674 (%o3)                       @{a, b, z@}
1675 (%i4) setdifference (S_2, S_1);
1676 (%o4)                     @{aa, bb, zz@}
1677 (%i5) setdifference (S_1, S_1);
1678 (%o5)                          @{@}
1679 (%i6) setdifference (S_1, @{@});
1680 (%o6)                  @{a, b, c, x, y, z@}
1681 (%i7) setdifference (@{@}, S_1);
1682 (%o7)                          @{@}
1683 @end example
1684 @end deffn
1685
1686
1687 @deffn {Función} setequalp (@var{a}, @var{b})
1688
1689 Devuelve  @code{true} si los conjuntos @var{a} y @var{b} tienen
1690 el mismo número de elementos
1691 @c $SETEQUALP CALLS THE LISP FUNCTION LIKE,
1692 @c AND SO DOES THE CODE TO EVALUATE IS (X = Y).
1693 y @code{is (@var{x} = @var{y})} vale @code{true}
1694 para @code{x} perteneciente a @var{a}
1695 e @code{y} perteneciente a @var{b},
1696 considerados en el orden que determina la función
1697 @code{listify}. En caso contrario, @code{setequalp}
1698 devuelve @code{false}.
1699
1700 Ejemplos:
1701
1702 @c ===beg===
1703 @c setequalp ({1, 2, 3}, {1, 2, 3});
1704 @c setequalp ({a, b, c}, {1, 2, 3});
1705 @c setequalp ({x^2 - y^2}, {(x + y) * (x - y)});
1706 @c ===end===
1707 @example
1708 (%i1) setequalp (@{1, 2, 3@}, @{1, 2, 3@});
1709 (%o1)                         true
1710 (%i2) setequalp (@{a, b, c@}, @{1, 2, 3@});
1711 (%o2)                         false
1712 (%i3) setequalp (@{x^2 - y^2@}, @{(x + y) * (x - y)@});
1713 (%o3)                         false
1714 @end example
1715 @end deffn
1716
1717
1718 @deffn {Función} setify (@var{a})
1719
1720 Construye un conjunto con los miembros de la lista @var{a}.
1721 Los elementos duplicados de la lista @var{a} son borrados
1722 y ordenados de acuerdo con el predicado @code{orderlessp}.
1723
1724 La función @code{setify} emite un mensaje de error si
1725 @var{a} no es un conjunto literal.
1726
1727 Ejemplos:
1728
1729 @c ===beg===
1730 @c setify ([1, 2, 3, a, b, c]);
1731 @c setify ([a, b, c, a, b, c]);
1732 @c setify ([7, 13, 11, 1, 3, 9, 5]);
1733 @c ===end===
1734 @example
1735 (%i1) setify ([1, 2, 3, a, b, c]);
1736 (%o1)                  @{1, 2, 3, a, b, c@}
1737 (%i2) setify ([a, b, c, a, b, c]);
1738 (%o2)                       @{a, b, c@}
1739 (%i3) setify ([7, 13, 11, 1, 3, 9, 5]);
1740 (%o3)                @{1, 3, 5, 7, 9, 11, 13@}
1741 @end example
1742 @end deffn
1743
1744
1745 @deffn {Función} setp (@var{a})
1746
1747 Devuelve @code{true} si y sólo si @var{a} es un conjunto de Maxima.
1748
1749 La función @code{setp} devuelve @code{true} tanto cuando el conjunto
1750 tiene como cuando no tiene elementos repetidos.
1751
1752 @c NOT SURE WE NEED TO MENTION THIS. OK FOR NOW
1753 La función @code{setp} is equivalent to the Maxima function
1754 @code{setp(a) := not atom(a) and op(a) = 'set}.
1755
1756 Ejemplos:
1757
1758 @c ===beg===
1759 @c simp : false;
1760 @c {a, a, a};
1761 @c setp (%);
1762 @c ===end===
1763 @example
1764 (%i1) simp : false;
1765 (%o1)                         false
1766 (%i2) @{a, a, a@};
1767 (%o2)                       @{a, a, a@}
1768 (%i3) setp (%);
1769 (%o3)                         true
1770 @end example
1771 @end deffn
1772
1773
1774 @deffn {Función} set_partitions (@var{a})
1775 @deffnx {Función} set_partitions (@var{a}, @var{n})
1776
1777 Devuelve el conjunto de todas las particiones de @var{a} o
1778 un subconjunto de ellas.
1779
1780 La sentencia @code{set_partitions(@var{a}, @var{n})}
1781 devuelve un conjunto con todas las descomposiciones de @var{a}
1782 en @var{n} conjuntos no vacíos disjuntos.
1783
1784 La sentencia @code{set_partitions(@var{a})} devuelve el
1785 conjunto de todas las particiones.
1786
1787 La función @code{stirling2} devuelve la cardinalidad del conjunto
1788 de las particiones de un conjunto.
1789
1790 Se dice que un conjunto @math{P} es una partición del conjunto @math{S} si verifica
1791
1792 @enumerate
1793 @item
1794 cada elemento de @math{P} es un conjunto no vacío,
1795 @item
1796 los elementos de @math{P} son disjuntos,
1797 @item
1798 la unión de los elementos de @math{P} es igual a  @math{S}.
1799 @end enumerate
1800
1801 Ejemplos:
1802
1803 El conjunto vacío forma una partición de sí mismo,
1804
1805 @c ===beg===
1806 @c set_partitions ({});
1807 @c ===end===
1808 @example
1809 (%i1) set_partitions (@{@});
1810 (%o1)                         @{@{@}@}
1811 @end example
1812
1813 La cardinalidad del conjunto de particiones de un conjunto puede calcularse con @code{stirling2},
1814
1815 @c ===beg===
1816 @c s: {0, 1, 2, 3, 4, 5}$
1817 @c p: set_partitions (s, 3)$
1818 @c cardinality(p) = stirling2 (6, 3);
1819 @c ===end===
1820 @example
1821 (%i1) s: @{0, 1, 2, 3, 4, 5@}$
1822 (%i2) p: set_partitions (s, 3)$
1823 (%i3) cardinality(p) = stirling2 (6, 3);
1824 (%o3)                        90 = 90
1825 @end example
1826
1827 Cada elemento de @code{p} debería tener @var{n} = 3 miembros,
1828
1829 @c ===beg===
1830 @c s: {0, 1, 2, 3, 4, 5}$
1831 @c p: set_partitions (s, 3)$
1832 @c map (cardinality, p);
1833 @c ===end===
1834 @example
1835 (%i1) s: @{0, 1, 2, 3, 4, 5@}$
1836 (%i2) p: set_partitions (s, 3)$
1837 (%i3) map (cardinality, p);
1838 (%o3)                          @{3@}
1839 @end example
1840
1841 Por último, para cada miembro de @code{p}, la unión de sus elementos
1842 debe ser igual a @code{s},
1843
1844 @c ===beg===
1845 @c s: {0, 1, 2, 3, 4, 5}$
1846 @c p: set_partitions (s, 3)$
1847 @c map (lambda ([x], apply (union, listify (x))), p);
1848 @c ===end===
1849 @example
1850 (%i1) s: @{0, 1, 2, 3, 4, 5@}$
1851 (%i2) p: set_partitions (s, 3)$
1852 (%i3) map (lambda ([x], apply (union, listify (x))), p);
1853 (%o3)                 @{@{0, 1, 2, 3, 4, 5@}@}
1854 @end example
1855 @end deffn
1856
1857
1858 @deffn {Función} some (@var{f}, @var{a})
1859 @deffnx {Función} some (@var{f}, @var{L_1}, ..., @var{L_n})
1860
1861 Devuelve @code{true} si el predicado @var{f} devuelve @code{true}
1862 para al menos uno de sus argumentos.
1863 Si el segundo argumento es un conjunto, @code{some (@var{f}, @var{a})}
1864 devuelve @code{true} si @code{@var{f}(@var{a_i})} devuelve también
1865 @code{true} para alguno de los @var{a_i} en @var{a}; puede ser que
1866 @code{some} no evalúe @var{f} para todos los @var{a_i} de @var{s}.
1867 Puesto que los conjuntos no están ordenados, @code{some} puede evaluar
1868 @code{@var{f}(@var{a_i})} en cualquier orden.
1869
1870 Dada una o más listas como argumentos,
1871 @code{some (@var{f}, @var{L_1}, ..., @var{L_n})} devuelve @code{true}
1872 si @code{@var{f}(@var{x_1}, ..., @var{x_n})} devuelve también
1873 @code{true} para al menos un  @var{x_1}, ..., @var{x_n} de
1874 @var{L_1}, ..., @var{L_n}, respectivamente; puede ser que
1875 @code{some} no evalúe @var{f} para todos las combinaciones
1876 @var{x_1}, ..., @var{x_n}. La función @code{some} evalúa
1877 las listas en el orden creciente de su índice
1878
1879 Dado un conjunto vacío @code{@{@}} o una lista
1880 vacía como argumentos, @code{some} devuelve @code{false}.
1881
1882 Si la variable global @code{maperror} vale @code{true},
1883 todas las listas @var{L_1}, ..., @var{L_n} deben tener
1884 igual número de elementos. Si @code{maperror} vale
1885 @code{false}, los argumentos se truncan para tener todos
1886 el número de elementos de la lista más corta.
1887
1888 Los valores que devuelve el predicado @var{f} cuando toman
1889 (mediante @code{is}) un valor diferente a @code{true} y @code{false}
1890 se controlan con la variable global @code{prederror}.
1891 Si @code{prederror} vale @code{true}, tales valores se
1892 consideran como @code{false}.
1893 Si @code{prederror} vale @code{false}, tales valores se
1894 consideran como desconocidos (@code{unknown}).
1895
1896 Ejemplos:
1897
1898 La función @code{some} aplicada a un único conjunto.
1899 El predicado es una función de un argumento,
1900
1901 @c ===beg===
1902 @c some (integerp, {1, 2, 3, 4, 5, 6});
1903 @c some (atom, {1, 2, sin(3), 4, 5 + y, 6});
1904 @c ===end===
1905 @example
1906 (%i1) some (integerp, @{1, 2, 3, 4, 5, 6@});
1907 (%o1)                         true
1908 (%i2) some (atom, @{1, 2, sin(3), 4, 5 + y, 6@});
1909 (%o2)                         true
1910 @end example
1911
1912 La función @code{some} aplicada a dos listas.
1913 El predicado es una función de dos argumentos,
1914
1915 @c ===beg===
1916 @c some ("=", [a, b, c], [a, b, c]);
1917 @c some ("#", [a, b, c], [a, b, c]);
1918 @c ===end===
1919 @example
1920 (%i1) some ("=", [a, b, c], [a, b, c]);
1921 (%o1)                         true
1922 (%i2) some ("#", [a, b, c], [a, b, c]);
1923 (%o2)                         false
1924 @end example
1925
1926 Las respuestas del predicado @var{f} que se evalúan
1927 a cualquier cosa diferente de @code{true} y @code{false}
1928 están controlados por la variable global @code{prederror}.
1929
1930 @c ===beg===
1931 @c prederror : false;
1932 @c map (lambda ([a, b], is (a < b)), [x, y, z],
1933 @c                 [x^2, y^2, z^2]);
1934 @c some ("<", [x, y, z], [x^2, y^2, z^2]);
1935 @c some ("<", [x, y, z], [x^2, y^2, z + 1]);
1936 @c prederror : true;
1937 @c some ("<", [x, y, z], [x^2, y^2, z^2]);
1938 @c some ("<", [x, y, z], [x^2, y^2, z + 1]);
1939 @c ===end===
1940 @example
1941 (%i1) prederror : false;
1942 (%o1)                         false
1943 (%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
1944                      [x^2, y^2, z^2]);
1945 (%o2)              [unknown, unknown, unknown]
1946 (%i3) some ("<", [x, y, z], [x^2, y^2, z^2]);
1947 (%o3)                        unknown
1948 (%i4) some ("<", [x, y, z], [x^2, y^2, z + 1]);
1949 (%o4)                         true
1950 (%i5) prederror : true;
1951 (%o5)                         true
1952 (%i6) some ("<", [x, y, z], [x^2, y^2, z^2]);
1953 (%o6)                         false
1954 (%i7) some ("<", [x, y, z], [x^2, y^2, z + 1]);
1955 (%o7)                         true
1956 @end example
1957 @end deffn
1958
1959
1960 @deffn {Función} stirling1 (@var{n}, @var{m})
1961
1962 Es el número de Stirling de primera especie.
1963
1964 Si tanto @var{n} como @var{m} son enteros no negativos,
1965 el valor que toma @code{stirling1 (@var{n}, @var{m})}
1966 es el número de permutaciones de un conjunto de
1967 @var{n} elementos con @var{m} ciclos. Para más detalles,
1968 véase Graham, Knuth and Patashnik @i{Concrete Mathematics}.
1969 Maxima utiliza una relación recursiva para definir
1970 @code{stirling1 (@var{n}, @var{m})} para @var{m} menor
1971 que 0; no está definida para @var{n} menor que 0 ni
1972 para argumentos no enteros.
1973
1974 La función @code{stirling1} es simplificadora. Maxima
1975 reconoce las siguientes identidades:
1976
1977 @c COPIED VERBATIM FROM SRC/NSET.LISP
1978 @enumerate
1979 @item
1980 @math{stirling1(0, n) = kron_delta(0, n)} (Ref. [1])
1981 @item
1982 @math{stirling1(n, n) = 1} (Ref. [1])
1983 @item
1984 @math{stirling1(n, n - 1) = binomial(n, 2)} (Ref. [1])
1985 @item
1986 @math{stirling1(n + 1, 0) = 0} (Ref. [1])
1987 @item
1988 @math{stirling1(n + 1, 1) = n!} (Ref. [1])
1989 @item
1990 @math{stirling1(n + 1, 2) = 2^n  - 1} (Ref. [1])
1991 @end enumerate
1992
1993 Estas identidades se aplican cuando los argumentos son enteros
1994 literales o símbolos declarados como enteros y
1995 el primer argumento es no negativo. La función @code{stirling1}
1996 no simplifica para argumentos no enteros.
1997
1998 Referencias:
1999
2000 [1] Donald Knuth, @i{The Art of Computer Programming,}
2001 Tercera Edición, Volumen 1, Sección 1.2.6, Ecuaciones 48, 49 y 50.
2002
2003 Ejemplos:
2004
2005 @c ===beg===
2006 @c declare (n, integer)$
2007 @c assume (n >= 0)$
2008 @c stirling1 (n, n);
2009 @c ===end===
2010 @example
2011 (%i1) declare (n, integer)$
2012 (%i2) assume (n >= 0)$
2013 (%i3) stirling1 (n, n);
2014 (%o3)                           1
2015 @end example
2016
2017 La función @code{stirling1} no simplifica en caso de argumentos no enteros,
2018
2019 @c ===beg===
2020 @c stirling1 (sqrt(2), sqrt(2));
2021 @c ===end===
2022 @example
2023 (%i1) stirling1 (sqrt(2), sqrt(2));
2024 (%o1)              stirling1(sqrt(2), sqrt(2))
2025 @end example
2026
2027 Maxima aplicas algunas identidades a @code{stirling1},
2028
2029 @c ===beg===
2030 @c declare (n, integer)$
2031 @c assume (n >= 0)$
2032 @c stirling1 (n + 1, n);
2033 @c stirling1 (n + 1, 1);
2034 @c ===end===
2035 @example
2036 (%i1) declare (n, integer)$
2037 (%i2) assume (n >= 0)$
2038 (%i3) stirling1 (n + 1, n);
2039                             n (n + 1)
2040 (%o3)                       ---------
2041                                 2
2042 (%i4) stirling1 (n + 1, 1);
2043 (%o4)                          n!
2044 @end example
2045 @end deffn
2046
2047
2048 @deffn {Función} stirling2 (@var{n}, @var{m})
2049
2050 Es el número de Stirling de segunda especie.
2051
2052 Si @var{n} y @var{m} son enteros no negativos,
2053 @code{stirling2 (@var{n}, @var{m})} es el número
2054 de formas en las que se puede particionar un conjunto
2055 de cardinal @var{n} en @var{m} subconjuntos disjuntos.
2056 Maxima utiliza una relación recursiva para definir
2057 @code{stirling2 (@var{n}, @var{m})} con @var{m} menor
2058 que 0; la función no está definida para  @var{n}
2059 menor que 0  ni para argumentos no enteros.
2060
2061 La función @code{stirling2} es simplificadora. Maxima
2062 reconoce las siguientes identidades:
2063
2064 @c COPIED VERBATIM FROM SRC/NSET.LISP
2065 @enumerate
2066 @item
2067 @math{stirling2(0, n) = kron_delta(0, n)} (Ref. [1])
2068 @item
2069 @math{stirling2(n, n) = 1} (Ref. [1])
2070 @item
2071 @math{stirling2(n, n - 1) = binomial(n, 2)} (Ref. [1])
2072 @item
2073 @math{stirling2(n + 1, 1) = 1} (Ref. [1])
2074 @item
2075 @math{stirling2(n + 1, 2) = 2^n  - 1} (Ref. [1])
2076 @item
2077 @math{stirling2(n, 0) = kron_delta(n, 0)} (Ref. [2])
2078 @item
2079 @math{stirling2(n, m) = 0} when @math{m > n} (Ref. [2])
2080 @item
2081 @math{stirling2(n, m) = sum((-1)^(m - k) binomial(m k) k^n,i,1,m) / m!}
2082 si @math{m} y @math{n} son enteros y @math{n} no negativo. (Ref. [3])
2083 @end enumerate
2084
2085 Estas identidades se aplican cuando los argumentos son enteros
2086 literales o símbolos declarados como enteros y
2087 el primer argumento es no negativo. La función @code{stirling2}
2088 no simplifica para argumentos no enteros.
2089
2090 Referencias:
2091
2092 [1] Donald Knuth. @i{The Art of Computer Programming},
2093 Tercera Edición, Volumen 1, Sección 1.2.6, Ecuaciones 48, 49 y 50.
2094
2095 [2] Graham, Knuth y Patashnik. @i{Concrete Mathematics}, Tabla 264.
2096
2097 [3] Abramowitz y Stegun. @i{Handbook of Mathematical Functions}, Sección 24.1.4.
2098
2099 Ejemplos:
2100
2101 @c ===beg===
2102 @c declare (n, integer)$
2103 @c assume (n >= 0)$
2104 @c stirling2 (n, n);
2105 @c ===end===
2106 @example
2107 (%i1) declare (n, integer)$
2108 (%i2) assume (n >= 0)$
2109 (%i3) stirling2 (n, n);
2110 (%o3)                           1
2111 @end example
2112
2113 La función @code{stirling2} no simplifica en caso de argumentos no enteros,
2114
2115 @c ===beg===
2116 @c stirling2 (%pi, %pi);
2117 @c ===end===
2118 @example
2119 (%i1) stirling2 (%pi, %pi);
2120 (%o1)                  stirling2(%pi, %pi)
2121 @end example
2122
2123 Maxima aplicas algunas identidades a @code{stirling2},
2124
2125 @c ===beg===
2126 @c declare (n, integer)$
2127 @c assume (n >= 0)$
2128 @c stirling2 (n + 9, n + 8);
2129 @c stirling2 (n + 1, 2);
2130 @c ===end===
2131 @example
2132 (%i1) declare (n, integer)$
2133 (%i2) assume (n >= 0)$
2134 (%i3) stirling2 (n + 9, n + 8);
2135                          (n + 8) (n + 9)
2136 (%o3)                    ---------------
2137                                 2
2138 (%i4) stirling2 (n + 1, 2);
2139                               n
2140 (%o4)                        2  - 1
2141 @end example
2142 @end deffn
2143
2144
2145 @deffn {Función} subset (@var{a}, @var{f})
2146
2147 Devuelve el subconjunto del conjunto @var{a} que satisface el predicado @var{f}.
2148
2149 La función @code{subset} devuelve el conjunto que contiene a los
2150 elementos de @var{a} para los cuales @var{f} devuelve un resultado
2151 diferente de @code{false}. La función @code{subset} no aplica
2152 @code{is} al valor retornado por @var{f}.
2153
2154 La función @code{subset} emite un mensaje de error si @var{a}
2155 no es un conjunto literal.
2156
2157 Véase también @code{partition_set}.
2158
2159 Ejemplos:
2160
2161 @c ===beg===
2162 @c subset ({1, 2, x, x + y, z, x + y + z}, atom);
2163 @c subset ({1, 2, 7, 8, 9, 14}, evenp);
2164 @c ===end===
2165 @example
2166 (%i1) subset (@{1, 2, x, x + y, z, x + y + z@}, atom);
2167 (%o1)                     @{1, 2, x, z@}
2168 (%i2) subset (@{1, 2, 7, 8, 9, 14@}, evenp);
2169 (%o2)                      @{2, 8, 14@}
2170 @end example
2171 @end deffn
2172
2173
2174 @deffn {Función} subsetp (@var{a}, @var{b})
2175
2176 Devuelve @code{true} si y sólo si el conjunto @var{a} es un subconjunto de @var{b}.
2177
2178 La función @code{subsetp} emite un mensaje de error si
2179 cualesquiera @var{a} o @var{b} no es un conjunto literal.
2180
2181 Ejemplos:
2182
2183 @c ===beg===
2184 @c subsetp ({1, 2, 3}, {a, 1, b, 2, c, 3});
2185 @c subsetp ({a, 1, b, 2, c, 3}, {1, 2, 3});
2186 @c ===end===
2187 @example
2188 (%i1) subsetp (@{1, 2, 3@}, @{a, 1, b, 2, c, 3@});
2189 (%o1)                         true
2190 (%i2) subsetp (@{a, 1, b, 2, c, 3@}, @{1, 2, 3@});
2191 (%o2)                         false
2192 @end example
2193 @end deffn
2194
2195
2196
2197 @deffn {Función} symmdifference (@var{a_1}, @dots{}, @var{a_n})
2198
2199 Devuelve la diferencia simétrica de los conjuntos @code{ @var{a_1}, @dots{}, @var{a_n}}.
2200
2201 Dados dos argumentos, @code{symmdifference (@var{a}, @var{b})} equivale a
2202 @code{union (setdifference (@var{a}, @var{b}), setdifference (@var{b}, @var{a}))}.
2203
2204 La función @code{symmdifference} emite un mensaje de error si alguno de
2205 su argumentos no es un conjunto literal.
2206
2207 Ejemplos:
2208
2209 @c ===beg===
2210 @c S_1 : {a, b, c};
2211 @c S_2 : {1, b, c};
2212 @c S_3 : {a, b, z};
2213 @c symmdifference ();
2214 @c symmdifference (S_1);
2215 @c symmdifference (S_1, S_2);
2216 @c symmdifference (S_1, S_2, S_3);
2217 @c symmdifference ({}, S_1, S_2, S_3);
2218 @c ===end===
2219 @example
2220 (%i1) S_1 : @{a, b, c@};
2221 (%o1)                       @{a, b, c@}
2222 (%i2) S_2 : @{1, b, c@};
2223 (%o2)                       @{1, b, c@}
2224 (%i3) S_3 : @{a, b, z@};
2225 (%o3)                       @{a, b, z@}
2226 (%i4) symmdifference ();
2227 (%o4)                          @{@}
2228 (%i5) symmdifference (S_1);
2229 (%o5)                       @{a, b, c@}
2230 (%i6) symmdifference (S_1, S_2);
2231 (%o6)                        @{1, a@}
2232 (%i7) symmdifference (S_1, S_2, S_3);
2233 (%o7)                       @{1, b, z@}
2234 (%i8) symmdifference (@{@}, S_1, S_2, S_3);
2235 (%o8)                       @{1,b, z@}
2236 @end example
2237 @end deffn
2238
2239 @c TREE_REDUCE ACCEPTS A SET OR LIST AS AN ARGUMENT, BUT RREDUCE AND LREDUCE WANT ONLY LISTS; STRANGE
2240 @deffn {Función} tree_reduce (@var{F}, @var{s})
2241 @deffnx {Función} tree_reduce (@var{F}, @var{s}, @var{s_0})
2242
2243
2244 Amplía la función binaria @var{F} a n-aria, siendo @var{s} una lista.
2245
2246 La función @code{tree_reduce} equivale a lo suguiente:
2247 Aplicar @var{F} a pares sucesivos de elementos para formar
2248 una nueva lista @code{[@var{F}(@var{s_1}, @var{s_2}), @var{F}(@var{s_3}, @var{s_4}), ...]},
2249 llevando el elemento final sin cambiar si el número de elementos es impar;
2250 después repetir hasta que la lista se reduzca a un único elemento,
2251 que es el valor de retorno.
2252
2253 Cuando está presente el argumento opcional @var{s_0},
2254 el resultado equivale a @code{tree_reduce(@var{F}, cons(@var{s_0}, @var{s})}.
2255
2256 Para la suma de números decimales en coma flotante,
2257 @code{tree_reduce} puede devolver una suma que tenga un error
2258 de redondeo menor que el conseguido por @code{rreduce} o @code{lreduce}.
2259
2260 Los elementos de @var{s} y los resultados parciales pueden colocarse
2261 en un árbol binario de mínima profundidad, de ahí
2262 el nombre de @i{tree_reduce}.
2263
2264 Ejemplos:
2265
2266 La función @code{tree_reduce} aplicada a una lista con un número
2267 par de elementos,
2268
2269 @c ===beg===
2270 @c tree_reduce (f, [a, b, c, d]);
2271 @c ===end===
2272 @example
2273 (%i1) tree_reduce (f, [a, b, c, d]);
2274 (%o1)                  f(f(a, b), f(c, d))
2275 @end example
2276
2277 La función @code{tree_reduce} aplicada a una lista con un número
2278 impar de elementos,
2279
2280 @c ===beg===
2281 @c tree_reduce (f, [a, b, c, d, e]);
2282 @c ===end===
2283 @example
2284 (%i1) tree_reduce (f, [a, b, c, d, e]);
2285 (%o1)               f(f(f(a, b), f(c, d)), e)
2286 @end example
2287 @end deffn
2288
2289
2290 @deffn {Function} union (@var{a_1}, ..., @var{a_n})
2291
2292 Devuelve la unión de los conjuntos @var{a_1} hasta @var{a_n}.
2293
2294 La sentencia @code{union()} (sin argumentos) devuelve el
2295 conjunto vacío.
2296
2297 La función @code{union} emite un mensaje de error si alguno
2298 de sus argumentos no es un conjunto literal.
2299
2300 Ejemplos:
2301
2302 @c ===beg===
2303 @c S_1 : {a, b, c + d, %e};
2304 @c S_2 : {%pi, %i, %e, c + d};
2305 @c S_3 : {17, 29, 1729, %pi, %i};
2306 @c union ();
2307 @c union (S_1);
2308 @c union (S_1, S_2);
2309 @c union (S_1, S_2, S_3);
2310 @c union ({}, S_1, S_2, S_3);
2311 @c ===end===
2312 @example
2313 (%i1) S_1 : @{a, b, c + d, %e@};
2314 (%o1)                   @{%e, a, b, d + c@}
2315 (%i2) S_2 : @{%pi, %i, %e, c + d@};
2316 (%o2)                 @{%e, %i, %pi, d + c@}
2317 (%i3) S_3 : @{17, 29, 1729, %pi, %i@};
2318 (%o3)                @{17, 29, 1729, %i, %pi@}
2319 (%i4) union ();
2320 (%o4)                          @{@}
2321 (%i5) union (S_1);
2322 (%o5)                   @{%e, a, b, d + c@}
2323 (%i6) union (S_1, S_2);
2324 (%o6)              @{%e, %i, %pi, a, b, d + c@}
2325 (%i7) union (S_1, S_2, S_3);
2326 (%o7)       @{17, 29, 1729, %e, %i, %pi, a, b, d + c@}
2327 (%i8) union (@{@}, S_1, S_2, S_3);
2328 (%o8)       @{17, 29, 1729, %e, %i, %pi, a, b, d + c@}
2329 @end example
2330 @end deffn
2331
2332
2333 @deffn {Función} xreduce (@var{F}, @var{s})
2334 @deffnx {Función} xreduce (@var{F}, @var{s}, @var{s_0})
2335
2336
2337
2338 Amplía la función @var{F} a n-aria mediante
2339 composición; si @var{F} ya es n-aria, aplica @var{F} a @var{s}.
2340 Si @var{F} no es n-aria, @code{xreduce} equivale a @code{lreduce}.
2341 El argumento @var{s} debe ser una lista.
2342
2343 Funciones n-arias reconocidas por Maxima son la suma @code{+}, la
2344 multiplicación @code{*}, @code{and}, @code{or}, @code{max},
2345 @code{min} y @code{append}. Las funciones también se pueden
2346 declarar n-arias mediante @code{declare(@var{F}, nary)};
2347 para estas funciones, @code{xreduce} será más rápida que
2348 @code{rreduce} o @code{lreduce}.
2349
2350 Cuando está presente el argumento opcional @var{s_0},
2351 el resultado equivale a @code{xreduce(@var{s}, cons(@var{s_0}, @var{s}))}.
2352
2353 La suma de números decimales en coma flotante no es exactamente asociativa;
2354 aún así, @code{xreduce} aplica la suma n-aria cuando @var{s}
2355 contiene números en coma flotante.
2356
2357 Ejemplos:
2358
2359 La función @code{xreduce} aplicada a una función n-aria;
2360 @code{F} es invocada una sóla vez, con todos sus argumentos,
2361
2362 @c ===beg===
2363 @c declare (F, nary);
2364 @c F ([L]) := L;
2365 @c xreduce (F, [a, b, c, d, e]);
2366 @c ===end===
2367 @example
2368 (%i1) declare (F, nary);
2369 (%o1)                         done
2370 (%i2) F ([L]) := L;
2371 (%o2)                      F([L]) := L
2372 (%i3) xreduce (F, [a, b, c, d, e]);
2373 (%o3)         [[[[[("[", simp), a], b], c], d], e]
2374 @end example
2375
2376 La función @code{xreduce} aplicada a una función que se desconoce si
2377 es n-aria; @code{G} es invocada varias veces, con dos argumentos de cada vez,
2378
2379 @c ===beg===
2380 @c G ([L]) := L;
2381 @c xreduce (G, [a, b, c, d, e]);
2382 @c lreduce (G, [a, b, c, d, e]);
2383 @c ===end===
2384 @example
2385 (%i1) G ([L]) := L;
2386 (%o1)                      G([L]) := L
2387 (%i2) xreduce (G, [a, b, c, d, e]);
2388 (%o2)         [[[[[("[", simp), a], b], c], d], e]
2389 (%i3) lreduce (G, [a, b, c, d, e]);
2390 (%o3)                 [[[[a, b], c], d], e]
2391 @end example
2392 @end deffn
2393
2394
2395
2396
2397
2398
2399
2400