curso3.mw

 

Capítulo 3  Manipulação de Expressões 

 

Introdução 

A simplificação de expressões é um problema clássico no uso computação algébrica. Em diversas situações, os resultados são fórmulas muito extensas que, mesmo estando matematicamente corretas, não permitem uma boa análise ou interpretação. Infelizmente não existe um comando satisfatório de simplificação em nunhuma linguagem algébrica disponível. Temos um conjunto de comandos de manipulação de expressões que na maioria dos casos nos ajuda obter uma forma final satisfatória, mas dificilmente obtemos exatamente aquilo de desejamos. 

 

Todo mundo tem uma idéia intuitiva do que seja a forma mais simples de uma expressão, no entanto, na computação, não é possível dar um comando intuitivo. É necessário fornecer um algoritmo, de forma que, uma vez seguida a sequência de passos, o computador sempre chegue na forma mais simples. Uma regra poderia ser: fatores não nulos comuns ao numerador e denominador de uma expressão devem ser cancelados. O comando normal (normalize) executa essa tarefa. Por exemplo: 

> restart

> `/`(`*`(`+`(`*`(`^`(x, 2)), `-`(1))), `*`(`+`(`*`(`^`(x, 2)), `-`(x), `-`(2))))
`/`(`*`(`+`(`*`(`^`(x, 2)), `-`(1))), `*`(`+`(`*`(`^`(x, 2)), `-`(x), `-`(2)))) (1.1)
 

> normal(%)
`/`(`*`(`+`(x, `-`(1))), `*`(`+`(x, `-`(2)))) (1.2)
 

O resultado ficou mais simples que o original. Agora, vamos aplicar a mesma regra à seguinte expressão: 

> `/`(`*`(`+`(`*`(`^`(x, 20)), `-`(1))), `*`(`+`(x, `-`(1))))
`/`(`*`(`+`(`*`(`^`(x, 20)), `-`(1))), `*`(`+`(x, `-`(1)))) (1.3)
 

> normal(%)
`+`(`*`(`^`(x, 19)), `*`(`^`(x, 18)), `*`(`^`(x, 17)), `*`(`^`(x, 16)), `*`(`^`(x, 15)), `*`(`^`(x, 14)), `*`(`^`(x, 13)), `*`(`^`(x, 12)), `*`(`^`(x, 11)), `*`(`^`(x, 10)), `*`(`^`(x, 9)), `*`(`^`(x,... (1.4)
 

Neste último exemplo temos x elevado a potência 20, porém poderia ser x elevado a 1000. A expressão sem fatores comuns ocuparia várias páginas. Qual das formas é a mais simples? Existem situações onde é possivel decidir qual é a forma mais simples. Isto é o que tenta fazer o comando simplify. Em outras situações o próprio usuário deve decidir qual é a forma que ele quer que a expressão seja colocada. Para isso, o Maple possui uma série de comandos de simplificação e manipulação de expressões. São comandos que, quando aplicados a uma expressão, mudam sua forma, mas na maioria das vezes não mudam seu conteúdo. As diferentes formas são matematicamente equivalentes, ou melhor, quase equivalentes. As duas últimas expressões são equivalentes em todos os pontos diferentes de 1, porém não são equivalentes em x = 1. 

 

Este capítulo discute um conjunto de comandos que podem axiliar na simplificação de expressões tais como: 

simplify - tentar simplificar a expressão matemática. 

expand, factor e combine - são comandos mutuamente complementares. expand abre os parênteses executando as propriedades distributivas. factor e combine tentam combinar os termos de modo a agrupar as expressões. 

normal - transforma funções racionais para suas formas normais. 

 

Existem diversos outros que executam processamentos mais específicos como dividir polinômios ou expandir uma expressão em frações parciais. 

 

Simplify 

Este comando tenta simplificar uma expressão matemática dada aplicando várias regras de transformação. Por ser um comando geral de simplificação, a sua utilização é sempre a primeira tentativa em tornar a expressão mais simples. Pode ser que não faça exatamente a mudança desejada pelo usuário e neste caso outros comandos deverão ser tentados. Os exemplos seguintes mostram algumas aplicações do simplify: Primeiro vamos calcular a terceira derivada da expressão `/`(`*`(x), `*`(`+`(`-`(`*`(`^`(x, 2))), 1))) e simplificar o resultado. 

> diff(`/`(`*`(x), `*`(`+`(`-`(`*`(`^`(x, 2))), 1))), x, x, x)
`+`(`/`(`*`(48, `*`(`^`(x, 2))), `*`(`^`(`+`(`-`(`*`(`^`(x, 2))), 1), 3))), `/`(`*`(6), `*`(`^`(`+`(`-`(`*`(`^`(x, 2))), 1), 2))), `/`(`*`(48, `*`(`^`(x, 4))), `*`(`^`(`+`(`-`(`*`(`^`(x, 2))), 1), 4))... (2.1)
 

> simplify(%)
`+`(`/`(`*`(6, `*`(`+`(`*`(`^`(x, 4)), `*`(6, `*`(`^`(x, 2))), 1))), `*`(`^`(`+`(`*`(`^`(x, 2)), `-`(1)), 4)))) (2.2)
 

Expressões contendo trigonometria, potência e logarítmos também podem ser simplificadas com suas respectivas propiedades de manipulação. 

> `+`(`*`(`^`(sin(theta), 2)), `*`(`^`(cos(theta), 2))) = simplify(`+`(`*`(`^`(sin(theta), 2)), `*`(`^`(cos(theta), 2))))
`+`(`*`(`^`(sin(theta), 2)), `*`(`^`(cos(theta), 2))) = 1 (2.3)
 

> exp(`*`(a, `*`(ln(b)))) = simplify(exp(`*`(a, `*`(ln(b)))))
exp(`*`(a, `*`(ln(b)))) = `^`(b, a) (2.4)
 

Enquanto estes exemplos fornecem uma boa impressão da funcionalidade do simplify, não é difícil achar exemplos em que a expressão fica menos simples ou que não se altera. 

> `+`(`*`(`^`(`+`(x, `-`(1)), 10)), 1) = simplify(`+`(`*`(`^`(`+`(x, `-`(1)), 10)), 1))
`+`(`*`(`^`(`+`(x, `-`(1)), 10)), 1) = `+`(`*`(`^`(x, 10)), `-`(`*`(10, `*`(`^`(x, 9)))), `*`(45, `*`(`^`(x, 8))), `-`(`*`(120, `*`(`^`(x, 7)))), `*`(210, `*`(`^`(x, 6))), `-`(`*`(252, `*`(`^`(x, 5)))... (2.5)
 

> `*`(`+`(x, `-`(2)), `*`(`+`(x, 2), `*`(`+`(`*`(`^`(x, 2)), 4)))) = simplify(`*`(`+`(x, `-`(2)), `*`(`+`(x, 2), `*`(`+`(`*`(`^`(x, 2)), 4)))))
`*`(`+`(x, `-`(2)), `*`(`+`(x, 2), `*`(`+`(`*`(`^`(x, 2)), 4)))) = `*`(`+`(`*`(`^`(x, 2)), 4), `*`(`+`(`*`(`^`(x, 2)), `-`(4)))) (2.6)
 

Para expressões na forma `^`(a, b), simplify executa as simplificações que são matematicamente permitidas para quaisquer valores possíveis para a e b. Outras simplificações que, por exemplo, só podem ser realizadas para a > 0, são obtidas com a opção symbolic ou assumindo propriedades com o comando assume. 

> simplify(sqrt(`*`(`^`(Pi, 2), `*`(`^`(n, 2))))) = simplify(sqrt(`*`(`^`(Pi, 2), `*`(`^`(n, 2)))), symbolic)
`*`(Pi, `*`(csgn(n), `*`(n))) = `*`(Pi, `*`(n)) (2.7)
 

> simplify(`^`(`*`(a, `*`(b)), c)) = simplify(`^`(`*`(a, `*`(b)), c), symbolic)
`^`(`*`(a, `*`(b)), c) = `*`(`^`(a, c), `*`(`^`(b, c))) (2.8)
 

Em muitos contextos, a opção symbolic é muito forte ou não consegue expressar as propriedades matemáticas desejadas. Podemos usar a opção assume  

> simplify(sqrt(`*`(`^`(Pi, 2), `*`(`^`(n, 2), `*`(`^`(sin(x), 2))))), assume = real)
`*`(Pi, `*`(abs(`*`(n, `*`(sin(x)))))) (2.9)
 

> simplify(cos(`*`(n, `*`(Pi))), assume = integer)
-1 (2.10)
 

A sintaxe é assume = propriedade, onde propriedade pode ser o nome de um tipo (Maple type ): real, rational, posint, nonnegint, even, odd, entre centenas de outros nomes ou uma propriedade (veja property ).  

 

Se o usuário desejar restringir os efeitos do simplify a uma área da expressão, pode-se especificar uma das seguintes opções como parâmetro do comando: exp, GAMMA, hypergeom, ln, polar, power, radical, sqrt e trig. Veja alguns exemplos:    

> f := `+`(exp(`*`(b, `*`(ln(a)))), `-`(`^`(`+`(`*`(a, `*`(`^`(sin(x), 2))), `*`(a, `*`(`^`(cos(x), 2)))), b)))
`+`(exp(`*`(b, `*`(ln(a)))), `-`(`^`(`+`(`*`(a, `*`(`^`(sin(x), 2))), `*`(a, `*`(`^`(cos(x), 2)))), b))) (2.11)
 

> simplify(f, trig)
`+`(exp(`*`(b, `*`(ln(a)))), `-`(`^`(a, b))) (2.12)
 

> simplify(f, exp)
`+`(`^`(a, b), `-`(`^`(`+`(`*`(a, `*`(`^`(sin(x), 2))), `*`(a, `*`(`^`(cos(x), 2)))), b))) (2.13)
 

> simplify(f, atsign)
`+`(exp(`*`(b, `*`(ln(a)))), `-`(`^`(`+`(`*`(a, `*`(`^`(sin(x), 2))), `*`(a, `*`(`^`(cos(x), 2)))), b))) (2.14)
 

Se uma ou mais equações são fornecidas como parâmetro do simplify, o Maple usa estas informações como vínculos adicionais para simplificar as expressões. Estes vículos podem ser passados como um conjunto, mesmo que tenha apenas um elemento. O background matemático para esta simplificação é representado pelas bases de Gröbner. Pense como seria trabalhoso realizar a simplificação da expressão 

> expr := `+`(`*`(`^`(a, 4)), `*`(`^`(b, 4)), `*`(`^`(c, 4)))
`+`(`*`(`^`(a, 4)), `*`(`^`(b, 4)), `*`(`^`(c, 4))) (2.15)
 

utilizando os seguintes vínculos: 

> eq1 := `+`(a, b, c) = 3

> eq2 := `+`(`*`(`^`(a, 2)), `*`(`^`(b, 2)), `*`(`^`(c, 2))) = 9

> eq3 := `+`(`*`(`^`(a, 3)), `*`(`^`(b, 3)), `*`(`^`(c, 3))) = 24
 

 

`+`(a, b, c) = 3
`+`(`*`(`^`(a, 2)), `*`(`^`(b, 2)), `*`(`^`(c, 2))) = 9
`+`(`*`(`^`(a, 3)), `*`(`^`(b, 3)), `*`(`^`(c, 3))) = 24 (2.16)
 

O Maple encontra soluções não triviais de primeira (e em pouco tempo): 

> simplify(expr, {eq1, eq2, eq3})
69 (2.17)
 

O comando simplify também pode ser usado para eliminar determinadas variáveis de um sistema de equação. No exemplo abaixo,  

> eq1 := `+`(`*`(`^`(x, 2)), `*`(4, `*`(x, `*`(y))), `*`(3, `*`(x))) = 7

> eq2 := `+`(`*`(6, `*`(x, `*`(y))), `*`(`^`(y, 2)), x) = 0
 

`+`(`*`(`^`(x, 2)), `*`(4, `*`(x, `*`(y))), `*`(3, `*`(x))) = 7
`+`(`*`(6, `*`(x, `*`(y))), `*`(`^`(y, 2)), x) = 0 (2.18)
 

primeiramente vamos eliminar x do sistema de equações 

> simplify(eq1, {eq2}, {x})
`/`(`*`(`+`(`-`(`*`(23, `*`(`^`(y, 4)))), `-`(`*`(22, `*`(`^`(y, 3)))), `-`(`*`(3, `*`(`^`(y, 2)))))), `*`(`+`(`*`(36, `*`(`^`(y, 2))), `*`(12, `*`(y)), 1))) = 7 (2.19)
 

agora vamos eliminar y  

> simplify(eq2, {eq1}, {y})
`+`(`/`(`*`(`/`(1, 16), `*`(`+`(`-`(`*`(23, `*`(`^`(x, 4)))), `-`(`*`(50, `*`(`^`(x, 3)))), `*`(163, `*`(`^`(x, 2))), `-`(`*`(42, `*`(x))), 49))), `*`(`^`(x, 2)))) = 0 (2.20)
 

Vamos eliminar a variável a do sistema 

> eq1 := `+`(a, b, c) = 7

> eq2 := `+`(a, `-`(b), `*`(3, `*`(c))) = 8

> eq3 := `+`(a, `-`(`*`(2, `*`(b))), `*`(5, `*`(c))) = 9
 

 

`+`(a, b, c) = 7
`+`(a, `-`(b), `*`(3, `*`(c))) = 8
`+`(a, `-`(`*`(2, `*`(b))), `*`(5, `*`(c))) = 9 (2.21)
 

> simplify({eq1, eq2}, {eq3}, {a})
{`+`(b, `-`(`*`(2, `*`(c))), 9) = 8, `+`(`*`(3, `*`(b)), `-`(`*`(4, `*`(c))), 9) = 7} (2.22)
 

Expand e Normal 

O comando expand abre os parênteses contidos na expressão realizando as propriedades distributivas 

> `*`(x, `*`(`^`(`+`(x, `-`(a)), 2), `*`(`^`(`+`(x, `-`(b)), 3))))
`*`(x, `*`(`^`(`+`(x, `-`(a)), 2), `*`(`^`(`+`(x, `-`(b)), 3)))) (3.1)
 

> expand(%)
`+`(`-`(`*`(`^`(a, 2), `*`(`^`(b, 3), `*`(x)))), `*`(3, `*`(`^`(a, 2), `*`(`^`(b, 2), `*`(`^`(x, 2))))), `-`(`*`(3, `*`(`^`(a, 2), `*`(b, `*`(`^`(x, 3)))))), `*`(`^`(a, 2), `*`(`^`(x, 4))), `*`(2, `*`... (3.2)
 

e tem efeito similar quando há potência 

> `^`(a, `+`(b, `^`(c, `+`(`*`(e, `*`(f)), d)))) = expand(`^`(a, `+`(b, `^`(c, `+`(`*`(e, `*`(f)), d)))))
`^`(a, `+`(b, `^`(c, `+`(`*`(e, `*`(`+`(exp(`*`(b, `*`(ln(a)))), `-`(`^`(`+`(`*`(a, `*`(`^`(sin(x), 2))), `*`(a, `*`(`^`(cos(x), 2)))), b))))), d)))) = `*`(`^`(a, b), `*`(`^`(a, `/`(`*`(`^`(c, `*`(e, ... (3.3)
 

As propriedades trigonométricas também são usadas pelo comando 

> sin(`+`(`*`(4, `*`(x)))) = expand(sin(`+`(`*`(4, `*`(x)))))
sin(`+`(`*`(4, `*`(x)))) = `+`(`*`(8, `*`(sin(x), `*`(`^`(cos(x), 3)))), `-`(`*`(4, `*`(sin(x), `*`(cos(x)))))) (3.4)
 

> sin(`+`(a, b)) = expand(sin(`+`(a, b)))
sin(`+`(b, a)) = `+`(`*`(sin(b), `*`(cos(a))), `*`(cos(b), `*`(sin(a)))) (3.5)
 

Para funções racionais, só o numerador é alterado 

> f := `/`(`*`(`^`(`+`(x, `-`(a)), 2)), `*`(`^`(`+`(x, b), 3))); -1

> f = expand(f)
`/`(`*`(`^`(`+`(x, `-`(a)), 2)), `*`(`^`(`+`(x, b), 3))) = `+`(`/`(`*`(`^`(a, 2)), `*`(`^`(`+`(x, b), 3))), `-`(`/`(`*`(2, `*`(x, `*`(a))), `*`(`^`(`+`(x, b), 3)))), `/`(`*`(`^`(x, 2)), `*`(`^`(`+`(x,... (3.6)
 

Para que a expansão do denominador também seja feita devemos acessá-lo através do comando denom e processá-lo separado do numerador que é realizado com o comando numer. Esta mesma simplificação pode ser também realizada pelo normal com a opção expanded 

> normal(f, expanded) = `/`(`*`(expand(numer(f))), `*`(expand(denom(f))))
`/`(`*`(`+`(`*`(`^`(a, 2)), `-`(`*`(2, `*`(a, `*`(x)))), `*`(`^`(x, 2)))), `*`(`+`(`*`(`^`(b, 3)), `*`(3, `*`(`^`(b, 2), `*`(x))), `*`(3, `*`(b, `*`(`^`(x, 2)))), `*`(`^`(x, 3))))) = `/`(`*`(`+`(`*`(`... (3.7)
 

Em certos casos, queremos expandir uma expressão sem expandir um certo pedaço. Para isto, devemos colocar a parte que queremos manter intacta como argumento do comando. 

> sin(`+`(`*`(omega, `*`(`+`(t, t0))), delta))
sin(`+`(`*`(omega, `*`(`+`(t, t0))), delta)) (3.8)
 

> expand(%, `+`(t, t0))
`+`(`*`(sin(`*`(omega, `*`(`+`(t, t0)))), `*`(cos(delta))), `*`(cos(`*`(omega, `*`(`+`(t, t0)))), `*`(sin(delta)))) (3.9)
 

Factor 

O comando factor executa o processo inverso do expand tentando converter as várias parcelas de uma soma em um conjunto de produtos 

> `*`(x, `*`(`^`(`+`(x, `-`(`*`(2, `*`(b)))), 2), `*`(`+`(x, a))))
`*`(x, `*`(`^`(`+`(x, `-`(`*`(2, `*`(b)))), 2), `*`(`+`(x, a)))) (4.1)
 

> expand(%)
`+`(`*`(4, `*`(a, `*`(`^`(b, 2), `*`(x)))), `-`(`*`(4, `*`(a, `*`(b, `*`(`^`(x, 2)))))), `*`(a, `*`(`^`(x, 3))), `*`(4, `*`(`^`(b, 2), `*`(`^`(x, 2)))), `-`(`*`(4, `*`(b, `*`(`^`(x, 3))))), `*`(`^`(x,... (4.2)
 

> factor(%)
`*`(x, `*`(`^`(`+`(`*`(2, `*`(b)), `-`(x)), 2), `*`(`+`(x, a)))) (4.3)
 

Neste comando a fatorização é feita tanto para o numerador como para o denominador de funções racionais 

> factor(`/`(`*`(`+`(`*`(`^`(x, 2)), x, `-`(6))), `*`(`+`(`*`(`^`(x, 2)), `-`(1)))))
`/`(`*`(`+`(x, 3), `*`(`+`(x, `-`(2)))), `*`(`+`(x, `-`(1)), `*`(`+`(x, 1)))) (4.4)
 

Quando o factor não encontra raízes inteiras, o formato original é mantido. Entretanto, adicionando um argumento pode ajudar o Maple na fatoração 

> factor(`+`(`*`(`^`(x, 2)), 1))
`+`(`*`(`^`(x, 2)), 1) (4.5)
 

> factor(`+`(`*`(`^`(x, 2)), 1), I)
`+`(`-`(`*`(`+`(x, I), `*`(`+`(`-`(x), I))))) (4.6)
 

> factor(`+`(`*`(`^`(x, 2)), 3), `*`(`^`(-3, `/`(1, 2))))
`+`(`-`(`*`(`+`(`-`(x), `*`(`^`(-3, `/`(1, 2)))), `*`(`+`(x, `*`(`^`(-3, `/`(1, 2)))))))) (4.7)
 

Combine 

O combine representa outro comando que executa o processo inverso do expand. Ele tem a finalidade de agrupar funções mais genéricas 

> `^`(x, `+`(a, b))
`^`(x, `+`(a, b)) (5.1)
 

> expand(%)
`*`(`^`(x, a), `*`(`^`(x, b))) (5.2)
 

> combine(%, power)
`^`(x, `+`(a, b)) (5.3)
 

Pode combinar várias raízes em uma só 

> `*`(sqrt(3), `*`(sqrt(5))) = combine(`*`(sqrt(3), `*`(sqrt(5))))
`*`(`^`(3, `/`(1, 2)), `*`(`^`(5, `/`(1, 2)))) = `*`(`^`(15, `/`(1, 2))) (5.4)
 

Pode fazer simplificações especificando o tipo ao passar como parâmetreo um dos argumentos: abs, conjugate, exp, ln, plus, power, product, Psi, range, trig e signum 

> `+`(`*`(4, `*`(`^`(cos(x), 3)))) = combine(`+`(`*`(4, `*`(`^`(cos(x), 3)))), trig)
`+`(`*`(4, `*`(`^`(cos(x), 3)))) = `+`(cos(`+`(`*`(3, `*`(x)))), `*`(3, `*`(cos(x)))) (5.5)
 

> `*`(`^`(cos(x), 2)) = combine(`*`(`^`(cos(x), 2)), trig)
`*`(`^`(cos(x), 2)) = `+`(`*`(`/`(1, 2), `*`(cos(`+`(`*`(2, `*`(x)))))), `/`(1, 2)) (5.6)
 

> `+`(`*`(2, `*`(ln(3))), `-`(ln(2))) = combine(`+`(`*`(2, `*`(ln(3))), `-`(ln(2))), ln)
`+`(`*`(2, `*`(ln(3))), `-`(ln(2))) = `+`(`*`(2, `*`(ln(`+`(`*`(`/`(3, 2), `*`(`^`(2, `/`(1, 2))))))))) (5.7)
 

E ainda pode combinar integrais, limites e somas de acordo com seu índices 

> `+`(Int(x, x = a .. b), `-`(Int(`*`(`^`(x, 2)), x = a .. b))) = combine(`+`(Int(x, x = a .. b), `-`(Int(`*`(`^`(x, 2)), x = a .. b))))
`+`(Int(x, x = a .. b), `-`(Int(`*`(`^`(x, 2)), x = a .. b))) = Int(`+`(`-`(`*`(`^`(x, 2))), x), x = a .. b) (5.8)
 

> `*`(Limit(`*`(`^`(g(x), 3)), x = a), `*`(Limit(`*`(`^`(g(x), 2)), x = a))) = combine(`*`(Limit(`*`(`^`(g(x), 3)), x = a), `*`(Limit(`*`(`^`(g(x), 2)), x = a))))
`*`(Limit(`*`(`^`(g(x), 3)), x = a), `*`(Limit(`*`(`^`(g(x), 2)), x = a))) = Limit(`*`(`^`(g(x), 5)), x = a) (5.9)
 

Convert 

O comando convert é usado para converter expressões matemáticas em diferentes notações. Estas notações são passadas com argumento para o comando que podem ser: exp, expln, expsincos, ln, sincos, tan, trig, radical, RootOf, factorial, GAMMA entre outros 

> sinh(x) = convert(sinh(x), exp)
sinh(x) = `+`(`*`(`/`(1, 2), `*`(exp(x))), `-`(`*`(`/`(1, 2), `*`(exp(`+`(`-`(x))))))) (6.1)
 

> sin(`+`(`*`(2, `*`(x)))) = convert(sin(`+`(`*`(2, `*`(x)))), tan)
sin(`+`(`*`(2, `*`(x)))) = `+`(`/`(`*`(2, `*`(tan(x))), `*`(`+`(1, `*`(`^`(tan(x), 2)))))) (6.2)
 

> arctan(x) = convert(arctan(x), ln)
arctan(x) = `*`(`*`(`/`(1, 2), `*`(I)), `*`(`+`(ln(`+`(1, `-`(`*`(`+`(I), `*`(x))))), `-`(ln(`+`(1, `*`(I, `*`(x)))))))) (6.3)
 

> factorial(n) = convert(factorial(n), GAMMA)
factorial(n) = GAMMA(`+`(n, 1)) (6.4)
 

> binomial(n, k) = convert(binomial(n, k), factorial)
binomial(n, k) = `/`(`*`(factorial(n)), `*`(factorial(k), `*`(factorial(`+`(n, `-`(k)))))) (6.5)
 

Não existe um comando só para converter uma expressão para frações parciais; ao invés disso o comando convert possui a opção parfrac que realiza esta tarefa. É necessário passar como terceiro argumento a variável na qual se quer modificar 

> `/`(`*`(x), `*`(`+`(`*`(`^`(x, 4)), `-`(1)))) = convert(`/`(`*`(x), `*`(`+`(`*`(`^`(x, 4)), `-`(1)))), parfrac, x)
`/`(`*`(x), `*`(`+`(`*`(`^`(x, 4)), `-`(1)))) = `+`(`-`(`/`(`*`(`/`(1, 2), `*`(x)), `*`(`+`(`*`(`^`(x, 2)), 1)))), `/`(`*`(`/`(1, 4)), `*`(`+`(x, `-`(1)))), `/`(`*`(`/`(1, 4)), `*`(`+`(x, 1)))) (6.6)
 

A conversão para frações contínuas também é possível com o auxílio da opção confrac 

> `/`(`*`(`+`(`*`(`^`(x, 2)), `-`(2))), `*`(`^`(x, 3))) = convert(`/`(`*`(`+`(`*`(`^`(x, 2)), `-`(2))), `*`(`^`(x, 3))), confrac, x)
`/`(`*`(`+`(`*`(`^`(x, 2)), `-`(2))), `*`(`^`(x, 3))) = `/`(1, `*`(`+`(x, `/`(`*`(2), `*`(`+`(x, `-`(`/`(`*`(2), `*`(x))))))))) (6.7)
 

Sort e Collect 

O uso destes dois comandos se torna importante quando as expressões são grandes ou quando possuem muitas variáveis. O comando sort reorganiza a expressão ordenando os termos de acordo com a potência 

> f := expand(`+`(`*`(`^`(`+`(`*`(a, `*`(`^`(x, 2), `*`(y))), `*`(b, `*`(y))), 2)), `*`(`^`(`+`(`*`(c, `*`(`^`(y, 2))), x, `-`(`*`(2, `*`(y)))), 2)), `*`(`^`(x, 3)), `*`(`^`(x, 4), `*`(`^`(y, 2)))))
`+`(`*`(`^`(a, 2), `*`(`^`(x, 4), `*`(`^`(y, 2)))), `*`(2, `*`(a, `*`(b, `*`(`^`(x, 2), `*`(`^`(y, 2)))))), `*`(`^`(c, 2), `*`(`^`(y, 4))), `*`(`^`(x, 4), `*`(`^`(y, 2))), `*`(`^`(b, 2), `*`(`^`(y, 2)... (7.1)
 

> sort(f)
`+`(`*`(`^`(a, 2), `*`(`^`(x, 4), `*`(`^`(y, 2)))), `*`(2, `*`(a, `*`(b, `*`(`^`(x, 2), `*`(`^`(y, 2)))))), `*`(`^`(c, 2), `*`(`^`(y, 4))), `*`(`^`(x, 4), `*`(`^`(y, 2))), `*`(`^`(b, 2), `*`(`^`(y, 2)... (7.2)
 

Sem nenhum parâmetro adicional, este comando ordena os termos de acordo com a soma das potências das variáveis de cada parcela. Normalmente a ordenação é feita em relação a uma determinada variável, mas também é possível ordenar para duas 

> sort(f, x, ascending)
`+`(`*`(4, `*`(`^`(y, 2))), `-`(`*`(4, `*`(c, `*`(`^`(y, 3))))), `*`(`^`(c, 2), `*`(`^`(y, 4))), `*`(`^`(b, 2), `*`(`^`(y, 2))), `-`(`*`(4, `*`(y, `*`(x)))), `*`(2, `*`(c, `*`(`^`(y, 2), `*`(x)))), `*... (7.3)
 

> sort(f, [x, y])
`+`(`*`(`^`(x, 4), `*`(`^`(y, 2))), `*`(`^`(a, 2), `*`(`^`(x, 4), `*`(`^`(y, 2)))), `*`(2, `*`(a, `*`(b, `*`(`^`(x, 2), `*`(`^`(y, 2)))))), `*`(`^`(c, 2), `*`(`^`(y, 4))), `*`(`^`(x, 3)), `*`(2, `*`(c... (7.4)
 

O comando collect possui uma certa afinidade com o comando sort. Ele combina termos que possuem uma variável em comum colocando-a em evidência 

> collect(f, x)
`+`(`*`(`+`(`*`(`^`(a, 2), `*`(`^`(y, 2))), `*`(`^`(y, 2))), `*`(`^`(x, 4))), `*`(`^`(x, 3)), `*`(`+`(`*`(2, `*`(a, `*`(b, `*`(`^`(y, 2))))), 1), `*`(`^`(x, 2))), `*`(`+`(`*`(2, `*`(c, `*`(`^`(y, 2)))... (7.5)
 

Pode-se escpecificar também duas variáveis para este comando. O critério de associação fica sendo o de colocar em evidência em relação à primeira variável e para os termos resultantes é que será colocada em evidência a segunda variável 

> collect(f, [x, y])
`+`(`*`(`+`(`*`(`^`(a, 2)), 1), `*`(`^`(y, 2), `*`(`^`(x, 4)))), `*`(`^`(x, 3)), `*`(`+`(`*`(2, `*`(a, `*`(b, `*`(`^`(y, 2))))), 1), `*`(`^`(x, 2))), `*`(`+`(`*`(2, `*`(c, `*`(`^`(y, 2)))), `-`(`*`(4,... (7.6)
 

> collect(f, [y, x])
`+`(`*`(`^`(c, 2), `*`(`^`(y, 4))), `-`(`*`(4, `*`(c, `*`(`^`(y, 3))))), `*`(`+`(`*`(`+`(`*`(`^`(a, 2)), 1), `*`(`^`(x, 4))), `*`(2, `*`(a, `*`(b, `*`(`^`(x, 2))))), `*`(2, `*`(c, `*`(x))), `*`(`^`(b,... (7.7)
 

Os dois comandos citados podem trabalhar com funções tais como sin e cos, porém não são capazes de manipular xy ou `+`(x, y) 

> g := expand(`+`(`*`(`^`(`+`(sin(x), `-`(`*`(`^`(cos(x), 2)))), 2)), `*`(`^`(`+`(a, `-`(cos(x))), 2))))
`+`(`*`(`^`(cos(x), 4)), `-`(`*`(2, `*`(sin(x), `*`(`^`(cos(x), 2))))), `*`(`^`(cos(x), 2)), `-`(`*`(2, `*`(a, `*`(cos(x))))), `*`(`^`(a, 2)), `*`(`^`(sin(x), 2))) (7.8)
 

> sort(g, cos(x))
`+`(`*`(`^`(cos(x), 4)), `-`(`*`(2, `*`(sin(x), `*`(`^`(cos(x), 2))))), `*`(`^`(cos(x), 2)), `-`(`*`(2, `*`(a, `*`(cos(x))))), `*`(`^`(a, 2)), `*`(`^`(sin(x), 2))) (7.9)
 

> collect(g, cos(x))
`+`(`*`(`^`(cos(x), 4)), `*`(`+`(`-`(`*`(2, `*`(sin(x)))), 1), `*`(`^`(cos(x), 2))), `-`(`*`(2, `*`(a, `*`(cos(x))))), `*`(`^`(sin(x), 2)), `*`(`^`(a, 2))) (7.10)
 

O comando collect pode agrupar derivadas através da opção diff ou D 

> h := `+`(`*`(y, `*`(diff(f1(x), x))), `*`(x, `*`(diff(f1(x), x))))
`+`(`*`(y, `*`(diff(f1(x), x))), `*`(x, `*`(diff(f1(x), x)))) (7.11)
 

> collect(h, diff)
`*`(`+`(x, y), `*`(diff(f1(x), x))) (7.12)
 

Exercícios 

Refs. [1] R. Nicolaides e N. Walkington, Maple a Comprehensive Introduction, [2] Andre Heck, Introduction to Maple 

 

1. Simplifique 

 

`+`(ln(`+`(`*`(cos(y), `*`(sin(x))), `-`(`*`(cos(x), `*`(sin(y)))))), `-`(ln(`+`(`*`(cos(x), `*`(cos(y))), `-`(`*`(sin(x), `*`(sin(y)))))))) 

 

2. Expresse 

`/`(`*`(`+`(x, `*`(5, `*`(sqrt(x))), 6)), `*`(`+`(sqrt(x), 3))) 

como a soma de um inteiro e um radical. 

 

3. Mostre que 

`/`(`*`(`+`(`*`(`^`(cos(`+`(x, y)), 2)), `-`(`*`(`^`(cos(`+`(x, `-`(y))), 2))))), `*`(`+`(`*`(`^`(cos(`+`(x, y)), 2)), `*`(`^`(cos(`+`(x, `-`(y))), 2))))) = `+`(`-`(`/`(`*`(2, `*`(cos(x), `*`(cos(y), ... 

 

4. Ache a expansão em frações parciais de: 

(a) `/`(`*`(`+`(`*`(`^`(x, 2)), `*`(2, `*`(x)), `-`(1))), `*`(`+`(`*`(2, `*`(`^`(x, 3))), `*`(3, `*`(`^`(x, 2))), `-`(`*`(2, `*`(x)))))) 

 

(b)  `/`(1, `*`(`^`(`+`(`*`(`^`(x, 4)), 4), 2))) 

 

Você consegue simplificar a expressão de modo que ela volte ao formato original? 

 

5. Transforme 

`+`(`*`(`^`(x, 2)), `*`(2, `*`(x)), 1, `/`(1, `*`(`+`(`*`(`^`(x, 2)), `*`(2, `*`(x)), 1)))) 

em 

`/`(`*`(`+`(`*`(`^`(`+`(x, 1), 4)), 1)), `*`(`^`(`+`(x, 1), 2))) 

e vice-versa. 

 

6. Considere o polinômio `*`(`+`(`*`(`^`(x, 2)), `*`(x, `*`(y)), x, y), `*`(`+`(x, y))). Use o Maple para transformar em: 

(a)  `+`(`*`(`^`(x, 3)), `*`(2, `*`(`^`(x, 2), `*`(y))), `*`(x, `*`(`^`(y, 2))), `*`(`^`(x, 2)), `*`(2, `*`(x, `*`(y))), `*`(`^`(y, 2))) 

(b) `*`(`+`(x, 1), `*`(`^`(`+`(x, y), 2))) 

(c) `+`(`*`(`^`(y, 2)), `*`(`+`(`*`(`^`(y, 2)), `*`(2, `*`(y))), `*`(x)), `*`(`+`(1, `*`(2, `*`(y))), `*`(`^`(x, 2))), `*`(`^`(x, 3))) 

(d) `+`(`*`(`^`(x, 3)), `*`(`^`(x, 2)), `*`(`+`(`*`(2, `*`(`^`(x, 2))), `*`(2, `*`(x))), `*`(y)), `*`(`+`(x, 1), `*`(`^`(y, 2)))) 

 

7. Transforme `+`(`*`(`^`(`+`(x, y), 2)), `/`(1, `*`(`+`(x, y)))) em `/`(`*`(`+`(`*`(`^`(`+`(x, y), 3)), 1)), `*`(`+`(x, y))) e vice-versa. 

 

8. Considere o polinômio `*`(`+`(`*`(2, `*`(`^`(x, 2))), `-`(x)), `*`(`+`(`*`(2, `*`(`^`(x, 2))), x))). Use o Maple para transformar em: 

(a) `*`(`+`(`*`(4, `*`(`^`(x, 2))), `-`(1)), `*`(`^`(x, 2))) 

(b) `*`(`^`(x, 2), `*`(`+`(`*`(2, `*`(x)), `-`(1)), `*`(`+`(`*`(2, `*`(x)), 1)))) 

(c) `*`(`+`(`*`(2, `*`(`^`(x, 3))), `*`(`^`(x, 2))), `*`(`+`(`*`(2, `*`(x)), `-`(1)))) 

 

9. Considere a expressão racional `/`(`*`(`+`(`*`(`^`(x, 4)), `*`(`^`(x, 3)), `-`(`*`(4, `*`(`^`(x, 2)))), `-`(`*`(4, `*`(x))))), `*`(`+`(`*`(`^`(x, 4)), `*`(`^`(x, 3)), `-`(`*`(`^`(x, 2))), `-`(x)))). Transforme a expressão em 

(a) `/`(`*`(`+`(x, 2), `*`(`+`(x, 1), `*`(`+`(x, `-`(2))))), `*`(`+`(`*`(`^`(x, 3)), `*`(`^`(x, 2)), `-`(x), `-`(1)))) 

(b) `/`(`*`(`+`(`*`(`^`(x, 4)), `*`(`^`(x, 3)), `-`(`*`(4, `*`(`^`(x, 2)))), `-`(`*`(4, `*`(x))))), `*`(x, `*`(`+`(x, `-`(1)), `*`(`^`(`+`(x, 1), 2))))) 

(c) `/`(`*`(`+`(x, 2), `*`(`+`(x, `-`(2)))), `*`(`+`(x, `-`(1)), `*`(`+`(x, 1)))) 

(d) `+`(`/`(`*`(`^`(x, 2)), `*`(`+`(x, `-`(1)), `*`(`+`(x, 1)))), `-`(`/`(`*`(4), `*`(`+`(x, `-`(1)), `*`(`+`(x, 1)))))) 

 

 

10. Ache o resultado mais simples para a expressão   onde f(x) = `+`(ln(`+`(sqrt(`+`(`-`(`*`(`^`(x, 2))), 1)), 1)), `-`(ln(x)), `-`(sqrt(`+`(`-`(`*`(`^`(x, 2))), 1))))  para `and`(`<`(0, x), `<=`(x, 1)). 

 

>