curso6.mw

 

Capítulo 6  Cálculo Diferencial e Integral  

 

Funções Matemáticas e Derivada 

Esta seção é importante. O leitor deve ler cuidadosamente e, principalmente, entender a diferença entre expressão algébrica e função. Qualquer mau entendimento desta diferença provoca diversos problemas de difícil correção no uso de Maple. O leitor deve também entender a diferença entre "o nome de uma função" e "a expressão algébrica que define a função". 

Definindo uma Função e Calculando a Derivada 

O Maple tem uma grande variedade de funções definidas internamente, incluindo as funções trigonométricas, hiperbólicas, elíticas, hipergeométricas, de Bessel e muitas outras. A lista completa pode ser obtida através do help on line com o comando ? inifcn . Todos os comandos do Maple, como o comando de integração, de diferenciação, de limite, etc., estão aptos a reconhecer estas funções e fornecer o resultado esperado.  

 

Por maior que seja a lista das funções definidas internamente pelo Maple, um usuário necessita definir suas próprias funções, por exemplo, generalizando funções já existentes. Estas funções definidas pelo usuário serão incluidas na lista das funções do Maple no sentido de que elas também serão reconhecidas pelos comandos de diferenciação, integração, etc., como funções válidas, mas não serão reinicializadas automaticamente caso o usuário sai do Maple ou dê o comando restart. O usuário deve salvar a worksheet e processar os comandos para ativar a função. 

 

Para definir uma função no Maple usamos o operador seta (->), isto é, sinal de menos seguido do sinal de maior. Por exemplo, a função f(x) = `/`(`*`(`+`(`*`(`^`(x, 2)), `-`(1))), `*`(`+`(`*`(`^`(x, 2)), 1))) é definida da seguinte maneira. 

> restart

> f := proc (x) options operator, arrow; `/`(`*`(`+`(`*`(`^`(x, 2)), `-`(1))), `*`(`+`(`*`(`^`(x, 2)), 1))) end proc
proc (x) options operator, arrow; `/`(`*`(`+`(`*`(`^`(x, 2)), `-`(1))), `*`(`+`(`*`(`^`(x, 2)), 1))) end proc (1.1.1)
 

Podemos avaliar essa função em um ponto ou encontrar sua derivada com o comando diff . 

> f(1)
0 (1.1.2)
 

> simplify(diff(f(x), x))
`+`(`/`(`*`(4, `*`(x)), `*`(`^`(`+`(`*`(`^`(x, 2)), 1), 2)))) (1.1.3)
 

Também é possível definir uma função da forma 

> g := proc (x) options operator, arrow; `*`(`^`(x, 2)) end proc
proc (x) options operator, arrow; `*`(`^`(x, 2)) end proc (1.1.4)
 

desde que escolha function definition na janela que se abre após dar o comando acima. Porém, este método deve ser evitado. Por que? Porque é a maneira errada de definir funções no Maple. Evite! 

 

É importante distinguir uma função (tem variáveis) de uma expressão algébrica (não têm variáveis). Por exemplo, vamos definir  expressão algébrica: 

> expr := sin(`*`(a, `*`(x)))
sin(`*`(a, `*`(x))) (1.1.5)
 

No comando acima, sin(`*`(a, `*`(x))) é uma expressão que foi atribuida a variável expr. Não podemos considerar expr como uma função de x, pois não obteríamos o resultado desejado com o comando expr(Pi): 

> expr(Pi)
(sin(`*`(a, `*`(x))))(Pi) (1.1.6)
 

O resultado desejado era sin(`*`(a, `*`(Pi))).  Para obter o valor da função sin(`*`(a, `*`(x))) em x = Pi, temos que usar o comando subs ou algsubs : 

> algsubs(x = Pi, expr)
sin(`*`(a, `*`(Pi))) (1.1.7)
 

Para definir uma verdadeira função a partir uma expressão algébrica já nomeada, devemos usar o comando unapply (em vez do operador seta): 

> F := unapply(expr, x)
proc (x) options operator, arrow; sin(`*`(a, `*`(x))) end proc (1.1.8)
 

Neste caso especificamos que a expressão sin(`*`(a, `*`(x))) é uma função de x e a é um parâmetro. Até agora, o Maple não tinha condições de saber se queríamos uma função na variável x tendo a como parâmetro ou vice-versa. Vejamos o que ocorre com esta nova definição: 

> F(Pi)
sin(`*`(a, `*`(Pi))) (1.1.9)
 

> F(y)
sin(`*`(a, `*`(y))) (1.1.10)
 

> F(x)
sin(`*`(a, `*`(x))) (1.1.11)
 

 

ATENÇÃO: Não deixe espaço entre a função e o parêntese esquerdo. Por exemplo, "F  (a)" produz um resultado diferente de F(a). "F  (a)" quer dizer o produto de F por a. 

 

Assim podemos obter o valor da função em um ponto da forma F(ponto). Podemos dizer que  F é o nome da função proc (x) options operator, arrow; sin(`*`(a, `*`(x))) end proc. Vejamos: 

> eval(F)
proc (x) options operator, arrow; sin(`*`(a, `*`(x))) end proc (1.1.12)
 

Exitem alguns comandos no Maple que têm funções como argumento. Eles não aceitam uma expressão algébrica como argumento. Este é o caso do operador D, que só atua em funções dando como resultado outras funções (a derivada). Por exemplo: 

> D(F)
proc (x) options operator, arrow; `*`(cos(`*`(a, `*`(x))), `*`(a)) end proc (1.1.13)
 

O comando acima está com a sintaxe correta. O comando abaixo está com a sintaxe errada. 

> D(expr)
D(sin(`*`(a, `*`(x)))) (1.1.14)
 

D(sin(`*`(a, `*`(x)))) tem a sintaxe errada, pois o operador D está sendo aplicado a uma expressão. Vamos comparar com o operador diff. Este atua em expressões algébricas e também retorna uma expressão algébrica. Por exemplo: 

> diff(F(x), x)
`*`(cos(`*`(a, `*`(x))), `*`(a)) (1.1.15)
 

Outro comando perfeitamente válido: 

> diff(expr, x)
`*`(cos(`*`(a, `*`(x))), `*`(a)) (1.1.16)
 

A derivada segunda é obtida da seguinte forma 

> (`@@`(D, 2))(F)
proc (x) options operator, arrow; `+`(`-`(`*`(sin(`*`(a, `*`(x))), `*`(`^`(a, 2))))) end proc (1.1.17)
 

Note que os parênteses são obrigatórios.  Se os parênteses não forem colocados, obteremos 

> (`*`(`^`(D, 2)))(F)
`*`(`^`(proc (x) options operator, arrow; `*`(cos(`*`(a, `*`(x))), `*`(a)) end proc, 2)) (1.1.18)
 

que é equivalente a `*`(`^`(D(F), 2)), isto é, o quadrado de D(F). 

 

Vimos que a letra D é usada como operador diferencial. Todos os comandos do Maple estão protegidos contra atribuição. Por exemplo, o comando 

> D := 1

retorna um erro. Se o usuário faz questão absoluta de usar D como variável em alguma aplicação, o usuário pode usar o comando unprotect para liberar a proteção sobre D. O comando restart fará o operador D voltar a ser o que era. O usuário também pode proteger nomes através do comando protect . 

 

Como vimos acima, uma outra maneira de definir uma função é usar diretamente o operador seta (-> sinal de menos seguido do maior).  Por exemplo: 

Error, attempting to assign to `D` which is protected.  Try declaring `local D`; see ?protect for details.

> g := proc (x) options operator, arrow; `+`(`*`(`^`(x, 2)), 1) end proc
proc (x) options operator, arrow; `+`(`*`(`^`(x, 2)), 1) end proc (1.1.19)
 

> g(2)
5 (1.1.20)
 

Esta forma não é necessariamente equivalente ao comando unapply. 

 

ATENÇÃO: Quando usar o operador seta (->), a expressão da função deve ser dada explicitamente.  

 

Não devemos usar % dentro do operador seta. Veja a seguinte sequência de comandos problemática. 

> `*`(`^`(x, 2))
`*`(`^`(x, 2)) (1.1.21)
 

> f := proc (x) options operator, arrow; `+`(%, 1) end proc
proc (x) options operator, arrow; `+`(%, 1) end proc (1.1.22)
 

> f(2)
`+`(, 1) (1.1.23)
 

O problema ocorreu porque o operador seta não avalia a expressão colocada no lado direito. O objetivo era definir a função porém o resultado foi catastrófico. Neste caso precisamos usar o comando unapply :  

> `*`(`^`(x, 2))

> f := unapply(`+`(%, 1), x)
 

(1.1.24)
 

> f(2)
5 (1.1.25)
 

Exceção a esta regra é o uso de label da expressão. Por exemplo 

> f := proc (x) options operator, arrow; `+`(`*`(`^`(x, 2)), 1) end proc
proc (x) options operator, arrow; `+`(`*`(`^`(x, 2)), 1) end proc (1.1.26)
 

> f(2)
5 (1.1.27)
 

Para colocar um label em uma expressão, o usuário deve clicar no INSERIR ou INSERT, clicar em LABEL (gerando um nova janela), e digitar no número do label (com os pontos) no espaço apropriado na janela. Se houver alguma mudança no número de expressões anteriores à linha do label, o número do label é atualizado automaticamente. 

 

É preciso entender que existem alguns comandos no Maple que não avaliam os operandos antes da execução. A maioria dos comandos avaliam os operandos, porém isto também pode ser um problema.  Vamos ver um exemplo. Vamos contruir a função que soma o MDC com o MMC de dois números. Por exemplo, o MDC de 25 e 15  é 5 e o MMC é 75, de forma que a função deve retornar 80. Confirmando no Maple: 

> `+`(gcd(25, 15), lcm(25, 15))
80 (1.1.28)
 

Vamos construir duas versões, a primeira usando o comando unapply e a segunda usando o operador seta: 

> F1 := unapply(`+`(gcd(n1, n2), lcm(n1, n2)), n1, n2); -1

> F2 := proc (n1, n2) options operator, arrow; `+`(gcd(n1, n2), lcm(n1, n2)) end proc; -1

> F1(25, 15)
376 (1.1.29)
 

> F2(25, 15)
80 (1.1.30)
 

Obtivemos o resultado errado com F1. A função foi definida de maneira incorreta e o motivo foi que o comando unapply avaliou os seus argumentos antes de criar a função.  A avaliação de `+`(gcd(n1, n2), lcm(n1, n2)) é `+`(`*`(n1, `*`(n2)), 1), como podemos verificar: 

> `+`(gcd(n1, n2), lcm(n1, n2))
`+`(`*`(n1, `*`(n2)), 1) (1.1.31)
 

De fato: 

> eval(F1)
proc (n1, n2) options operator, arrow; `+`(`*`(n1, `*`(n2)), 1) end proc (1.1.32)
 

A maneira correta de definir esta função usando o comando unapply é: 

> F1 := unapply('`+`(gcd(n1, n2), lcm(n1, n2))', n1, n2)
proc (n1, n2) options operator, arrow; `+`(gcd(n1, n2), lcm(n1, n2)) end proc (1.1.33)
 

> F1(25, 15)
80 (1.1.34)
 

A versão com o operador seta não sofre deste problema, pois seus argumentos não são avaliados. 

> eval(F2)
proc (n1, n2) options operator, arrow; `+`(gcd(n1, n2), lcm(n1, n2)) end proc (1.1.35)
 

Derivada Parcial 

A derivada parcial também é calculada com o comando diff . Por exemplo, vamos definir uma função de duas variáveis e calcular a derivada parcial em relação ao segundo argumento. 

> f := proc (x, y) options operator, arrow; sin(`+`(`*`(2, `*`(x)), `*`(`^`(y, 3)))) end proc
proc (x, y) options operator, arrow; sin(`+`(`*`(2, `*`(x)), `*`(`^`(y, 3)))) end proc (1.2.1)
 

> diff(f(x, y), y)
`+`(`*`(3, `*`(cos(`+`(`*`(`^`(y, 3)), `*`(2, `*`(x)))), `*`(`^`(y, 2))))) (1.2.2)
 

Através do operador D podemos calcular a "função derivada parcial". 

> D[2](f)
proc (x, y) options operator, arrow; `+`(`*`(3, `*`(cos(`+`(`*`(2, `*`(x)), `*`(`^`(y, 3)))), `*`(`^`(y, 2))))) end proc (1.2.3)
 

Note que quando aplicamos o operador D à uma função de duas ou mais variáveis temos que especificar a posição da variável. A derivada parcial de segunda ordem em relação a segunda variável é 

> D[2, 2](f)
proc (x, y) options operator, arrow; `+`(`-`(`*`(9, `*`(sin(`+`(`*`(2, `*`(x)), `*`(`^`(y, 3)))), `*`(`^`(y, 4))))), `*`(6, `*`(cos(`+`(`*`(2, `*`(x)), `*`(`^`(y, 3)))), `*`(y)))) end proc (1.2.4)
 

 

A derivada mista é 

Para obter a expressão diff(f(x, y), y, x) devemos usar a forma 

> D[1, 2](f)

> (D[1, 2](f))(x, y)
`+`(`-`(`*`(6, `*`(sin(`+`(`*`(`^`(y, 3)), `*`(2, `*`(x)))), `*`(`^`(y, 2)))))) (1.2.5)
 

Usando o operador D, é possível calcular diretamente a derivada em um ponto, por exemplo 

> (D[1, 2](f))(0, 0)
0 (1.2.6)
 

Isto não é possível de ser feito como o comando diff. 

Funções Anônimas 

Diversos comandos do Maple usam funções como argumento e muitas vezes é mais econômico usar uma função anônima. Vejamos alguns exemplos. Suponha que temos uma lista com 20 números aleatórios menores ou iguais a 10: 

> L := [seq((rand(1 .. 10))(i), i = 1 .. 20)]
[7, 10, 6, 2, 4, 6, 5, 1, 8, 5, 10, 2, 2, 4, 8, 3, 9, 10, 2, 8] (1.3.1)
 

Queremos selecionar os números são menores que 5. 

> select(proc (x) options operator, arrow; `<`(x, 5) end proc, L)
[2, 4, 1, 2, 2, 4, 3, 2] (1.3.2)
 

Usamos a função booleana anônima proc (x) options operator, arrow; `<`(x, 5) end proc como primeiro operando do comando select . O segundo operando deve ser uma estrutura de dados, cujos elementos queremos selecionar. A saída é uma estrutura de dados do mesmo tipo com os elementos que satisfazem à função booleana. Lembre, o primeiro argumento deve ser uma função booleana (retorna false ou true). 

 

A função anônima pode ter duas variáveis. Por exemplo, para associar elementos de duas listas, podemos usar o comando zip :  

> L1, L2 := [1, 2, 3], [4, 5, 6]
[1, 2, 3], [4, 5, 6] (1.3.3)
 

> zip(proc (x, y) options operator, arrow; [x, y] end proc, L1, L2)
[[1, 4], [2, 5], [3, 6]] (1.3.4)
 

O primeiro operando do comando zip deve ser uma função de duas variáveis. A primeira variável assume valores em L1 (segundo operando) e a segunda variável assume valores em L2 (terceiro operando). O comando zip também pode ser usado com vetores e matrizes, porém não deve ser usado com conjuntos. 

Álgebra e Composição de Funções (@ e @@) 

Podemos somar, multiplicar e compor duas ou mais funções. Por exemplo, se temos uma equação e queremos subtrair o lado direito do lado esquerdo podemos usar a soma das funções lhs e rhs: 

> equacao := `+`(`*`(2, `*`(x, `*`(y))), x, `-`(1)) = `+`(`*`(2, `*`(x)), `-`(5))
`+`(`*`(2, `*`(x, `*`(y))), x, `-`(1)) = `+`(`*`(2, `*`(x)), `-`(5)) (1.4.1)
 

> (`+`(lhs, `-`(rhs)))(equacao)
`+`(`*`(2, `*`(x, `*`(y))), `-`(x), 4) (1.4.2)
 

O último comando é equivalente a 

> `+`(lhs(equacao), `-`(rhs(equacao)))
`+`(`*`(2, `*`(x, `*`(y))), `-`(x), 4) (1.4.3)
 

porém tem um sentido diferente. No primeiro caso, fizemos uma subtração de funções antes de aplicar ao argumento. No segundo caso fizemos uma subtração usual de expressões algébricas. 

 

Vejamos outros exemplos. Vamos elevar a função seno ao quadrado e depois aplicá-lo ao ponto Pi. 

> `*`(`^`(sin(`+`(`*`(`/`(1, 4), `*`(Pi)))), 2))
`/`(1, 2) (1.4.4)
 

Vejamos agora como fazer composição de funções dentro das álgebra de funções. 

> (`@`(g1, g2))(x)
g1(g2(x)) (1.4.5)
 

> (`+`(`@`(g3, g3), `-`(`@@`(g3, 2))))(x)
0 (1.4.6)
 

O símbolo @ é o operador de composição de funções enquanto que F@@n quer dizer F@F@F... n vezes. Isso explica porque o último resultado é zero. O primeiro resultado, por sua vez, deu o que é esperado, pois composição de funcões é equivalente a aplicação sucessivas das funções. Vejamos outros exemplos:  

> F := proc (x) options operator, arrow; `^`(a, x) end proc
proc (x) options operator, arrow; `^`(a, x) end proc (1.4.7)
 

> (`@@`(F, 5))(x)
`^`(a, `^`(a, `^`(a, `^`(a, `^`(a, x))))) (1.4.8)
 

> G := proc (x) options operator, arrow; `/`(1, `*`(`+`(1, x))) end proc
proc (x) options operator, arrow; `/`(1, `*`(`+`(1, x))) end proc (1.4.9)
 

> (`@@`(G, 4))(x)
`/`(1, `*`(`+`(1, `/`(1, `*`(`+`(1, `/`(1, `*`(`+`(1, `/`(1, `*`(`+`(1, x)))))))))))) (1.4.10)
 

> evalf(subs(x = 1, %))
.6250000000 (1.4.11)
 

> evalf((`@@`(G, 100))(1))
.6180339887 (1.4.12)
 

Se o operador @@ for usado com um número negativo, o Maple entende que a função inversa deve ser usada: 

> (`@@`(cos, -1))(0) = arccos(0)
`+`(`*`(`/`(1, 2), `*`(Pi))) = `+`(`*`(`/`(1, 2), `*`(Pi))) (1.4.13)
 

Exercício 

Defina a função f(x) = exp(`+`(`*`(5, `*`(x)))) usando o operador seta. Calcule a segunda derivada no ponto 0 usando o operador D. Calcule a segunda derivada usando o comando diff e substitua o valor de x por 0. Os resultados são iguais? 

Integral 

A  integral indefinida de uma expressão pode ser obtida com o comando int , por exemplo 

> Int(`/`(`*`(x), `*`(`+`(`*`(`^`(x, 3)), 1))), x)
Int(`/`(`*`(x), `*`(`+`(`*`(`^`(x, 3)), 1))), x) (2.1)
 

> res := value(%)
`+`(`*`(`/`(1, 6), `*`(ln(`+`(`*`(`^`(x, 2)), `-`(x), 1)))), `*`(`/`(1, 3), `*`(`^`(3, `/`(1, 2)), `*`(arctan(`+`(`*`(`/`(1, 3), `*`(`+`(`*`(2, `*`(x)), `-`(1)), `*`(`^`(3, `/`(1, 2)))))))))), `-`(`*`... (2.2)
 

Podemos confirmar o resultado da seguinte forma: 

> normal(diff(res, x), expanded)
`/`(`*`(x), `*`(`+`(`*`(`^`(x, 3)), 1))) (2.3)
 

 

Na integral definida, os limites de integração devem ser especificados da seguinte forma: 

> int(`/`(1, `*`(`^`(x, 2))), x = -1 .. 1)
infinity (2.4)
 

Podemos ver que o Maple reconhece que há uma descontinuidade na função `/`(1, `*`(`^`(x, 2))) dentro dos limites de integração e calcula corretamente a integral. 

 

O método usado para calcular uma integral definida é exato. Para realizar uma integração numérica aproximada, usamos a opção numeric: 

> int(`*`(exp(`+`(`-`(`*`(2, `*`(t))))), `*`(t, `*`(ln(t)))), t = 0 .. infinity, numeric)
-0.6759071137e-1 (2.5)
 

Outra forma é usar a forma inerte do comando int e depois evalf (veja evalf/int ).  

> Int(`*`(exp(`+`(`-`(`*`(2, `*`(t))))), `*`(t, `*`(ln(t)))), t = 0 .. infinity)
Int(`*`(exp(`+`(`-`(`*`(2, `*`(t))))), `*`(t, `*`(ln(t)))), t = 0 .. infinity) (2.6)
 

> evalf(%)
-0.6759071137e-1 (2.7)
 

Integrais múltiplas podem ser calculadas com um único comando int usando a seguinte sintaxe: 

> int(f(x, y), [x = a .. b, y = c .. d])
int(int(f(x, y), x = a .. b), y = c .. d) (2.8)
 

 

Diversos comando para manipulação com integrais podem ser encontrados no pacote IntegrationTools : 

> with(IntegrationTools)
[Change, CollapseNested, Combine, Expand, ExpandMultiple, Flip, GetIntegrand, GetOptions, GetParts, GetRange, GetVariable, Parts, Split, StripOptions]
[Change, CollapseNested, Combine, Expand, ExpandMultiple, Flip, GetIntegrand, GetOptions, GetParts, GetRange, GetVariable, Parts, Split, StripOptions]
(2.9)
 

Por exemplo, para divider o intervalo de integração: 

> expr := Int(`/`(1, `*`(sqrt(abs(x)))), x = -1 .. 1)
 

Int(`/`(1, `*`(`^`(abs(x), `/`(1, 2)))), x = -1 .. 1)
4 (2.10)
 

> Split(expr, 0)
`+`(Int(`/`(1, `*`(`^`(abs(x), `/`(1, 2)))), x = -1 .. 0), Int(`/`(1, `*`(`^`(abs(x), `/`(1, 2)))), x = 0 .. 1)) (2.11)
 

Séries 

O comando para expandir em séries é series. Por exemplo 

> series(exp(x), x)
series(`+`(1, x, `*`(`/`(1, 2), `*`(`^`(x, 2))), `*`(`/`(1, 6), `*`(`^`(x, 3))), `*`(`/`(1, 24), `*`(`^`(x, 4))), `*`(`/`(1, 120), `*`(`^`(x, 5))))O(`^`(x, 6)),x,6) (3.1)
 

O primeiro operando deve ser a expressão a ser expandida, o segundo é a variável, e o terceiro controla a ordem da expansão: 

> series(exp(x), x, 10)
series(`+`(1, x, `*`(`/`(1, 2), `*`(`^`(x, 2))), `*`(`/`(1, 6), `*`(`^`(x, 3))), `*`(`/`(1, 24), `*`(`^`(x, 4))), `*`(`/`(1, 120), `*`(`^`(x, 5))), `*`(`/`(1, 720), `*`(`^`(x, 6))), `*`(`/`(1, 5040), ... (3.2)
 

Se o terceiro argumento estiver ausente, o Maple usa o valor da variável global Order , que por default é 6. O resultado do comando series é uma estrutura especial que deve ser manipulada pelo próprio comando series. Por exemplo 

> coseno := series(cos(x), x)
series(`+`(1, `-`(`*`(`/`(1, 2), `*`(`^`(x, 2)))), `*`(`/`(1, 24), `*`(`^`(x, 4))))O(`^`(x, 6)),x,6) (3.3)
 

> seno := series(sin(x), x)
series(`+`(x, `-`(`*`(`/`(1, 6), `*`(`^`(x, 3)))), `*`(`/`(1, 120), `*`(`^`(x, 5))))O(`^`(x, 7)),x,7) (3.4)
 

O comando expand nada pode fazer com essas expressões. 

> expand(`+`(`*`(`^`(coseno, 2)), `*`(`^`(seno, 2))))
`+`(`*`(`^`(series(`+`(1, `-`(`*`(`/`(1, 2), `*`(`^`(x, 2)))), `*`(`/`(1, 24), `*`(`^`(x, 4))))O(`^`(x, 6)),x,6), 2)), `*`(`^`(series(`+`(x, `-`(`*`(`/`(1, 6), `*`(`^`(x, 3)))), `*`(`/`(1, 120), `*`(`... (3.5)
 

A forma correta é usar o próprio comando series. 

> series(`+`(`*`(`^`(coseno, 2)), `*`(`^`(seno, 2))), x)
series(`+`(1)O(`^`(x, 6)),x,6) (3.6)
 

`*`(Outro, `*`(caminho, `*`(poss\EDvel, `*`(\E9, `*`(transformar, `*`(as, `*`(express\F5es, `*`(em, `*`(polin\F4mios, `*`(da, `*`(seguinte, `*`(forma)))))))))))) 

> convert(coseno, polynom)
`+`(1, `-`(`*`(`/`(1, 2), `*`(`^`(x, 2)))), `*`(`/`(1, 24), `*`(`^`(x, 4)))) (3.7)
 

Note que o term O(`*`(`^`(x, 6))) foi eliminado. Agora os termos de ordem 6 ou superior não serão eliminados quando essa expressão for manipulada a menos que voltemos a usar o comando series. A série de Taylor para funções de várias variáveis é obtida com o comando mtaylor. 

> mtaylor(sin(`+`(`*`(`^`(x, 2)), `*`(`^`(y, 2)))), [x, y], 8)
`+`(`*`(`^`(x, 2)), `*`(`^`(y, 2)), `-`(`*`(`/`(1, 6), `*`(`^`(x, 6)))), `-`(`*`(`/`(1, 2), `*`(`^`(y, 2), `*`(`^`(x, 4))))), `-`(`*`(`/`(1, 2), `*`(`^`(y, 4), `*`(`^`(x, 2))))), `-`(`*`(`/`(1, 6), `*... (3.8)
 

Nesse caso o resultado já é do tipo polinomial. 

Séries de Fourier e Transformadas 

A série de Fourier de uma função f(x) é definida como 

 

f(x) = `+`(`*`(`/`(1, 2), `*`(a[0])), Sum(`+`(`*`(a[n], `*`(cos(`*`(n, `*`(x))))), `*`(b[n], `*`(sin(`*`(n, `*`(x)))))), n = 1 .. infinity))  

onde  

 

a[n] = `/`(`*`(int(`*`(f(x), `*`(cos(`*`(n, `*`(x))))), x = `+`(`-`(Pi)) .. Pi)), `*`(Pi)) 

  

b[n] = `/`(`*`(int(`*`(f(x), `*`(sin(`*`(n, `*`(x))))), x = `+`(`-`(Pi)) .. Pi)), `*`(Pi)) 

  

O Maple não tem nenhum comando pré-definido para calcular séries de Fourier. Um programa para esse fim, baseado nas fórmulas acima, é 

Os comandos proc, local e return são comandos especiais para procedimentos. O comando proc começa um bloco que se fecha no comando end proc. O comando local define variáveis locais ao procedimento de forma a não interferir com as variáveis de mesmo nome utilizadas pelo usuário. Finalmente, o comando return retorna o valor do procedimento. Vejamos um exemplo. 

> FourierSeries := proc (expr, x) local a0, a, b, n, k; assume(n, integer); a0 := normal(`/`(`*`(int(expr, x = `+`(`-`(Pi)) .. Pi)), `*`(Pi))); a := normal(`/`(`*`(int(`*`(expr, `*`(cos(`*`(n, `*`(x))))...
FourierSeries := proc (expr, x) local a0, a, b, n, k; assume(n, integer); a0 := normal(`/`(`*`(int(expr, x = `+`(`-`(Pi)) .. Pi)), `*`(Pi))); a := normal(`/`(`*`(int(`*`(expr, `*`(cos(`*`(n, `*`(x))))...
FourierSeries := proc (expr, x) local a0, a, b, n, k; assume(n, integer); a0 := normal(`/`(`*`(int(expr, x = `+`(`-`(Pi)) .. Pi)), `*`(Pi))); a := normal(`/`(`*`(int(`*`(expr, `*`(cos(`*`(n, `*`(x))))...
FourierSeries := proc (expr, x) local a0, a, b, n, k; assume(n, integer); a0 := normal(`/`(`*`(int(expr, x = `+`(`-`(Pi)) .. Pi)), `*`(Pi))); a := normal(`/`(`*`(int(`*`(expr, `*`(cos(`*`(n, `*`(x))))...
FourierSeries := proc (expr, x) local a0, a, b, n, k; assume(n, integer); a0 := normal(`/`(`*`(int(expr, x = `+`(`-`(Pi)) .. Pi)), `*`(Pi))); a := normal(`/`(`*`(int(`*`(expr, `*`(cos(`*`(n, `*`(x))))...
FourierSeries := proc (expr, x) local a0, a, b, n, k; assume(n, integer); a0 := normal(`/`(`*`(int(expr, x = `+`(`-`(Pi)) .. Pi)), `*`(Pi))); a := normal(`/`(`*`(int(`*`(expr, `*`(cos(`*`(n, `*`(x))))...
FourierSeries := proc (expr, x) local a0, a, b, n, k; assume(n, integer); a0 := normal(`/`(`*`(int(expr, x = `+`(`-`(Pi)) .. Pi)), `*`(Pi))); a := normal(`/`(`*`(int(`*`(expr, `*`(cos(`*`(n, `*`(x))))...
FourierSeries := proc (expr, x) local a0, a, b, n, k; assume(n, integer); a0 := normal(`/`(`*`(int(expr, x = `+`(`-`(Pi)) .. Pi)), `*`(Pi))); a := normal(`/`(`*`(int(`*`(expr, `*`(cos(`*`(n, `*`(x))))...

> res := FourierSeries(`*`(`^`(x, 2)), x)
`+`(`*`(`/`(1, 3), `*`(`^`(Pi, 2))), Sum(`+`(`/`(`*`(4, `*`(`^`(-1, k), `*`(cos(`*`(k, `*`(x)))))), `*`(`^`(k, 2)))), k = 1 .. infinity)) (4.1)
 

> plot(subs(infinity = 10000, res), x = 0 .. Pi)
Plot_2d
 

 

As transformadas de funções são calculada após carregar o pacote inttrans (integral transforms). 

> with(inttrans)
[addtable, fourier, fouriercos, fouriersin, hankel, hilbert, invfourier, invhilbert, invlaplace, invmellin, laplace, mellin, savetable] (4.2)
 

Por exemplo, a transformada de Laplace de f(t) = sin(`*`(k, `*`(t))) é 

> laplace(sin(`*`(k, `*`(t))), t, s)
`/`(`*`(k), `*`(`+`(`*`(`^`(k, 2)), `*`(`^`(s, 2))))) (4.3)
 

e a transformada inversa é 

> simplify(invlaplace(%, s, t))
sin(`*`(k, `*`(t))) (4.4)
 

Exercícios 

1. Defina a função f(x) = `+`(`*`(`^`(x, 2)), `-`(x), 1) e seja x[0] = 2. Defina a reta tangente a f(x) que passa pelo ponto x[0], f(x[0]). Faça o gráfico simultâneo de f(x) e da reta tangente no intervalo [1, 3] onde f(x) tem cor vermelha e a reta tem cor azul. [Sugestão: o coeficiente angular da reta pode ser obtido através da derivada de f(x).] 

 

2. Defina a função f(x) = `+`(`*`(3, `*`(`^`(x, 4))), `-`(`*`(2, `*`(`^`(x, 3)))), `-`(`*`(12, `*`(`^`(x, 2)))), `*`(12, `*`(x)), `-`(1)) e encontre os pontos críticos e seus respectivos valores. Faça o gráfico no intervalo x = -2.5 .. 2.5 e verifique o resultado. 

 

3. Ache os pontos de inflexão da função g(x) = `+`(`*`(`^`(x, 4)), `-`(`*`(12, `*`(`^`(x, 2)))), `-`(`*`(12, `*`(x))), 6). Faça o gráfico de g(x) no domínio x = -3.5 .. 4.5 junto com as retas que passam pelos pontos de inflexão, exibindo o eixo vertical limitado pelo intervalo -60 .. 40. 

 

4. Defina uma função f de duas variáveis ímpares a,b que retorna um número aleatório ímpar entre a e b inclusive. [sugestão: use os comandos floor e rand ] 

 

5. Defina uma função ndiff que tem três variáveis: a primeira é uma expressão algébrica expr, a segunda é símbolo x e a terceira é um número inteiro positivo n. A função ndiff(expr, x, n) calcula a n-ésima derivada de expr em relação a x. Por exemplo, ndiff(`*`(`^`(x, 10)), x, 3) deve resultar em `+`(`*`(720, `*`(`^`(x, 7)))). 

 

6. a) Suponha que o preço de uma ação seja dada por `+`(`*`(`^`(x, 3)), `-`(`*`(3, `*`(`^`(x, 2)))), `*`(2, `*`(x)), 1), para `and`(`<`(0, t), `<`(t, 2)) onde t é o instante de tempo em horas a partir da abertura da bolsa. Qual é a melhor hora de comprar estas ações e qual é a melhor hora de vender?
b) Suponha que o preço de uma ação seja dada por `+`(`*`(`^`(t, 2)), `*`(50, `*`(t, `*`(exp(`+`(`-`(t)))))), .25), para `and`(`<`(0, t), `<`(t, 3.5)) onde t é o instante de tempo em horas a partir da abertura da bolsa. Qual é a melhor hora de comprar estas ações e qual é a melhor hora de vender?
 

 

 

 

 

>