[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

40. Conjuntos


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

40.1 Introdução a Conjuntos

Maxima fornece funções de conjunto, tais como intersecção e união , para conjuntos finitos que são definidos através de enumeração explícita. Maxima trata listas e conjuntos como objetos distintos. Esse recurso torna possível trabalhar com conjuntos que possuem elementos que são ou listas ou conjuntos.

Adicionalmente a funções para conjuntos finitos, Maxima fornece algumas funções relacionadas à combinatória; essas incluem números de Stirling, números de Bell, e muitas outras.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

40.1.1 Uso

Para construir um conjunto como elementos a_1, ..., a_n, use o comando set(a_1, ..., a_n); para construir o conjunto vazio, use set(). Se um elemento for listado mais que uma vez, o processo de simplificação elimina o número 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]}

Dois elementos x e y podem ser redundantes (i.e., considerados iguais para propósito de construção de conjunto) se e somente se is (x = y) retornar true. Note que is (equal (x, y)) pode retornar true enquanto is (x = y) retorna false; se is (x = y) retornar true 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) set (x, y, z);
                          b + a  b   a
(%o9)                    {-----, - + -}
                            c    c   c

Conjuntos são sempre mostrados na saída como uma lista delimitada por chaves; Se você quiser que seja possível inserir um conjunto usando chaves, veja Definindo conjuntos com chaves.

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

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

Membros de conjuntos x e y são iguais fazendo com que is(x = y) avalie para true. Dessa forma rat(x) e x são iguais com conjuntos membros; conseqüentemente,

 
(%i1) set(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 distintos membros de conjuntos; dessa forma

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

Para reduzir esses conjuntos a um único conjunto, aplique rat a cada membro do conjunto:

 
(%i1) set((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 de outros conjuntos, você pode precisar usar outras funções de simplificação. Aqui está um exemplo que usa trigsimp:

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

Um conjunto é simplificado quando seus elementos não são redundantes e ordenados. a versão atual das funções de conjunto usam a função Maxima orderlessp para ordenar conjuntos; todavia, versões futuras das funções de conjunto podem usar uma diferente função de ordenação.

Algumas operações sobre conjuntos, tais como substituição de elementos, forçam automaticamente uma re-simplificação; por exemplo,

 
(%i1) s: set (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 objetos distintos; funções tais como union e intersection sinalizarão um erro se qualquer argumento for uma lista. Se você precisar aplicar uma função de conjunto a uma lista, use a função setify para coverter a lista para um conjunto. Dessa forma

 
(%i1) union ([1, 2], set (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]), set (a, b));
(%o2)                     {1, 2, a, b}

Para extrair todos os elementos de um conjunto s que atendem a uma condição f, use subset(s,f). (Uma condição é uma função booleana que avalia para verdadeiro ou falso.) Por exemplo, para achar as equações em um dado conjunto que não depende de uma variável z, use

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

A seção Definições para Conjuntos tem uma lista completa das funções de conjunto no Maxima.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

40.1.2 Iteração entre Membros de Conjuntos

Existem dois caminhos para interagir sobre membros de conjuntos. Um caminho é usar map; por exemplo:

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

O outro caminho é usar for x in s do

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

As funções Maxima first e rest trabalham corretamente sobre conjuntos. Aplicada a um conjunto, first retorna o primeiro elemento mostrado de um conjunto; elemento esse que pode ser dependente da implementação. Se s for um conjunto, então rest(s) é equivalente a disjoin (first(s), s). Atualmente, existe outras funções Maxima que trabalham corretamente sobre conjuntos. Em futuras versões de funções de conjunto, first e rest podem funcionar diferentemente ou não funcionar em algumas situações.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

40.1.3 Falhas

As funções de conjunto usam a função Maxima orderlessp para ordenar membros de conjuntos e a função ( a nível de Lisp) like para testar a igualdade entre membros de conjuntos. Ambas (orderlessp e like) possuem falhas conhecidas (versões 5.9.2 e seguintes) que podem se manifestar se você tentar usar conjuntos com membros que são listas ou matrizes que contenham expressões na forma CRE (expressão racional canônica). Um exemplo é

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

 CAR: #:X13129 is not a LIST

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

Esse comando faz com que Maxima feche com um erro (a mensagem de erro depende de qual versão de Lisp seu Maxima estiver utilizando). Outro exemplo é

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

 CAR: #:A13129 is not a LIST

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

Essas falhas são causadas por erros em orderlessp e like; elas não são causadas através de falhas em funções de conjunto. Para ilustrar, tente os comandos

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

 CAR: #:B13130 is not a LIST

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

Até essas falhas serem corrigidas, não construa conjuntos com membros que sejam listas ou matrizes contendo expressões na forma de expressão racional canônica; um conjunto com um membro na forma de expressão racional canônica, todavia, pode não ser um problema:

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

A função orderlessp do Maxima tem outra falha que pode trazer problemas com funções de conjunto, a saber que o predicado de ordenação orderlessp não é transitivo. O exemplo mais simples 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 poderá causar problemas com todas as funções de conjunto bem como com funções Maxima em geral. \'E possivel, mas não certoe, que se todos membros de conjunto estiverem ou na forma de expressão racional canônica ou tiverem sido simplificados usando ratsimp, essa falha não se manifeste.

Os mecanismos orderless e ordergreat do Maxima são incompatíveis com funções de conjuntos. Se você precisar usar ou orderless ou ordergreat, descarregue esses comandos antes de construir quaisquer conjuntos e não use o comando unorder.

Você pode encontrar duas outras falhas menores. Na versão Maxima 5.5 e seguintes tinha uma falha na função tex que fazia o conjunto vazio ser incorretamente traduzido para TeX; essa falha foi corrigida no Maxima 5.9.0. Adicionalmente, a função setup_autoload no Maxima 5.9.0 não funciona adequadamente; uma correção está no arquivo nset-init.lisp localizado no diretório maxima/share/contrib/nset.

A função de sinal do Maxima tem uma falha que pode causar comportamento inadequado na função de Kronecker; por exemplo:

 
(%i1) kron_delta (1/sqrt(2), sqrt(2)/2);
(%o1)                           0

O valor correto é 1; a falha é relatada para sign

 
(%i1) sign (1/sqrt(2) - sqrt(2)/2);
(%o1)                          pos

Se você encontrar alguma coisa que você pense ser uma falha de função de conjunto, por favor emita um relatório para a base de dados de falhas do Maxima. Veja bug_report.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

40.1.4 Definindo conjuntos com chaves

Se você quiser entrar conjuntos usando chaves, você pode fazer então através de declaração para que a chave esquerda seja um operador matchfix; isso é feito usando os comandos

 
(%i1) matchfix("{","}")$
(%i2) "{" ([a]) := apply (set, a)$

Agora podemos definir conjuntos usando chaves; dessa forma

 
(%i1) matchfix("{","}")$
(%i2) "{" ([a]) := apply (set, a)$
(%i3) {};
(%o3)                          {}
(%i4) {a, {a, b}};
(%o4)                      {a, {a, b}}

Para sempre permitir essa forma de entrada de conjunto, coloque os dois comandos nas linhas (%i1) e (%i2) em seu arquivo maxima-init.mac.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

40.1.5 Combinatória e Funções diversas

Adicionalmente para funções de conjuntos finitos, Maxima fornece algumas funções relacionada a combinatória; essas incluem números de Stirling de primeiro e de segundo tipo, os número de Bell, coeficientes multinomiais, particionamento de inteiros não negativos, e umas poucas outras. Maxima também define uma função delta de Kronecker.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

40.1.6 Autores

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


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

40.2 Definições para Conjuntos

Função: adjoin (x, a)

Anexa x ao conjunto a e retorna um conjunto. Dessa forma adjoin(x, a) e union(set(x),a) são equivalentes; todavia, usando adjoin pode ser algo mais rápido que usando union. Se a não for um conjunto, sinaliza um erro.

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

See also disjoin.

Função: belln (n)

Para inteiros não negativos n, retorna o n-ésimo número de Bell. Se s for um conjunto com n membros, belln(n) é o número de partições de s. Por exemplo:

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

Quando n não for um inteiro não negativo, belln(n) não simplifica.

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

A função belln trabalha sobre igualdades, listas, matrizes, e conjuntos.

Função: cardinality (a)

Retorna o números de elementos distintos do conjunto a.

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

Na linha (%o3), vemos que cardinality trabalha correetamente mesmo quandoa simplificação tiver sido desabilitada.

Função: cartesian_product (b_1, ... , b_n)

Retorna um conjunto de listas da forma [x_1, ..., x_n], onde x_1 está em b_1, ..., x_n in b_n. Sinaliza um erro quando qualquer b_k não for um conjunto.

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

Função: disjoin (x, a)

Remove x do conjunto a e retorna um conjunto. Se x não for um membro de a, retorna a. Cada um dos seguintes faz a mesma coisa: disjoin(x, a), delete(x, a), e setdifference(a,set(x)); todavia, disjoin é geralmente o caminho mais rápido para remover um membro de um conjunto. Sinaliza um erro se a não for um conjunto.

Função: disjointp (a, b)

Retorna true se os conjuntos a e b forem disjuntos. sinaliza um erro se ou a ou b não for um conjunto.

Função: divisors (n)

Quando n for um inteiro não nulo, retorna o conjunto de seus divisores. O conjunto de divisores inclue os membros 1 e n. Os divisores de um inteiro negativo são os divisores de seus valores absolutos.

Podemos verificar que 28 é um número perfeito.

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

A função divisors trabalha através de simplificação; você pode não precisar re-avaliar manualmente apóes uma substituição. Por exemplo:

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

A função divisors trabalha sobre igualdades, listas, matrizes, e conjuntos. Aqui está um exemplo de trabalho sobre uma lista e uma igualdade.

 
(%i1) divisors ([a, b, c=d]);
(%o1) [divisors(a), divisors(b), divisors(c) = divisors(d)]

Função: elementp (x, a)

Retorna true se e somente se x for um membro do conjunto a. Sinaliza um erro se a não for um conjunto.

Função: emptyp (a)

Retorna true se e somente se a for um conjunto vazio ou a lista vazia.

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

Função: equiv_classes (s, f)

Retorna um conjunto de classes de equivalência de s com relação à relação de equivalência f. A função f pode ser uma função de valor booleano definida sobre o produto cartesiano de s com s. Adicionalmente, a função f pode ser uma relação de equivalência; equiv_classes, todavia, não verifica se f é uma relação de equivalência.

 
(%i1) equiv_classes (set (a, b, c), lambda ([x, y], is (x=y)));
(%o1)                    {{a}, {b}, {c}}

Atualmente, equiv_classes (s, f) aplica automaticamente a função do Maxima is após aplicar a função f; portanto, podemos reescrever o exemplo anterior mais resumidamente.

 
(%i1) equiv_classes (set (a, b, c), "=");
(%o1)                    {{a}, {b}, {c}}

Aqui está outro exemplo.

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

Função: every (f, a)
Função: every (f, L_1, ..., L_n)

O primeiro argumento f pode ser um predicado (uma função que avalia para verdadeiro, falso, ou indeterminado).

Fornecendo um conjunto como segundo argumento, every (f, a) retorna true se f(a_i) retornar true para todos a_i em a. Uma vez que conjuntos são desordenados, every está livre para avaliar f(a_i) em qualquer ordem. every pode ou não avaliar f para todo a_i em a. Porque a ordem de avaliação não é especificada, o predicado f pode não ter efeito de lado ou erro de sinal para qualquer entrada.

Fornecendo uma ou mais listas como argumentos, every (f, L_1, ..., L_n) retorna true se f(x_1, ..., x_n) retornar true para todos x_1, ..., x_n em L_1, ..., L_n, respectivamente. every pode ou não avaliar f para toda conbinação x_1, ..., x_n. Uma vez que listas são ordenadas, every avalia na ordem de incremento do índice.

Para usar every sobre multiplos conjuntos argumentos, os conjuntos devem primeiro serem convertidos para uma seqüência ordenada de forma que seu alinhamento relativo comece bem definido.

Se o sinalizador global maperror for true (o padrão), todas as listas L_1, ..., L_n devem ter comprimentos iguais - de outra forma, every sinalizará um erro. Quando maperror for false, os argumentos lista são efetivamente truncados para o comprimento da lista mais curta.

A função Maxima is é automaticamente aplicada após a avaliação do predicado f.

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

Função: extremal_subset (s, f, max)
Função: extremal_subset (s, f, min)

Quando o terceiro argumento for max, retorna o subconjunto do conjunto ou a lista s para a qual a função real avaliada f toma sobre seu maior valor; quando o terceiro argumento for min, retorna o subconjunto para o qual f toma sobre seu menor valor.

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

Função: flatten (e)

flatten essencialmente avalia uma expressão como se seu principal operador tivesse sido declarado n-ário; existe, todavia, uma diferença - flatten não não age recursivamente dentro de outros argumentos de função. Por exemplo:

 
(%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)))

Aplicada a um conjunto, flatten reune todos os membros de elementos de conjuntos que são conjuntos; por exemplo:

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

flatten trabalha corretamente quando o operador principal for uma função subscrita

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

Para aplicar flatten a uma expressão, o principal operador deve ser definido para zero ou mais argumentos; se esse não for o caso, Maxima sairá com um erro. Expressões com representações especiais, por exemplo expressões racionais canônicas, não podem ser tratadas por flatten; nesse caso, flatten retorna seu argumento inalterado.

Função: full_listify (a)

Se a for um conjunto, converte a para uma lista e aplica full_listify para cada elemento lista.

Para converter apenas o operador de nível mais alto de um conjunto para uma lista, veja listify.

Função: fullsetify (a)

Se a for uma lista, converte a para um conjunto e aplica fullsetify para cada membro do conjunto.

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

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

Para converter apenas o operador de nível mais alto para um conjunto, veja setify.

Função: identity (x)

A função identidade avalia para seu argumento em todas as entradas. Para determinar se todo membro de um conjunto é true, você pode usar

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

Função: integer_partitions (n)
Função: integer_partitions (n, len)

Se o segundo argumento opcional len não for especificado, retorna o conjunto de todas as partições do inteiro n. Quando len for especificado, retorna todas as partições de comprimento len ou menor; nesse caso, zeros são anexados a cada partição de comprimento menor que len termos para fazer com que cada partição tenha exatamente len termos. No outro caso, cada partição é uma lista ordenada do maior para o menor.

Dizemos que uma lista [a_1, ..., a_m] é uma partição de um inteiro não negativo n fazendo com que (1) cada a_i é um inteiro não nulo e (2) a_1 + ... + a_m = n. Dessa forma 0 não tem partições.

 
(%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 achar todas as partições que satisfazem uma condição, use a função subset; aqui está um exemplo que encontra todas as partições de 10 que consistem em números primos.

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

(Note que primep(1) é verdadeiro em Maxima. Isso discorda de muitas definições de número primo.)

Função: intersect (a_1, ..., a_n)

Retorna um conjunto contendo os elementos que são comuns aos conjuntos de a_1 até a_n. A função intersect deve receber um ou mais argumentos. Sinaliza um erro se qualquer dos a_1 até a_n não for um conjunto. Veja também intersection.

Função: intersection (a_1, ..., a_n)

Retorna um conjunto contendo os elementos que são comuns aos conjuntos de a_1 até a_n. A função intersection must receive one or more arguments. Sinaliza um erro se quaisquer dos a_1 até a_n não for um conjunto. Veja também intersect.

Função: kron_delta (x, y)

A função delta de Kronecker; kron_delta (x, y) simplifica para 1 quando is(x = y) for verdadeiro e para zero quando sign (|x - y|) for pos. Quando sign (|x - y|) for zero e x - y não for um número em ponto flutuante (nem do tipo double e nem do tipo bfloat), retorna 0. De outra forma, retorna uma forma substantiva.

A função, kron_delta é declarada para ser simétrica; dessa forma, por exemplo, kron_delta(x, y) - kron_delta(y, x) simplifica para zero.

Aqui alguns exemplos.

 
(%i1) [kron_delta (a, a), kron_delta (a + 1, a)];
(%o1)                        [1, 0]
(%i2) kron_delta (a, b);
(%o2)                   kron_delta(a, b)

Assumindo que a > b faz sign (|a - b|) avaliar para pos; dessa forma

 
(%i1) assume (a > b)$
(%i2) kron_delta (a, b);
(%o2)                           0

Se de outra maneira assumirmos que x >= y, então sign (|x - y|) avalia para pz; nesse caso, kron_delta (x, y) não simplifica

 
(%i1) assume(x >= y)$
(%i2) kron_delta (x, y);
(%o2)                   kron_delta(x, y)

Finalmente, uma vez que 1/10 - 0.1 avalia para um número em ponto flutuante, teremos

 
(%i1) kron_delta (1/10, 0.1);
                                  1
(%o1)                  kron_delta(--, 0.1)
                                  10

Se você quiser que kron_delta (1/10, 0.1) avalie para 1, aplique float.

 
(%i1) float (kron_delta (1/10, 0.1));
(%o1)                           1

Função: listify (a)

Se a for um conjunto, retorna uma lista contendo os membros de a; quando a não for um conjunto, retorna a. Para converter um conjunto e todos os seus membros para listas, veja full_listify.

Função: lreduce (f, s)
Função: lreduce (f, s, init)

A função lreduce (reduzir à esquerda) extende a função 2-aridade para uma n-aridade através de composição; um exemplo pode tornar isso mais claro. Quando o argumento opcional não for definido, teremos

 
(%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)

Note que a função f é primeiro aplicada aos leftmost (mais à esquerda) elementos da lista (dessa forma o nome lreduce). Quando init for definido, o segundo argumento para a avaliação de função mais interna é init; por exemplo:

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

A função lreduce torna isso fácil para encontrar o produto ou adição dos elementos de uma lista.

 
(%i1) lreduce ("+", args (set (a, b)));
(%o1)                         b + a
(%i2) lreduce ("*", args (set (1, 2, 3, 4, 5)));
(%o2)                          120

Veja também See rreduce, See xreduce, e See tree_reduce.

Função: makeset (e, v, s)

Essa função é similar a makelist, mas makeset permite substituições multiplas. o primeiro argumento e é uma espressão; o segundo argumento v é uma lista de variáveis; e s é uma lista ou conjunto de valores para as variáveis v. Cada membro de s deve ter o mesmo comprimento que v. Temos makeset (e, v, s) é o conjunto {z | z = substitute(v -> s_i) e s_i em s}.

 
(%i1) makeset (i/j, [i, j], [[a, b], [c, d]]);
                              a  c
(%o1)                        {-, -}
                              b  d
(%i2) ind: set (0, 1, 2, 3)$
(%i3) makeset (i^2 + j^2 + k^2, [i, j, k], cartesian_product (ind, ind, ind));
(%o3) {0, 1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 17, 18, 
                                                      19, 22, 27}

Função: moebius (n)

A função de Moebius; quando n for produto de k primos distintos, moebius(n) avalia para (-1)^k; isso avalia para 1 quando n = 1; e isso avalia para 0 para todos os outros inteiros positivos. A função de Moebius trabalha sobre igualdades, listas, matrizes, e conjuntos.

Função: multinomial_coeff (a_1, ..., a_n)
Função: multinomial_coeff ()

Retorna o coeficiente multinomial. Quando cada a_k for um inteiro não negativo, o coeficiente multinomial fornece o número de caminhos de substituição a_1 + ... + a_n objetos distintos dentro de n caixas com a_k elementos na k'ésima caixa. Em geral, multinomial (a_1, ..., a_n) avalia para (a_1 + ... + a_n)!/(a_1! ... a_n!). Sem nenhum argumento, multinomial() avalia para 1. É possível usar minfactorial para simplificar o valor retornado por multinomial_coeff; por exemplo:

 
(%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

Função: num_distinct_partitions (n)
Função: num_distinct_partitions (n, a)

Quando n for um inteiro não negativo, retorna o número de partições inteiras distintas de n.

Se o parāmetro opcional a tiver o valor list, retorna uma lista do número de partições distintas de 1,2,3, ... , n. Se n não for um inteiro não negativo, retorna uma forma substantiva.

Definição: Se n = k_1 + ... + k_m, onde k_1 até k_m são distintos inteiros positivos, chamamos k_1 + ... + k_m uma partição distinta de n.

Função: num_partitions (n)
Função: num_partitions (n, a)

Quando n for um intero não negativo, retorna o número de partições de n. Se o parāmetro opcional a tem o valor list, retorna uma lista do número de partições de 1,2,3, ... , n. Se n não for um inteiro não negativo, retorna uma forma substantiva.

 
(%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)

Para um inteiro não negativo n, num_partitions (n) é igual a cardinality (integer_partitions (n)); todavia, chamando num_partitions torna-se mais rápido.

Função: partition_set (a, f)

Retorna uma lista de dois conjuntos; o primeiro conjunto é o subconjunto de a para o qual o predicado f avalia pra falso e o segundo é o subconjunto de a a para o qual f avalia para verdadeiro. Se a não for um conjunto, sinaliza um erro. Veja também subset.

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

Função: permutations (a)

Retorna um conjunto de todas as permutações distintas distintas dos membros da lista ou conjunto a. (Cada permutacão é uma lista, não um conjunto.) Quando a for uma lista, membros duplicados de a não são apagados antes de encontradas todas as pemutações. Dessa forma

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

Se a não for uma lista ou conjunto, sinaliza um erro.

Função: powerset (a)
Função: powerset (a, n)

Quando o segundo argumento opcional n não for definido, retorna o conjunto de todos os subconjuntos de conjunto a. powerset(a) tem 2^cardinality(a) membros. Fornecido um segundo argumento, powerset(a,n) retorna o conjunto de todos os subconjunto de a que possuem cardinalidade n. Sinaliza um erro se a não for um conjunto; adicionalmente sinaliza um erro se n não for um inteiro positivo.

Função: rreduce (f, s)
Função: rreduce (f, s, init)

A função rreduce (right reduce) extende a 2-aridade da função pra uma n-aridade por composição; um exemplo pode tornar isso claro. Quando o argumento opcional init não for definido, temos

 
(%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)))

Note que a função f é primeiro aplicada aos elementos da lista mais à direita (dessa forma o nome rreduce). Quando init for definido, o segundo argumento para a avaliação da função mais interna é init; por exemplo:

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

A função rreduce torna isso fácil para encontrar o produto ou adição de elementos de uma lista.

 
(%i1) rreduce ("+", args (set (a, b)));
(%o1)                         b + a
(%i2) rreduce ("*", args (set (1, 2, 3, 4, 5)));
(%o2)                          120

Veja também See lreduce, See tree_reduce, e See xreduce.

Função: setdifference (a, b)

Retorna um conjunto contendo os elementos no conjunto a que não estão no conjunto b. Sinaliza um erro se a ou b não for um conjunto.

Função: setify (a)

Constrói um conjunto a partir dos elementos da lista a. Elementos duplicados da lista a são apagados e os elementos são organizados conforme o predicado orderlessp. Sinaliza um erro se a não for uma lista.

Função: setp (a)

Retorna verdadeiro se e somente se a for um conjunto Maxima. A função setp verifica se o operador de seu argumento é conjunto; a função setp não verifica se seu argumento é um conjunto simplificado. Dessa forma

 
(%i1) setp (set (a, a)), simp: false;
(%o1)                         true

A função setp pode ser codificada no Maxima como setp(a) := is (inpart (a, 0) = set).

Função: set_partitions (a)
Função: set_partitions (a, n)

Quando o argumento opcional n for definido, retorna um conjunto de todas as decomposições de a dentro de n não vazios subconjuntos disjuntos. Quando n não for definido, retorna o conjunto de todas as partições.

Dizemos que um conjunto P é uma partição de um conjunto S dado quando

  1. each member of P is a nonempty set,
  2. distinct members of P are disjoint,
  3. the union of the members of P equals S.

O conjunto vazio é uma partição de si mesmo (as condições 1 e 2 sendo vacuosamente verdadeiras); dessa forma

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

A cardinalidade do conjunto de partições de um conjunto pode ser encontrada usando stirling2; dessa forma

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

Cada membro de p pode ter 3 membros; Vamos verificar.

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

Finalmente, para cada membro de p, a união de seus membros será igual a s; novamente vamos verificar.

 
(%i1) s: set (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);

Função: some (f, a)
Função: some (f, L_1, ..., L_n)

O primeiro argumento de f pode ser um predicado (uma função que avalia para verdadeiro, falso ou indetermindo).

Fornecendo um conjunto como o segundo argumento, some (f, a) retorna true se f(a_i) retornar true para ao menos um a_i em a. Uma vez que conjuntos são não ordenados, some está livre para avaliar f(a_i) em qualquer ordem. some pode ou não avaliar f para todos a_i em a. Porque a ordem de avaliação não é especificada, o predicado f poderá não ter efeitos de lado ou erros de sinal para qualquer entrada. Para usar some sobre multiplos argumentos de conjunto, eles devem primeiro ser convertidos para uma seqüência ordenada de forma que seu alinhamento relativo torne-se bem definido.

Fornecendo uma ou mais listas como argumentos, some (f, L_1, ..., L_n) retorna true se f(x_1, ..., x_n) retornar true para ao menos um x_1, ..., x_n in L_1, ..., L_n, respectivamente. some pode ou não avaliar f para toda combinação x_1, ..., x_n. Uma vez que listar são ordenadas, some avalia na ordem de incremento dos índices.

Se o sinalizador global maperror for true (o padrão), todas as listas L_1, ..., L_n devem ter igual comprimento - de outra forma, some sinaliza um erro. Quando maperror for falso, os argumentos lista são efetivamente truncados cada um para ter o comprimento da menor lista.

A função Maxima is é automaticamente aplicada após o predicado f.

 
(%i1) some ("<", [a, b, 5], [1, 2, 8]);
(%o1)                         true
(%i2) some ("=", [2, 3], [2, 7]);
(%o2)                         true

Função: stirling1 (n, m)

O número de Stirling de primeiro tipo. Quando n e m forem inteiros não negativos, a magnitude (módulo) de stirling1 (n, m) é o número de permutações de um conjunto com n membros que possuem m ciclos. Para detalhes, veja Graham, Knuth e Patashnik Concrete Mathematics. Usamos uma relação recursiva para definir stirling1 (n, m) para m menor que 0; nós não extendemos isso para n menor que 0 ou para argumentos não inteiros.

A função stirling1 trabalha através de simplificação; A função stirling1 conhece os valores especiais básicos (veja Donald Knuth, The Art of Computer Programming, terceira edição, Volume 1, Seção 1.2.6, Equações 48, 49, e 50). Para Maxima aplicar essas regras, os argumentos devem ser declarados para serem inteiros e o primeiro argumento deve ser não negativo. Por exemplo:

 
(%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 conhece uns poucos outros valores especiais; por exemplo:

 
(%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!

Função: stirling2 (n, m)

O número de Stirling de segundo tipo. Quando n e m são inteiros não negativos, stirling2 (n, m) é o número de possibilidades que um conjunto com cardinalidade n pode ser particionado em m subconjuntos disjuntos. Usamos uma relação recursiva para definir stirling2 (n, m) para m menor que 0; não extendemos isso para n menor que 0 ou para argumentos não inteiros.

A função stirling2 trabalha através de simplificação; A função stirling2 conhece os valores especiais básicos (veja Donald Knuth, The Art of Computer Programming, terceira edição, Volume 1, Seção 1.2.6, Equações 48, 49, e 50). Para Maxima aplicar essas regras, os argumentos devem ser declarados para serem inteiros e o primeiro argumento deve ser não negativo. Por exemplo:

 
(%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 conhece uns poucos outros valores especiais.

 
(%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

Função: subset (a, f)

Retorna um subconjunto do conjunto a que satisfaz o predicado f. Por exemplo:

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

O segundo argumento para subset deve ser um predicado (uma função que avalia para valores booleanos de um argumento) se o primeiro argumento para subset não for um conjunto, sinaliza com um erro. Veja também partition_set.

Função: subsetp (a, b)

Retorna verdadeiro se e somente se o conjunto a for um subconjunto de b. Sinaliza um erro se a ou b não for um conjunto.

Função: symmdifference (a_1, ..., a_n)

Retorna o conjunto dos membros que ocorrem em exatamente um conjunto a_k. Sinaliza um erro se qualquer argumento a_k não for um conjunto. Fornecidos dois argumentos, symmdifference (a, b) é o mesmo que union (setdifference (a, b), setdifference (b, a)).

Função: tree_reduce (f, s)
Função: tree_reduce (f, s, init)

A função tree_reduce extende um operador binário associativo f : S x S -> S de dois argumentos para qualquer número de argumentos usando uma árvore de comprimento mínimo. Um exemplo pode tornar isso claro.

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

Fornecido um número ímpar de argumentos, tree_reduce favorece o lado esquerdo da árvore; por exemplo:

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

Para adição de número em ponto flutuantes, usando tree_reduce pode fornecer uma adição que tem a menor perda de algarismos significativos que usando ou rreduce ou lreduce.

Função: union (a_1, ..., a_n)

Retorna a união dos conjuntos a_1 até a_n. Quando union não recebe argumentos, retorna o conjunto vazio. Sinaliza um erro quando um ou mais argumentos para union não for um conjunto.

Função: xreduce (f, s)
Função: xreduce (f, s, init)

Essa função é similar a ambas lreduce e rreduce exceto que xreduce está livre para usar ou a associatividade à esquerda ou a associatividade à direita; em particular quando f for uma função associativa e Maxima tem um avaliador interno para isso, xreduce pode usar a função n-ária; essas funções n-árias incluem adição +, multiplicação *, and, or, max, min, e append. Para esses operadores, nós geralmente esperamos usar xreduce para ser mais rápida que usando ou rreduce ou lreduce. Quando f não for n-ária, xreduce usa associatividade à esquerda. Adição em ponto flutuante não é associativa; todavia, xreduce usa a adição n-ária do Maxima quando o conjunto ou lista s contiver números em ponto flutuante.


[ << ] [ >> ]           [Top] [Contents] [Índice] [ ? ]

This document was generated by root on Outubro, 3 2006 using texi2html 1.76.