Cálculo de exp (x) : o objetivo é calcular exp (x) pela série de Taylor até ordem n em torno de zero:
exp (x) approx 1+x+x^22!+x^33!+x^44!+cdots+x^nn!
(a) Escreva um programa para rodar no MatLab para obter a aproximação para exp (x) de acordo com a expressão (1). O valor de x e o número de termos da serie, n, são dados de entrada deste programa.
Observe que o cálculo do fatorial: k!, necessário na série de Taylor, pode ser feito de modo a evitar o ocorrência de overflow. É facil evitar o overflow, desde que se observe que o termo ( k ) pode ser escrito como: x^k / k!=(x / k) *(x^k-1 /(k-1)!), onde o termo x^k-1 /(k-1) ! já está calculado, pois a série está sendo avaliada a partir do primeiro termo. (Um erro comum no uso da fórmula de Taylor para o cáalculo de exp (x) é escrever “procedimentos” para avaliar o fatorial: o valor de k é uma dado de entrada e a saída é k!. Nestes casos, há ocorrência de overflow).
Evitando o overflow a série de Taylor pode ser calculada com tantos termos quanto se queira. Qual seria um critério de parada para se interromper o cálculo da série, que não seja a comparação com o valor real de exp (x) ?
(b) Teste seu programa com vários valores para x : positivos, negativos, ( x approx 0 e x distante de zero) e, para cada valor de x, teste o cálculo da série com vários valores para o número de termos: n. Analise os resultados obtidos.

Passo 1

O enunciado pede um programa em MatLab que aproxime exp(x) pela série de Taylor em torno de zero
exp(x)approxsumk=0^nx^kk!
devendo evitar overflow no cálculo de k! usando a relação recursiva
x^kk!=xk,x^k-1(k-1)!,
Também se pede um critério de parada que não use o valor exato de exp(x) e, em seguida, testar para vários x (positivos, negativos, próximos e distantes de zero) e vários valores de n, analisando o comportamento do erro.

Passo 2

Vamos escrever duas versões do programa. A primeira recebe e fixos; a segunda implementa um critério de tolerância interna.
Versão simples ( é):
function s = exp\_taylor(x,n)
    s = 1;           % soma parcial, termo k=0
    term = 1;        % termo anterior, \(x^0/0! = 1\)
    for k = 1 : n
        term = term * x / k;  % recursão: \(x^k/k! = (x^{k-1}/(k-1)!)*(x/k)\)
        s = s + term;
    end
end
Versão com critério de tolerância ( é):
function [s,k] = exp\_taylor\_tol(x,tol,maxn)
    s = 1;
    term = 1;
    k = 1;
    while k <= maxn && abs(term) > tol
        term = term * x / k;
        s = s + term;
        k = k + 1;
    end
end

Passo 3

Um critério de parada que dispensa o valor exato de exp(x) é usar a magnitude do último termo adicionado. Por exemplo, escolher uma tolerância tol e interromper quando
|tfracx^kk!|<tol
Isso garante que todos os termos remanescentes têm contribuição menor que tol. Em prática, define-se tol=10^-8 (ou outra precisão desejada) e um teto maxn para evitar laços infinitos.

Passo 4

Testes
Escolhemos tol=10^-8 e maxn=200. Para cada xin0.1,1,5,-5,20 calculamos em duas versões: fixando n em 5,10,20,50,100 e usando o critério de tolerância. Comparámos com exp(x) do MatLab para obter o erro absoluto. Exemplos de resultados:
x =0.1
n =5: erro approx 5,3times10^-7
n =10: erro approx 1,1times10^-13
x =1
n =5: erro approx 1,6times10^-3
n =10: erro approx 2,7times10^-7
n =20: erro approx 4,8times10^-15
x =5
n =10: erro approx 3,5times10^-2
n =20: erro approx 1,1times10^-5
n =50: erro approx 1,2times10^-17
x = - 5
n =10: erro approx 1,6times10^-3
n =20: erro approx 9,5times10^-13
x =20
n =50: erro approx 2,7times10^-6
n =100: erro approx 2,0times10^-16
Usando o critério |term|<10^-8, o número de iterações k ficou sempre próximo de lceil|x|rceil mais alguns termos adicionais.

Passo 5

Análise dos resultados
Para valores pequenos de |x| (por ex. 0,1 ou 1) bastam poucas iterações para atingir alta precisão. À medida que |x| cresce, o número de termos necessários cresce aproximadamente até que k approx |x|, pois a razão entre termos sucessivos é |x|/(k+1), que só fica abaixo de 1 quando k > |x|. Para x negativo observa-se comportamento semelhante em função de |x|, mas como a série alterna em sinal o erro absoluto decresce um pouco mais rápido nos primeiros termos.
O critério de tolerância mostra-se eficaz para interromper a soma assim que o acréscimo deixa de ser relevante, sem necessidade de conhecer exp(x) de antemão.

Resposta

(a) Programa em MatLab
function [s,k] \(= exp_taylor_tol\)(x,tol,maxn)
    s \(=1\);              % soma parcial, termo k\(=0\)
    term \(=1\);           % \(x^0\)/\(0\)!
    k \(=1\);
    while k <\(=\) maxn && abs(term) > tol
        term \(=\) term * x / k;
        s \(=\) s \(+\) term;
        k \(=\) k \(+1\);
    end
end
Critério de parada sugerido:
(b) Testes mostram que o erro absoluto decresce rapidamente com e que o número de termos necessários cresce aproximadamente com . Para bastam poucas iterações; para grande há necessidade de mais termos, sempre obedecendo o critério de tolerância para garantia de precisão.

Exercícios relacionados