doc/info/pt_BR/nset.texi

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