Próximo: Definições para Conjuntos, Anterior: Conjuntos, Acima: Conjuntos [Conteúdo][Índice]
Maxima fornece funções de conjunto, tais como intersecção e união, para conjuntos finitos que são definidos por enumeraçã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 funções de conjuntos finitos, Maxima fornece algumas funções relacionadas com análise combinatória: números de Stirling de primeiro e de segundo tipo, números de Bell, coeficientes multinomiais e partições de inteiros não negativos, entre outras. Maxima também define a função delta de Kronecker.
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
inserçã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 construçã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 funções de simplificaçã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
funções de conjunto usam a função
orderlessp do Maxima para ordenar conjuntos; contudo,
versões futuras das funções de conjunto poderão
vir a usar uma função de ordenação
diferente.
Algumas operações sobre conjuntos, tais como substituições, forçam automaticamente a uma re-simplificaçã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;
funções tais como union e intersection
produzem um erro se qualquer argumento não for um conjunto. se
precisar aplicar uma função de conjunto a uma lista, use
a funçã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 função que avalia para os valores booleanos
true/false.) Por exemplo, para encontrar as
equaçõ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 secção Definições para Conjuntos possui uma lista completa das funções de conjunto no Maxima.
Existem duas formas de fazer iteraçõ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 funçõ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
implementação. Se s for um conjunto, então
rest(s) é equivalente a disjoin(first(s), s).
Actualmente, existem outras funções do Maxima que
trabalham correctamente sobre conjuntos. Em versões futuras das
funções de conjunto, first e rest podem
vir a funcionar diferentemente ou deixar de funcionar.
As funções de conjunto usam a função
orderlessp do Maxima para organizar os elementos dum conjunto e a
função (a nível do Lisp) like para
testar a igualdade entre elementos de conjuntos. Ambas essas
funçõ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 funçõ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 funções de conjunto; nomeadamente, o
predicado de ordenaçã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 funções de
conjunto bem como com funçõ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 funções de
conjunto. Se precisar usar orderless ou ordergrreat, chame
todas essas funções antes de construir quaisquer
conjuntos, e não use unorder.
Se encontrar alguma coisa que pense ser uma falha em alguma
função de conjunto, por favor relate isso para a base de
dados de falhas do Maxima. Veja bug_report.
Stavros Macrakis de Cambridge, Massachusetts e Barton Willis da Universidade de Nebraska e Kearney (UNK) escreveram as fnções de conjunto do Maxima e sua documentação.
Próximo: Definições para Conjuntos, Anterior: Conjuntos, Acima: Conjuntos [Conteúdo][Índice]