[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
40.1 Introdução a Conjuntos | ||
40.2 Definições para Conjuntos |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
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] | [ ? ] |
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] | [ ? ] |
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] | [ ? ] |
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] | [ ? ] |
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] | [ ? ] |
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] | [ ? ] |
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] | [ ? ] |
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
.
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.
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.
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]} |
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.
Retorna true
se os conjuntos a e b forem disjuntos. sinaliza um
erro se ou a ou b não for um conjunto.
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)] |
Retorna true
se e somente se x for um membro do
conjunto a. Sinaliza um erro se a não for um conjunto.
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] |
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}} |
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 |
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)} |
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.
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.
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.
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 |
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.)
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.
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.
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 |
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.
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.
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} |
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.
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 |
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.
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.
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}] |
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.
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.
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.
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.
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.
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)
.
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
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); |
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 |
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! |
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 |
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.
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.
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))
.
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
.
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.
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.