Cálculo usando MatLab

Resumo da matéria de cálculo com o uso do MATLAB - Antonio Sérgio Nogueira
A derivada aproximada
1)Função diferenciável
Uma função f é diferenciável se em cada ponto do domínio o gráfico graf(f) tiver
uma reta tangente. A reta tangente no ponto (a, f(a)) tem um coeficiente angular m e nós
diremos que f′(a) = m. A função derivada, f′ é uma outra função que descreve as
derivadas de f e portanto as taxas de variação instantâneas de f. No Cálculo dizemos que
a derivada define a reta tangente ao gráfico.
Figura de tangente e 3 secantes.
Se f representar a parte da equação e a o ponto onde temos a tangente, então
derivada de f é f'(a) no ponto (a,f(a)).
Como podemos ver na figura temos uma tangente e 3 secantes, as secantes são
aproximações da tangente. Como temos 3 secantes podemos dizer que o coeficiente
angular de uma das secantes é:
m= f(a+h)-f(a)
(a+h) – a
Quanto mais próximo estiver (a+h) de a mas preciso será o valor do coeficiente
angular da secante, relativamente ao desejado coeficiente angular da tangente.

Considere a figura abaixo, que representa o gráfico de uma função y = f(x), definida
num intervalo de números reais.
Observando a figura, podemos definir o seguinte quociente, denominado razão
incremental da função
y = f(x), quando x varia de x0 para x0 + ∆x0 :
Define-se a derivada da função y = f(x) no ponto x = x0, como sendo o limite da
razão incremental acima, quando x0 tende a zero, e é representada por f ' (x0) , ou seja:
Nota: a derivada de uma função y = f(x), pode ser representada também pelos símbolos y'
ou dy/dx.
Guarde então a seguinte conclusão importante:
A derivada de uma função y = f(x) num ponto x = x0 , coincide numericamente com
o valor da tangente trigonométrica do ângulo formado pela tangente geométrica à curva
representativa de y = f(x), no ponto x = x0.
Voltando a figura 1 dizemos:
f' (a)=f(a+h) – f(a) x=a e x1=a+h
(a+h) – a

f'(x)= f(x1)-f(x)
h
y(x1)=f(x1), f'(x)=y'(x), f(x)=y(x)
y(x1)-y(x)= h* f'(x)

2)Interpolação polinomial
Interpolar uma função f(x) consiste em aproximar essa função por uma outra
função g(x), escolhida entre uma classe de funções definida a priori e que satisfaça
algumas propriedades. A função g(x) é então usada em substituição à função f(x). A
necessidade de se efetuar esta substituição surge em várias situações, como por
exemplo:
a.)quando são conhecidos somente os valores numéricos da função para um conjunto de
pontos e é necessário calcular o valor da função em um ponto não tabelado;
b.)quando a função em estudo tem uma expressão tal que operações como a
diferenciação e a integração são difíceis (ou mesmo impossíveis) de serem realizadas.
Denomina-se interpolação polinomial o processo matemático de interpolação em
que a função interpoladora é um polinômio. A função interpoladora é a função
Definidos um intervalo e uma função denomina-se
interpolação o processo matemático de avaliar substituindo-se a
função pela função interpoladora de modo que
( ). Assim, é a função real, definida em da qual conhecem-se os
valores nos pontos de abcissas ( ).
Consideremos um conjunto de pontos (designados nós de interpolação)
x0 , ... , xn , a que estão associados os valores de uma função f0 , ... , fn,
respectivamente.
Pretendemos encontrar um polinômio p tal que
p ( xi ) = fi
para i = 0, ..., n.
O polinómio de 3º grau interpola a função em 4 pontos
Escrevendo p( x ) = a0 + a1 x + ... + am xm, obtemos o sistema

a0 + a1 x0 + ... + am x0m = f0
...
a0 + a1 xn + ... + am xnm = fn
Exemplo: Dados os pontos (x0, f(x0)), (x1, f(x1)), ..., (xn, f(xn)), portanto (n + 1) pontos,
queremos aproximar f(x) por um polinômio pn(x), de grau menor ou igual a n, tal que:
f(xk) = pn(xk) k = 0, 1, 2, ..., n
Surgem aqui as perguntas: existe sempre um polinômio pn(x) que satisfaça estas
condições? Caso exista, ele é único?
Representaremos pn(x) por: pn(x) = a0 + a1x + a2x2 + ... + anxn.
Portanto, obter pn(x) significa obter os coeficientes a0, a1, ..., an.
Da condição pn(xk) = f(xk), " k = 0, 1, 2, ..., n, montamos o seguinte sistema linear:
com n + 1 equações e n + 1 variáveis: a0, a1, ..., an.
A matriz A dos coeficientes é
que é uma matriz de Vandermonde e, portanto, desde que x0, x1, ..., xn sejam pontos
distintos, temos det (A) ≠ 0 e, então, o sistema linear admite solução única.
Demonstramos assim o seguinte teorema:
Existência e unicidade do Polinômio Interpolador
Existe um único polinômio pn(x), de grau £ n, tal que: pn(xk) = f(xk), k = 0, 1, 2,...,
n, desde que xk ≠ xj, j ≠ k.

Exercício: Dado x=[0 1 2 3] e y=[-5 -6 -1 16]. Calcular o polinômio interpolador e o valor
de x=1.5. Desenhe o gráfico da função e o pontos.
Solução MatLab:
%Interpolação
x=[0 1 2 3];
x=x'; % transformando em matriz coluna
y=[-5 -6 -1 16];
y=y' %transformando em matriz coluna
% polinômio interpolador p(x)=ao+a1*x+a2*x^2+a3*x^3
% A*p=y
A= [ 1 x(1) x(1)^2 x(1)^3;
1 x(2) x(2)^2 x(3)^3;
1 x(3) x(3)^2 x(3)^3;
1 x(4) x(4)^2 x(4)^3];
% calcula p através da matriz inversa
p=inv(A)*y;
disp(p); %mostra valores de a0,...,an do polinômio
%entre o valor a ser interposto
interp=input('Digite o valor:');
resultado=p(1)+p(2)*interp+p(3)*interp^2+p(4)*interp^3;
disp(resultado); %mostra resultado
%definindo uma matriz de valores a serem calculados
xx=0:0.01:4;
res=p(1)+p(2)*xx+p(3)*xx.^2+p(4)*xx.^3;
plot(x,y,'r+',xx,res,'-');
Resultado: Digite o valor:1.5
-5.5000

Exercício 2: resolução Vandermonde
clc
clear
%Interpolação
x=[0 1 2 3];
% transformando em matriz coluna
y=[-5 -6 -1 16];
y=y' %transformando em matriz coluna
% polinômio interpolador p(x)=ao+a1*x+a2*x^2+a3*x^3
% A*p=y
A=vander(x) %calcula matriz
p=inv(A)*y
%definindo uma matriz de valores a serem calculados
xx=0:0.01:4;
res=p(4)+p(3)*xx+p(2)*xx.^2+p(1)*xx.^3;
plot(x,y,'r+',xx,res,'-');
Resposta:p =
1.0000
0.0000
-2.0000
-5.0000

Exercício 3: Dados os valores x=[00
450
600
900
] y=[1 √2/2 ½ 0] Calcular o Valor de 350
usando interpolação.
Vamos transformar graus em radianos: x=[0 π/4 π/3 π/2]
Solução MatLab:
%interpolacao cosseno
clc
clear
y=[ 1 sqrt(2)/2 1/2 0];
y=y';
x=[ 0 pi/4 pi/3 pi/2];
A=[1 x(1) x(1)^2 x(1)^3;
1 x(2) x(2)^2 x(2)^3;
1 x(3) x(3)^2 x(3)^3;
1 x(4) x(4)^2 x(4)^3];
p=inv(A)*y;
%interpolação de valor
valor=input('Leia valor em graus a ser interpolado:');
valor=valor/180*pi;
resnum=p(1)+p(2)*valor+p(3)*valor.^2+p(4)*valor.^3;
%interpolacao de varios valores
xx=0:0.1:pi/2;
res=p(1)+p(2)*xx+p(3)*xx.^2+p(4)*xx.^3;
plot(xx,res,'-',xx,cos(xx),'r.',valor,resnum,'+b');

Lagrange Interpolação
Dado um conjunto de k+1 pontos:
com todos xj distintos, o polinômio de interpolação de um conjunto de pontos na forma de
Lagrange é a combinação linear dos polinômios da base de Lagrange:
,
com polinômios da base de Lagrange dados por:
p(x)=y0 L0(x)+y1 L1(x)+........+yn Ln(x)

Note que: L1(x1)=1 …., Ln(xn)=1 e que Lo(xn) onde n≠0 Lo=0 ….
Exercício: Dado Ө= [0 45 60 90] e y=[1 √2 /2 1/2 0] . Obter a aproximação de 35o
por
Lagrange.
Resolução:
Transformando Ө em radianos temos: Ө=[0 pi/4 pi/3 pi/2]=[0 0,79 1,05 1,57]
35o
= pi*35/180=0,611 → x=?
L1(x)=(x-x2) (x-x3) (x-x4)
(x1-x2)(x1-x3)(x1-x4)
L2(x)=(x-x1) (x-x3) (x-x4)
(x2-x1)(x2-x3)(x2-x4)
L3(x)=(x-x1) (x-x2) (x-x4)
(x3-x1)(x3-x2)(x3-x4)
L4(x)=(x-x1) (x-x2) (x-x3)
(x4-x1)(x4-x2)(x4-x3)
p(0,611)=1*L1+√2 /2*L2+1/2*L3+0*L4
Solução no MatLab:
%Lagrange interpolação
clear
clc

%Lagrange interpolação
v=pi/3
x=[0 pi/4 pi/3 pi/2]
y=[1 sqrt(2)/2 1/2 0]
L(1)=((v-x(2))*(v-x(3))*(v-x(4)))/((x(1)-x(2))*(x(1)-x(3))*(x(1)-x(4)));
L(2)=((v-x(1))*(v-x(3))*(v-x(4)))/((x(2)-x(1))*(x(2)-x(3))*(x(2)-x(4)));
L(3)=((v-x(1))*(v-x(2))*(v-x(4)))/((x(3)-x(1))*(x(3)-x(2))*(x(3)-x(4)));
L(4)=((v-x(1))*(v-x(2))*(v-x(3)))/((x(4)-x(1))*(x(4)-x(2))*(x(4)-x(3)));
L
valor=y(1)*L(1)+y(2)*L(2)+y(3)*L(3)+y(3)*L(4)

3. Integração Numérica
Seja f uma função contínua no intervalo [a, b] da qual se conhece a
primitiva F. O valor da integral definida de f pode ser calculada usando a fórmula de
Newton-Leibniz:
Método dos trapézios
2
Exemplo: f(x)=ex
Calcular :
Devemos obter um vetor e usar a forma do trapézio.
Solução MatLab:

%integral de f(x)=exp(x.^2)
x=0:0.05:0.5;
y=exp(x.^2);
h=0.05;
soma=0;
for i=1:length(x)-1
soma= s+h/2(y(i)+y(i+1);
end
disp(['Valor integral:' num2str(soma));
Exercício MatLab – integral de um triângulo
clear
%calcular a integral de um triangulo
xx=0:0.005:5;
plot(xx,xx,'-');
hold
plot(xx,xx,'r*');
h=0.005;
s=0;
for y=1:length(xx)-1;
s=s+(xx(y)+(xx(y+1)))*h*0.5;
end
disp(s);
>> integral
Current plot released
12.5000
Exercício: Maior valor em módulo dos elementos de uma matriz

%maior valor módulo matriz 5x5
clear
maior=0;
for x=1:2;
for y=1:2;
A(x,y)=input(['Leia matriz a(' num2str(x) ',' num2str(y) '):']);
if (abs(maior)<= abs(A(x,y)))
maior=A(x,y);
i=x;
j=y;
end
end
end
disp(A);
disp(['Maior:' num2str(maior)]);
disp(['x=' num2str(i) ' y=' num2str(j)]);
Exercício: Preencher a diagonal de uma matriz com 5 e as 2 secundárias com 2 e 1.
%ex05.m
%preeencher matriz 10x10 com a diag principal c 5 e diag sec com 2
n=10;
M=zeros(n,n);
for i=1:n
for j=1:n
if i==j
M(i,j)=5;
end
if i+1==j | i-1==j
M(i,j)=2;
end
end
end
M
Exercício: Troca elementos da matriz
%troca os elementos da matriz
M=[1 2 3 4;
1 2 3 4;
1 2 3 4;
1 2 3 4];
M
A=M(1:2,1:2);
M(1:2,1:2)= M(3:4,3:4);
M(3:4,3:4)= A;
M

4.Equações Lineares: Com a notação de matriz, um sistema de várias equações lineares
simultâneas pode ser escrito como:
Ax=b
A – matriz quadrada de ordem n
b – vetor coluna com n componentes
x – é a coluna de componentes desconhecidos
A solução de Ax=b pode ser escrita como x=inv(A)*b. Esta solução é pouco utilizada pois
produz resultados menos precisos.
MatLab tem o operador Backslash que calcula a inversa de uma matriz.
Ax=b
x=Ab;
Resolver:
x1+3x2=5
2x1+4x2=6
Solução MatLab:
A=[1 3;
2 4]
b=[5; 6];
x=inv(A)*b;
x
Saída: x= [-1; 2]

5) Método da Eliminação de Gauss
A idéia central do Método da Eliminação de Gauss, é a de transformar em
triangular um sistema que não o seja, permitindo, assim, sua solução.
Para tanto, o método contem duas fases:
1. triangularização do sistema original, chamada de “forward”.
2. resolução propriamente dita, da última variável para a primeira, chamada de
“backward”.
Na primeira fase, é preciso eliminar a variável x1 da segunda, terceira, ... até a última
equação, só ficando na primeira; em seguida elimina-se x2 da terceira, quarta, ... só
ficando nas duas primeiras; elimina-se a variável x3 da quarta em diante, só ficando nas
três primeiras etc...
Ao final dessa fase, o sistema estará triangularizado.
Na segunda fase resolve-se de trás para a frente, calculando-se a última, a penúltima,...
até a primeira variável, a exemplo do que foi feito acima.
Exercício MatLab
%preeencher matriz 10x10 com a diag principal c/ 5 e diag sec. com 2
n=10;
M=zeros(n,n);
for i=1:n
for j=1:n
if i==j
M(i,j)=5;
end
if i+1==j | i-1==j
M(i,j)=2;
end
end
end
M
for j=2:n
af=-M(j,j-1)/M(j-1,j-1);
M(j,:)=M(j,:)+M(j-1,:)*af;
end
M
* Programa elimina a matriz secundária inferior.

Exercício MatLab
%matriz de gauss generica se a diagonal principal for diferente de zero
clear
n=3
A=zeros(n,n);
for i=1:n
for j=1:n
if i==j
A(i,j)=5;
end
if ((i+1)==j)| ((i-1)==j)
A(i,j)=2;
end
if ((i+2)==j)| ((i-2)==j)
A(i,j)=1;
end
end
end
A
for j=2:n
for k=j:n
af=-A(k,j-1)/A(j-1,j-1);
A(k,:)=A(k,:)+af*A(j-1,:);
end
end
A
* gera matriz triangular superior
Resultado:
n =
3
A =
5 2 1
2 5 2
1 2 5
A =
5.0000 2.0000 1.0000
0 4.2000 1.6000
0 0 4.1905

Exercício de Solução de sistema linear incorporando a matriz y
%gauss genercioincorporandomatriz b
n=3;
M=zeros(n,n);
B=zeros(1,n);
for i=1:n
for j=1:n
M(i,j)=input ('Leia valores da matriz:');
end
end
for i=1:n
B(i)= input('Valores de B:')
end
%transformando em matriz coluna
B=B';
MM=M;
M(:,n+1)=B
M
for i=2:n
for j=i:n
af=-M(j,i-1)/M(i-1,i-1);
M(j,:)=M(j,:)+af*M(i-1,:)
end
end
x(n)=M(n,n+1)/M(n,n)
for k=n-1:-1:1
sum=0;
for j = k+1: n;
sum=sum+M(k,j)*x(j);
end
x(k)=(M(k,n+1)-sum)/M(k,k);
end
M
x
%verificando o resultado
MM*x'
Solução:
M =

5.0000 2.0000 1.0000 1.0000
0 4.2000 1.6000 1.6000
0 0 4.1905 2.1905
x = 0.0227 0.1818 0.5227
Exercício de solução de equações lineares com pivoteamento.
%calculando sistema de eq lineares por gauss
clc
n=3
M=[0 1 5;
10 -1 1;
1 -6 2];
b=[1; 19; -4];
%calcular usando matriz inversa
y=inv(M)*b
%fazer o pivotamento e calcular matriz triang superior
%anexar vetor b a M
M(:,n+1)=b
for j=1:n-1;
maior=abs(M(j,j));
posicao=1;
for i=j+1:n;
if abs(M(i,j))>maior
maior=abs(M(i,j));
posicao=i;
end
end
piv=M(j,:);
M(j,:)=M(posicao,:);
M(posicao,:)=piv;
for k=j+1:n
af=-M(k,j )/M(j,j);
M(k,:)=M(k,:)+af*M(j,:)
end
end
x(n)=M(n,n+1)/M(n,n);
for k=n-1:-1:1
sum=0;
for i=n:-1:k+1
sum=sum+M(k,i)*x(i);
sum
x(k)=(M(k,n+1)-sum)/M(k,i-1)
end
end
x

6) Solução de sistemas retangulares
Resolver sistemas retangulares significa achar a melhor solução.
x1+x2=1
x1-x2= -1
2x1-x2=1
x1+3x2=-1
-4x1+5x2
A solução do sistema se obtem da seguinte forma:
t t
A * A * x = A * b
Solução MatLab
%Achar a melhor solucao de um sistema retangular
clc
A=[1 1;
1 -1;
2 -1;
1 3;
-4 5];
b=[1 -1 1 -1 1];
b=b';
%construcao do sistema normal
B=A'*A
bb=A'*b
%solucao
x=inv(B)*bb

%calculo dos residuos r=Ax-b
r=A*x-b
%este é o menor residuo em termos da soma
%dos quadrados somaq=r1^2+r2^2+r3^2+r4^2+r5^2
soma=0;
for x=1:5
soma=soma+r(x)^2;
end
soma
A*[0;0]-b
● Esta solução minimiza os resíduos de r=Ax+b
● soma=r1^2+r2^2+r3^2+r4^5+r^5^2
● Método dos mínimos quadrados
7)Métodos dos mínimos quadrados para ajustamento de curvas
O Método dos Mínimos Quadrados, ou Mínimos Quadrados Ordinários
(MQO) ou OLS (do inglês Ordinary Least Squares) é uma técnica de otimização
matemática que procura encontrar o melhor ajuste para um conjunto de dados tentando
minimizar a soma dos quadrados das diferenças entre o valor estimado e os dados
observados (tais diferenças são chamadas resíduos).
X | x1 x2 x3 x4
Y | y1 y2 y3 y4
Y(xi)=Y=ax+b

ri= yi-Y(xi)= yi-axi-b → reta no ponto
n 2
min= ∑ (ri)
i=1
Toda vez que eu tiver 2 parâmetros eu consigo fazer a regressão linear.
b
Ex: y(x)=a*x
b
log y = log a x = log a + b log x
Y = B + A X
Y é a reta ajustada aos pontos logx e log y.

8) Método da bisseção
Este método pode ser usado para encontrar as raízes de uma função f(x)
contínua com x pertencente aos reais definida num intervalo [a,b], tendo f(a) e f(b) sinais
opostos, ou seja, f(a).f(b)≤0. Como f(a) e f(b) têm sinais opostos e f(x) é contínua, pelo
teorema do valor intermediário podemos afirmar que existe uma raiz neste intervalo [a,b].
Vamos considerar também que esta raiz seja a única no intervalo.
Algoritmo
e=precisao
faca
x=(a1+b1)/2
se f(x)*f(a)<0
b=x
else
a=x
fim
ate que precisao seja obtida

9)Algoritmo de Newton
Em análise numérica, o método de Newton (ou método de
Newton-Raphson) tem o objetivo de estimar as raízes de uma função. Para isso, toma-se
um ponto qualquer do domínio da função, calcula-se a equação da tangente (derivada) da
função nesse ponto, calcula-se o intersecção da tangente ao eixo das abcissas a fim de
encontrar um novo ponto do domínio da função e repete-se o processo, que deve tender a
uma das raízes da função rapidamente, ou não tender a nada, deixando isso claro logo.
Em notação matemática representa-se desta forma:
,
onde n indica a n-ésima iteração do algoritmo e é a derivada da função f em xn.
Para que se obtenha sucesso na iteração deve-se primeiramente delimitar um intervalo, a
fim de escolher um valor estimado inicial adequado, para que a convergência de (xn) seja
propícia. Para tanto existem apenas quatro condições a serem satisfeitas:
● O intervalo delimitado deve conter a raiz de f;
● A função f deve ser diferenciável em todo o intervalo;
● A primeira derivada no intervalo não deve trocar de sinal;
● A segunda derivada no intervalo não deve trocar de sinal.
Exercício MatLab
clc
clear
%newton1 f(x)=25*x^2+8x-58
%f'(x)=50*x+8
n=10 %numero de iterações
x(1)=input('Valor inicial de x:');

for k=2:n
x(k)=x(k-1)- ((25*x(k-1)^2+8*x(k-1)-58)/(50*x(k-1)+8))
end
xx=-10:0.1:10
yy=25*xx.^2+8*xx-58
plot(xx,yy,'-')
y=25*x(n)^2+8*x(n)-58
hold on
plot(x(n),y,'+r')

9)Método iterativo de Jacobi para solução de sistemas lineares
O método de Jacobi trata-se de um algoritmo para determinar a solução
de um sistema de equações lineares com os maiores valores absolutos em cada linha e
coluna dominados pelo elemento da sua diagonal. Trata-se duma versão simplificada do
algoritmo de valores próprios de Jacobi. O método tem o nome do matemático Alemão
Carl Gustav Jakob Jacobi, é um método clássico que data do final do século XVIII.
Técnicas iterativas são raramente utilizadas para solucionar sistemas lineares de
pequenas dimensões, já que o tempo requerido para obter um mínimo de precisão
ultrapassa o requerido pelas técnicas diretas como a eliminação gaussiana. Contudo,
para sistemas grandes, com grande porcentagem de entradas de zero, essa técnicas são
eficientes em termo de cálculo como de armazenamento. Sistemas desse tipo
frequentemente surgem na análise de circuitos e na solução numérica de problemas de
valor de limite e equações diferenciais parciais.
Dado o sistema de equações lineares:
Ax=b
Podemos decompor este sistema em matriz diagonal + matriz resto:
Dx+Rx=b
Dx=b-Rx

Dados as equações lineares, calcular as raízes pelo método iterativo de Jacobi
Solução MatLab
%método de jacobi
A=[10 -1 1;
1 -6 2;
0 1 5];
b=[19; -4; 1];
x=[0; 0; 0];
n=length(b);
for k=1:5
for i=1:n
s=0;
for ind=1:i-1
s=s+A(i,ind)*x(ind);
end
for ind=i+1:n
s=s+A(i,ind)*x(ind);
end
x(i)=(b(i)-s)/A(i,i);
end
x
end
x

10) Método de Euler
O método de Euler é um procedimento numérico para aproximar a
solução da equação diferencial y0 = f(t, y) que satisfaz a condição inicial y(t0) = y0.
Sabemos que o gráfico da solução passa pelo ponto (t0, y0) com inclinaçãoao igual
a y0(t0) (ou seja, com inclinação igual f(t0, y0)). Isto serve de ponto de partida para achar
uma aproximação da solução.
Começando pelo ponto (t0, y0), podemos seguir na direção dada pela inclinação.
Usando um pequeno passo h, seguimos ao longo da reta tangente até chegar ao ponto
(t1, y1), onde, t1 = t0 + h e y1 = y0 + h f(t0, y0) .
Tomando (t1, y1) como novo ponto de partida, pode-se repetir o processo e obter
um segundo ponto (t2, y2), onde t2 = t1 + h e y2 = y1 + h f(t1, y1) .
O método de Euler consiste na repetição deste processo e gera a sucessão de
pontos tn+1 = tn + h e yn+1 = yn + h f(tn, yn) , n = 0, 1, 2, . . .
y(x)=y(a)+(x-a)*f'(a)
y(x+h)=y(x)+h* f'(x) – Método de EULER explícito
Método de Euler implícito:
y(x+h)=y(x)+h*f'(x+h)

2x
Exemplo: y=e
{ y'=2y e y(0)=1
Vamos calcular até x=1 passo h=0.1
MatLab
clc
clear
%método de Euler explícito
%dado: y(x)=2e^2x calcular
%y'(x)=2*y(x) y(0)=1
% y(x+1)=y(x)+h*f'(x)
y(1)=1;
h=0.1;
xx=0:h:1;
n=length(xx);
for i=2:n
y(i)=y(i-1)+h*2*y(i-1);
end
z=exp(2*xx);
plot(xx,z,'-',xx,y,'or')

Exercício dado em aula
%exercicio de aula
e=0.01
A=[5 1 0 0;
1 5 1 0;
0 1 5 1;
0 0 1 5];
b=[ 0 1 4 -4];
v=[0 0 0 0];
v=v';
r=A*v+b';
n=50;
for k=1:n
tm=(r'*r)/((A*r)'*r)
va=v
v=v-(tm*r)
r=r-tm*A*r
if norm(r)<e | norm(v-va)/norm(v)<e
break
end
end
v
Exercícios Finais
1) Fale sobre o comando de repetição e dê exemplos.
O comando de repetição é usado quando queremos repetir alguma parte
do algoritmo, temos comando do tipo “for” em que podemos determinar o número de
execuções e comando do tipo “while” onde a execução continua até que uma condição
seja satisfeita.
Ex: for x=1:10
---------<comandos>
end
2)Fale sobre comando de desvio. Se temos 4 casos ou possibilidades, como
implementar?
A implementação de 4 possibilidades pode ser feita através de comandos
if aninhados.
Ex:
%O comando de desvio normalmente é utilizado na tomada de decisão e a

%implementação pode ser feita através de comandos if aninhados.
x=input('Leia x:');
if x==0
disp (x);
elseif x==1
disp(x);
elseif x==02
disp(x);
elseif x==3
disp(x);
else
disp('Maior');
end
3) Dados 3 vetores um com 5, outro com 15 e outro com 10 componentes. Trocar no de
15 os 5 centrais e no de 10 os 5 últimos.
clear
clc
x=[4 3 2 1 0];
y=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14];
z=[0 1 2 3 4 5 6 7 8 9 10];
y1=[y(1):y(5)]
y2=[y(11):y(15)]
y=[y1 x y2]
z1=[z(1):z(5)]
z=[z1 x]
4) Dados um vetor de 13 elementos, com valores inteiros de 10 a 90. Verificar quantos
elementos estão entre 10 e 30, 31 e 60 e entre 61 e 90.
x=[23 10 34 45 60 90 34 65 56 78 80 61 15]
s1=0
s2=0
s3=0
for i=1:length(x)
if x(i)>=10 & x(i)<=30
s1=s1+1;
end
if x(i)>=31 & x(i)<=60
s2=s2+1;
end
if x(i)>=61 & x(i)<=90
s3=s3+1;
end
end
% s1 entre 10 e 30

s1
% s2 entre 31 e 60
s2
% s3 entre 61 e 90
s3
5) Dado um número entre 5 e 95 verificar se ele é primo.
%número primo
x=input('Leia x:')
primo=0
for i=1:x % ou for i=1:round(sqrt(x))
if mod(x,i)==0
primo=primo+1
end
end
primo
if primo>2
disp('Nao eh primo');
else
disp('Eh primo');
end
6)Dados os valores
2
Obter a ∫ dx por trapézio.
-2
int = 0;
% primeiro intervalo
h=2;
f1=0;
f2=-4;
int1=(f2-f1)*h/2
% segundo intervalo
h=1;
f1=0;
f2=-1;

int2=(f2-f1)*h/2
% terceiro intervalo
h=1;
f1=-1;
f2=4;
int3=(f2-f1)*h/2
int= int1+int2+int3
7) Interpolar y sobre x com os dados anteriores.
%interpolar
x=[-2 0 1 2];
y=[-4 0 -1 4];
A=[1 x(1) x(1)^2 x(1)^3;
1 x(2) x(2)^2 x(2)^3;
1 x(3) x(3)^2 x(3)^3;
1 x(4) x(4)^2 x(4)^3];
p=inv(A)*y'
h=0.1
xx=-2:h:2
int=0;
for i=2:length(xx)
f(i-1)=p(1)+p(2)*xx(i-1)+p(3)*xx(i)^2+p(4)*xx(i-1)^3;
f(i)=p(1)+p(2)*xx(i)+p(3)*xx(i)^2+p(4)*xx(i)^3;
int=int+h/2*abs((f(i)+f(i-1)));
end
plot(xx,f)
int

8) Faça uma função círculo(x,y,r) para traçar uma circunferência. Dados: centro x, y e raio
r.
%circunferencia centro x,y raio r
function c(x,y,r)
z=0:0.1:2*pi;
j=r*cos(z)+x;
k=r*sin(z)+y;
plot(j,k,'-',x,y,'o')
end
9. Implemente um algoritmo de eliminação para zerar a diagonal inferior de uma matriz de
10x10.

% algoritmo
M= zeros(10,10);
n=10;
for i=1:n
for j=1:n
if i==j
M(i,j)=4;
end
if i+1==j | i-1==j
M(i,j)=1;
end
end
end
M
for i=2:n
for j=i:n
af=-(M(j,i-1)/M(i-1,i-1));
M(j,:)=M(j,:)+af*M(i-1,:)
end
end
M

10) Implementar o algoritmo, para v(0)
e Є dados.
%exercicio 10
n=50
k=50 %estabelecemos um valor de K
v=[1; 1; 1; 1; 1] %adotamos um valor de vo
e=0.01; % estabelecemos a margem de erro
A=[4 1 0 1 0;
1 1 1 0 1;
0 1 4 1 0;
0 0 1 4 1;
0 1 0 1 4]
b=[ 1 -1 0 -1 1]'
ro=A*vo+b
p=-ro
q1=(ro'*ro)/ ((A*ro)'*ro)
v=v+q1*p
r1=ro+q1*A*p
for k=2:3
alpha=(r1'*r1)/(ro'*ro);
p=-ro+alpha*p
q=(r1'*r1)/((A*p2)'*p2);
v2=v1+(q*p2);
r2=r1+(q*A*p2);
if ((norm(v2-v1))/norm(v2))<e
break
end
%atualiza valores anteriores
r0=r1;
r1=r2;
v1=v2;
disp(norm(v2-v1)/norm(v2));
end

Cálculo usando MatLab

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Cálculo usando MatLab

Similar to Cálculo usando MatLab (20)

More from antonio sérgio nogueira

More from antonio sérgio nogueira (20)

Recently uploaded

Recently uploaded (20)

Cálculo usando MatLab