Introducedilhaão a Conjuntos
============================

Maxima fornece funcedilhaões de conjunto, tais como interseccedilhaão e união, para conjuntos finitos que são definidos por enumeracedilhaão explícita. Maxima trata listas e conjuntos como objectos distintos. Este recurso torna possível trabalhar com conjuntos que possuem elementos que são ou listas ou conjuntos.

Adicionalmente, para funcedilhaões de conjuntos finitos, Maxima fornece algumas funcedilhaões relacionadas com análise combinatória: números de Stirling de primeiro e de segundo tipo, números de Bell, coeficientes multinomiais e particedilhaões de inteiros não negativos, entre outras. Maxima também define a funcedilhaão delta de Kronecker.

Utilizacedilhaão
----------------

Para construir um conjunto com elementos a_1, ..., a_n, escreva set(a_1, ..., a_n) ou {a_1, ..., a_n}; para construir o conjunto vazio, escreva set() ou {}.  Para insercedilhaão de dados, set(...) e { ... } são equivalentes. Os conjuntos são sempre mostrados entre chaves ({ ... }).

Se um elemento é listado mais de uma vez, o simplificador do Maxima elimina o elemento redundante.

     (%i1) set();
     (%o1)                          {}
     (%i2) set(a, b, a);
     (%o2)                        {a, b}
     (%i3) set(a, set(b));
     (%o3)                       {a, {b}}
     (%i4) set(a, [b]);
     (%o4)                       {a, [b]}
     (%i5) {};
     (%o5)                          {}
     (%i6) {a, b, a};
     (%o6)                        {a, b}
     (%i7) {a, {b}};
     (%o7)                       {a, {b}}
     (%i8) {a, [b]};
     (%o8)                       {a, [b]}

Dois elementos X e Y são redundantes (nomeadamente, considerados o mesmo para propósito de construcedilhaão de conjuntos) se e somente se is(X = Y) retornar true. Note que is(equal(X, Y)) pode retornar true enquanto is(X = Y) retorna false; nesse caso os elementos X e Y são considerados distintos.

     (%i1) x: a/c + b/c;
                                   b   a
     (%o1)                         - + -
                                   c   c
     (%i2) y: a/c + b/c;
                                   b   a
     (%o2)                         - + -
                                   c   c
     (%i3) z: (a + b)/c;
                                   b + a
     (%o3)                         -----
                                     c
     (%i4) is (x = y);
     (%o4)                         true
     (%i5) is (y = z);
     (%o5)                         false
     (%i6) is (equal (y, z));
     (%o6)                         true
     (%i7) y - z;
                                b + a   b   a
     (%o7)                    - ----- + - + -
                                  c     c   c
     (%i8) ratsimp (%);
     (%o8)                           0
     (%i9) {x, y, z};
                               b + a  b   a
     (%o9)                    {-----, - + -}
                                 c    c   c

Para construir um conjunto dos elementos de uma lista, use setify.

     (%i1) setify ([b, a]);
     (%o1)                        {a, b}

Os elementos de conjunto x e y serão considerados iguais se is(x = y) for avaliando para true. Dessa forma, rat(x) e x são iguais como elementos de conjunto; consequentemente,

     (%i1) {x, rat(x)};
     (%o1)                          {x}

Adicionalmente, uma vez que is((x - 1)*(x + 1) = x^2 - 1) avalia para false, (x - 1)*(x + 1) e x^2 - 1 são considerados elementos de conjunto diferentes; dessa forma

     (%i1) {(x - 1)*(x + 1), x^2 - 1};
                                            2
     (%o1)               {(x - 1) (x + 1), x  - 1}

Para reduzir esse conjunto a um conjunto simples, apliquemos rat a cada elemento do conjunto

     (%i1) {(x - 1)*(x + 1), x^2 - 1};
                                            2
     (%o1)               {(x - 1) (x + 1), x  - 1}
     (%i2) map (rat, %);
                                   2
     (%o2)/R/                    {x  - 1}

Para remover redundâncias em outros conjuntos, poderá ter que usar outras funcedilhaões de simplificacedilhaão. Aqui está um exemplo que usa trigsimp:

     (%i1) {1, cos(x)^2 + sin(x)^2};
                                 2         2
     (%o1)                {1, sin (x) + cos (x)}
     (%i2) map (trigsimp, %);
     (%o2)                          {1}

Um conjunto está simplificado quando os seus elementos não são redundantes e o conjunto está ordenado. A versão actual das funcedilhaões de conjunto usam a funcedilhaão orderlessp do Maxima para ordenar conjuntos; contudo, versões futuras das funcedilhaões de conjunto poderão
vir a usar uma funcedilhaão de ordenacedilhaão
diferente.

Algumas operacedilhaões sobre conjuntos, tais como substituicedilhaões, forcedilhaam automaticamente a uma re-simplificacedilhaão; por exemplo,

     (%i1) s: {a, b, c}$
     (%i2) subst (c=a, s);
     (%o2)                        {a, b}
     (%i3) subst ([a=x, b=x, c=x], s);
     (%o3)                          {x}
     (%i4) map (lambda ([x], x^2), set (-1, 0, 1));
     (%o4)                        {0, 1}

Maxima trata listas e conjuntos como objectos distintos; funcedilhaões tais como union e intersection produzem um erro se qualquer argumento não for um conjunto. se precisar aplicar uma funcedilhaão de conjunto a uma lista, use a funcedilhaão setify para converter essa lista num conjunto. Dessa forma

     (%i1) union ([1, 2], {a, b});
     Function union expects a set, instead found [1,2]
      -- an error.  Quitting.  To debug this try debugmode(true);
     (%i2) union (setify ([1, 2]), {a, b});
     (%o2)                     {1, 2, a, b}

Para extrair todos os elementos de um conjunto s que satisfazem um predicado f, use subset(s, f). (Um predicado é um uma funcedilhaão que avalia para os valores booleanos true/false.) Por exemplo, para encontrar as equacedilhaões num dado conjunto que não depende de uma variável z, use

     (%i1) subset ({x + y + z, x - y + 4, x + y - 5}, lambda ([e], freeof (z, e)));
     (%o1)               {- y + x + 4, y + x - 5}

A seccedilhaão Definicedilhaões para
Conjuntos possui uma lista completa das funcedilhaões de conjunto no Maxima.

Iteracedilhaões entre Elementos de Conjuntos
--------------------------------------------

Existem duas formas de fazer iteracedilhaões sobre elementos de conjuntos. Uma forma é usar map; por exemplo:

     (%i1) map (f, {a, b, c});
     (%o1)                  {f(a), f(b), f(c)}

A outra forma consiste em usar for X in S do

     (%i1) s: {a, b, c};
     (%o1)                       {a, b, c}
     (%i2) for si in s do print (concat (si, 1));
     a1
     b1
     c1
     (%o2)                         done

As funcedilhaões first e rest do Maxima trabalham actualmente sobre conjuntos. Aplicada a um conjunto, first retorna o primeiro elemento mostrado de um conjunto; qual o élemento que será mostrado dependerá da implementacedilhaão. Se s for um conjunto, então rest(s) é equivalente a disjoin(first(s), s). Actualmente, existem outras funcedilhaões do Maxima que trabalham correctamente sobre conjuntos. Em versões futuras das funcedilhaões de conjunto, first e rest podem vir a funcionar diferentemente ou deixar de funcionar.

Erros
-----

As funcedilhaões de conjunto usam a funcedilhaão orderlessp do Maxima para organizar os elementos dum conjunto e a funcedilhaão (a nível do Lisp) like para testar a igualdade entre elementos de conjuntos. Ambas essas funcedilhaões possuem falhas conhecidas que podem se manifestar quando tentar usar conjuntos com elementos que são listas ou matrizes que contenham expressões na forma racional canónica (CRE). Um exemplo é

     (%i1) {[x], [rat (x)]};
     Maxima encountered a Lisp error:

       The value #:X1440 is not of type LIST.

     Automatically continuing.
     To reenable the Lisp debugger set *debugger-hook* to nil.

Essa expressão faz com que o Maxima produza um erro (a mensagem de erro dependerá da versão do Lisp que o Maxima estiver a utilizar). Outro exemplo é

     (%i1) setify ([[rat(a)], [rat(b)]]);
     Maxima encountered a Lisp error:

       The value #:A1440 is not of type LIST.

     Automatically continuing.
     To reenable the Lisp debugger set *debugger-hook* to nil.

Essas falhas são causadas por falhas em orderlessp e like, e não por falhas nas funcedilhaões de conjunto. Para ilustrar, experimente as expressões

     (%i1) orderlessp ([rat(a)], [rat(b)]);
     Maxima encountered a Lisp error:

       The value #:B1441 is not of type LIST.

     Automatically continuing.
     To reenable the Lisp debugger set *debugger-hook* to nil.
     (%i2) is ([rat(a)] = [rat(a)]);
     (%o2)                         false

Até que essas falhas forem corrigidas, não construa conjuntos com elementos que sejam listas ou matrizes contendo expressões na forma racional canónica (CRE); um conjunto com um elemento na forma CRE, contudo, pode não ser um problema:

     (%i1) {x, rat (x)};
     (%o1)                          {x}

A orderlessp do Maxima possui outra falha que pode causar problemas com funcedilhaões de conjunto; nomeadamente, o predicado de ordenacedilhaão orderlessp não é transitivo. O mais simples exemplo conhecido que mostra isso é

     (%i1) q: x^2$
     (%i2) r: (x + 1)^2$
     (%i3) s: x*(x + 2)$
     (%i4) orderlessp (q, r);
     (%o4)                         true
     (%i5) orderlessp (r, s);
     (%o5)                         true
     (%i6) orderlessp (q, s);
     (%o6)                         false

Essa falha pode causar problemas com todas as funcedilhaões de conjunto bem como com funcedilhaões do Maxima em geral. É provável, mas não certo, que essa falha possa ser evitada se todos os elementos do conjunto estiverem ou na forma CRE ou tiverem sido simplificados usando ratsimp.

Os mecanismos orderless e ordergreat do Maxima são incompatíveis com as funcedilhaões de conjunto. Se precisar usar orderless ou ordergrreat, chame todas essas funcedilhaões antes de construir quaisquer conjuntos, e não use unorder.

Se encontrar alguma coisa que pense ser uma falha em alguma funcedilhaõ de conjunto, por favor relate isso para a base de dados de falhas do Maxima. Veja bug_report.

Autores
-------

Stavros Macrakis de Cambridge, Massachusetts e Barton Willis da Universidade de Nebraska e Kearney (UNK) escreveram as fncedilhaões de conjunto do Maxima e sua documentacedilhaão.

Definicedilhaões para Conjuntos
===============================

 -- Funcedilhaão: adjoin (X, A)

     Calcula a união do conjunto A com {X}.

     adjoin falha se A não for um conjunto literal.

     adjoin(X, A) e union(set(X), A) são equivalentes; contudo, adjoin pode ser um pouco mais rápida que union.

     Veja também disjoin.

     Exemplos:

          (%i1) adjoin (c, {a, b});
          (%o1)                       {a, b, c}
          (%i2) adjoin (a, {a, b});
          (%o2)                        {a, b}

 -- Funcedilhaão: belln (N)

     Representa o n-ésimo número de Bell.  belln(n) é o número de particedilhaões de um conjunto de N elementos.

     Para inteiros não negativos N, belln(N) simplifica para o n-ésimo número de Bell.  belln não simplifica para qualquer outro tipo de argumento.

     belln, aplicada a equacedilhaões, listas, matrizes e conjuntos, é calculada em forma distributiva.

     Exemplos:

     belln aplicado a inteiros não negativos.

          (%i1) makelist (belln (i), i, 0, 6);
          (%o1)               [1, 1, 2, 5, 15, 52, 203]
          (%i2) is (cardinality (set_partitions ({})) = belln (0));
          (%o2)                         true
          (%i3) is (cardinality (set_partitions ({1, 2, 3, 4, 5, 6})) = belln (6));
          (%o3)                         true

     belln aplicado a argumentos que não são inteiros não negativos.

          (%i1) [belln (x), belln (sqrt(3)), belln (-9)];
          (%o1)        [belln(x), belln(sqrt(3)), belln(- 9)]

 -- Funcedilhaão: cardinality (A)

     Calcula o número de elementos distintos do conjunto A.

     cardinality ignora elementos redundantes mesmo quando a simplificacedilhaão não estiver habilitada.

     Exemplos:

          (%i1) cardinality ({});
          (%o1)                           0
          (%i2) cardinality ({a, a, b, c});
          (%o2)                           3
          (%i3) simp : false;
          (%o3)                         false
          (%i4) cardinality ({a, a, b, c});
          (%o4)                           3

 -- Funcedilhaão: cartesian_product (B_1, ... , B_N)
     Retorna um conjunto de listas da forma [X_1, ..., X_N], onde X_1, ..., X_N são elementos dos conjuntos B_1, ... , B_N, respectivamente.

     cartesian_product falha se qualquer argumento não for um conjunto literal.

     Exemplos:

          (%i1) cartesian_product ({0, 1});
          (%o1)                      {[0], [1]}
          (%i2) cartesian_product ({0, 1}, {0, 1});
          (%o2)           {[0, 0], [0, 1], [1, 0], [1, 1]}
          (%i3) cartesian_product ({x}, {y}, {z});
          (%o3)                      {[x, y, z]}
          (%i4) cartesian_product ({x}, {-1, 0, 1});
          (%o4)              {[x, - 1], [x, 0], [x, 1]}

 -- Funcedilhaão: disjoin (X, A)
     Retorna o conjunto A sem o elemento X.  Se X não for um elemento de A, retorna A sem modificacedilhaões.

     disjoin reclama se A não for um conjunto literal.

     disjoin(X, A), delete(X, A), e setdifference(A, set(X)) são todos equivalentes. Desses, disjoin é geralmente mais rápido que os outros.

     Exemplos:

          (%i1) disjoin (a, {a, b, c, d});
          (%o1)                       {b, c, d}
          (%i2) disjoin (a + b, {5, z, a + b, %pi});
          (%o2)                      {5, %pi, z}
          (%i3) disjoin (a - b, {5, z, a + b, %pi});
          (%o3)                  {5, %pi, b + a, z}

 -- Funcedilhaão: disjointp (A, B)
     Retorna true se e somente se os conjuntos A e B forem disjuntos.

     disjointp falha se ou A ou B não forem conjuntos literais.

     Exemplos:

          (%i1) disjointp ({a, b, c}, {1, 2, 3});
          (%o1)                         true
          (%i2) disjointp ({a, b, 3}, {1, 2, 3});
          (%o2)                         false

 -- Funcedilhaão: divisors (N)

     Representa o conjunto dos divisores de N.

     divisors(N) produz um conjunto de divisores inteiros quando N for um inteiro não nulo. O conjunto dos divisores inclui os elementos 1 e N. Os divisores de um inteiro negativo são os divisores do seu valor absoluto.

     divisors, aplicada a equacedilhaões, listas, matrizes e conjuntos, é calculada em forma distributiva.

     Exemplos:

     Podemos verificar que 28 é um número perfeito: a adicedilhaão dos seus divisores (excepto o próprio 28) é 28.

          (%i1) s: divisors(28);
          (%o1)                 {1, 2, 4, 7, 14, 28}
          (%i2) lreduce ("+", args(s)) - 28;
          (%o2)                          28

     divisors é uma funcedilhaão de simplificacedilhaão.  Substituindo 8 por a em divisors(a) calcula os divisores sem ser preciso pedir que divisors(8) seja reavaliada.

          (%i1) divisors (a);
          (%o1)                      divisors(a)
          (%i2) subst (8, a, %);
          (%o2)                     {1, 2, 4, 8}

     divisors, aplicada a equacedilhaões, listas, matrizes e conjuntos, é calculada em forma distributiva.

          (%i1) divisors (a = b);
          (%o1)               divisors(a) = divisors(b)
          (%i2) divisors ([a, b, c]);
          (%o2)        [divisors(a), divisors(b), divisors(c)]
          (%i3) divisors (matrix ([a, b], [c, d]));
                            [ divisors(a)  divisors(b) ]
          (%o3)             [                          ]
                            [ divisors(c)  divisors(d) ]
          (%i4) divisors ({a, b, c});
          (%o4)        {divisors(a), divisors(b), divisors(c)}

 -- Funcedilhaão: elementp (X, A)
     Retorna true se e somente se X for um elemento do conjunto A.

     elementp falha se A não for um conjunto literal.

     Exemplos:

          (%i1) elementp (sin(1), {sin(1), sin(2), sin(3)});
          (%o1)                         true
          (%i2) elementp (sin(1), {cos(1), cos(2), cos(3)});
          (%o2)                         false

 -- Funcedilhaão: emptyp (A)
     Retorna true se e somente se A for o conjunto vazio ou uma lista vazia.

     Exemplos:

          (%i1) map (emptyp, [{}, []]);
          (%o1)                     [true, true]
          (%i2) map (emptyp, [a + b, {{}}, %pi]);
          (%o2)                 [false, false, false]

 -- Funcedilhaão: equiv_classes (S, F)
     Retorna um conjunto das classes de equivalências do conjunto S com relacedilhaão à relacedilhaão de equivalência F.

     F é uma funcedilhaão de duas variáveis definida sobre o produto cartesiano S por S.  O valor de retorno de F é ou true ou false, ou uma expressão EXPR tal que is(EXPR) é ou true ou false.

     Quando F nõ for uma relacedilhaão de equivalência, equiv_classes aceita-a sem reclamacedilhaão, mas o resultado é geralmente incorrecto nesse caso.

     Exemplos:

     A relacedilhaão de equivalência é uma expressão lambda a qual retorna true ou false.

          (%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, lambda ([x, y], is (equal (x, y))));
          (%o1)            {{1, 1.0}, {2, 2.0}, {3, 3.0}}

     A relacedilhaão de equivalência é o nome de uma funcedilhaão relacional que avalia para true ou false.

          (%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, equal);
          (%o1)            {{1, 1.0}, {2, 2.0}, {3, 3.0}}

     As classes de equivalência são números que diferem por um múltiplo de 3.

          (%i1) equiv_classes ({1, 2, 3, 4, 5, 6, 7}, lambda ([x, y], remainder (x - y, 3) = 0));
          (%o1)              {{1, 4, 7}, {2, 5}, {3, 6}}

 -- Funcedilhaão: every (F, S)
 -- Funcedilhaão: every (F, L_1, ..., L_N)

     Retorna true se o predicado F for true para todos os argumentos fornecidos.

     Dado um conjunto como segundo argumento, every(F, S) retorna true se is(F(A_I)) retornar true para todos os A_I em S.  every pode ou não avaliar F para todos os A_I em S. Uma vez que os conjuntos são desordenados, every pode avaliar F(A_I) em qualquer ordem.

     Dada uma ou mais listas como argumentos, every(F, L_1, ..., L_N) retorna true se is(F(X_1, ..., X_N)) retornar true para todos os X_1, ..., X_N em L_1, ..., L_N, respectivamente. every pode ou não avaliar F para toda combinacedilhaão X_1, ..., X_N.  every avalia listas na ordem de incremento do índice.

     Dado um conjunto vazio {} ou uma lista vazia [] como argumentos, every retorna false.

     Quando o sinalizador global maperror for true, todas as listas L_1, ..., L_N deverão ter o mesmo comprimento. Quando maperror for falso, as listas dadas como argumentos serão efectivamente truncadas para o comprimento da menor lista.

     Os resultados do predicado F que avaliarem (via is) para algo diferente de true ou false são governados através da variável global prederror. Quando prederror for true, tais valores são tratados como false, e o valor de retorno de every é false.  Quando prederror for false, tais valores são tratados como unknown, e o valor de retorno de every é unknown.

     Exemplos:

     every aplicada a um conjunto simples. O predicado é uma funcedilhaão de um argumento.

          (%i1) every (integerp, {1, 2, 3, 4, 5, 6});
          (%o1)                         true
          (%i2) every (atom, {1, 2, sin(3), 4, 5 + y, 6});
          (%o2)                         false

     every aplicada a duas listas. O predicado é uma funcedilhaão de dois argumentos.

          (%i1) every ("=", [a, b, c], [a, b, c]);
          (%o1)                         true
          (%i2) every ("#", [a, b, c], [a, b, c]);
          (%o2)                         false

     Predicado F que produz resultados diferentes de true ou false, governados por meio da variável global prederror.

          (%i1) prederror : false;
          (%o1)                         false
          (%i2) map (lambda ([a, b], is (a < b)), [x, y, z], [x^2, y^2, z^2]);
          (%o2)              [unknown, unknown, unknown]
          (%i3) every ("<", [x, y, z], [x^2, y^2, z^2]);
          (%o3)                        unknown
          (%i4) prederror : true;
          (%o4)                         true
          (%i5) every ("<", [x, y, z], [x^2, y^2, z^2]);
          (%o5)                         false

 -- Funcedilhaão: extremal_subset (S, F, max)
 -- Funcedilhaão: extremal_subset (S, F, min)

     Encontra o subconjunto de S para o qual a funcedilhaão F toma valores máximos ou mínimos.

     extremal_subset(S, F, max) encontra o subconjunto do conjunto ou lista S para os quais a funcedilhaão real F assume um valor máximo.

     extremal_subset(S, F, min) encontra o subconjunto do conjunto ou lista S para a qual a funcedilhaão real F assume um valor mínimo.

     Exemplos:

          (%i1) extremal_subset ({-2, -1, 0, 1, 2}, abs, max);
          (%o1)                       {- 2, 2}
          (%i2) extremal_subset ({sqrt(2), 1.57, %pi/2}, sin, min);
          (%o2)                       {sqrt(2)}

 -- Funcedilhaão: flatten (EXPR)

     Colecta argumentos de subexpressões que possuem o mesmo operador que EXPR e constrói uma expressão a partir desses argumentos colectados.

     Subexpressões nas quais o operador é diferente do operador principal de expr são copiadas sem modificacedilhaão, mesmo se tiverem subexpressões com o mesmo operador que expr.

     É possível que flatten construia expressões nas quais o número de argumentos difira dos argumentos declarados para um operador; isso pode provocar uma mensagem de erro do simplificador ou do avaliador.  flatten não tenta detectar tais situacedilhaões.

     Expressões com representacedilhaões especiais, por exemplo, expressões racionais canónicas (CRE), não podem usar a funcedilhaão flatten; nesses casos, flatten retorna os seus argumentos sem modificacedilhaão.

     Exemplos:

     Aplicado a uma lista, flatten reúne todos os elementos da lista que sejam listas.

          (%i1) flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]);
          (%o1)            [a, b, c, d, e, f, g, h, i, j]

     Aplicado a um conjunto, flatten reúne todos os elementos do conjunto que sejam conjuntos.

          (%i1) flatten ({a, {b}, {{c}}});
          (%o1)                       {a, b, c}
          (%i2) flatten ({a, {[a], {a}}});
          (%o2)                       {a, [a]}

     o efeito de flatten é similar a declarar o operador principal para ser enário. No entanto, flatten não faz efeito sobre subexpressões que possuem um operador diferente do operador principal, enquanto uma declaracedilhaão enária faz efeito.

          (%i1) expr: flatten (f (g (f (f (x)))));
          (%o1)                     f(g(f(f(x))))
          (%i2) declare (f, nary);
          (%o2)                         done
          (%i3) ev (expr);
          (%o3)                      f(g(f(x)))

     flatten trata funcedilhaões subscritas da mesma forma que qualquer outro operador.

          (%i1) flatten (f[5] (f[5] (x, y), z));
          (%o1)                      f (x, y, z)
                                      5

     É possível que flatten construa expressões nas quais o número de argumentos difira dos argumentos declarados para um operador;

          (%i1) 'mod (5, 'mod (7, 4));
          (%o1)                   mod(5, mod(7, 4))
          (%i2) flatten (%);
          (%o2)                     mod(5, 7, 4)
          (%i3) ''%, nouns;
          Wrong number of arguments to mod
           -- an error.  Quitting.  To debug this try debugmode(true);

 -- Funcedilhaão: full_listify (A)
     Substitui todo operador de conjunto em A por um operador de lista, e retorna o resultado. fullt_listify substitui operadores de conjunto em subexpressões aninhadas, mesmo se o operador principal não for (set).

     listify substitui unicamente o operador principal.

     Exemplos:

          (%i1) full_listify ({a, b, {c, {d, e, f}, g}});
          (%o1)               [a, b, [c, [d, e, f], g]]
          (%i2) full_listify (F (G ({a, b, H({c, d, e})})));
          (%o2)              F(G([a, b, H([c, d, e])]))

 -- Funcedilhaão: fullsetify (A)
     Quando A for uma lista, substitui o operador de lista por um operador de conjunto, e aplica fullsetify a cada elemento que for um conjunto.  Quando A não for uma lista, o resultado é A na sua forma original e sem modificacedilhaões.

     setify substitui unicamente o operador principal.

     Exemplos:

     Na linha (%o2), o argumento de f não é convertido para um conjunto porque o operador principal de f([b]) não é uma lista.

          (%i1) fullsetify ([a, [a]]);
          (%o1)                       {a, {a}}
          (%i2) fullsetify ([a, f([b])]);
          (%o2)                      {a, f([b])}

 -- Funcedilhaão: identity (X)

     Retorna X para qualquer argumento X.

     Exemplos:

     identity pode ser usado como um predicado quando os argumentos forem valores Booleanos.

          (%i1) every (identity, [true, true]);
          (%o1)                         true

 -- Funcedilhaão: integer_partitions (N)
 -- Funcedilhaão: integer_partitions (N, LEN)

     Calcula particedilhaões inteiras de N, isto é, listas de inteiros cuja soma dos elementos de cada lista é N.

     integer_partitions(N) encontra o conjunto de todas as particedilhaões do inteiro N. Cada particedilhaão é uma lista ordenada do maior para o menor.

     integer_partitions(N, LEN) encontra todas as particedilhaões com comprimento LEN ou menor; nesse caso, serão adicionados zeros ao final de cada particedilhaão de comprimento menor que LEN, para fazer com que todas as partições tenham exactamente LEN termos. Cada particedilhaão é uma lista ordenada do maior para o menor.

     Uma lista [a_1, ..., a_m] é uma particedilhaão de um inteiro não negativo n quando: (1) cada a_i é um inteiro não nulo, e (2) a_1 + ... + a_m = n. Dessa forma, 0 não tem particedilhaões.

     Exemplos:

          (%i1) integer_partitions (3);
          (%o1)               {[1, 1, 1], [2, 1], [3]}
          (%i2) s: integer_partitions (25)$
          (%i3) cardinality (s);
          (%o3)                         1958
          (%i4) map (lambda ([x], apply ("+", x)), s);
          (%o4)                         {25}
          (%i5) integer_partitions (5, 3);
          (%o5) {[2, 2, 1], [3, 1, 1], [3, 2, 0], [4, 1, 0], [5, 0, 0]}
          (%i6) integer_partitions (5, 2);
          (%o6)               {[3, 2], [4, 1], [5, 0]}

     Para encontrar todas as particedilhaões que satisfazem uma condicedilhaão, use a funcedilhaão subset; aqui está um exemplo que encontra todas as particedilhaões de 10 cujos elementos da lista são números primos.

          (%i1) s: integer_partitions (10)$
          (%i2) cardinality (s);
          (%o2)                          42
          (%i3) xprimep(x) := integerp(x) and (x > 1) and primep(x)$
          (%i4) subset (s, lambda ([x], every (xprimep, x)));
          (%o4) {[2, 2, 2, 2, 2], [3, 3, 2, 2], [5, 3, 2], [5, 5], [7, 3]}

 -- Funcedilhaão: intersect (A_1, ..., A_N)

     intersect é o mesmo que intersection, como veremos.

 -- Funcedilhaão: intersection (A_1, ..., A_N)
     Retorna um conjunto contendo os elementos que são comuns aos conjuntos A_1 até A_N.

     intersection falha se qualquer dos argumentos não for um conjunto literal.

     Exemplos:

          (%i1) S_1 : {a, b, c, d};
          (%o1)                     {a, b, c, d}
          (%i2) S_2 : {d, e, f, g};
          (%o2)                     {d, e, f, g}
          (%i3) S_3 : {c, d, e, f};
          (%o3)                     {c, d, e, f}
          (%i4) S_4 : {u, v, w};
          (%o4)                       {u, v, w}
          (%i5) intersection (S_1, S_2);
          (%o5)                          {d}
          (%i6) intersection (S_2, S_3);
          (%o6)                       {d, e, f}
          (%i7) intersection (S_1, S_2, S_3);
          (%o7)                          {d}
          (%i8) intersection (S_1, S_2, S_3, S_4);
          (%o8)                          {}

 -- Funcedilhaão: kron_delta (X, Y)

     Representa a funcedilhaão delta de Kronecker.

     kron_delta simplifica para 1 quando X e Y forem idênticos ou equivalentes, e simplifica para 0 quando X e Y não forem equivalentes. De outra forma, se não for certo que X e Y são equivalentes, kron_delta simplificará para uma expressão substantiva. kron_delta implementa uma política de segurancedilhaa para expressões em ponto flutuante: se a diferencedilhaa X - Y for um número em ponto flutuante, kron_delta simplifica para uma expressão substantiva quando X for aparentemente equivalente a Y.

     Especificamente, kron_delta(X, Y) simplifica para 1 quando is(x = y) for true. kron_delta também simplifica para 1 quando sign(abs(X - Y)) for zero e X - Y não for um número em ponto flutuante (e também não for um número de precisão simples em ponto flutuante nem um número de precisão dupla em poto flutuante, isto é, não for um bigfloat). kron_delta simplifica para 0 quando sign(abs(X - Y)) for pos.

     Caso contrário, sign(abs(X - Y)) é diferente de pos ou zero, ou é zero e X - Y é um número em ponto flutuante. Nesses casos, kron_delta retorna um expressão substantiva.

     kron_delta é declarada como sendo simétrica. Isto é, kron_delta(X, Y) é igual a kron_delta(Y, X).

     Exemplos:

     Os argumentos de kron_delta são idênticos. kron_delta simplifica para 1.

          (%i1) kron_delta (a, a);
          (%o1)                           1
          (%i2) kron_delta (x^2 - y^2, x^2 - y^2);
          (%o2)                           1
          (%i3) float (kron_delta (1/10, 0.1));
          (%o3)                           1

     Os argumentos de kron_delta são equivalentes, e a diferencedilhaa entre eles não é um número em ponto flutuante.  kron_delta simplifica para 1.

          (%i1) assume (equal (x, y));
          (%o1)                     [equal(x, y)]
          (%i2) kron_delta (x, y);
          (%o2)                           1

     Os argumentos de kron_delta não são equivalentes. kron_delta simplifica para 0.

          (%i1) kron_delta (a + 1, a);
          (%o1)                           0
          (%i2) assume (a > b)$
          (%i3) kron_delta (a, b);
          (%o3)                           0
          (%i4) kron_delta (1/5, 0.7);
          (%o4)                           0

     Os argumentos de kron_delta podem ou não ser equivalentes. kron_delta simplifica para uma expressão substantiva.

          (%i1) kron_delta (a, b);
          (%o1)                   kron_delta(a, b)
          (%i2) assume(x >= y)$
          (%i3) kron_delta (x, y);
          (%o3)                   kron_delta(x, y)

     Os argumentos de kron_delta são equivalentes, mas a diferencedilhaa entre eles é um número em ponto flutuante. kron_delta simplifica para uma expressão substantiva.

          (%i1) 1/4 - 0.25;
          (%o1)                          0.0
          (%i2) 1/10 - 0.1;
          (%o2)                          0.0
          (%i3) 0.25 - 0.25b0;
          Warning:  Float to bigfloat conversion of 0.25
          (%o3)                         0.0b0
          (%i4) kron_delta (1/4, 0.25);
                                            1
          (%o4)                  kron_delta(-, 0.25)
                                            4
          (%i5) kron_delta (1/10, 0.1);
                                            1
          (%o5)                  kron_delta(--, 0.1)
                                            10
          (%i6) kron_delta (0.25, 0.25b0);
          Warning:  Float to bigfloat conversion of 0.25
          (%o6)               kron_delta(0.25, 2.5b-1)

     kron_delta é simétrica.

          (%i1) kron_delta (x, y);
          (%o1)                   kron_delta(x, y)
          (%i2) kron_delta (y, x);
          (%o2)                   kron_delta(x, y)
          (%i3) kron_delta (x, y) - kron_delta (y, x);
          (%o3)                           0
          (%i4) is (equal (kron_delta (x, y), kron_delta (y, x)));
          (%o4)                         true
          (%i5) is (kron_delta (x, y) = kron_delta (y, x));
          (%o5)                         true

 -- Funcedilhaão: listify (A)

     Retorna uma lista contendo os elementos de A quando A for um conjunto. De outra forma, listify retorna A.

     full_listify substitui todos os operadores de conjunto em A por operadores de lista.

     Exemplos:

          (%i1) listify ({a, b, c, d});
          (%o1)                     [a, b, c, d]
          (%i2) listify (F ({a, b, c, d}));
          (%o2)                    F({a, b, c, d})

 -- Funcedilhaão: lreduce (F, S)
 -- Funcedilhaão: lreduce (F, S, S_0)

     Extende a funcedilhaão de dois argumentos F para uma funcedilhaão de n argumentos, usando composicedilhaão, onde S é uma lista.

     lreduce(F, S) retorna F(... F(F(s_1, s_2), s_3), ... s_n).  Quando o argumento opcional S_0 estiver presente, o resultado é equivalente a lreduce(F, cons(S_0, S)).

     A funcedilhaão F é aplicada primeiro aos elementos mais à esquerda de lista; daí o nome "lreduce".

     Veja também rreduce, xreduce, e tree_reduce.

     Exemplos:

     lreduce sem o argumento opcional.

          (%i1) lreduce (f, [1, 2, 3]);
          (%o1)                     f(f(1, 2), 3)
          (%i2) lreduce (f, [1, 2, 3, 4]);
          (%o2)                  f(f(f(1, 2), 3), 4)

     lreduce com o argumento opcional.

          (%i1) lreduce (f, [1, 2, 3], 4);
          (%o1)                  f(f(f(4, 1), 2), 3)

     lreduce aplicada a operadores binários internos do Maxima // é o operador de divisão.

          (%i1) lreduce ("^", args ({a, b, c, d}));
                                         b c d
          (%o1)                       ((a ) )
          (%i2) lreduce ("//", args ({a, b, c, d}));
                                          a
          (%o2)                         -----
                                        b c d

 -- Funcedilhaão: makeset (EXPR, X, S)

     Retorna um conjunto com elementos gerados a partir da expressão EXPR, onde X é uma lista de variáveis em EXPR, e Sé um conjunto ou lista de listas.  Para gerar cada elemento do conjunto, EXPR é avaliada com as variáveis X substituídas, em paralelo, por elementos de S.

     Cada elemento de S deve ter o mesmo comprimento que X.  A lista de variáveis X deve ser uma lista de símbolos, sem índices.  Mesmo se existir somente um símbolo, X deve ser uma lista de um elemento, e cada elemento de S deve ser uma lista de um elemento.

     Veja também makelist.

     Exemplos:

          (%i1) makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]);
                                     1  2  3  4
          (%o1)                     {-, -, -, -}
                                     a  b  c  d
          (%i2) S : {x, y, z}$
          (%i3) S3 : cartesian_product (S, S, S);
          (%o3) {[x, x, x], [x, x, y], [x, x, z], [x, y, x], [x, y, y],
          [x, y, z], [x, z, x], [x, z, y], [x, z, z], [y, x, x],
          [y, x, y], [y, x, z], [y, y, x], [y, y, y], [y, y, z],
          [y, z, x], [y, z, y], [y, z, z], [z, x, x], [z, x, y],
          [z, x, z], [z, y, x], [z, y, y], [z, y, z], [z, z, x],
          [z, z, y], [z, z, z]}
          (%i4) makeset (i + j + k, [i, j, k], S3);
          (%o4) {3 x, 3 y, y + 2 x, 2 y + x, 3 z, z + 2 x, z + y + x,
                                                 z + 2 y, 2 z + x, 2 z + y}
          (%i5) makeset (sin(x), [x], {[1], [2], [3]});
          (%o5)               {sin(1), sin(2), sin(3)}

 -- Funcedilhaão: moebius (N)

     Representa a funcedilhaão de Moebius.

     Quando N for o produto de k primos distintos, moebius(N) simplifica para (-1)^k; quando N = 1, simplifica para 1; e simplifica para 0 para todos os outros inteiros positivos.

     moebius, aplicada a equacedilhaões, listas, matrizes e conjuntos, é calculada em forma distributiva.

     Exemplos:

          (%i1) moebius (1);
          (%o1)                           1
          (%i2) moebius (2 * 3 * 5);
          (%o2)                          - 1
          (%i3) moebius (11 * 17 * 29 * 31);
          (%o3)                           1
          (%i4) moebius (2^32);
          (%o4)                           0
          (%i5) moebius (n);
          (%o5)                      moebius(n)
          (%i6) moebius (n = 12);
          (%o6)                    moebius(n) = 0
          (%i7) moebius ([11, 11 * 13, 11 * 13 * 15]);
          (%o7)                      [- 1, 1, 1]
          (%i8) moebius (matrix ([11, 12], [13, 14]));
                                     [ - 1  0 ]
          (%o8)                      [        ]
                                     [ - 1  1 ]
          (%i9) moebius ({21, 22, 23, 24});
          (%o9)                      {- 1, 0, 1}

 -- Funcedilhaão: multinomial_coeff (A_1, ..., A_N)
 -- Funcedilhaão: multinomial_coeff ()

     Calcula o coeficiente multinomial.

     Quando cada A_K for um inteiro não negativo, o coeficiente multinomial indica o número de formas possíveis de colocar A_1 + ... + A_N objectos distintos em n caixas com A_K elementos na k'ésima caixa. Em geral, multinomial_coeff (A_1, ..., A_N) calcula (A_1 + ... + A_N)!/(A_1! ... A_N!).

     multinomial_coeff() (sem argumentos) produz 1.

     minfactorial poderá conseguir simplificar o valor calculado por multinomial_coeff.

     Exemplos:

          (%i1) multinomial_coeff (1, 2, x);
                                      (x + 3)!
          (%o1)                       --------
                                        2 x!
          (%i2) minfactorial (%);
                               (x + 1) (x + 2) (x + 3)
          (%o2)                -----------------------
                                          2
          (%i3) multinomial_coeff (-6, 2);
                                       (- 4)!
          (%o3)                       --------
                                      2 (- 6)!
          (%i4) minfactorial (%);
          (%o4)                          10

 -- Funcedilhaão: num_distinct_partitions (N)
 -- Funcedilhaão: num_distinct_partitions (N, list)

     Calcula o n;umero de particedilhaões de inteiros distintos de N quando N for um inteiro não negativo. De outra forma, num_distinct_partitions retorna uma expressão substantiva.

     num_distinct_partitions(N, list) retorna uma lista do número de particedilhaões distintas de 1, 2, 3, ..., N.

     Uma particedilhaão distinta de N é uma lista de inteiros positivos distintos k_1, ..., k_m tais que N = k_1 + ... + k_m.

     Exemplos:

          (%i1) num_distinct_partitions (12);
          (%o1)                          15
          (%i2) num_distinct_partitions (12, list);
          (%o2)      [1, 1, 1, 2, 2, 3, 4, 5, 6, 8, 10, 12, 15]
          (%i3) num_distinct_partitions (n);
          (%o3)              num_distinct_partitions(n)

 -- Funcedilhaão: num_partitions (N)
 -- Funcedilhaão: num_partitions (N, list)

     Calcula o número das particedilhaões inteiras de N quando N for um inteiro não negativo.  De outra forma, num_partitions retorna uma expressão substantiva.

     num_partitions(N, list) retorna uma lista do número de particedilhaões inteiras de 1, 2, 3, ..., N.

     Para um inteiro não negativo N, num_partitions(N) é igual a cardinality(integer_partitions(N)); todavia, num_partitions não constrói actualmente o conjunto das particedilhaões, nesse sentido num_partitions é mais rápida.

     Exemplos:

          (%i1) num_partitions (5) = cardinality (integer_partitions (5));
          (%o1)                         7 = 7
          (%i2) num_partitions (8, list);
          (%o2)            [1, 1, 2, 3, 5, 7, 11, 15, 22]
          (%i3) num_partitions (n);
          (%o3)                   num_partitions(n)

 -- Funcedilhaão: partition_set (A, F)

     Particedilhaões do conjunto A que satisfazem o predicado F.

     partition_set retorna uma lista de dois conjuntos. O primeiro conjunto compreende os elementos de A para os quais F avalia para false, e o segundo conjunto compreende quaisquer outros elementos de A. partition_set não aplica is ao valor de retorno de F.

     partition_set reclama se A não for um conjunto literal.

     Veja também subset.

     Exemplos:

          (%i1) partition_set ({2, 7, 1, 8, 2, 8}, evenp);
          (%o1)                   [{1, 7}, {2, 8}]
          (%i2) partition_set ({x, rat(y), rat(y) + z, 1}, lambda ([x], ratp(x)));
          (%o2)/R/              [{1, x}, {y, y + z}]

 -- Funcedilhaão: permutations (A)

     Retorna um conjunto todas as permutacedilhaões distintas dos elementos da lista ou do conjunto A. Cada permutacedilhaão é uma lista, não um conjunto.

     Quando A for uma lista, elementos duplicados de A são incluídos nas permutacedilhaões.

     permutations reclama se A não for um conjunto literal ou uma lista literal.

     Exemplos:

          (%i1) permutations ([a, a]);
          (%o1)                       {[a, a]}
          (%i2) permutations ([a, a, b]);
          (%o2)           {[a, a, b], [a, b, a], [b, a, a]}

 -- Funcedilhaão: powerset (A)
 -- Funcedilhaão: powerset (A, N)

     Retorna o conjunto de todos os dubconjuntos de A, ou um subconjunto de A.

     powerset(A) retorna o conjunto de todos os subconjuntos do conjunto A. powerset(A) tem 2^cardinality(A) elementos.

     powerset(A, N) retorna o conjunto de todos os subconjuntos de A que possuem cardinalidade N.

     powerset reclama se A não for um conjunto literal, ou se N não for um inteiro não negativo.

     Exemplos:

          (%i1) powerset ({a, b, c});
          (%o1) {{}, {a}, {a, b}, {a, b, c}, {a, c}, {b}, {b, c}, {c}}
          (%i2) powerset ({w, x, y, z}, 4);
          (%o2)                    {{w, x, y, z}}
          (%i3) powerset ({w, x, y, z}, 3);
          (%o3)     {{w, x, y}, {w, x, z}, {w, y, z}, {x, y, z}}
          (%i4) powerset ({w, x, y, z}, 2);
          (%o4)   {{w, x}, {w, y}, {w, z}, {x, y}, {x, z}, {y, z}}
          (%i5) powerset ({w, x, y, z}, 1);
          (%o5)                 {{w}, {x}, {y}, {z}}
          (%i6) powerset ({w, x, y, z}, 0);
          (%o6)                         {{}}

 -- Funcedilhaão: rreduce (F, S)
 -- Funcedilhaão: rreduce (F, S, S_{N + 1})

     Extende a funcedilhaão de dois argumentos F para uma funcedilhaão de N argumentos usando composicedilhaão de funcedilhaões, onde S é uma lista.

     rreduce(F, S) retorna F(s_1, ... F(s_{n - 2}, F(s_{n - 1}, s_n))). Quando o argumento opcional S_{N + 1} estiver presente, o resultado é equivalente a rreduce(F, endcons(S_{N + 1}, S)).

     A funcedilhaão F é primeiro aplicada à lista de elementos mais à direita - rightmost, daí o nome "rreduce".

     Veja também lreduce, tree_reduce, e xreduce.

     Exemplos:

     rreduce sem o argumento opcional.

          (%i1) rreduce (f, [1, 2, 3]);
          (%o1)                     f(1, f(2, 3))
          (%i2) rreduce (f, [1, 2, 3, 4]);
          (%o2)                  f(1, f(2, f(3, 4)))

     rreduce com o argumento opcional.

          (%i1) rreduce (f, [1, 2, 3], 4);
          (%o1)                  f(1, f(2, f(3, 4)))

     rreduce aplicada a operadores de dois argumentos internos ( definidos por padrão) ao Maxima. // é o operadro de divisão.

          (%i1) rreduce ("^", args ({a, b, c, d}));
                                           d
                                          c
                                         b
          (%o1)                         a
          (%i2) rreduce ("//", args ({a, b, c, d}));
                                         a c
          (%o2)                          ---
                                         b d

 -- Funcedilhaão: setdifference (A, B)

     Retorna um conjunto contendo os elementos no conjunto A que não estãono conjunto B.

     setdifference reclama se ou A ou B não for um conjunto literal.

     Exemplos:

          (%i1) S_1 : {a, b, c, x, y, z};
          (%o1)                  {a, b, c, x, y, z}
          (%i2) S_2 : {aa, bb, c, x, y, zz};
          (%o2)                 {aa, bb, c, x, y, zz}
          (%i3) setdifference (S_1, S_2);
          (%o3)                       {a, b, z}
          (%i4) setdifference (S_2, S_1);
          (%o4)                     {aa, bb, zz}
          (%i5) setdifference (S_1, S_1);
          (%o5)                          {}
          (%i6) setdifference (S_1, {});
          (%o6)                  {a, b, c, x, y, z}
          (%i7) setdifference ({}, S_1);
          (%o7)                          {}

 -- Funcedilhaão: setequalp (A, B)

     Retorna true se os conjuntos A e B possuirem o mesmo número de elementos e is(X = Y) for true para x nos elementos de A e y nos elementos de B, considerados na ordem determinada por listify. De outra forma, setequalp retorna false.

     Exemplos:

          (%i1) setequalp ({1, 2, 3}, {1, 2, 3});
          (%o1)                         true
          (%i2) setequalp ({a, b, c}, {1, 2, 3});
          (%o2)                         false
          (%i3) setequalp ({x^2 - y^2}, {(x + y) * (x - y)});
          (%o3)                         false

 -- Funcedilhaão: setify (A)

     Constrói um conjunto de elementos a partir da lista A. Elementos duplicados da lista A são apagados e os elementos são ordenados de acordo com o predicado orderlessp.

     setify reclama se A não for uma lista literal.

     Exemplos:

          (%i1) setify ([1, 2, 3, a, b, c]);
          (%o1)                  {1, 2, 3, a, b, c}
          (%i2) setify ([a, b, c, a, b, c]);
          (%o2)                       {a, b, c}
          (%i3) setify ([7, 13, 11, 1, 3, 9, 5]);
          (%o3)                {1, 3, 5, 7, 9, 11, 13}

 -- Funcedilhaão: setp (A)

     Retorna true se e somente se A for um conjunto na interpretacedilhaão do Maxima.

     setp retorna true para conjuntos não simplificados (isto é, conjuntos com elementos redundantes) e também para conjuntos simplificados.

     setp é equivalente à funcedilhaão do Maxima setp(a) := not atom(a) and op(a) = 'set.

     Exemplos:

          (%i1) simp : false;
          (%o1)                         false
          (%i2) {a, a, a};
          (%o2)                       {a, a, a}
          (%i3) setp (%);
          (%o3)                         true

 -- Funcedilhaão: set_partitions (A)
 -- Funcedilhaão: set_partitions (A, N)

     Retorna o conjunto de todas as particedilhaões de A, ou um subconjunto daquele conjunto de particedilhaões.

     set_partitions(A, N) retorna um conjunto de todas as decomposicedilhaões de A em N subconjutnos disjuntos não vazios.

     set_partitions(A) retorna o conjunto de todas as particedilhaões.

     stirling2 retorna a cardinalidade de um conjuntode particedilhaões de um conjunto.

     Um conjunto de conjuntos P é uma particedilhaão de um conjunto S quando

      1. cada elemento de P é um conjunto não vazio,

      2. elementos distintos de P são disjuntos,

      3. a união dos elementos de P é igual a S.

     Exemplos:

     O conjunto vazio é uma particedilhaão de si mesmo, as ondicedilhaões 1 e 2 são "vaziamente" verdadeiras.

          (%i1) set_partitions ({});
          (%o1)                         {{}}

     A cardinalidade do conjunto de particedilhaões de um conjunto pode ser encontrada usando stirling2.

          (%i1) s: {0, 1, 2, 3, 4, 5}$
          (%i2) p: set_partitions (s, 3)$
          (%o3)                        90 = 90
          (%i4) cardinality(p) = stirling2 (6, 3);

     Cada elemento de p pode ter N = 3 elementos; vamos verificar.

          (%i1) s: {0, 1, 2, 3, 4, 5}$
          (%i2) p: set_partitions (s, 3)$
          (%o3)                          {3}
          (%i4) map (cardinality, p);

     Finalmente, para cada elementos de p, a união de seus elementos possivelmente será igua a s; novamente vamos comprovar.

          (%i1) s: {0, 1, 2, 3, 4, 5}$
          (%i2) p: set_partitions (s, 3)$
          (%o3)                 {{0, 1, 2, 3, 4, 5}}
          (%i4) map (lambda ([x], apply (union, listify (x))), p);

 -- Funcedilhaão: some (F, A)
 -- Funcedilhaão: some (F, L_1, ..., L_N)

     Retorna true se o predicado F for true para um ou mais argumentos dados.

     Given one set as the second argument, some(F, S) returns true if is(F(A_I)) returns true for one or more A_I in S. some may or may not evaluate F for all A_I in S. Since sets are unordered, some may evaluate F(A_I) in any order.

     Dadas uma ou mais listas como argumentos, some(F, L_1, ..., L_N) retorna true se is(F(X_1, ..., X_N)) retornar true para um ou mais X_1, ..., X_N em L_1, ..., L_N, respectivamente. some pode ou não avaliar F para algumas combinacedilhaões X_1, ..., X_N. some avalia listas na ordem do índice de incremento.

     Dado um conjunto vazio {} ou uma lista vazia [] como argumentos, some retorna false.

     Quando o sinalizador global maperror for true, todas as listas L_1, ..., L_N devem ter obrigatóriamente comprimentos iguais. Quando maperror for false, argumentos do tipo lista são efectivamente truncados para o comprimento da menor lista.

     Retorna o valor de um predicado F o qual avalia (por meio de is) para alguma coisa outra que não true ou false e são governados pelo sinalizador global prederror. Quando prederror for true, tais valores são tratados como false. Quando prederror for false, tais valores são tratados como unknown (desconhecidos).

     Exemplos:

     some aplicado a um conjunto simples. O predicado é uma funcedilhaão de um argumento.

          (%i1) some (integerp, {1, 2, 3, 4, 5, 6});
          (%o1)                         true
          (%i2) some (atom, {1, 2, sin(3), 4, 5 + y, 6});
          (%o2)                         true

     some aplicada a duas listas. O predicado é uma funcedilhaão de dois argumentos.

          (%i1) some ("=", [a, b, c], [a, b, c]);
          (%o1)                         true
          (%i2) some ("#", [a, b, c], [a, b, c]);
          (%o2)                         false

     Retorna o valor do predicado F o qual avalia para alguma coisa que não true ou false e são governados através do sinalizador global prederror.

          (%i1) prederror : false;
          (%o1)                         false
          (%i2) map (lambda ([a, b], is (a < b)), [x, y, z], [x^2, y^2, z^2]);
          (%o2)              [unknown, unknown, unknown]
          (%i3) some ("<", [x, y, z], [x^2, y^2, z^2]);
          (%o3)                        unknown
          (%i4) some ("<", [x, y, z], [x^2, y^2, z + 1]);
          (%o4)                         true
          (%i5) prederror : true;
          (%o5)                         true
          (%i6) some ("<", [x, y, z], [x^2, y^2, z^2]);
          (%o6)                         false
          (%i7) some ("<", [x, y, z], [x^2, y^2, z + 1]);
          (%o7)                         true

 -- Funcedilhaão: stirling1 (N, M)

     Representa o número de Stirling de primeiro tipo.

     Quando N e M forem não negativos inteiros, a magnitude de stirling1 (N, M) é o número de permutacedilhaões de um conjunto com N elementos que possui M ciclos. Para detalhes, veja Graham, Knuth e Patashnik Concrete Mathematics. Maxima utiliza uma relacedilhaão recursiva para definir stirling1 (N, M) para M menor que 0; stirling1 não é definida para N menor que 0 e para argumentos não inteiros.

     stirling1 é uma funcedilhaão de simplificacedilhaão. Maxima conhece as seguintes identidades:

      1. stirling1(0, n) = kron_delta(0, n) (Ref. [1])

      2. stirling1(n, n) = 1 (Ref. [1])

      3. stirling1(n, n - 1) = binomial(n, 2) (Ref. [1])

      4. stirling1(n + 1, 0) = 0 (Ref. [1])

      5. stirling1(n + 1, 1) = n! (Ref. [1])

      6. stirling1(n + 1, 2) = 2^n  - 1 (Ref. [1])

     Essas identidades são aplicadas quando os argumentos forem inteiros literais ou símbolos declarados como inteiros, e o primeiro argumento for não negativo. stirling1 não simplififca para argumentos não inteiros.

     Referências:

     [1] Donald Knuth, The Art of Computer Programming, terceira edicedilhaão, Volume 1, Secedilhaão 1.2.6, Equacedilhaões 48, 49, e 50.

     Exemplos:

          (%i1) declare (n, integer)$
          (%i2) assume (n >= 0)$
          (%i3) stirling1 (n, n);
          (%o3)                           1

     stirling1 não simplifica para argumentos não inteiros.

          (%i1) stirling1 (sqrt(2), sqrt(2));
          (%o1)              stirling1(sqrt(2), sqrt(2))

     Maxima aplica identidades a stirling1.

          (%i1) declare (n, integer)$
          (%i2) assume (n >= 0)$
          (%i3) stirling1 (n + 1, n);
                                      n (n + 1)
          (%o3)                       ---------
                                          2
          (%i4) stirling1 (n + 1, 1);
          (%o4)                          n!

 -- Funcedilhaão: stirling2 (N, M)

     Representa o número de Stirling de segundo tipo.

     Quando N e M forem inteiros não negativos, stirling2 (N, M) é o número de maneiras através dos quais um conjunto com cardinalidade N pode ser particionado em M subconjuntos disjuntos. Maxima utiliza uma relacedilhaão recursiva para definir stirling2 (N, M) para M menor que 0; stirling2 é indefinida para N menor que 0 e para argumentos não inteiros.

     stirling2 é uma funcedilhaão de simplificacedilhaão. Maxima conhece as seguintes identidades.

      1. stirling2(0, n) = kron_delta(0, n) (Ref. [1])

      2. stirling2(n, n) = 1 (Ref. [1])

      3. stirling2(n, n - 1) = binomial(n, 2) (Ref. [1])

      4. stirling2(n + 1, 1) = 1 (Ref. [1])

      5. stirling2(n + 1, 2) = 2^n  - 1 (Ref. [1])

      6. stirling2(n, 0) = kron_delta(n, 0) (Ref. [2])

      7. stirling2(n, m) = 0 when m > n (Ref. [2])

      8. stirling2(n, m) = sum((-1)^(m - k) binomial(m k) k^n,i,1,m) / m! onde m e n são inteiros, e n é não negativo. (Ref. [3])

     Essas identidades são aplicadas quando os argumentos forem inteiros literais ou símbolos declarados como inteiros, e o primeiro argumento for não negativo. stirling2 não simplifica para argumentos não inteiros.

     Referências:

     [1] Donald Knuth. The Art of Computer Programming, terceira edicedilhaão, Volume 1, Secedilhaão 1.2.6, Equacedilhaões 48, 49, e 50.

     [2] Graham, Knuth, e Patashnik. Concrete Mathematics, Tabela 264.

     [3] Abramowitz e Stegun. Handbook of Mathematical Functions, Secedilhaão 24.1.4.

     Exemplos:

          (%i1) declare (n, integer)$
          (%i2) assume (n >= 0)$
          (%i3) stirling2 (n, n);
          (%o3)                           1

     stirling2 não simplifica para argumentos não inteiros.

          (%i1) stirling2 (%pi, %pi);
          (%o1)                  stirling2(%pi, %pi)

     Maxima aplica identidades a stirling2.

          (%i1) declare (n, integer)$
          (%i2) assume (n >= 0)$
          (%i3) stirling2 (n + 9, n + 8);
                                   (n + 8) (n + 9)
          (%o3)                    ---------------
                                          2
          (%i4) stirling2 (n + 1, 2);
                                        n
          (%o4)                        2  - 1

 -- Funcedilhaão: subset (A, F)

     Retorna o subconjuntode um conjunto A que satisfaz o predicado F.

     subset returns um conjunto which comprises the elements of A for which F returns anything other than false. subset does not apply is to the return value of F.

     subset reclama se A não for um conjunto literal.

     See also partition_set.

     Exemplos:

          (%i1) subset ({1, 2, x, x + y, z, x + y + z}, atom);
          (%o1)                     {1, 2, x, z}
          (%i2) subset ({1, 2, 7, 8, 9, 14}, evenp);
          (%o2)                      {2, 8, 14}

 -- Funcedilhaão: subsetp (A, B)

     Retorna true se e somente se o conjunto A for um subconjunto de B.

     subsetp reclama se ou A ou B não forem um conjunto literal.

     Exemplos:

          (%i1) subsetp ({1, 2, 3}, {a, 1, b, 2, c, 3});
          (%o1)                         true
          (%i2) subsetp ({a, 1, b, 2, c, 3}, {1, 2, 3});
          (%o2)                         false

 -- Funcedilhaão: symmdifference (A_1, ..., A_N)

     Retorna a diferencedilhaa simétrica, isto é, o conjunto dos elemetnos que ocorrem em exactamente um conjunto A_K.

     Given two arguments, symmdifference(A, B) is the same as union(setdifference(A, B), setdifference(B, A)).

     symmdifference reclama se any argument não for um conjunto literal.

     Exemplos:

          (%i1) S_1 : {a, b, c};
          (%o1)                       {a, b, c}
          (%i2) S_2 : {1, b, c};
          (%o2)                       {1, b, c}
          (%i3) S_3 : {a, b, z};
          (%o3)                       {a, b, z}
          (%i4) symmdifference ();
          (%o4)                          {}
          (%i5) symmdifference (S_1);
          (%o5)                       {a, b, c}
          (%i6) symmdifference (S_1, S_2);
          (%o6)                        {1, a}
          (%i7) symmdifference (S_1, S_2, S_3);
          (%o7)                        {1, z}
          (%i8) symmdifference ({}, S_1, S_2, S_3);
          (%o8)                        {1, z}

 -- Funcedilhaão: tree_reduce (F, S)
 -- Funcedilhaão: tree_reduce (F, S, S_0)

     Extende a funcedilhaão binária F a uma funcedilhaão enária através de composicedilhaão, onde S é um conjunto ou uma lista.

     tree_reduce é equivalente ao seguinte: Aplicar F a sucessivos pares de elementos para formar uma nova lista [F(S_1, S_2), F(S_3, S_4), ...], mantendo o elemento final inalterado caso haja um número ímpar de elementos. Repetindo então o processo até que a lista esteja reduzida a um elemento simples, o qual é o valor de retorno da funcedilhaão.

     Quando o argumento opcional S_0 estiver presente, o resultado é equivalente a tree_reduce(F, cons(S_0, S).

     Para adicedilhaões em ponto flutuante, tree_reduce pode retornar uma soma que possui um menor ero de arredondamento que rreduce ou lreduce.

     Os elementos da lista S e os resultados parciais podem ser arranjados em uma árvore binária de profundidade mínima, daí o nome "tree_reduce".

     Exemplos:

     tree_reduce aplicada a uma lista com um número par de elementos.

          (%i1) tree_reduce (f, [a, b, c, d]);
          (%o1)                  f(f(a, b), f(c, d))

     tree_reduce aplicada a uma lista com um número ímpar de elementos.

          (%i1) tree_reduce (f, [a, b, c, d, e]);
          (%o1)               f(f(f(a, b), f(c, d)), e)

 -- Funcedilhaão: union (A_1, ..., A_N)
     Retorna a união dos conjuntos de A_1 a A_N.

     union() (sem argumentos) retorna o conjunto vazio.

     union reclama se qualquer argumento não for um conjunto literal.

     Exemplos:

          (%i1) S_1 : {a, b, c + d, %e};
          (%o1)                   {%e, a, b, d + c}
          (%i2) S_2 : {%pi, %i, %e, c + d};
          (%o2)                 {%e, %i, %pi, d + c}
          (%i3) S_3 : {17, 29, 1729, %pi, %i};
          (%o3)                {17, 29, 1729, %i, %pi}
          (%i4) union ();
          (%o4)                          {}
          (%i5) union (S_1);
          (%o5)                   {%e, a, b, d + c}
          (%i6) union (S_1, S_2);
          (%o6)              {%e, %i, %pi, a, b, d + c}
          (%i7) union (S_1, S_2, S_3);
          (%o7)       {17, 29, 1729, %e, %i, %pi, a, b, d + c}
          (%i8) union ({}, S_1, S_2, S_3);
          (%o8)       {17, 29, 1729, %e, %i, %pi, a, b, d + c}

 -- Funcedilhaão: xreduce (F, S)
 -- Funcedilhaão: xreduce (F, S, S_0)

     Extendendo a funcedilhaão F para uma funcedilhaão enária por composicedilhaão, ou, se F já for enária, aplica-se F a S. Quando F não for enária, xreduce funciona da mesma forma que lreduce. O argumento S é uma lista.

     Funcedilhaões sabidamente enárias inclui adicedilhaão +, multiplicacedilhaão *, and, or, max, min, e append. Funcedilhaões podem também serem declaradas enárias por meio de declare(F, nary). Para essas funcedilhaões, é esperado que xreduce seja mais rápida que ou rreduce ou lreduce.

     Quando o argumento opcional S_0 estiver presente, o resultado é equivalente a xreduce(S, cons(S_0, S)).

     Adicedilhaões em ponto flutuante não são exactamente associativas; quando a associatividade ocorrer, xreduce aplica a adicedilhaão enária do Maxima quando S contiver números em ponto flutuante.

     Exemplos:

     xreduce aplicada a uma funcedilhaão sabidamente enária. F é chamada uma vez, com todos os argumentos.

          (%i1) declare (F, nary);
          (%o1)                         done
          (%i2) F ([L]) := L;
          (%o2)                      F([L]) := L
          (%i3) xreduce (F, [a, b, c, d, e]);
          (%o3)         [[[[[("[", simp), a], b], c], d], e]

     xreduce aplicada a uma funcedilhaão não sabidamente enária. G é chamada muitas vezes, com dois argumentos de cada vez.

          (%i1) G ([L]) := L;
          (%o1)                      G([L]) := L
          (%i2) xreduce (G, [a, b, c, d, e]);
          (%o2)         [[[[[("[", simp), a], b], c], d], e]
          (%i3) lreduce (G, [a, b, c, d, e]);
          (%o3)                 [[[[a, b], c], d], e]