doc/info/pt/nset.texi

   1 @c English version: 1.17
   2 @menu
   3 * Introdução a Conjuntos::
   4 * Definições para Conjuntos::
   5 @end menu
   6
   7 @node Introdução a Conjuntos, Definições para Conjuntos, Conjuntos, Conjuntos
   8 @section Introdução a Conjuntos
   9
  10 Maxima fornece funções de conjunto, tais como
  11 intersecção e união, para conjuntos finitos que são
  12 definidos por enumeração explícita.
  13 Maxima trata listas e conjuntos como objectos distintos. Este recurso
  14 torna possível trabalhar com conjuntos que possuem
  15 elementos que são ou listas ou conjuntos.
  16
  17 Adicionalmente, para funções de conjuntos finitos,
  18 Maxima fornece algumas funções relacionadas com
  19 análise combinatória: números de Stirling de primeiro e de segundo
  20 tipo, números de Bell, coeficientes multinomiais e
  21 partições de inteiros não negativos, entre
  22 outras. Maxima também define a função delta de
  23 Kronecker.
  24
  25 @subsection Utilização
  26
  27 Para construir um conjunto com elementos @code{a_1, ..., a_n}, escreva
  28 @code{set(a_1, ..., a_n)} ou @code{@{a_1, ..., a_n@}}; para construir o
  29 conjunto vazio, escreva @code{set()} ou @code{@{@}}.  Para
  30 inserção de dados, @code{set(...)} e @code{@{ ... @}}
  31 são equivalentes. Os conjuntos são sempre mostrados entre chaves
  32 (@code{@{ ... @}}).
  33
  34 Se um elemento é listado mais de uma vez, o simplificador do Maxima
  35 elimina o elemento redundante.
  36
  37 @c ===beg===
  38 @c set();
  39 @c set(a, b, a);
  40 @c set(a, set(b));
  41 @c set(a, [b]);
  42 @c {};
  43 @c {a, b, a};
  44 @c {a, {b}};
  45 @c {a, [b]};
  46 @c ===end===
  47 @example
  48 (%i1) set();
  49 (%o1)                          @{@}
  50 (%i2) set(a, b, a);
  51 (%o2)                        @{a, b@}
  52 (%i3) set(a, set(b));
  53 (%o3)                       @{a, @{b@}@}
  54 (%i4) set(a, [b]);
  55 (%o4)                       @{a, [b]@}
  56 (%i5) @{@};
  57 (%o5)                          @{@}
  58 (%i6) @{a, b, a@};
  59 (%o6)                        @{a, b@}
  60 (%i7) @{a, @{b@}@};
  61 (%o7)                       @{a, @{b@}@}
  62 (%i8) @{a, [b]@};
  63 (%o8)                       @{a, [b]@}
  64 @end example
  65
  66 Dois elementos @var{x} e @var{y} são redundantes (nomeadamente,
  67 considerados o mesmo para propósito de construção de
  68 conjuntos) se e somente se @code{is(@var{x} = @var{y})} retornar
  69 @code{true}.
  70 @c THAT IS BECAUSE THE SET SIMPLIFICATION CODE CALLS THE LISP FUNCTION LIKE,
  71 @c AND SO DOES THE CODE TO EVALUATE IS (X = Y).
  72 Note que @code{is(equal(@var{x}, @var{y}))} pode retornar @code{true}
  73 enquanto @code{is(@var{x} = @var{y})} retorna @code{false}; nesse caso
  74 os elementos @var{x} e @var{y} são considerados distintos.
  75
  76 @c ===beg===
  77 @c x: a/c + b/c;
  78 @c y: a/c + b/c;
  79 @c z: (a + b)/c;
  80 @c is (x = y);
  81 @c is (y = z);
  82 @c is (equal (y, z));
  83 @c y - z;
  84 @c ratsimp (%);
  85 @c {x, y, z};
  86 @c ===end===
  87 @example
  88 (%i1) x: a/c + b/c;
  89                               b   a
  90 (%o1)                         - + -
  91                               c   c
  92 (%i2) y: a/c + b/c;
  93                               b   a
  94 (%o2)                         - + -
  95                               c   c
  96 (%i3) z: (a + b)/c;
  97                               b + a
  98 (%o3)                         -----
  99                                 c
 100 (%i4) is (x = y);
 101 (%o4)                         true
 102 (%i5) is (y = z);
 103 (%o5)                         false
 104 (%i6) is (equal (y, z));
 105 (%o6)                         true
 106 (%i7) y - z;
 107                            b + a   b   a
 108 (%o7)                    - ----- + - + -
 109                              c     c   c
 110 (%i8) ratsimp (%);
 111 (%o8)                           0
 112 (%i9) @{x, y, z@};
 113                           b + a  b   a
 114 (%o9)                    @{-----, - + -@}
 115                             c    c   c
 116 @end example
 117
 118 Para construir um conjunto dos elementos de uma lista, use @code{setify}.
 119
 120 @c ===beg===
 121 @c setify ([b, a]);
 122 @c ===end===
 123 @example
 124 (%i1) setify ([b, a]);
 125 (%o1)                        @{a, b@}
 126 @end example
 127
 128 Os elementos de conjunto @code{x} e @code{y} serão considerados iguais
 129 se @code{is(x = y)} for avaliando para @code{true}. Dessa forma,
 130 @code{rat(x)} e @code{x} são iguais como elementos de conjunto;
 131 consequentemente,
 132
 133 @c ===beg===
 134 @c {x, rat(x)};
 135 @c ===end===
 136 @example
 137 (%i1) @{x, rat(x)@};
 138 (%o1)                          @{x@}
 139 @end example
 140
 141 Adicionalmente, uma vez que @code{is((x - 1)*(x + 1) = x^2 - 1)} avalia
 142 para @code{false}, @code{(x - 1)*(x + 1)} e @code{x^2 - 1} são
 143 considerados elementos de conjunto diferentes; dessa forma
 144
 145 @c ===beg===
 146 @c {(x - 1)*(x + 1), x^2 - 1};
 147 @c ===end===
 148 @example
 149 (%i1) @{(x - 1)*(x + 1), x^2 - 1@};
 150                                        2
 151 (%o1)               @{(x - 1) (x + 1), x  - 1@}
 152 @end example
 153
 154 Para reduzir esse conjunto a um conjunto simples, apliquemos @code{rat}
 155 a cada elemento do conjunto
 156
 157 @c ===beg===
 158 @c {(x - 1)*(x + 1), x^2 - 1};
 159 @c map (rat, %);
 160 @c ===end===
 161 @example
 162 (%i1) @{(x - 1)*(x + 1), x^2 - 1@};
 163                                        2
 164 (%o1)               @{(x - 1) (x + 1), x  - 1@}
 165 (%i2) map (rat, %);
 166                               2
 167 (%o2)/R/                    @{x  - 1@}
 168 @end example
 169
 170 Para remover redundâncias em outros conjuntos, poderá ter que usar
 171 outras funções de simplificação. Aqui
 172 está um exemplo que usa @code{trigsimp}:
 173
 174 @c ===beg===
 175 @c {1, cos(x)^2 + sin(x)^2};
 176 @c map (trigsimp, %);
 177 @c ===end===
 178 @example
 179 (%i1) @{1, cos(x)^2 + sin(x)^2@};
 180                             2         2
 181 (%o1)                @{1, sin (x) + cos (x)@}
 182 (%i2) map (trigsimp, %);
 183 (%o2)                          @{1@}
 184 @end example
 185
 186 Um conjunto está simplificado quando os seus elementos não são
 187 redundantes e o conjunto está ordenado. A versão actual das
 188 funções de conjunto usam a função
 189 @code{orderlessp} do Maxima para ordenar conjuntos; contudo,
 190 @emph{versões futuras das funções de conjunto poderão
 191 vir a usar uma função de ordenação
 192 diferente}.
 193
 194 Algumas operações sobre conjuntos, tais como
 195 substituições, forçam automaticamente a
 196 uma re-simplificação; por exemplo,
 197
 198 @c ===beg===
 199 @c s: {a, b, c}$
 200 @c subst (c=a, s);
 201 @c subst ([a=x, b=x, c=x], s);
 202 @c map (lambda ([x], x^2), set (-1, 0, 1));
 203 @c ===end===
 204 @example
 205 (%i1) s: @{a, b, c@}$
 206 (%i2) subst (c=a, s);
 207 (%o2)                        @{a, b@}
 208 (%i3) subst ([a=x, b=x, c=x], s);
 209 (%o3)                          @{x@}
 210 (%i4) map (lambda ([x], x^2), set (-1, 0, 1));
 211 (%o4)                        @{0, 1@}
 212 @end example
 213
 214 Maxima trata listas e conjuntos como objectos distintos;
 215 funções tais como @code{union} e @code{intersection}
 216 produzem um erro se qualquer argumento não for um conjunto. se
 217 precisar aplicar uma função de conjunto a uma lista, use
 218 a função @code{setify} para converter essa lista num
 219 conjunto. Dessa forma
 220
 221 @c ===beg===
 222 @c union ([1, 2], {a, b});
 223 @c union (setify ([1, 2]), {a, b});
 224 @c ===end===
 225 @example
 226 (%i1) union ([1, 2], @{a, b@});
 227 Function union expects a set, instead found [1,2]
 228  -- an error.  Quitting.  To debug this try debugmode(true);
 229 (%i2) union (setify ([1, 2]), @{a, b@});
 230 (%o2)                     @{1, 2, a, b@}
 231 @end example
 232
 233 Para extrair todos os elementos de um conjunto @code{s} que satisfazem
 234 um predicado @code{f}, use @code{subset(s, f)}. (Um @i{predicado} é um
 235 uma função que avalia para os valores booleanos
 236 @code{true}/@code{false}.) Por exemplo, para encontrar as
 237 equações num dado conjunto que não depende de uma
 238 variável @code{z}, use
 239
 240 @c ===beg===
 241 @c subset ({x + y + z, x - y + 4, x + y - 5}, lambda ([e], freeof (z, e)));
 242 @c ===end===
 243 @example
 244 (%i1) subset (@{x + y + z, x - y + 4, x + y - 5@}, lambda ([e], freeof (z, e)));
 245 (%o1)               @{- y + x + 4, y + x - 5@}
 246 @end example
 247
 248 A secção @emph{Definições para
 249 Conjuntos} possui uma lista completa das funções de
 250 conjunto no Maxima.
 251
 252 @subsection Iterações entre Elementos de Conjuntos
 253
 254 Existem duas formas de fazer iterações sobre elementos
 255 de conjuntos. Uma forma é usar @code{map}; por exemplo:
 256
 257 @c ===beg===
 258 @c map (f, {a, b, c});
 259 @c ===end===
 260 @example
 261 (%i1) map (f, @{a, b, c@});
 262 (%o1)                  @{f(a), f(b), f(c)@}
 263 @end example
 264
 265 A outra forma consiste em usar @code{for @var{x} in @var{s} do}
 266
 267 @c ===beg===
 268 @c s: {a, b, c};
 269 @c for si in s do print (concat (si, 1));
 270 @c ===end===
 271 @example
 272 (%i1) s: @{a, b, c@};
 273 (%o1)                       @{a, b, c@}
 274 (%i2) for si in s do print (concat (si, 1));
 275 a1
 276 b1
 277 c1
 278 (%o2)                         done
 279 @end example
 280
 281 As funções @code{first} e @code{rest} do Maxima
 282 trabalham actualmente sobre conjuntos. Aplicada a um conjunto,
 283 @code{first} retorna o primeiro elemento mostrado de um conjunto; qual o
 284 élemento que será mostrado dependerá da
 285 implementação. Se @code{s} for um conjunto, então
 286 @code{rest(s)} é equivalente a @code{disjoin(first(s), s)}.
 287 Actualmente, existem outras funções do Maxima que
 288 trabalham correctamente sobre conjuntos. Em versões futuras das
 289 funções de conjunto, @code{first} e @code{rest} podem
 290 vir a funcionar diferentemente ou deixar de funcionar.
 291
 292 @subsection Erros
 293
 294 As funções de conjunto usam a função
 295 @code{orderlessp} do Maxima para organizar os elementos dum conjunto e a
 296 função (a nível do Lisp) @code{like} para
 297 testar a igualdade entre elementos de conjuntos. Ambas essas
 298 funções possuem falhas conhecidas que podem se
 299 manifestar quando tentar usar conjuntos com elementos que são listas
 300 ou matrizes que contenham expressões na forma racional canónica
 301 (CRE). Um exemplo é
 302
 303 @c ===beg===
 304 @c {[x], [rat (x)]};
 305 @c ===end===
 306 @example
 307 (%i1) @{[x], [rat (x)]@};
 308 Maxima encountered a Lisp error:
 309
 310   The value #:X1440 is not of type LIST.
 311
 312 Automatically continuing.
 313 To reenable the Lisp debugger set *debugger-hook* to nil.
 314 @end example
 315
 316 Essa expressão faz com que o Maxima produza um erro (a mensagem de
 317 erro dependerá da versão do Lisp que o Maxima estiver a
 318 utilizar). Outro exemplo é
 319
 320 @c ===beg===
 321 @c setify ([[rat(a)], [rat(b)]]);
 322 @c ===end===
 323 @example
 324 (%i1) setify ([[rat(a)], [rat(b)]]);
 325 Maxima encountered a Lisp error:
 326
 327   The value #:A1440 is not of type LIST.
 328
 329 Automatically continuing.
 330 To reenable the Lisp debugger set *debugger-hook* to nil.
 331 @end example
 332
 333 Essas falhas são causadas por falhas em @code{orderlessp} e
 334 @code{like}, e não por falhas nas funções de
 335 conjunto. Para ilustrar, experimente as expressões
 336
 337 @c ===beg===
 338 @c orderlessp ([rat(a)], [rat(b)]);
 339 @c is ([rat(a)] = [rat(a)]);
 340 @c ===end===
 341 @example
 342 (%i1) orderlessp ([rat(a)], [rat(b)]);
 343 Maxima encountered a Lisp error:
 344
 345   The value #:B1441 is not of type LIST.
 346
 347 Automatically continuing.
 348 To reenable the Lisp debugger set *debugger-hook* to nil.
 349 (%i2) is ([rat(a)] = [rat(a)]);
 350 (%o2)                         false
 351 @end example
 352
 353 Até que essas falhas forem corrigidas, não construa conjuntos com
 354 elementos que sejam listas ou matrizes contendo expressões na forma
 355 racional canónica (CRE); um conjunto com um elemento na forma CRE,
 356 contudo, pode não ser um problema:
 357
 358 @c ===beg===
 359 @c {x, rat (x)};
 360 @c ===end===
 361 @example
 362 (%i1) @{x, rat (x)@};
 363 (%o1)                          @{x@}
 364 @end example
 365
 366 A @code{orderlessp} do Maxima possui outra falha que pode causar
 367 problemas com funções de conjunto; nomeadamente, o
 368 predicado de ordenação @code{orderlessp} não é
 369 transitivo. O mais simples exemplo conhecido que mostra isso é
 370
 371 @c ===beg===
 372 @c q: x^2$
 373 @c r: (x + 1)^2$
 374 @c s: x*(x + 2)$
 375 @c orderlessp (q, r);
 376 @c orderlessp (r, s);
 377 @c orderlessp (q, s);
 378 @c ===end===
 379 @example
 380 (%i1) q: x^2$
 381 (%i2) r: (x + 1)^2$
 382 (%i3) s: x*(x + 2)$
 383 (%i4) orderlessp (q, r);
 384 (%o4)                         true
 385 (%i5) orderlessp (r, s);
 386 (%o5)                         true
 387 (%i6) orderlessp (q, s);
 388 (%o6)                         false
 389 @end example
 390
 391 Essa falha pode causar problemas com todas as funções de
 392 conjunto bem como com funções do Maxima em geral. É
 393 provável, mas não certo, que essa falha possa ser evitada se todos
 394 os elementos do conjunto estiverem ou na forma CRE ou tiverem sido
 395 simplificados usando @code{ratsimp}.
 396
 397 @c WHAT EXACTLY IS THE EFFECT OF ordergreat AND orderless ON THE SET FUNCTIONS ??
 398 Os mecanismos @code{orderless} e @code{ordergreat} do Maxima são
 399 incompatíveis com as funções de
 400 conjunto. Se precisar usar @code{orderless} ou @code{ordergrreat}, chame
 401 todas essas funções antes de construir quaisquer
 402 conjuntos, e não use @code{unorder}.
 403
 404 @c APPARENTLY THIS NEXT BIT REFERS TO BUG REPORT 798571
 405 @c EXAMPLE WITH kron_delta (1/sqrt(2), sqrt(2)/2); NOW WORKS AS EXPECTED
 406 @c COMMENT OUT PENDING CONSTRUCTION OF ANOTHER EXAMPLE WHICH TRIGGERS THE BUG
 407 @c
 408 @c Maxima's sign function has a bug that may cause the Kronecker
 409 @c delta function to misbehave; for example:
 410 @c
 411 @c @c ===beg===
 412 @c @c kron_delta (1/sqrt(2), sqrt(2)/2);
 413 @c @c ===end===
 414 @c @example
 415 @c (%i1) kron_delta (1/sqrt(2), sqrt(2)/2);
 416 @c (%o1)                           0
 417 @c @end example
 418 @c
 419 @c The correct value is 1; the bug is related to the @code{sign} bug
 420 @c
 421 @c @c ===beg===
 422 @c @c sign (1/sqrt(2) - sqrt(2)/2);
 423 @c @c ===end===
 424 @c @example
 425 @c (%i1) sign (1/sqrt(2) - sqrt(2)/2);
 426 @c (%o1)                          pos
 427 @c @end example
 428
 429 Se encontrar alguma coisa que pense ser uma falha em alguma
 430 funçõ de conjunto, por favor relate isso para a base de
 431 dados de falhas do Maxima. Veja @code{bug_report}.
 432
 433 @subsection Autores
 434
 435 Stavros Macrakis de Cambridge, Massachusetts e Barton Willis da
 436 Universidade de Nebraska e Kearney (UNK) escreveram as
 437 fnções de conjunto do Maxima e sua
 438 documentação.
 439
 440 @node Definições para Conjuntos,  , Introdução a Conjuntos, Conjuntos
 441 @section Definições para Conjuntos
 442
 443 @anchor{adjoin}
 444 @deffn {Função} adjoin (@var{x}, @var{a})
 445
 446 Calcula a união do conjunto @var{a} com @code{@{@var{x}@}}.
 447
 448 @code{adjoin} falha se @var{a} não for um conjunto literal.
 449
 450 @code{adjoin(@var{x}, @var{a})} e @code{union(set(@var{x}), @var{a})}
 451 são equivalentes; contudo, @code{adjoin} pode ser um pouco mais
 452 rápida que @code{union}.
 453
 454 Veja também @code{disjoin}.
 455
 456 Exemplos:
 457
 458 @c ===beg===
 459 @c adjoin (c, {a, b});
 460 @c adjoin (a, {a, b});
 461 @c ===end===
 462 @example
 463 (%i1) adjoin (c, @{a, b@});
 464 (%o1)                       @{a, b, c@}
 465 (%i2) adjoin (a, @{a, b@});
 466 (%o2)                        @{a, b@}
 467 @end example
 468
 469 @end deffn
 470
 471 @anchor{belln}
 472 @deffn {Função} belln (@var{n})
 473
 474 Representa o @math{n}-ésimo número de Bell.  @code{belln(n)} é o
 475 número de partições de um conjunto de @var{n}
 476 elementos.
 477
 478 Para inteiros não negativos @var{n}, @code{belln(@var{n})} simplifica
 479 para o @math{n}-ésimo número de Bell.  @code{belln} não simplifica
 480 para qualquer outro tipo de argumento.
 481
 482 @code{belln}, aplicada a equações, listas, matrizes
 483 e conjuntos, é calculada em forma distributiva.
 484
 485 Exemplos:
 486
 487 @code{belln} aplicado a inteiros não negativos.
 488
 489 @c ===beg===
 490 @c makelist (belln (i), i, 0, 6);
 491 @c is (cardinality (set_partitions ({})) = belln (0));
 492 @c is (cardinality (set_partitions ({1, 2, 3, 4, 5, 6})) = belln (6));
 493 @c ===end===
 494 @example
 495 (%i1) makelist (belln (i), i, 0, 6);
 496 (%o1)               [1, 1, 2, 5, 15, 52, 203]
 497 (%i2) is (cardinality (set_partitions (@{@})) = belln (0));
 498 (%o2)                         true
 499 (%i3) is (cardinality (set_partitions (@{1, 2, 3, 4, 5, 6@})) = belln (6));
 500 (%o3)                         true
 501 @end example
 502
 503 @code{belln} aplicado a argumentos que não são inteiros não negativos.
 504
 505 @c ===beg===
 506 @c [belln (x), belln (sqrt(3)), belln (-9)];
 507 @c ===end===
 508 @example
 509 (%i1) [belln (x), belln (sqrt(3)), belln (-9)];
 510 (%o1)        [belln(x), belln(sqrt(3)), belln(- 9)]
 511 @end example
 512
 513 @end deffn
 514
 515 @anchor{cardinality}
 516 @deffn {Função} cardinality (@var{a})
 517
 518 Calcula o número de elementos distintos do conjunto @var{a}.
 519
 520 @code{cardinality} ignora elementos redundantes mesmo quando a
 521 simplificação não estiver habilitada.
 522
 523 Exemplos:
 524
 525 @c ===beg===
 526 @c cardinality ({});
 527 @c cardinality ({a, a, b, c});
 528 @c simp : false;
 529 @c cardinality ({a, a, b, c});
 530 @c ===end===
 531 @example
 532 (%i1) cardinality (@{@});
 533 (%o1)                           0
 534 (%i2) cardinality (@{a, a, b, c@});
 535 (%o2)                           3
 536 (%i3) simp : false;
 537 (%o3)                         false
 538 (%i4) cardinality (@{a, a, b, c@});
 539 (%o4)                           3
 540 @end example
 541
 542 @end deffn
 543
 544 @anchor{cartesian_product}
 545 @deffn {Função} cartesian_product (@var{b_1}, ... , @var{b_n})
 546 Retorna um conjunto de listas da forma @code{[@var{x_1}, ...,
 547 @var{x_n}]}, onde @var{x_1}, ..., @var{x_n} são elementos dos
 548 conjuntos @var{b_1}, ... , @var{b_n}, respectivamente.
 549
 550 @code{cartesian_product} falha se qualquer argumento não for um
 551 conjunto literal.
 552
 553 Exemplos:
 554
 555 @c ===beg===
 556 @c cartesian_product ({0, 1});
 557 @c cartesian_product ({0, 1}, {0, 1});
 558 @c cartesian_product ({x}, {y}, {z});
 559 @c cartesian_product ({x}, {-1, 0, 1});
 560 @c ===end===
 561 @example
 562 (%i1) cartesian_product (@{0, 1@});
 563 (%o1)                      @{[0], [1]@}
 564 (%i2) cartesian_product (@{0, 1@}, @{0, 1@});
 565 (%o2)           @{[0, 0], [0, 1], [1, 0], [1, 1]@}
 566 (%i3) cartesian_product (@{x@}, @{y@}, @{z@});
 567 (%o3)                      @{[x, y, z]@}
 568 (%i4) cartesian_product (@{x@}, @{-1, 0, 1@});
 569 (%o4)              @{[x, - 1], [x, 0], [x, 1]@}
 570 @end example
 571 @end deffn
 572
 573
 574 @anchor{disjoin}
 575 @deffn {Função} disjoin (@var{x}, @var{a})
 576 Retorna o conjunto @var{a} sem o elemento @var{x}.  Se @var{x} não for
 577 um elemento de @var{a}, retorna @var{a} sem
 578 modificações.
 579
 580 @code{disjoin} reclama se @var{a} não for um conjunto literal.
 581
 582 @code{disjoin(@var{x}, @var{a})}, @code{delete(@var{x}, @var{a})}, e
 583 @code{setdifference(@var{a}, set(@var{x}))} são todos equivalentes.
 584 Desses, @code{disjoin} é geralmente mais rápido que os outros.
 585
 586 Exemplos:
 587
 588 @c ===beg===
 589 @c disjoin (a, {a, b, c, d});
 590 @c disjoin (a + b, {5, z, a + b, %pi});
 591 @c disjoin (a - b, {5, z, a + b, %pi});
 592 @c ===end===
 593 @example
 594 (%i1) disjoin (a, @{a, b, c, d@});
 595 (%o1)                       @{b, c, d@}
 596 (%i2) disjoin (a + b, @{5, z, a + b, %pi@});
 597 (%o2)                      @{5, %pi, z@}
 598 (%i3) disjoin (a - b, @{5, z, a + b, %pi@});
 599 (%o3)                  @{5, %pi, b + a, z@}
 600 @end example
 601
 602 @end deffn
 603
 604 @anchor{disjointp}
 605 @deffn {Função} disjointp (@var{a}, @var{b})
 606 Retorna @code{true} se e somente se os conjuntos @var{a} e @var{b} forem
 607 disjuntos.
 608
 609 @code{disjointp} falha se ou @var{a} ou @var{b} não forem conjuntos
 610 literais.
 611
 612 Exemplos:
 613
 614 @c ===beg===
 615 @c disjointp ({a, b, c}, {1, 2, 3});
 616 @c disjointp ({a, b, 3}, {1, 2, 3});
 617 @c ===end===
 618 @example
 619 (%i1) disjointp (@{a, b, c@}, @{1, 2, 3@});
 620 (%o1)                         true
 621 (%i2) disjointp (@{a, b, 3@}, @{1, 2, 3@});
 622 (%o2)                         false
 623 @end example
 624
 625 @end deffn
 626
 627 @anchor{divisors}
 628 @deffn {Função} divisors (@var{n})
 629
 630 Representa o conjunto dos divisores de @var{n}.
 631
 632 @code{divisors(@var{n})} produz um conjunto de divisores inteiros quando
 633 @var{n} for um inteiro não nulo. O conjunto dos divisores inclui os
 634 elementos 1 e @var{n}. Os divisores de um inteiro negativo são os
 635 divisores do seu valor absoluto.
 636
 637 @code{divisors}, aplicada a equações, listas, matrizes
 638 e conjuntos, é calculada em forma distributiva.
 639
 640 Exemplos:
 641
 642 Podemos verificar que 28 é um número perfeito: a
 643 adição dos seus divisores (excepto o próprio 28) é
 644 28.
 645
 646 @c ===beg===
 647 @c s: divisors(28);
 648 @c lreduce ("+", args(s)) - 28;
 649 @c ===end===
 650 @example
 651 (%i1) s: divisors(28);
 652 (%o1)                 @{1, 2, 4, 7, 14, 28@}
 653 (%i2) lreduce ("+", args(s)) - 28;
 654 (%o2)                          28
 655 @end example
 656
 657 @code{divisors} é uma função de
 658 simplificação.  Substituindo 8 por @code{a} em
 659 @code{divisors(a)} calcula os divisores sem ser preciso pedir que
 660 @code{divisors(8)} seja reavaliada.
 661
 662 @c ===beg===
 663 @c divisors (a);
 664 @c subst (8, a, %);
 665 @c ===end===
 666 @example
 667 (%i1) divisors (a);
 668 (%o1)                      divisors(a)
 669 (%i2) subst (8, a, %);
 670 (%o2)                     @{1, 2, 4, 8@}
 671 @end example
 672
 673 @code{divisors}, aplicada a equações, listas, matrizes
 674 e conjuntos, é calculada em forma distributiva.
 675
 676 @c ===beg===
 677 @c divisors (a = b);
 678 @c divisors ([a, b, c]);
 679 @c divisors (matrix ([a, b], [c, d]));
 680 @c divisors ({a, b, c});
 681 @c ===end===
 682 @example
 683 (%i1) divisors (a = b);
 684 (%o1)               divisors(a) = divisors(b)
 685 (%i2) divisors ([a, b, c]);
 686 (%o2)        [divisors(a), divisors(b), divisors(c)]
 687 (%i3) divisors (matrix ([a, b], [c, d]));
 688                   [ divisors(a)  divisors(b) ]
 689 (%o3)             [                          ]
 690                   [ divisors(c)  divisors(d) ]
 691 (%i4) divisors (@{a, b, c@});
 692 (%o4)        @{divisors(a), divisors(b), divisors(c)@}
 693 @end example
 694 @end deffn
 695
 696 @anchor{elementp}
 697 @deffn {Função} elementp (@var{x}, @var{a})
 698 Retorna @code{true} se e somente se @var{x} for um elemento do conjunto
 699 @var{a}.
 700
 701 @code{elementp} falha se @var{a} não for um conjunto literal.
 702
 703 Exemplos:
 704
 705 @c ===beg===
 706 @c elementp (sin(1), {sin(1), sin(2), sin(3)});
 707 @c elementp (sin(1), {cos(1), cos(2), cos(3)});
 708 @c ===end===
 709 @example
 710 (%i1) elementp (sin(1), @{sin(1), sin(2), sin(3)@});
 711 (%o1)                         true
 712 (%i2) elementp (sin(1), @{cos(1), cos(2), cos(3)@});
 713 (%o2)                         false
 714 @end example
 715
 716 @end deffn
 717
 718 @anchor{emptyp}
 719 @deffn {Função} emptyp (@var{a})
 720 Retorna @code{true} se e somente se @var{a} for o conjunto vazio ou uma
 721 lista vazia.
 722
 723 Exemplos:
 724
 725 @c ===beg===
 726 @c map (emptyp, [{}, []]);
 727 @c map (emptyp, [a + b, {{}}, %pi]);
 728 @c ===end===
 729 @example
 730 (%i1) map (emptyp, [@{@}, []]);
 731 (%o1)                     [true, true]
 732 (%i2) map (emptyp, [a + b, @{@{@}@}, %pi]);
 733 (%o2)                 [false, false, false]
 734 @end example
 735 @end deffn
 736
 737 @anchor{equiv_classes}
 738 @deffn {Função} equiv_classes (@var{s}, @var{F})
 739 Retorna um conjunto das classes de equivalências do conjunto @var{s}
 740 com relação à relação de
 741 equivalência @var{F}.
 742
 743 @var{F} é uma função de duas variáveis definida
 744 sobre o produto cartesiano @var{s} por @var{s}.  O valor de retorno de
 745 @var{F} é ou @code{true} ou @code{false}, ou uma expressão
 746 @var{expr} tal que @code{is(@var{expr})} é ou @code{true} ou
 747 @code{false}.
 748
 749 Quando @var{F} nõ for uma relação de equivalência,
 750 @code{equiv_classes} aceita-a sem reclamação,
 751 mas o resultado é geralmente incorrecto nesse caso.
 752
 753 @c EXCESSIVE DETAIL HERE. PROBABLY JUST CUT THIS
 754 @c @var{F} may be a relational operator (built-in or user-defined),
 755 @c an ordinary Maxima function, a Lisp function, a lambda expression,
 756 @c a macro, or a subscripted function.
 757
 758 Exemplos:
 759
 760 A relação de equivalência é uma expressão lambda a
 761 qual retorna @code{true} ou @code{false}.
 762
 763 @c ===beg===
 764 @c equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, lambda ([x, y], is (equal (x, y))));
 765 @c ===end===
 766 @example
 767 (%i1) equiv_classes (@{1, 1.0, 2, 2.0, 3, 3.0@}, lambda ([x, y], is (equal (x, y))));
 768 (%o1)            @{@{1, 1.0@}, @{2, 2.0@}, @{3, 3.0@}@}
 769 @end example
 770
 771 A relação de equivalência é o nome de uma
 772 função relacional que avalia para @code{true} ou
 773 @code{false}.
 774
 775 @c ===beg===
 776 @c equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, equal);
 777 @c ===end===
 778 @example
 779 (%i1) equiv_classes (@{1, 1.0, 2, 2.0, 3, 3.0@}, equal);
 780 (%o1)            @{@{1, 1.0@}, @{2, 2.0@}, @{3, 3.0@}@}
 781 @end example
 782
 783 As classes de equivalência são números que diferem por um múltiplo
 784 de 3.
 785
 786 @c ===beg===
 787 @c equiv_classes ({1, 2, 3, 4, 5, 6, 7}, lambda ([x, y], remainder (x - y, 3) = 0));
 788 @c ===end===
 789 @example
 790 (%i1) equiv_classes (@{1, 2, 3, 4, 5, 6, 7@}, lambda ([x, y], remainder (x - y, 3) = 0));
 791 (%o1)              @{@{1, 4, 7@}, @{2, 5@}, @{3, 6@}@}
 792 @end example
 793 @end deffn
 794
 795 @anchor{every}
 796 @deffn {Função} every (@var{f}, @var{s})
 797 @deffnx {Função} every (@var{f}, @var{L_1}, ..., @var{L_n})
 798
 799 Retorna @code{true} se o predicado @var{f} for @code{true} para todos os
 800 argumentos fornecidos.
 801
 802 Dado um conjunto como segundo argumento, @code{every(@var{f}, @var{s})}
 803 retorna @code{true} se @code{is(@var{f}(@var{a_i}))} retornar
 804 @code{true} para todos os @var{a_i} em @var{s}.  @code{every} pode ou
 805 não avaliar @var{f} para todos os @var{a_i} em @var{s}. Uma vez que
 806 os conjuntos são desordenados, @code{every} pode avaliar
 807 @code{@var{f}(@var{a_i})} em qualquer ordem.
 808
 809 Dada uma ou mais listas como argumentos, @code{every(@var{f}, @var{L_1},
 810 ..., @var{L_n})} retorna @code{true} se @code{is(@var{f}(@var{x_1}, ...,
 811 @var{x_n}))} retornar @code{true} para todos os @var{x_1}, ...,
 812 @var{x_n} em @var{L_1}, ..., @var{L_n}, respectivamente. @code{every}
 813 pode ou não avaliar @var{f} para toda combinação
 814 @var{x_1}, ..., @var{x_n}.  @code{every} avalia listas na ordem de
 815 incremento do índice.
 816
 817 Dado um conjunto vazio @code{@{@}} ou uma lista vazia @code{[]} como
 818 argumentos, @code{every} retorna @code{false}.
 819
 820 Quando o sinalizador global @code{maperror} for @code{true}, todas as
 821 listas @var{L_1}, ..., @var{L_n} deverão ter o mesmo comprimento.
 822 Quando @code{maperror} for falso, as listas dadas como argumentos
 823 serão efectivamente truncadas para o comprimento da menor lista.
 824
 825 Os resultados do predicado @var{f} que avaliarem (via @code{is}) para
 826 algo diferente de @code{true} ou @code{false} são governados através
 827 da variável global @code{prederror}. Quando @code{prederror} for
 828 @code{true}, tais valores são tratados como @code{false}, e o valor de
 829 retorno de @code{every} é @code{false}.  Quando @code{prederror} for
 830 @code{false}, tais valores são tratados como @code{unknown}, e o valor
 831 de retorno de @code{every} é @code{unknown}.
 832
 833 Exemplos:
 834
 835 @code{every} aplicada a um conjunto simples. O predicado é uma
 836 função de um argumento.
 837
 838 @c ===beg===
 839 @c every (integerp, {1, 2, 3, 4, 5, 6});
 840 @c every (atom, {1, 2, sin(3), 4, 5 + y, 6});
 841 @c ===end===
 842 @example
 843 (%i1) every (integerp, @{1, 2, 3, 4, 5, 6@});
 844 (%o1)                         true
 845 (%i2) every (atom, @{1, 2, sin(3), 4, 5 + y, 6@});
 846 (%o2)                         false
 847 @end example
 848
 849 @code{every} aplicada a duas listas. O predicado é uma
 850 função de dois argumentos.
 851
 852 @c ===beg===
 853 @c every ("=", [a, b, c], [a, b, c]);
 854 @c every ("#", [a, b, c], [a, b, c]);
 855 @c ===end===
 856 @example
 857 (%i1) every ("=", [a, b, c], [a, b, c]);
 858 (%o1)                         true
 859 (%i2) every ("#", [a, b, c], [a, b, c]);
 860 (%o2)                         false
 861 @end example
 862
 863 Predicado @var{f} que produz resultados diferentes de @code{true} ou
 864 @code{false}, governados por meio da variável global @code{prederror}.
 865
 866 @c ===beg===
 867 @c prederror : false;
 868 @c map (lambda ([a, b], is (a < b)), [x, y, z], [x^2, y^2, z^2]);
 869 @c every ("<", [x, y, z], [x^2, y^2, z^2]);
 870 @c prederror : true;
 871 @c every ("<", [x, y, z], [x^2, y^2, z^2]);
 872 @c ===end===
 873 @example
 874 (%i1) prederror : false;
 875 (%o1)                         false
 876 (%i2) map (lambda ([a, b], is (a < b)), [x, y, z], [x^2, y^2, z^2]);
 877 (%o2)              [unknown, unknown, unknown]
 878 (%i3) every ("<", [x, y, z], [x^2, y^2, z^2]);
 879 (%o3)                        unknown
 880 (%i4) prederror : true;
 881 (%o4)                         true
 882 (%i5) every ("<", [x, y, z], [x^2, y^2, z^2]);
 883 (%o5)                         false
 884 @end example
 885
 886 @end deffn
 887
 888 @anchor{extremal_subset}
 889 @deffn {Função} extremal_subset (@var{s}, @var{f}, max)
 890 @deffnx {Função} extremal_subset (@var{s}, @var{f}, min)
 891
 892 Encontra o subconjunto de @var{s} para o qual a função
 893 @var{f} toma valores máximos ou mínimos.
 894
 895 @code{extremal_subset(@var{s}, @var{f}, max)} encontra o subconjunto do
 896 conjunto ou lista @var{s} para os quais a função real
 897 @var{f} assume um valor máximo.
 898
 899 @code{extremal_subset(@var{s}, @var{f}, min)} encontra o subconjunto do
 900 conjunto ou lista @var{s} para a qual a função real
 901 @var{f} assume um valor mínimo.
 902
 903 Exemplos:
 904
 905 @c ===beg===
 906 @c extremal_subset ({-2, -1, 0, 1, 2}, abs, max);
 907 @c extremal_subset ({sqrt(2), 1.57, %pi/2}, sin, min);
 908 @c ===end===
 909 @example
 910 (%i1) extremal_subset (@{-2, -1, 0, 1, 2@}, abs, max);
 911 (%o1)                       @{- 2, 2@}
 912 (%i2) extremal_subset (@{sqrt(2), 1.57, %pi/2@}, sin, min);
 913 (%o2)                       @{sqrt(2)@}
 914 @end example
 915 @end deffn
 916
 917 @anchor{flatten}
 918 @deffn {Função} flatten (@var{expr})
 919
 920 Colecta argumentos de subexpressões que possuem o mesmo operador que
 921 @var{expr} e constrói uma expressão a partir desses argumentos
 922 colectados.
 923
 924 Subexpressões nas quais o operador é diferente do operador principal
 925 de @code{expr} são copiadas sem modificação, mesmo se
 926 tiverem subexpressões com o mesmo operador que @code{expr}.
 927
 928 É possível que @code{flatten} construia expressões nas
 929 quais o número de argumentos difira dos argumentos declarados para um
 930 operador; isso pode provocar uma mensagem de erro do simplificador ou do
 931 avaliador.  @code{flatten} não tenta detectar tais
 932 situações.
 933
 934 Expressões com representações especiais, por exemplo,
 935 expressões racionais canónicas (CRE), não podem usar a
 936 função @code{flatten}; nesses casos, @code{flatten}
 937 retorna os seus argumentos sem modificação.
 938
 939 Exemplos:
 940
 941 Aplicado a uma lista, @code{flatten} reúne todos os elementos da
 942 lista que sejam listas.
 943
 944 @c ===beg===
 945 @c flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]);
 946 @c ===end===
 947 @example
 948 (%i1) flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]);
 949 (%o1)            [a, b, c, d, e, f, g, h, i, j]
 950 @end example
 951
 952 Aplicado a um conjunto, @code{flatten} reúne todos os elementos do
 953 conjunto que sejam conjuntos.
 954
 955 @c ===beg===
 956 @c flatten ({a, {b}, {{c}}});
 957 @c flatten ({a, {[a], {a}}});
 958 @c ===end===
 959 @example
 960 (%i1) flatten (@{a, @{b@}, @{@{c@}@}@});
 961 (%o1)                       @{a, b, c@}
 962 (%i2) flatten (@{a, @{[a], @{a@}@}@});
 963 (%o2)                       @{a, [a]@}
 964 @end example
 965
 966 o efeito de @code{flatten} é similar a declarar o operador principal
 967 para ser enário. No entanto, @code{flatten} não faz efeito sobre
 968 subexpressões que possuem um operador diferente do operador principal,
 969 enquanto uma declaração enária faz efeito.
 970
 971 @c ===beg===
 972 @c expr: flatten (f (g (f (f (x)))));
 973 @c declare (f, nary);
 974 @c ev (expr);
 975 @c ===end===
 976 @example
 977 (%i1) expr: flatten (f (g (f (f (x)))));
 978 (%o1)                     f(g(f(f(x))))
 979 (%i2) declare (f, nary);
 980 (%o2)                         done
 981 (%i3) ev (expr);
 982 (%o3)                      f(g(f(x)))
 983 @end example
 984
 985 @code{flatten} trata funções subscritas da mesma forma
 986 que qualquer outro operador.
 987
 988 @c ===beg===
 989 @c flatten (f[5] (f[5] (x, y), z));
 990 @c ===end===
 991 @example
 992 (%i1) flatten (f[5] (f[5] (x, y), z));
 993 (%o1)                      f (x, y, z)
 994                             5
 995 @end example
 996
 997 É possível que @code{flatten} construa expressões nas
 998 quais o número de argumentos difira dos argumentos declarados para um
 999 operador;
1000
1001 @c ===beg===
1002 @c 'mod (5, 'mod (7, 4));
1003 @c flatten (%);
1004 @c ''%, nouns;
1005 @c ===end===
1006 @example
1007 (%i1) 'mod (5, 'mod (7, 4));
1008 (%o1)                   mod(5, mod(7, 4))
1009 (%i2) flatten (%);
1010 (%o2)                     mod(5, 7, 4)
1011 (%i3) ''%, nouns;
1012 Wrong number of arguments to mod
1013  -- an error.  Quitting.  To debug this try debugmode(true);
1014 @end example
1015 @end deffn
1016
1017 @anchor{full_listify}
1018 @deffn {Função} full_listify (@var{a})
1019 Substitui todo operador de conjunto em @var{a} por um operador de lista,
1020 e retorna o resultado. @code{fullt_listify} substitui operadores de
1021 conjunto em subexpressões aninhadas, mesmo se o operador principal
1022 não for (@code{set}).
1023
1024 @code{listify} substitui unicamente o operador principal.
1025
1026 Exemplos:
1027
1028 @c ===beg===
1029 @c full_listify ({a, b, {c, {d, e, f}, g}});
1030 @c full_listify (F (G ({a, b, H({c, d, e})})));
1031 @c ===end===
1032 @example
1033 (%i1) full_listify (@{a, b, @{c, @{d, e, f@}, g@}@});
1034 (%o1)               [a, b, [c, [d, e, f], g]]
1035 (%i2) full_listify (F (G (@{a, b, H(@{c, d, e@})@})));
1036 (%o2)              F(G([a, b, H([c, d, e])]))
1037 @end example
1038
1039 @end deffn
1040
1041 @anchor{fullsetify}
1042 @deffn {Função} fullsetify (@var{a})
1043 Quando @var{a} for uma lista, substitui o operador de lista por um
1044 operador de conjunto, e aplica @code{fullsetify} a cada elemento que for
1045 um conjunto.  Quando @var{a} não for uma lista, o resultado é
1046 @var{a} na sua forma original e sem modificações.
1047
1048 @code{setify} substitui unicamente o operador principal.
1049
1050 Exemplos:
1051
1052 Na linha (%o2), o argumento de @code{f} não é convertido para um
1053 conjunto porque o operador principal de @code{f([b])} não é uma
1054 lista.
1055
1056 @c ===beg===
1057 @c fullsetify ([a, [a]]);
1058 @c fullsetify ([a, f([b])]);
1059 @c ===end===
1060 @example
1061 (%i1) fullsetify ([a, [a]]);
1062 (%o1)                       @{a, @{a@}@}
1063 (%i2) fullsetify ([a, f([b])]);
1064 (%o2)                      @{a, f([b])@}
1065 @end example
1066
1067 @end deffn
1068
1069 @anchor{identity}
1070 @deffn {Função} identity (@var{x})
1071
1072 Retorna @var{x} para qualquer argumento @var{x}.
1073
1074 Exemplos:
1075
1076 @code{identity} pode ser usado como um predicado quando os argumentos
1077 forem valores Booleanos.
1078
1079 @c ===beg===
1080 @c every (identity, [true, true]);
1081 @c ===end===
1082 @example
1083 (%i1) every (identity, [true, true]);
1084 (%o1)                         true
1085 @end example
1086 @end deffn
1087
1088 @anchor{integer_partitions}
1089 @deffn {Função} integer_partitions (@var{n})
1090 @deffnx {Função} integer_partitions (@var{n}, @var{len})
1091
1092 Calcula partições inteiras de @var{n}, isto é, listas
1093 de inteiros cuja soma dos elementos de cada lista é @var{n}.
1094
1095 @code{integer_partitions(@var{n})} encontra o conjunto de todas as
1096 partições do inteiro @var{n}. Cada
1097 partição é uma lista ordenada do maior para o menor.
1098
1099 @code{integer_partitions(@var{n}, @var{len})} encontra todas as
1100 partições com comprimento @var{len} ou menor; nesse
1101 caso, serão adicionados zeros ao final de cada
1102 partição de comprimento menor que @var{len}, para fazer
1103 com que todas as partições tenham exactamente @var{len} termos.
1104 Cada partição é uma lista ordenada do maior para o
1105 menor.
1106
1107 Uma lista @math{[a_1, ..., a_m]} é uma partição de um
1108 inteiro não negativo @math{n} quando: (1) cada @math{a_i} é um
1109 inteiro não nulo, e (2) @math{a_1 + ... + a_m = n.} Dessa forma, 0
1110 não tem partições.
1111
1112 Exemplos:
1113
1114 @c ===beg===
1115 @c integer_partitions (3);
1116 @c s: integer_partitions (25)$
1117 @c cardinality (s);
1118 @c map (lambda ([x], apply ("+", x)), s);
1119 @c integer_partitions (5, 3);
1120 @c integer_partitions (5, 2);
1121 @c ===end===
1122 @example
1123 (%i1) integer_partitions (3);
1124 (%o1)               @{[1, 1, 1], [2, 1], [3]@}
1125 (%i2) s: integer_partitions (25)$
1126 (%i3) cardinality (s);
1127 (%o3)                         1958
1128 (%i4) map (lambda ([x], apply ("+", x)), s);
1129 (%o4)                         @{25@}
1130 (%i5) integer_partitions (5, 3);
1131 (%o5) @{[2, 2, 1], [3, 1, 1], [3, 2, 0], [4, 1, 0], [5, 0, 0]@}
1132 (%i6) integer_partitions (5, 2);
1133 (%o6)               @{[3, 2], [4, 1], [5, 0]@}
1134 @end example
1135
1136 Para encontrar todas as partições que satisfazem uma
1137 condição, use a função @code{subset};
1138 aqui está um exemplo que encontra todas as partições
1139 de 10 cujos elementos da lista são números primos.
1140
1141 @c ===beg===
1142 @c s: integer_partitions (10)$
1143 @c cardinality (s);
1144 @c xprimep(x) := integerp(x) and (x > 1) and primep(x)$
1145 @c subset (s, lambda ([x], every (xprimep, x)));
1146 @c ===end===
1147 @example
1148 (%i1) s: integer_partitions (10)$
1149 (%i2) cardinality (s);
1150 (%o2)                          42
1151 (%i3) xprimep(x) := integerp(x) and (x > 1) and primep(x)$
1152 (%i4) subset (s, lambda ([x], every (xprimep, x)));
1153 (%o4) @{[2, 2, 2, 2, 2], [3, 3, 2, 2], [5, 3, 2], [5, 5], [7, 3]@}
1154 @end example
1155
1156 @end deffn
1157
1158 @anchor{intersect}
1159 @deffn {Função} intersect (@var{a_1}, ..., @var{a_n})
1160
1161 @code{intersect} é o mesmo que @code{intersection}, como veremos.
1162
1163 @end deffn
1164
1165 @anchor{intersection}
1166 @deffn {Função} intersection (@var{a_1}, ..., @var{a_n})
1167 Retorna um conjunto contendo os elementos que são comuns aos conjuntos
1168 @var{a_1} até @var{a_n}.
1169
1170 @code{intersection} falha se qualquer dos argumentos não for um
1171 conjunto literal.
1172
1173 Exemplos:
1174
1175 @c ===beg===
1176 @c S_1 : {a, b, c, d};
1177 @c S_2 : {d, e, f, g};
1178 @c S_3 : {c, d, e, f};
1179 @c S_4 : {u, v, w};
1180 @c intersection (S_1, S_2);
1181 @c intersection (S_2, S_3);
1182 @c intersection (S_1, S_2, S_3);
1183 @c intersection (S_1, S_2, S_3, S_4);
1184 @c ===end===
1185 @example
1186 (%i1) S_1 : @{a, b, c, d@};
1187 (%o1)                     @{a, b, c, d@}
1188 (%i2) S_2 : @{d, e, f, g@};
1189 (%o2)                     @{d, e, f, g@}
1190 (%i3) S_3 : @{c, d, e, f@};
1191 (%o3)                     @{c, d, e, f@}
1192 (%i4) S_4 : @{u, v, w@};
1193 (%o4)                       @{u, v, w@}
1194 (%i5) intersection (S_1, S_2);
1195 (%o5)                          @{d@}
1196 (%i6) intersection (S_2, S_3);
1197 (%o6)                       @{d, e, f@}
1198 (%i7) intersection (S_1, S_2, S_3);
1199 (%o7)                          @{d@}
1200 (%i8) intersection (S_1, S_2, S_3, S_4);
1201 (%o8)                          @{@}
1202 @end example
1203
1204 @end deffn
1205
1206 @deffn {Função} kron_delta (@var{x}, @var{y})
1207
1208 Representa a função delta de Kronecker.
1209
1210 @code{kron_delta} simplifica para 1 quando @var{x} e @var{y} forem
1211 idênticos ou equivalentes, e simplifica para 0 quando @var{x} e
1212 @var{y} não forem equivalentes. De outra forma, se não for certo que
1213 @var{x} e @var{y} são equivalentes, @code{kron_delta} simplificará
1214 para uma expressão substantiva. @code{kron_delta} implementa uma
1215 política de segurança para expressões em
1216 ponto flutuante: se a diferença @code{@var{x} - @var{y}}
1217 for um número em ponto flutuante, @code{kron_delta} simplifica para
1218 uma expressão substantiva quando @var{x} for aparentemente equivalente
1219 a @var{y}.
1220
1221 Especificamente, @code{kron_delta(@var{x}, @var{y})} simplifica para 1
1222 quando @code{is(x = y)} for @code{true}. @code{kron_delta} também
1223 simplifica para 1 quando @code{sign(abs(@var{x} - @var{y}))} for
1224 @code{zero} e @code{@var{x} - @var{y}} não for um número em ponto
1225 flutuante (e também não for um número de precisão simples em
1226 ponto flutuante nem um número de precisão dupla em poto flutuante,
1227 isto é, não for um bigfloat). @code{kron_delta} simplifica para 0
1228 quando @code{sign(abs(@var{x} - @var{y}))} for @code{pos}.
1229
1230 Caso contrário, @code{sign(abs(@var{x} - @var{y}))} é diferente de
1231 @code{pos} ou @code{zero}, ou é @code{zero} e @code{@var{x} - @var{y}}
1232 é um número em ponto flutuante. Nesses casos, @code{kron_delta}
1233 retorna um expressão substantiva.
1234
1235 @code{kron_delta} é declarada como sendo simétrica. Isto é,
1236 @code{kron_delta(@var{x}, @var{y})} é igual a
1237 @code{kron_delta(@var{y}, @var{x})}.
1238
1239 Exemplos:
1240
1241 Os argumentos de @code{kron_delta} são idênticos. @code{kron_delta}
1242 simplifica para 1.
1243
1244 @c ===beg===
1245 @c kron_delta (a, a);
1246 @c kron_delta (x^2 - y^2, x^2 - y^2);
1247 @c float (kron_delta (1/10, 0.1));
1248 @c ===end===
1249 @example
1250 (%i1) kron_delta (a, a);
1251 (%o1)                           1
1252 (%i2) kron_delta (x^2 - y^2, x^2 - y^2);
1253 (%o2)                           1
1254 (%i3) float (kron_delta (1/10, 0.1));
1255 (%o3)                           1
1256 @end example
1257
1258 Os argumentos de @code{kron_delta} são equivalentes, e a
1259 diferença entre eles não é um número em ponto
1260 flutuante.  @code{kron_delta} simplifica para 1.
1261
1262 @c ===beg===
1263 @c assume (equal (x, y));
1264 @c kron_delta (x, y);
1265 @c ===end===
1266 @example
1267 (%i1) assume (equal (x, y));
1268 (%o1)                     [equal(x, y)]
1269 (%i2) kron_delta (x, y);
1270 (%o2)                           1
1271 @end example
1272
1273 Os argumentos de @code{kron_delta} não são equivalentes.
1274 @code{kron_delta} simplifica para 0.
1275
1276 @c ===beg===
1277 @c kron_delta (a + 1, a);
1278 @c assume (a > b)$
1279 @c kron_delta (a, b);
1280 @c kron_delta (1/5, 0.7);
1281 @c ===end===
1282 @example
1283 (%i1) kron_delta (a + 1, a);
1284 (%o1)                           0
1285 (%i2) assume (a > b)$
1286 (%i3) kron_delta (a, b);
1287 (%o3)                           0
1288 (%i4) kron_delta (1/5, 0.7);
1289 (%o4)                           0
1290 @end example
1291
1292 Os argumentos de @code{kron_delta} podem ou não ser equivalentes.
1293 @code{kron_delta} simplifica para uma expressão substantiva.
1294
1295 @c ===beg===
1296 @c kron_delta (a, b);
1297 @c assume(x >= y)$
1298 @c kron_delta (x, y);
1299 @c ===end===
1300 @example
1301 (%i1) kron_delta (a, b);
1302 (%o1)                   kron_delta(a, b)
1303 (%i2) assume(x >= y)$
1304 (%i3) kron_delta (x, y);
1305 (%o3)                   kron_delta(x, y)
1306 @end example
1307
1308 Os argumentos de @code{kron_delta} são equivalentes, mas a
1309 diferença entre eles é um número em ponto flutuante.
1310 @code{kron_delta} simplifica para uma expressão substantiva.
1311
1312 @c ===beg===
1313 @c 1/4 - 0.25;
1314 @c 1/10 - 0.1;
1315 @c 0.25 - 0.25b0;
1316 @c kron_delta (1/4, 0.25);
1317 @c kron_delta (1/10, 0.1);
1318 @c kron_delta (0.25, 0.25b0);
1319 @c ===end===
1320 @example
1321 (%i1) 1/4 - 0.25;
1322 (%o1)                          0.0
1323 (%i2) 1/10 - 0.1;
1324 (%o2)                          0.0
1325 (%i3) 0.25 - 0.25b0;
1326 Warning:  Float to bigfloat conversion of 0.25
1327 (%o3)                         0.0b0
1328 (%i4) kron_delta (1/4, 0.25);
1329                                   1
1330 (%o4)                  kron_delta(-, 0.25)
1331                                   4
1332 (%i5) kron_delta (1/10, 0.1);
1333                                   1
1334 (%o5)                  kron_delta(--, 0.1)
1335                                   10
1336 (%i6) kron_delta (0.25, 0.25b0);
1337 Warning:  Float to bigfloat conversion of 0.25
1338 (%o6)               kron_delta(0.25, 2.5b-1)
1339 @end example
1340
1341 @code{kron_delta} é simétrica.
1342
1343 @c ===beg===
1344 @c kron_delta (x, y);
1345 @c kron_delta (y, x);
1346 @c kron_delta (x, y) - kron_delta (y, x);
1347 @c is (equal (kron_delta (x, y), kron_delta (y, x)));
1348 @c is (kron_delta (x, y) = kron_delta (y, x));
1349 @c ===end===
1350 @example
1351 (%i1) kron_delta (x, y);
1352 (%o1)                   kron_delta(x, y)
1353 (%i2) kron_delta (y, x);
1354 (%o2)                   kron_delta(x, y)
1355 (%i3) kron_delta (x, y) - kron_delta (y, x);
1356 (%o3)                           0
1357 (%i4) is (equal (kron_delta (x, y), kron_delta (y, x)));
1358 (%o4)                         true
1359 (%i5) is (kron_delta (x, y) = kron_delta (y, x));
1360 (%o5)                         true
1361 @end example
1362
1363 @end deffn
1364
1365 @anchor{listify}
1366 @deffn {Função} listify (@var{a})
1367
1368 Retorna uma lista contendo os elementos de @var{a} quando @var{a} for um
1369 conjunto. De outra forma, @code{listify} retorna @var{a}.
1370
1371 @code{full_listify} substitui todos os operadores de conjunto em @var{a}
1372 por operadores de lista.
1373
1374 Exemplos:
1375
1376 @c ===beg===
1377 @c listify ({a, b, c, d});
1378 @c listify (F ({a, b, c, d}));
1379 @c ===end===
1380 @example
1381 (%i1) listify (@{a, b, c, d@});
1382 (%o1)                     [a, b, c, d]
1383 (%i2) listify (F (@{a, b, c, d@}));
1384 (%o2)                    F(@{a, b, c, d@})
1385 @end example
1386
1387 @end deffn
1388
1389 @anchor{lreduce}
1390 @deffn {Função} lreduce (@var{F}, @var{s})
1391 @deffnx {Função} lreduce (@var{F}, @var{s}, @var{s_0})
1392
1393 Extende a função de dois argumentos @var{F} para uma
1394 função de @code{n} argumentos, usando
1395 composição, onde @var{s} é uma lista.
1396
1397 @code{lreduce(@var{F}, @var{s})} retorna @code{F(... F(F(s_1, s_2),
1398 s_3), ... s_n)}.  Quando o argumento opcional @var{s_0} estiver
1399 presente, o resultado é equivalente a @code{lreduce(@var{F},
1400 cons(@var{s_0}, @var{s}))}.
1401
1402 A função @var{F} é aplicada primeiro aos elementos
1403 mais à @emph{esquerda} de lista; daí o nome "lreduce".
1404
1405 Veja também @code{rreduce}, @code{xreduce}, e @code{tree_reduce}.
1406
1407 Exemplos:
1408
1409 @code{lreduce} sem o argumento opcional.
1410
1411 @c ===beg===
1412 @c lreduce (f, [1, 2, 3]);
1413 @c lreduce (f, [1, 2, 3, 4]);
1414 @c ===end===
1415 @example
1416 (%i1) lreduce (f, [1, 2, 3]);
1417 (%o1)                     f(f(1, 2), 3)
1418 (%i2) lreduce (f, [1, 2, 3, 4]);
1419 (%o2)                  f(f(f(1, 2), 3), 4)
1420 @end example
1421
1422 @code{lreduce} com o argumento opcional.
1423
1424 @c ===beg===
1425 @c lreduce (f, [1, 2, 3], 4);
1426 @c ===end===
1427 @example
1428 (%i1) lreduce (f, [1, 2, 3], 4);
1429 (%o1)                  f(f(f(4, 1), 2), 3)
1430 @end example
1431
1432 @code{lreduce} aplicada a operadores binários internos do Maxima
1433 @code{/} é o operador de divisão.
1434
1435 @c ===beg===
1436 @c lreduce ("^", args ({a, b, c, d}));
1437 @c lreduce ("/", args ({a, b, c, d}));
1438 @c ===end===
1439 @example
1440 (%i1) lreduce ("^", args (@{a, b, c, d@}));
1441                                b c d
1442 (%o1)                       ((a ) )
1443 (%i2) lreduce ("/", args (@{a, b, c, d@}));
1444                                 a
1445 (%o2)                         -----
1446                               b c d
1447 @end example
1448
1449 @end deffn
1450
1451 @anchor{makeset}
1452 @deffn {Função} makeset (@var{expr}, @var{x}, @var{s})
1453
1454 Retorna um conjunto com elementos gerados a partir da expressão
1455 @var{expr}, onde @var{x} é uma lista de variáveis em @var{expr}, e
1456 @var{s}é um conjunto ou lista de listas.  Para gerar cada elemento do
1457 conjunto, @var{expr} é avaliada com as variáveis @var{x}
1458 substituídas, em paralelo, por elementos de @var{s}.
1459
1460 Cada elemento de @var{s} deve ter o mesmo comprimento que @var{x}.  A
1461 lista de variáveis @var{x} deve ser uma lista de
1462 símbolos, sem índices.  Mesmo se existir
1463 somente um símbolo, @var{x} deve ser uma lista de um
1464 elemento, e cada elemento de @var{s} deve ser uma lista de um elemento.
1465
1466 @c FOLLOWING EQUIVALENT EXPRESSION IS REALLY TOO COMPLICATED, JUST SKIP IT FOR NOW
1467 @c @code{makeset(@var{expr}, @var{x}, @var{s})} returns the same result as
1468 @c @code{setify(map(lambda([L], sublis(map("=", ''@var{x}, L), ''@var{expr})), args(@var{s})))}.
1469
1470 Veja também @code{makelist}.
1471
1472 Exemplos:
1473
1474 @c ===beg===
1475 @c makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]);
1476 @c S : {x, y, z}$
1477 @c S3 : cartesian_product (S, S, S);
1478 @c makeset (i + j + k, [i, j, k], S3);
1479 @c makeset (sin(x), [x], {[1], [2], [3]});
1480 @c ===end===
1481 @example
1482 (%i1) makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]);
1483                            1  2  3  4
1484 (%o1)                     @{-, -, -, -@}
1485                            a  b  c  d
1486 (%i2) S : @{x, y, z@}$
1487 (%i3) S3 : cartesian_product (S, S, S);
1488 (%o3) @{[x, x, x], [x, x, y], [x, x, z], [x, y, x], [x, y, y],
1489 [x, y, z], [x, z, x], [x, z, y], [x, z, z], [y, x, x],
1490 [y, x, y], [y, x, z], [y, y, x], [y, y, y], [y, y, z],
1491 [y, z, x], [y, z, y], [y, z, z], [z, x, x], [z, x, y],
1492 [z, x, z], [z, y, x], [z, y, y], [z, y, z], [z, z, x],
1493 [z, z, y], [z, z, z]@}
1494 (%i4) makeset (i + j + k, [i, j, k], S3);
1495 (%o4) @{3 x, 3 y, y + 2 x, 2 y + x, 3 z, z + 2 x, z + y + x,
1496                                        z + 2 y, 2 z + x, 2 z + y@}
1497 (%i5) makeset (sin(x), [x], @{[1], [2], [3]@});
1498 (%o5)               @{sin(1), sin(2), sin(3)@}
1499 @end example
1500 @end deffn
1501
1502 @anchor{moebius}
1503 @deffn {Função} moebius (@var{n})
1504
1505 Representa a função de Moebius.
1506
1507 Quando @var{n} for o produto de @math{k} primos distintos,
1508 @code{moebius(@var{n})} simplifica para @math{(-1)^k}; quando
1509 @math{@var{n} = 1}, simplifica para 1; e simplifica para 0 para todos os
1510 outros inteiros positivos.
1511
1512 @code{moebius}, aplicada a equações, listas, matrizes
1513 e conjuntos, é calculada em forma distributiva.
1514
1515 Exemplos:
1516
1517 @c ===beg===
1518 @c moebius (1);
1519 @c moebius (2 * 3 * 5);
1520 @c moebius (11 * 17 * 29 * 31);
1521 @c moebius (2^32);
1522 @c moebius (n);
1523 @c moebius (n = 12);
1524 @c moebius ([11, 11 * 13, 11 * 13 * 15]);
1525 @c moebius (matrix ([11, 12], [13, 14]));
1526 @c moebius ({21, 22, 23, 24});
1527 @c ===end===
1528 @example
1529 (%i1) moebius (1);
1530 (%o1)                           1
1531 (%i2) moebius (2 * 3 * 5);
1532 (%o2)                          - 1
1533 (%i3) moebius (11 * 17 * 29 * 31);
1534 (%o3)                           1
1535 (%i4) moebius (2^32);
1536 (%o4)                           0
1537 (%i5) moebius (n);
1538 (%o5)                      moebius(n)
1539 (%i6) moebius (n = 12);
1540 (%o6)                    moebius(n) = 0
1541 (%i7) moebius ([11, 11 * 13, 11 * 13 * 15]);
1542 (%o7)                      [- 1, 1, 1]
1543 (%i8) moebius (matrix ([11, 12], [13, 14]));
1544                            [ - 1  0 ]
1545 (%o8)                      [        ]
1546                            [ - 1  1 ]
1547 (%i9) moebius (@{21, 22, 23, 24@});
1548 (%o9)                      @{- 1, 0, 1@}
1549 @end example
1550
1551 @end deffn
1552
1553 @anchor{multinomial_coeff}
1554 @deffn {Função} multinomial_coeff (@var{a_1}, ..., @var{a_n})
1555 @deffnx {Função} multinomial_coeff ()
1556
1557 Calcula o coeficiente multinomial.
1558
1559 Quando cada @var{a_k} for um inteiro não negativo, o coeficiente
1560 multinomial indica o número de formas possíveis de
1561 colocar @code{@var{a_1} + ... + @var{a_n}} objectos distintos em
1562 @math{n} caixas com @var{a_k} elementos na @math{k}'ésima caixa. Em
1563 geral, @code{multinomial_coeff (@var{a_1}, ..., @var{a_n})} calcula
1564 @code{(@var{a_1} + ... + @var{a_n})!/(@var{a_1}! ... @var{a_n}!)}.
1565
1566 @code{multinomial_coeff()} (sem argumentos) produz 1.
1567
1568 @code{minfactorial} poderá conseguir simplificar o valor calculado por
1569 @code{multinomial_coeff}.
1570
1571 Exemplos:
1572
1573 @c ===beg===
1574 @c multinomial_coeff (1, 2, x);
1575 @c minfactorial (%);
1576 @c multinomial_coeff (-6, 2);
1577 @c minfactorial (%);
1578 @c ===end===
1579 @example
1580 (%i1) multinomial_coeff (1, 2, x);
1581                             (x + 3)!
1582 (%o1)                       --------
1583                               2 x!
1584 (%i2) minfactorial (%);
1585                      (x + 1) (x + 2) (x + 3)
1586 (%o2)                -----------------------
1587                                 2
1588 (%i3) multinomial_coeff (-6, 2);
1589                              (- 4)!
1590 (%o3)                       --------
1591                             2 (- 6)!
1592 (%i4) minfactorial (%);
1593 (%o4)                          10
1594 @end example
1595 @end deffn
1596
1597 @anchor{num_distinct_partitions}
1598 @deffn {Função} num_distinct_partitions (@var{n})
1599 @deffnx {Função} num_distinct_partitions (@var{n}, list)
1600
1601 Calcula o n;umero de partições de inteiros distintos de @var{n}
1602 quando @var{n} for um inteiro não negativo.
1603 De outra forma, @code{num_distinct_partitions} retorna uma expressão substantiva.
1604
1605 @code{num_distinct_partitions(@var{n}, list)} retorna uma
1606 lista do número de partições distintas de 1, 2, 3, ..., @var{n}.
1607
1608 Uma partição distinta de @var{n} é
1609 uma lista de inteiros positivos distintos @math{k_1}, ..., @math{k_m}
1610 tais que @math{@var{n} = k_1 + ... + k_m}.
1611
1612 Exemplos:
1613
1614 @c ===beg===
1615 @c num_distinct_partitions (12);
1616 @c num_distinct_partitions (12, list);
1617 @c num_distinct_partitions (n);
1618 @c ===end===
1619 @example
1620 (%i1) num_distinct_partitions (12);
1621 (%o1)                          15
1622 (%i2) num_distinct_partitions (12, list);
1623 (%o2)      [1, 1, 1, 2, 2, 3, 4, 5, 6, 8, 10, 12, 15]
1624 (%i3) num_distinct_partitions (n);
1625 (%o3)              num_distinct_partitions(n)
1626 @end example
1627
1628 @end deffn
1629
1630 @anchor{num_partitions}
1631 @deffn {Função} num_partitions (@var{n})
1632 @deffnx {Função} num_partitions (@var{n}, list)
1633
1634 Calcula o número das partições inteiras de @var{n}
1635 quando @var{n} for um inteiro não negativo.  De outra forma,
1636 @code{num_partitions} retorna uma expressão substantiva.
1637
1638 @code{num_partitions(@var{n}, list)} retorna uma
1639 lista do número de partições inteiras de 1, 2, 3, ..., @var{n}.
1640
1641 Para um inteiro não negativo @var{n}, @code{num_partitions(@var{n})} é igual a
1642 @code{cardinality(integer_partitions(@var{n}))}; todavia, @code{num_partitions}
1643 não constrói actualmente o conjunto das partições, nesse sentido @code{num_partitions} é mais rápida.
1644
1645 Exemplos:
1646
1647 @c ===beg===
1648 @c num_partitions (5) = cardinality (integer_partitions (5));
1649 @c num_partitions (8, list);
1650 @c num_partitions (n);
1651 @c ===end===
1652 @example
1653 (%i1) num_partitions (5) = cardinality (integer_partitions (5));
1654 (%o1)                         7 = 7
1655 (%i2) num_partitions (8, list);
1656 (%o2)            [1, 1, 2, 3, 5, 7, 11, 15, 22]
1657 (%i3) num_partitions (n);
1658 (%o3)                   num_partitions(n)
1659 @end example
1660
1661 @end deffn
1662
1663
1664
1665 @anchor{partition_set}
1666 @deffn {Função} partition_set (@var{a}, @var{f})
1667
1668 Partições do conjunto @var{a} que satisfazem o predicado @var{f}.
1669
1670 @code{partition_set} retorna uma lista de dois conjuntos.
1671 O primeiro conjunto compreende os elementos de @var{a} para os quais @var{f} avalia para @code{false},
1672 e o segundo conjunto compreende quaisquer outros elementos de @var{a}.
1673 @code{partition_set} não aplica @code{is} ao valor de retorno de @var{f}.
1674
1675 @code{partition_set} reclama se @var{a} não for um conjunto literal.
1676
1677 Veja também @code{subset}.
1678
1679 Exemplos:
1680
1681 @c ===beg===
1682 @c partition_set ({2, 7, 1, 8, 2, 8}, evenp);
1683 @c partition_set ({x, rat(y), rat(y) + z, 1}, lambda ([x], ratp(x)));
1684 @c ===end===
1685 @example
1686 (%i1) partition_set (@{2, 7, 1, 8, 2, 8@}, evenp);
1687 (%o1)                   [@{1, 7@}, @{2, 8@}]
1688 (%i2) partition_set (@{x, rat(y), rat(y) + z, 1@}, lambda ([x], ratp(x)));
1689 (%o2)/R/              [@{1, x@}, @{y, y + z@}]
1690 @end example
1691 @end deffn
1692
1693 @anchor{permutations}
1694 @deffn {Função} permutations (@var{a})
1695
1696 Retorna um conjunto todas as permutações distintas dos elementos da
1697 lista ou do conjunto @var{a}. Cada permutação é uma lista, não um conjunto.
1698
1699 Quando @var{a} for uma lista, elementos duplicados de @var{a} são incluídos
1700 nas permutações.
1701
1702 @code{permutations} reclama se @var{a} não for um conjunto literal ou uma lista literal.
1703
1704 Exemplos:
1705
1706 @c ===beg===
1707 @c permutations ([a, a]);
1708 @c permutations ([a, a, b]);
1709 @c ===end===
1710 @example
1711 (%i1) permutations ([a, a]);
1712 (%o1)                       @{[a, a]@}
1713 (%i2) permutations ([a, a, b]);
1714 (%o2)           @{[a, a, b], [a, b, a], [b, a, a]@}
1715 @end example
1716
1717 @end deffn
1718
1719 @anchor{powerset}
1720 @deffn {Função} powerset (@var{a})
1721 @deffnx {Função} powerset (@var{a}, @var{n})
1722
1723 Retorna o conjunto de todos os dubconjuntos de @var{a}, ou um subconjunto de @var{a}.
1724
1725 @code{powerset(@var{a})} retorna o conjunto de todos os subconjuntos do conjunto @var{a}.
1726 @code{powerset(@var{a})} tem @code{2^cardinality(@var{a})} elementos.
1727
1728 @code{powerset(@var{a}, @var{n})} retorna o conjunto de todos os subconjuntos de @var{a} que possuem
1729 cardinalidade @var{n}.
1730
1731 @code{powerset} reclama se @var{a} não for um conjunto literal,
1732 ou se @var{n} não for um inteiro não negativo.
1733
1734 Exemplos:
1735
1736 @c ===beg===
1737 @c powerset ({a, b, c});
1738 @c powerset ({w, x, y, z}, 4);
1739 @c powerset ({w, x, y, z}, 3);
1740 @c powerset ({w, x, y, z}, 2);
1741 @c powerset ({w, x, y, z}, 1);
1742 @c powerset ({w, x, y, z}, 0);
1743 @c ===end===
1744 @example
1745 (%i1) powerset (@{a, b, c@});
1746 (%o1) @{@{@}, @{a@}, @{a, b@}, @{a, b, c@}, @{a, c@}, @{b@}, @{b, c@}, @{c@}@}
1747 (%i2) powerset (@{w, x, y, z@}, 4);
1748 (%o2)                    @{@{w, x, y, z@}@}
1749 (%i3) powerset (@{w, x, y, z@}, 3);
1750 (%o3)     @{@{w, x, y@}, @{w, x, z@}, @{w, y, z@}, @{x, y, z@}@}
1751 (%i4) powerset (@{w, x, y, z@}, 2);
1752 (%o4)   @{@{w, x@}, @{w, y@}, @{w, z@}, @{x, y@}, @{x, z@}, @{y, z@}@}
1753 (%i5) powerset (@{w, x, y, z@}, 1);
1754 (%o5)                 @{@{w@}, @{x@}, @{y@}, @{z@}@}
1755 (%i6) powerset (@{w, x, y, z@}, 0);
1756 (%o6)                         @{@{@}@}
1757 @end example
1758
1759 @end deffn
1760
1761 @anchor{rreduce}
1762 @deffn {Função} rreduce (@var{F}, @var{s})
1763 @deffnx {Função} rreduce (@var{F}, @var{s}, @var{s_@{n + 1@}})
1764
1765 Extende a função de dois argumentos @var{F} para uma função de @var{n} argumentos usando composição de funções,
1766 onde @var{s} é uma lista.
1767
1768 @code{rreduce(@var{F}, @var{s})} retorna @code{F(s_1, ... F(s_@{n - 2@}, F(s_@{n - 1@}, s_n)))}.
1769 Quando o argumento opcional @var{s_@{n + 1@}} estiver presente,
1770 o resultado é equivalente a @code{rreduce(@var{F}, endcons(@var{s_@{n + 1@}}, @var{s}))}.
1771
1772 A função @var{F} é primeiro aplicada à
1773 lista de elementos @i{mais à direita - rightmost}, daí o nome "rreduce".
1774
1775 Veja também @code{lreduce}, @code{tree_reduce}, e @code{xreduce}.
1776
1777 Exemplos:
1778
1779 @code{rreduce} sem o argumento opcional.
1780
1781 @c ===beg===
1782 @c rreduce (f, [1, 2, 3]);
1783 @c rreduce (f, [1, 2, 3, 4]);
1784 @c ===end===
1785 @example
1786 (%i1) rreduce (f, [1, 2, 3]);
1787 (%o1)                     f(1, f(2, 3))
1788 (%i2) rreduce (f, [1, 2, 3, 4]);
1789 (%o2)                  f(1, f(2, f(3, 4)))
1790 @end example
1791
1792 @code{rreduce} com o argumento opcional.
1793
1794 @c ===beg===
1795 @c rreduce (f, [1, 2, 3], 4);
1796 @c ===end===
1797 @example
1798 (%i1) rreduce (f, [1, 2, 3], 4);
1799 (%o1)                  f(1, f(2, f(3, 4)))
1800 @end example
1801
1802 @code{rreduce} aplicada a operadores de dois argumentos internos ( definidos por padrão) ao Maxima.
1803 @code{/} é o operadro de divisão.
1804
1805 @c ===beg===
1806 @c rreduce ("^", args ({a, b, c, d}));
1807 @c rreduce ("/", args ({a, b, c, d}));
1808 @c ===end===
1809 @example
1810 (%i1) rreduce ("^", args (@{a, b, c, d@}));
1811                                  d
1812                                 c
1813                                b
1814 (%o1)                         a
1815 (%i2) rreduce ("/", args (@{a, b, c, d@}));
1816                                a c
1817 (%o2)                          ---
1818                                b d
1819 @end example
1820
1821 @end deffn
1822
1823 @anchor{setdifference}
1824 @deffn {Função}  setdifference (@var{a}, @var{b})
1825
1826 Retorna um conjunto contendo os elementos no conjunto @var{a} que
1827 não estãono conjunto @var{b}.
1828
1829 @code{setdifference} reclama se ou @var{a} ou @var{b} não for um conjunto literal.
1830
1831 Exemplos:
1832
1833 @c ===beg===
1834 @c S_1 : {a, b, c, x, y, z};
1835 @c S_2 : {aa, bb, c, x, y, zz};
1836 @c setdifference (S_1, S_2);
1837 @c setdifference (S_2, S_1);
1838 @c setdifference (S_1, S_1);
1839 @c setdifference (S_1, {});
1840 @c setdifference ({}, S_1);
1841 @c ===end===
1842 @example
1843 (%i1) S_1 : @{a, b, c, x, y, z@};
1844 (%o1)                  @{a, b, c, x, y, z@}
1845 (%i2) S_2 : @{aa, bb, c, x, y, zz@};
1846 (%o2)                 @{aa, bb, c, x, y, zz@}
1847 (%i3) setdifference (S_1, S_2);
1848 (%o3)                       @{a, b, z@}
1849 (%i4) setdifference (S_2, S_1);
1850 (%o4)                     @{aa, bb, zz@}
1851 (%i5) setdifference (S_1, S_1);
1852 (%o5)                          @{@}
1853 (%i6) setdifference (S_1, @{@});
1854 (%o6)                  @{a, b, c, x, y, z@}
1855 (%i7) setdifference (@{@}, S_1);
1856 (%o7)                          @{@}
1857 @end example
1858
1859 @end deffn
1860
1861 @anchor{setequalp}
1862 @deffn {Função} setequalp (@var{a}, @var{b})
1863
1864 Retorna @code{true} se os conjuntos @var{a} e @var{b} possuirem o mesmo número de elementos
1865 @c $SETEQUALP CALLS THE LISP FUNCTION LIKE,
1866 @c AND SO DOES THE CODE TO EVALUATE IS (X = Y).
1867 e @code{is(@var{x} = @var{y})} for @code{true}
1868 para @code{x} nos elementos de @var{a}
1869 e @code{y} nos elementos de @var{b},
1870 considerados na ordem determinada por @code{listify}.
1871 De outra forma, @code{setequalp} retorna @code{false}.
1872
1873 Exemplos:
1874
1875 @c ===beg===
1876 @c setequalp ({1, 2, 3}, {1, 2, 3});
1877 @c setequalp ({a, b, c}, {1, 2, 3});
1878 @c setequalp ({x^2 - y^2}, {(x + y) * (x - y)});
1879 @c ===end===
1880 @example
1881 (%i1) setequalp (@{1, 2, 3@}, @{1, 2, 3@});
1882 (%o1)                         true
1883 (%i2) setequalp (@{a, b, c@}, @{1, 2, 3@});
1884 (%o2)                         false
1885 (%i3) setequalp (@{x^2 - y^2@}, @{(x + y) * (x - y)@});
1886 (%o3)                         false
1887 @end example
1888
1889 @end deffn
1890
1891 @anchor{setify}
1892 @deffn {Função} setify (@var{a})
1893
1894 Constrói um conjunto de elementos a partir da lista @var{a}. Elementos
1895 duplicados da lista @var{a} são apagados e os elementos
1896 são ordenados de acordo com o predicado @code{orderlessp}.
1897
1898 @code{setify} reclama se @var{a} não for uma lista literal.
1899
1900 Exemplos:
1901
1902 @c ===beg===
1903 @c setify ([1, 2, 3, a, b, c]);
1904 @c setify ([a, b, c, a, b, c]);
1905 @c setify ([7, 13, 11, 1, 3, 9, 5]);
1906 @c ===end===
1907 @example
1908 (%i1) setify ([1, 2, 3, a, b, c]);
1909 (%o1)                  @{1, 2, 3, a, b, c@}
1910 (%i2) setify ([a, b, c, a, b, c]);
1911 (%o2)                       @{a, b, c@}
1912 (%i3) setify ([7, 13, 11, 1, 3, 9, 5]);
1913 (%o3)                @{1, 3, 5, 7, 9, 11, 13@}
1914 @end example
1915
1916 @end deffn
1917
1918 @anchor{setp}
1919 @deffn {Função} setp (@var{a})
1920
1921 Retorna @code{true} se e somente se @var{a} for um conjunto na interpretação do Maxima.
1922
1923 @code{setp} retorna @code{true} para conjuntos não simplificados (isto é, conjuntos com elementos redundantes)
1924 e também para conjuntos simplificados.
1925
1926 @c NOT SURE WE NEED TO MENTION THIS. OK FOR NOW
1927 @code{setp} é equivalente à função do Maxima
1928 @code{setp(a) := not atom(a) and op(a) = 'set}.
1929
1930 Exemplos:
1931
1932 @c ===beg===
1933 @c simp : false;
1934 @c {a, a, a};
1935 @c setp (%);
1936 @c ===end===
1937 @example
1938 (%i1) simp : false;
1939 (%o1)                         false
1940 (%i2) @{a, a, a@};
1941 (%o2)                       @{a, a, a@}
1942 (%i3) setp (%);
1943 (%o3)                         true
1944 @end example
1945
1946 @end deffn
1947
1948 @anchor{set_partitions}
1949 @deffn {Função} set_partitions (@var{a})
1950 @deffnx {Função} set_partitions (@var{a}, @var{n})
1951
1952 Retorna o conjunto de todas as partições de @var{a}, ou um subconjunto daquele conjunto de partições.
1953
1954 @code{set_partitions(@var{a}, @var{n})} retorna um conjunto de todas as
1955 decomposições de @var{a} em @var{n} subconjutnos disjuntos não vazios.
1956
1957 @code{set_partitions(@var{a})} retorna o conjunto de todas as partições.
1958
1959 @code{stirling2} retorna a cardinalidade de um conjuntode partições de um conjunto.
1960
1961 Um conjunto de conjuntos @math{P} é uma partição de um conjunto @math{S} quando
1962
1963 @enumerate
1964 @item
1965 cada elemento de @math{P} é um conjunto não vazio,
1966 @item
1967 elementos distintos de @math{P} são disjuntos,
1968 @item
1969 a união dos elementos de @math{P} é igual a @math{S}.
1970 @end enumerate
1971
1972 Exemplos:
1973
1974 O conjunto vazio é uma partição de si mesmo, as ondições 1 e 2 são "vaziamente" verdadeiras.
1975
1976 @c ===beg===
1977 @c set_partitions ({});
1978 @c ===end===
1979 @example
1980 (%i1) set_partitions (@{@});
1981 (%o1)                         @{@{@}@}
1982 @end example
1983
1984 A cardinalidade do conjunto de partições de um conjunto pode ser encontrada usando @code{stirling2}.
1985
1986 @c ===beg===
1987 @c s: {0, 1, 2, 3, 4, 5}$
1988 @c p: set_partitions (s, 3)$
1989 @c cardinality(p) = stirling2 (6, 3);
1990 @c ===end===
1991 @example
1992 (%i1) s: @{0, 1, 2, 3, 4, 5@}$
1993 (%i2) p: set_partitions (s, 3)$
1994 (%i3) cardinality(p) = stirling2 (6, 3);
1995 (%o3)                        90 = 90
1996 @end example
1997
1998 Cada elemento de @code{p} pode ter @var{n} = 3 elementos; vamos verificar.
1999
2000 @c ===beg===
2001 @c s: {0, 1, 2, 3, 4, 5}$
2002 @c p: set_partitions (s, 3)$
2003 @c map (cardinality, p);
2004 @c ===end===
2005 @example
2006 (%i1) s: @{0, 1, 2, 3, 4, 5@}$
2007 (%i2) p: set_partitions (s, 3)$
2008 (%i3) map (cardinality, p);
2009 (%o3)                          @{3@}
2010 @end example
2011
2012 Finalmente, para cada elementos de @code{p}, a união de seus elementos possivelmente será
2013 igua a @code{s}; novamente vamos comprovar.
2014
2015 @c ===beg===
2016 @c s: {0, 1, 2, 3, 4, 5}$
2017 @c p: set_partitions (s, 3)$
2018 @c map (lambda ([x], apply (union, listify (x))), p);
2019 @c ===end===
2020 @example
2021 (%i1) s: @{0, 1, 2, 3, 4, 5@}$
2022 (%i2) p: set_partitions (s, 3)$
2023 (%i3) map (lambda ([x], apply (union, listify (x))), p);
2024 (%o3)                 @{@{0, 1, 2, 3, 4, 5@}@}
2025 @end example
2026 @end deffn
2027
2028 @anchor{some}
2029 @deffn {Função} some (@var{f}, @var{a})
2030 @deffnx {Função} some (@var{f}, @var{L_1}, ..., @var{L_n})
2031
2032 Retorna @code{true} se o predicado @var{f} for @code{true} para um ou mais argumentos dados.
2033
2034 Given one set as the second argument,
2035 @code{some(@var{f}, @var{s})} returns @code{true}
2036 if @code{is(@var{f}(@var{a_i}))} returns @code{true} for one or more @var{a_i} in @var{s}.
2037 @code{some} may or may not evaluate @var{f} for all @var{a_i} in @var{s}.
2038 Since sets are unordered,
2039 @code{some} may evaluate @code{@var{f}(@var{a_i})} in any order.
2040
2041 Dadas uma ou mais listas como argumentos,
2042 @code{some(@var{f}, @var{L_1}, ..., @var{L_n})} retorna @code{true}
2043 se @code{is(@var{f}(@var{x_1}, ..., @var{x_n}))} retornar @code{true}
2044 para um ou mais @var{x_1}, ..., @var{x_n} em @var{L_1}, ..., @var{L_n}, respectivamente.
2045 @code{some} pode ou não avaliar
2046 @var{f} para algumas combinações @var{x_1}, ..., @var{x_n}.
2047 @code{some} avalia listas na ordem do índice de incremento.
2048
2049 Dado um conjunto vazio @code{@{@}} ou uma lista vazia @code{[]} como argumentos,
2050 @code{some} retorna @code{false}.
2051
2052 Quando o sinalizador global @code{maperror} for @code{true}, todas as listas
2053 @var{L_1}, ..., @var{L_n} devem ter obrigatóriamente comprimentos iguais.
2054 Quando @code{maperror} for @code{false}, argumentos do tipo lista são
2055 efectivamente truncados para o comprimento da menor lista.
2056
2057 Retorna o valor de um predicado @var{f} o qual avalia (por meio de @code{is})
2058 para alguma coisa outra que não @code{true} ou @code{false}
2059 e são governados pelo sinalizador global @code{prederror}.
2060 Quando @code{prederror} for @code{true},
2061 tais valores são tratados como @code{false}.
2062 Quando @code{prederror} for @code{false},
2063 tais valores são tratados como @code{unknown} (desconhecidos).
2064
2065 Exemplos:
2066
2067 @code{some} aplicado a um conjunto simples.
2068 O predicado é uma função de um argumento.
2069
2070 @c ===beg===
2071 @c some (integerp, {1, 2, 3, 4, 5, 6});
2072 @c some (atom, {1, 2, sin(3), 4, 5 + y, 6});
2073 @c ===end===
2074 @example
2075 (%i1) some (integerp, @{1, 2, 3, 4, 5, 6@});
2076 (%o1)                         true
2077 (%i2) some (atom, @{1, 2, sin(3), 4, 5 + y, 6@});
2078 (%o2)                         true
2079 @end example
2080
2081 @code{some} aplicada a duas listas.
2082 O predicado é uma função de dois argumentos.
2083
2084 @c ===beg===
2085 @c some ("=", [a, b, c], [a, b, c]);
2086 @c some ("#", [a, b, c], [a, b, c]);
2087 @c ===end===
2088 @example
2089 (%i1) some ("=", [a, b, c], [a, b, c]);
2090 (%o1)                         true
2091 (%i2) some ("#", [a, b, c], [a, b, c]);
2092 (%o2)                         false
2093 @end example
2094
2095 Retorna o valor do predicado @var{f} o qual avalia
2096 para alguma coisa que não @code{true} ou @code{false}
2097 e são governados através do sinalizador global @code{prederror}.
2098
2099 @c ===beg===
2100 @c prederror : false;
2101 @c map (lambda ([a, b], is (a < b)), [x, y, z], [x^2, y^2, z^2]);
2102 @c some ("<", [x, y, z], [x^2, y^2, z^2]);
2103 @c some ("<", [x, y, z], [x^2, y^2, z + 1]);
2104 @c prederror : true;
2105 @c some ("<", [x, y, z], [x^2, y^2, z^2]);
2106 @c some ("<", [x, y, z], [x^2, y^2, z + 1]);
2107 @c ===end===
2108 @example
2109 (%i1) prederror : false;
2110 (%o1)                         false
2111 (%i2) map (lambda ([a, b], is (a < b)), [x, y, z], [x^2, y^2, z^2]);
2112 (%o2)              [unknown, unknown, unknown]
2113 (%i3) some ("<", [x, y, z], [x^2, y^2, z^2]);
2114 (%o3)                        unknown
2115 (%i4) some ("<", [x, y, z], [x^2, y^2, z + 1]);
2116 (%o4)                         true
2117 (%i5) prederror : true;
2118 (%o5)                         true
2119 (%i6) some ("<", [x, y, z], [x^2, y^2, z^2]);
2120 (%o6)                         false
2121 (%i7) some ("<", [x, y, z], [x^2, y^2, z + 1]);
2122 (%o7)                         true
2123 @end example
2124 @end deffn
2125
2126 @anchor{stirling1}
2127 @deffn {Função} stirling1 (@var{n}, @var{m})
2128
2129 Representa o número de Stirling de primeiro tipo.
2130
2131 Quando @var{n} e @var{m} forem não negativos
2132 inteiros, a magnitude de @code{stirling1 (@var{n}, @var{m})} é o número de
2133 permutações de um conjunto com @var{n} elementos que possui @var{m} ciclos.
2134 Para detalhes, veja Graham, Knuth e Patashnik @i{Concrete Mathematics}.
2135 Maxima utiliza uma relação recursiva para definir @code{stirling1 (@var{n}, @var{m})} para
2136 @var{m} menor que 0; @code{stirling1} não é definida para @var{n} menor que 0 e para argumentos
2137 não inteiros.
2138
2139 @code{stirling1} é uma função de simplificação.
2140 Maxima conhece as seguintes identidades:
2141
2142 @c COPIED VERBATIM FROM SRC/NSET.LISP
2143 @enumerate
2144 @item
2145 @math{stirling1(0, n) = kron_delta(0, n)} (Ref. [1])
2146 @item
2147 @math{stirling1(n, n) = 1} (Ref. [1])
2148 @item
2149 @math{stirling1(n, n - 1) = binomial(n, 2)} (Ref. [1])
2150 @item
2151 @math{stirling1(n + 1, 0) = 0} (Ref. [1])
2152 @item
2153 @math{stirling1(n + 1, 1) = n!} (Ref. [1])
2154 @item
2155 @math{stirling1(n + 1, 2) = 2^n  - 1} (Ref. [1])
2156 @end enumerate
2157
2158 Essas identidades são aplicadas quando os argumentos forem inteiros literais
2159 ou símbolos declarados como inteiros, e o primeiro argumento for não negativo.
2160 @code{stirling1} não simplififca para argumentos não inteiros.
2161
2162 Referências:
2163
2164 [1] Donald Knuth, @i{The Art of Computer Programming,}
2165 terceira edição, Volume 1, Seção 1.2.6, Equações 48, 49, e 50.
2166
2167 Exemplos:
2168
2169 @c ===beg===
2170 @c declare (n, integer)$
2171 @c assume (n >= 0)$
2172 @c stirling1 (n, n);
2173 @c ===end===
2174 @example
2175 (%i1) declare (n, integer)$
2176 (%i2) assume (n >= 0)$
2177 (%i3) stirling1 (n, n);
2178 (%o3)                           1
2179 @end example
2180
2181 @code{stirling1} não simplifica para argumentos não inteiros.
2182
2183 @c ===beg===
2184 @c stirling1 (sqrt(2), sqrt(2));
2185 @c ===end===
2186 @example
2187 (%i1) stirling1 (sqrt(2), sqrt(2));
2188 (%o1)              stirling1(sqrt(2), sqrt(2))
2189 @end example
2190
2191 Maxima aplica identidades a @code{stirling1}.
2192
2193 @c ===beg===
2194 @c declare (n, integer)$
2195 @c assume (n >= 0)$
2196 @c stirling1 (n + 1, n);
2197 @c stirling1 (n + 1, 1);
2198 @c ===end===
2199 @example
2200 (%i1) declare (n, integer)$
2201 (%i2) assume (n >= 0)$
2202 (%i3) stirling1 (n + 1, n);
2203                             n (n + 1)
2204 (%o3)                       ---------
2205                                 2
2206 (%i4) stirling1 (n + 1, 1);
2207 (%o4)                          n!
2208 @end example
2209 @end deffn
2210
2211 @anchor{stirling2}
2212 @deffn {Função} stirling2 (@var{n}, @var{m})
2213
2214 Representa o número de Stirling de segundo tipo.
2215
2216 Quando @var{n} e @var{m} forem inteiros
2217 não negativos, @code{stirling2 (@var{n}, @var{m})} é o número de maneiras através dos quais um conjunto com
2218 cardinalidade @var{n} pode ser particionado em @var{m} subconjuntos disjuntos.
2219 Maxima utiliza uma relação recursiva para definir @code{stirling2 (@var{n}, @var{m})} para
2220 @var{m} menor que 0; @code{stirling2} é indefinida para @var{n} menor que 0 e para argumentos
2221 não inteiros.
2222
2223 @code{stirling2} é uma função de simplificação.
2224 Maxima conhece as seguintes identidades.
2225
2226 @c COPIED VERBATIM FROM SRC/NSET.LISP
2227 @enumerate
2228 @item
2229 @math{stirling2(0, n) = kron_delta(0, n)} (Ref. [1])
2230 @item
2231 @math{stirling2(n, n) = 1} (Ref. [1])
2232 @item
2233 @math{stirling2(n, n - 1) = binomial(n, 2)} (Ref. [1])
2234 @item
2235 @math{stirling2(n + 1, 1) = 1} (Ref. [1])
2236 @item
2237 @math{stirling2(n + 1, 2) = 2^n  - 1} (Ref. [1])
2238 @item
2239 @math{stirling2(n, 0) = kron_delta(n, 0)} (Ref. [2])
2240 @item
2241 @math{stirling2(n, m) = 0} when @math{m > n} (Ref. [2])
2242 @item
2243 @math{stirling2(n, m) = sum((-1)^(m - k) binomial(m k) k^n,i,1,m) / m!}
2244 onde @math{m} e @math{n} são inteiros, e @math{n} é não negativo. (Ref. [3])
2245 @end enumerate
2246
2247 Essas identidades são aplicadas quando os argumentos forem inteiros literais
2248 ou símbolos declarados como inteiros, e o primeiro argumento for não negativo.
2249 @code{stirling2} não simplifica para argumentos não inteiros.
2250
2251 Referências:
2252
2253 [1] Donald Knuth. @i{The Art of Computer Programming},
2254 terceira edição, Volume 1, Seção 1.2.6, Equações 48, 49, e 50.
2255
2256 [2] Graham, Knuth, e Patashnik. @i{Concrete Mathematics}, Tabela 264.
2257
2258 [3] Abramowitz e Stegun. @i{Handbook of Mathematical Functions}, Seção 24.1.4.
2259
2260 Exemplos:
2261
2262 @c ===beg===
2263 @c declare (n, integer)$
2264 @c assume (n >= 0)$
2265 @c stirling2 (n, n);
2266 @c ===end===
2267 @example
2268 (%i1) declare (n, integer)$
2269 (%i2) assume (n >= 0)$
2270 (%i3) stirling2 (n, n);
2271 (%o3)                           1
2272 @end example
2273
2274 @code{stirling2} não simplifica para argumentos não inteiros.
2275
2276 @c ===beg===
2277 @c stirling2 (%pi, %pi);
2278 @c ===end===
2279 @example
2280 (%i1) stirling2 (%pi, %pi);
2281 (%o1)                  stirling2(%pi, %pi)
2282 @end example
2283
2284 Maxima aplica identidades a @code{stirling2}.
2285
2286 @c ===beg===
2287 @c declare (n, integer)$
2288 @c assume (n >= 0)$
2289 @c stirling2 (n + 9, n + 8);
2290 @c stirling2 (n + 1, 2);
2291 @c ===end===
2292 @example
2293 (%i1) declare (n, integer)$
2294 (%i2) assume (n >= 0)$
2295 (%i3) stirling2 (n + 9, n + 8);
2296                          (n + 8) (n + 9)
2297 (%o3)                    ---------------
2298                                 2
2299 (%i4) stirling2 (n + 1, 2);
2300                               n
2301 (%o4)                        2  - 1
2302 @end example
2303 @end deffn
2304
2305 @anchor{subset}
2306 @deffn {Função} subset (@var{a}, @var{f})
2307
2308 Retorna o subconjuntode um conjunto @var{a} que satisfaz o predicado @var{f}.
2309
2310 @code{subset} returns um conjunto which comprises the elements of @var{a}
2311 for which @var{f} returns anything other than @code{false}.
2312 @code{subset} does not apply @code{is} to the return value of @var{f}.
2313
2314 @code{subset} reclama se @var{a} não for um conjunto literal.
2315
2316 See also @code{partition_set}.
2317
2318 Exemplos:
2319
2320 @c ===beg===
2321 @c subset ({1, 2, x, x + y, z, x + y + z}, atom);
2322 @c subset ({1, 2, 7, 8, 9, 14}, evenp);
2323 @c ===end===
2324 @example
2325 (%i1) subset (@{1, 2, x, x + y, z, x + y + z@}, atom);
2326 (%o1)                     @{1, 2, x, z@}
2327 (%i2) subset (@{1, 2, 7, 8, 9, 14@}, evenp);
2328 (%o2)                      @{2, 8, 14@}
2329 @end example
2330
2331 @end deffn
2332
2333 @anchor{subsetp}
2334 @deffn {Função} subsetp (@var{a}, @var{b})
2335
2336 Retorna @code{true} se e somente se o conjunto @var{a} for um subconjunto de @var{b}.
2337
2338 @code{subsetp} reclama se ou @var{a} ou @var{b} não forem um conjunto literal.
2339
2340 Exemplos:
2341
2342 @c ===beg===
2343 @c subsetp ({1, 2, 3}, {a, 1, b, 2, c, 3});
2344 @c subsetp ({a, 1, b, 2, c, 3}, {1, 2, 3});
2345 @c ===end===
2346 @example
2347 (%i1) subsetp (@{1, 2, 3@}, @{a, 1, b, 2, c, 3@});
2348 (%o1)                         true
2349 (%i2) subsetp (@{a, 1, b, 2, c, 3@}, @{1, 2, 3@});
2350 (%o2)                         false
2351 @end example
2352
2353 @end deffn
2354
2355 @anchor{symmdifference}
2356 @deffn {Função} symmdifference (@var{a_1}, ..., @var{a_n})
2357
2358 Retorna a diferença simétrica, isto é,
2359 o conjunto dos elemetnos que ocorrem em exactamente um conjunto @var{a_k}.
2360
2361 Given two arguments, @code{symmdifference(@var{a}, @var{b})} is
2362 the same as @code{union(setdifference(@var{a}, @var{b}), setdifference(@var{b}, @var{a}))}.
2363
2364 @code{symmdifference} reclama se any argument não for um conjunto literal.
2365
2366 Exemplos:
2367
2368 @c ===beg===
2369 @c S_1 : {a, b, c};
2370 @c S_2 : {1, b, c};
2371 @c S_3 : {a, b, z};
2372 @c symmdifference ();
2373 @c symmdifference (S_1);
2374 @c symmdifference (S_1, S_2);
2375 @c symmdifference (S_1, S_2, S_3);
2376 @c symmdifference ({}, S_1, S_2, S_3);
2377 @c ===end===
2378 @example
2379 (%i1) S_1 : @{a, b, c@};
2380 (%o1)                       @{a, b, c@}
2381 (%i2) S_2 : @{1, b, c@};
2382 (%o2)                       @{1, b, c@}
2383 (%i3) S_3 : @{a, b, z@};
2384 (%o3)                       @{a, b, z@}
2385 (%i4) symmdifference ();
2386 (%o4)                          @{@}
2387 (%i5) symmdifference (S_1);
2388 (%o5)                       @{a, b, c@}
2389 (%i6) symmdifference (S_1, S_2);
2390 (%o6)                        @{1, a@}
2391 (%i7) symmdifference (S_1, S_2, S_3);
2392 (%o7)                        @{1, z@}
2393 (%i8) symmdifference (@{@}, S_1, S_2, S_3);
2394 (%o8)                        @{1, z@}
2395 @end example
2396
2397 @end deffn
2398
2399 @c TREE_REDUCE ACCEPTS A SET OR LIST AS AN ARGUMENT, BUT RREDUCE AND LREDUCE WANT ONLY LISTS; STRANGE
2400 @anchor{tree_reduce}
2401 @deffn {Função} tree_reduce (@var{F}, @var{s})
2402 @deffnx {Função} tree_reduce (@var{F}, @var{s}, @var{s_0})
2403
2404 Extende a função binária @var{F} a uma função enária através de composição,
2405 onde @var{s} é um conjunto ou uma lista.
2406
2407 @code{tree_reduce} é equivalente ao seguinte:
2408 Aplicar @var{F} a sucessivos pares de elementos
2409 para formar uma nova lista @code{[@var{F}(@var{s_1}, @var{s_2}), @var{F}(@var{s_3}, @var{s_4}), ...]},
2410 mantendo o elemento final inalterado caso haja um número ímpar de elementos.
2411 Repetindo então o processo até que a lista esteja reduzida a um elemento simples, o qual é o valor de retorno da função.
2412
2413 Quando o argumento opcional @var{s_0} estiver presente,
2414 o resultado é equivalente a @code{tree_reduce(@var{F}, cons(@var{s_0}, @var{s})}.
2415
2416 Para adições em ponto flutuante,
2417 @code{tree_reduce} pode retornar uma soma que possui um menor ero de arredondamento
2418 que @code{rreduce} ou @code{lreduce}.
2419
2420 Os elementos da lista @var{s} e os resultados parciais podem ser arranjados em uma árvore binária de profundidade mínima,
2421 daí o nome "tree_reduce".
2422
2423 Exemplos:
2424
2425 @code{tree_reduce} aplicada a uma lista com um número par de elementos.
2426
2427 @c ===beg===
2428 @c tree_reduce (f, [a, b, c, d]);
2429 @c ===end===
2430 @example
2431 (%i1) tree_reduce (f, [a, b, c, d]);
2432 (%o1)                  f(f(a, b), f(c, d))
2433 @end example
2434
2435 @code{tree_reduce} aplicada a uma lista com um número ímpar de elementos.
2436
2437 @c ===beg===
2438 @c tree_reduce (f, [a, b, c, d, e]);
2439 @c ===end===
2440 @example
2441 (%i1) tree_reduce (f, [a, b, c, d, e]);
2442 (%o1)               f(f(f(a, b), f(c, d)), e)
2443 @end example
2444
2445 @end deffn
2446
2447 @anchor{union}
2448 @deffn {Função} union (@var{a_1}, ..., @var{a_n})
2449 Retorna a união dos conjuntos de @var{a_1} a @var{a_n}.
2450
2451 @code{union()} (sem argumentos) retorna o conjunto vazio.
2452
2453 @code{union} reclama se qualquer argumento não for um conjunto literal.
2454
2455 Exemplos:
2456
2457 @c ===beg===
2458 @c S_1 : {a, b, c + d, %e};
2459 @c S_2 : {%pi, %i, %e, c + d};
2460 @c S_3 : {17, 29, 1729, %pi, %i};
2461 @c union ();
2462 @c union (S_1);
2463 @c union (S_1, S_2);
2464 @c union (S_1, S_2, S_3);
2465 @c union ({}, S_1, S_2, S_3);
2466 @c ===end===
2467 @example
2468 (%i1) S_1 : @{a, b, c + d, %e@};
2469 (%o1)                   @{%e, a, b, d + c@}
2470 (%i2) S_2 : @{%pi, %i, %e, c + d@};
2471 (%o2)                 @{%e, %i, %pi, d + c@}
2472 (%i3) S_3 : @{17, 29, 1729, %pi, %i@};
2473 (%o3)                @{17, 29, 1729, %i, %pi@}
2474 (%i4) union ();
2475 (%o4)                          @{@}
2476 (%i5) union (S_1);
2477 (%o5)                   @{%e, a, b, d + c@}
2478 (%i6) union (S_1, S_2);
2479 (%o6)              @{%e, %i, %pi, a, b, d + c@}
2480 (%i7) union (S_1, S_2, S_3);
2481 (%o7)       @{17, 29, 1729, %e, %i, %pi, a, b, d + c@}
2482 (%i8) union (@{@}, S_1, S_2, S_3);
2483 (%o8)       @{17, 29, 1729, %e, %i, %pi, a, b, d + c@}
2484 @end example
2485
2486 @end deffn
2487
2488 @c XREDUCE ACCEPTS A SET OR LIST AS AN ARGUMENT, BUT RREDUCE AND LREDUCE WANT ONLY LISTS; STRANGE
2489 @anchor{xreduce}
2490 @deffn {Função} xreduce (@var{F}, @var{s})
2491 @deffnx {Função} xreduce (@var{F}, @var{s}, @var{s_0})
2492
2493 Extendendo a função @var{F} para uma função enária por composição,
2494 ou, se @var{F} já for enária, aplica-se @var{F} a @var{s}.
2495 Quando @var{F} não for enária, @code{xreduce} funciona da mesma forma que @code{lreduce}.
2496 O argumento @var{s} é uma lista.
2497
2498 Funções sabidamente enárias inclui
2499 adição @code{+}, multiplicação @code{*}, @code{and}, @code{or}, @code{max},
2500 @code{min}, e @code{append}.
2501 Funções podem também serem declaradas enárias por meio de @code{declare(@var{F}, nary)}.
2502 Para essas funções,
2503 é esperado que @code{xreduce} seja mais rápida que ou @code{rreduce} ou @code{lreduce}.
2504
2505 Quando o argumento opcional @var{s_0} estiver presente,
2506 o resultado é equivalente a @code{xreduce(@var{s}, cons(@var{s_0}, @var{s}))}.
2507
2508 @c NOT SURE WHAT IS THE RELEVANCE OF THE FOLLOWING COMMENT
2509 @c MAXIMA IS NEVER SO CAREFUL ABOUT FLOATING POINT ASSOCIATIVITY SO FAR AS I KNOW
2510 Adições em ponto flutuante não são exactamente associativas; quando a associatividade ocorrer,
2511 @code{xreduce} aplica a adição enária do Maxima quando @var{s} contiver números em ponto flutuante.
2512
2513 Exemplos:
2514
2515 @code{xreduce} aplicada a uma função sabidamente enária.
2516 @code{F} é chamada uma vez, com todos os argumentos.
2517
2518 @c ===beg===
2519 @c declare (F, nary);
2520 @c F ([L]) := L;
2521 @c xreduce (F, [a, b, c, d, e]);
2522 @c ===end===
2523 @example
2524 (%i1) declare (F, nary);
2525 (%o1)                         done
2526 (%i2) F ([L]) := L;
2527 (%o2)                      F([L]) := L
2528 (%i3) xreduce (F, [a, b, c, d, e]);
2529 (%o3)         [[[[[("[", simp), a], b], c], d], e]
2530 @end example
2531
2532 @code{xreduce} aplicada a uma função não sabidamente enária.
2533 @code{G} é chamada muitas vezes, com dois argumentos de cada vez.
2534
2535 @c ===beg===
2536 @c G ([L]) := L;
2537 @c xreduce (G, [a, b, c, d, e]);
2538 @c lreduce (G, [a, b, c, d, e]);
2539 @c ===end===
2540 @example
2541 (%i1) G ([L]) := L;
2542 (%o1)                      G([L]) := L
2543 (%i2) xreduce (G, [a, b, c, d, e]);
2544 (%o2)         [[[[[("[", simp), a], b], c], d], e]
2545 (%i3) lreduce (G, [a, b, c, d, e]);
2546 (%o3)                 [[[[a, b], c], d], e]
2547 @end example
2548
2549 @end deffn
2550