Analisando seu programa

Ver Todos os Exercícios

Teoria

Introdução

Olá, galerinha linda! Diga-me: você alguma vez na vida já planejou uma viagem, tipo um mochilão?

Um mochilão que vai durar umas duas semanas, em que você vai visitar várias cidades. Nestes mochilões, temos que programar tudo direitinho para aproveitar o máximo possível. Montar itinerário, reservar hostels, comprar passagens, etc. Por isso, normalmente a gente monta um esquema na nossa cabeça e fica repassando para ver se não esquecemos nada e termos uma viagem incrível!

Em programação, depurar ou debugar um código é um processo parecido. Debugamos um programa para encontrar erros, seja de sintaxe, digitação ou até lógica de programação mesmo, e os corrigirmos.

O MATLAB tem um debugger que ajuda muito neste processo, principalmente quando o código fica muito longo. É o debugger do MATLAB que vamos conhecer nesta aula =)

Criando breakpoints

Para vermos como usa o debugger do MATLAB, vamos direto para um exemplo. Crie um novo script no MATLAB e escreva o código abaixo. Vamos lá, eu te espero.

Pronto? O programa acima pede para o MATLAB criar um vetor r com n   =   50 elementos. Os elementos de r são números aleatórios, entre 0 e 1 . Em seguida, calcula-se a média dos elementos de r (linha 4), que é armazenada na variável m e d i a .

Nas linhas 4 e 5, são criados dois vetores para gerarmos o gráfico com os números randômicos: m , que é um vetor que contém 50 elementos iguais a m e d i a ; e x , que vai de 0 a n de um em um e servirá como o eixo x do nosso gráfico. Aparentemente está tudo certo, né?

Vamos rodar a função:

Vixe, deu errado. O MATLAB nos informa que tem um erro na linha 7 do programa, onde usamos a função p l o t .

“Ué”, você deve estar pensando, “mas não tem nada de errado com a linha 7 do código. E agora?”.

Repare que o MATLAB nos diz que o erro está relacionado ao tamanho dos vetores. Por isso, temos que ver o que está acontecendo antes da linha 7 do código, para ver de onde está vindo este problema com o comprimento dos vetores.

Para ver o que está acontecendo antes da linha 7, vamos usar um recurso chamado breakpoint.

Breakpoints são pontos no arquivo onde a execução do programa para temporariamente, para a gente avaliar o que vem antes deste ponto.

Criamos breakpoints no MATLAB na janela do Editor, naquela barra cinza à esquerda do código. Para criar um breakpoint, basta clicar nessa barra à esquerda, na linha onde você quer que o programa pare de rodar. No nosso exemplo, queremos ver o que acontece antes da linha 7, por isso vamos criar um breakpoint na linha 5:

O breakpoint é a bolinha vermelha à esquerda da linha com o código x   =   0 : n .

Se mandamos rodar o programa, com a presença de pelo menos um breakpoint, o MATLAB entra no modo debugger e para de executar o programa na linha do breakpoint. A parada da execução é indicada por uma flechinha verde:

Neste momento, a execução está em “stand-by” e podemos verificar as variáveis acima da linha 5.

Verificando valores das variáveis

No modo debugger do MATLAB, podemos ver o que cada variável contém colocando o cursor do mouse em cima dela. Por exemplo, para conhecer o valor de m e d i a , colocamos o cursor sobre ela e aparece um retângulo amarelo com seu tamanho, o tipo da variável e seu valor:

Já sabemos que nosso problema está no comprimento dos vetores. Vamos então dar uma checada neles fazendo o mesmo procedimento. Primeiro, vamos ver o vetor r parando o cursor em cima da variável:

Ali diz que ele é um vetor 50   ×   1 .

Agora vamos ver o vetor m :

Temos que o tamanho de m é 1   ×   50 .

Resta ver o valor de x . Como meu breakpoint está exatamente na linha que define x , o vetor x ainda não foi criado. Para criarmos ele, devemos executar a linha 5. Para isso, você pode clicar no botão “Step” no campo DEBUG acima do editor ou apertar F10.

Ao fazermos isso, a flechinha verde se desloca para baixo, indicando que a linha 5 foi executada:

Vamos ver as informações do vetor x :

Xiiiiiiii, olha o tamanho dele: 1   ×   51 . Isso quer dizer que ele tem um elemento a mais do que r e m , por isso que nosso plot tá dando errado. Temos que reduzir o comprimento dele para o nosso programa rodar direito.

Antes de corrigirmos nosso código, vamos interromper o debugger. Clique no botão vermelho escrito “Quit Debugging” ou use o atalho Shift + F5.

Agora, vamos mudar a linha 5 para:

Indicamos ao MATLAB que queremos que o vetor x comece em 1 e não em 0 . Desta forma, x terá 50 elementos e não mais 51 . Você pode verificar mandando debugar de novo.

Antes de rodarmos o código de novo para vermos se dá certo, vamos deletar o breakpoint. Você pode apagá-lo clicando nele ou usado o atalho F12:

Hora da verdade! Bora rodar o programa! Com a alteração que fizemos, não temos mais o erro de comprimento de vetores e geramos este lindo gráfico:

Prontinho! Agora você conhece o básico do debugger do MATLAB. Conhecendo esses comandos básicos, já dá pra se virar bastante. Não esqueça de fazer os exercícios que preparei com muito carinho, para fixar o conteúdo ;D

Verificando valores das variáveis

Exercícios Resolvidos

Exercício Resolvido #1

O código abaixo cria um vetor que contém a raiz cúbica de todos os elementos de A .

Descubra por que o programa não funciona, usando o MATLAB.

Passo 1

Este exercício pede que identifiquemos os erros do programa do enunciado, usando o MATLAB. Devemos copiar o programa em um novo script e rodá-lo algumas vezes, até que não apareçam mais mensagens de erro.

Passo 2

Crie um script novo no MATLAB e copie nele o programa do enunciado.

Antes de rodarmos o programa, vamos ver o que cada linha de código faz, para ajudar a identificar eventuais erros:

Na primeira linha, temos o comando c l e a r   a l l . Este comando limpa o Workspace do MATLAB cada vez que o programa é rodado. Como procuramos erros no código e teremos que rodá-lo várias vezes para ver se corrigimos alguma coisa e encontrar mais erros, é importante limpar o Workspace a cada tentativa.

Na segunda linha, o comando c l c limpa o Command Window do MATLAB cada vez que o programa é executado. Novamente, como vamos rodar o código diversas vezes, é importante limpar o Command Window a cada tentativa, para ficar mais fácil de ver qual erro foi corrigido e qual é o erro a ser corrigido na sequência, caso exista.

Na linha 4, criamos um vetor chamado A de 5 elementos.

Na linha 5, pegamos o vetor A e elevamos a 1 / 3 , para calcular a raiz cúbica de cada um dos seus elementos. O resultado dessa operação é armazenado em um vetor chamado r a i z _ c u b i c a , que contém a raiz cúbica de cada elemento de A .

Passo 3

Agora que sabemos o que cada linha faz, vamos rodar nosso programa pela primeira vez.

Apareceu o seguinte erro no Command Window:

O MATLAB avisou que tem um erro na linha 5, dizendo que o operador ^ só aceita como entrada um número escalar ou uma matriz quadrada. Isto quer dizer que o problema está em A ^ ( 1 / 3 ) .

Passo 4

O MATLAB só consegue elevar a uma potência matrizes quadradas ou números escalares. A é um vetor 1 × 5 . Além disso, não queremos elevar o vetor A a 1 / 3 (ou seja, calcular a raiz cúbica de A ), mas sim cada elemento de A . Para fazermos isto, coloque um ponto ao lado de A na linha 5:

Rode o programa novamente para ver se o programa foi corrigido. Dessa vez, nenhuma mensagem de erro deve aparecer. Para dar aquela conferida final, imprima no Command Window os vetores A e r a i z _ c u b i c a , para ver se realmente cada elemento de r a i z _ c u b i c a é a raiz cúbica do elemento de A que se encontra na mesma posição:

Tcharam! Descobrimos o problema do programa e o corrigimos ;D

Resposta

Ei, a resposta está no passo a passo :)

Exercício Resolvido #2

Copie o programa abaixo em um script do MATLAB:

Descubra porque o programa não funciona, usando o debugger do MATLAB.

Passo 1

Este exercício pede que identifiquemos os erros do programa do enunciado, usando o debugger do MATLAB. Devemos copiar o programa em um novo script e rodá-lo algumas vezes, até que não apareçam mais mensagens de erro.

Passo 2

Crie um script novo no MATLAB e copie nele o programa do enunciado.

Antes de rodarmos o programa e procurarmos eventuais erros, vamos ver o que cada linha significa:

Na primeira linha, temos o comando c l e a r   a l l . Este comando limpa o Workspace do MATLAB cada vez que o programa é rodado. Como procuramos erros no código e teremos que rodá-lo várias vezes para ver se corrigimos alguma coisa, é importante limpar o Workspace a cada tentativa.

Na segunda linha, o comando c l c limpa o Command Window do MATLAB cada vez que o programa é executado. Novamente, como vamos rodar o código diversas vezes, é importante limpar o Command Window a cada tentativa, para ficar mais fácil de ver qual erro foi corrigido e qual é o erro a ser corrigido na sequência, caso exista.

Na linha 4, criamos uma variável chamada m a x X que armazena o número 9. Em seguida, criamos o vetor X , que vai de 1 a m a x X , com um passo igual a 2.

Na linha 6, criamos o vetor Y , que inicia em 10 e termina em 1, com um passo de -1.

Finalmente, na linha 7, somamos os vetores X e Y e armazenamos o resultado no vetor Z .

Agora que sabemos o que cada linha faz, vamos rodar nosso programa pela primeira vez.

Ooops, apareceu o seguinte erro no Command Window:

Temos um erro na linha em que os vetores X e Y são somados (no meu script, o comando Z = X + Y ficou na linha 7, pode ser que no seu script ele esteja em uma linha diferente, dependendo da forma que você copiou o programa). O MATLAB diz que as dimensões das matrizes não batem. Logo, deve ter alguma coisa na criação dos vetores X e Y que fez com que eles tenham comprimentos diferentes, fazendo com que não consigamos somá-los.

Vamos encontrar essa coisa debugando o nosso programa.

Passo 3

Usamos breakpoints para debugar programas. Lembrando que um breakpoint é um ponto marcando uma linha de código, onde o programa vai parar temporariamente de ser executado, permitindo que a gente analise tudo o que aconteceu antes.

Como o erro está na linha 7, vamos criar um breakpoint nessa linha. Para isto, clique na barra cinza à esquerda do código, na linha 7 (ou na linha onde o MATLAB indicou que o erro aparece, caso você tenha copiado o programa um pouquinho diferente).

Vai aparecer um ponto vermelho onde você clicou, que é o nosso breakpoint:

Execute o programa novamente. O MATLAB entra em modo debugger e vai interromper a execução quando chegar na linha do breakpoint:

A interrupção é indicada pela flechinha verde, podemos ver tudo que tem acima dela. Como tivemos um problema de dimensões de matrizes, vamos dar uma olhada nos vetores X e Y , para vermos os tamanhos deles. Para vermos os elementos e as dimensões dos vetores, devemos deixar o cursor do mouse sobre as variáveis.

Ao fazermos isso com o vetor X , vemos que ele tem dimensões 1 × 5 , isto é, ele tem 5 elementos:

Quando fazemos o mesmo com o vetor Y , vemos que ele tem dimensões 1 × 10 :

Em outras palavras, Y tem o dobro de elementos de X . É por isso que o MATLAB não consegue somar os dois.

Passo 4

Vamos tentar corrigir o problema. Antes, pare o debugger clicando em “Quit Debugging”:

Agora, precisamos encontrar uma forma de fazer com que os vetores X e Y tenham o mesmo comprimento. Existem várias formas de fazer isso. Uma delas é mudarmos o valor de m a x X .

Pense comigo: se X começa em 1 e tem passo 2, quanto deve ser m a x X para que X tenha 10 elementos? O número de elementos de um vetor criado com o comando:

v e t o r = v a l o r   i n i c i a l : p a s s o : v a l o r   f i n a l

Pode ser calculado a partir da seguinte expressão:

n º   e l e m e n t o s = v a l o r   f i n a l - v a l o r   i n i c i a l p a s s o + 1

Para o vetor X :

n º   e l e m e n t o s = 10

v a l o r   f i n a l = m a x X

v a l o r   i n i c i a l = 1

p a s s o = 2

Logo, a equação fica:

10 = m a x X - 1 2 + 1

Temos que m a x X = 19 .

Vamos então trocar o valor de m a x X e debugar novamente para verificar como ficou o vetor X :

Agora X tem dimensões 1 × 10 , assim como Y . Desta forma, conseguiremos somar os dois vetores sem problemas.

Passo 5

Vamos ver agora está tudo certo? Para executar a linha 7 no modo debugger, aperte F10 ou o botão step.

Quando você fizer isso, a flechinha verde vai descer uma linha de código, indicando que a linha 7 foi executada sem erros. Como a linha 7 é a última linha do programa, esta flechinha muda de orientação, apontando para baixo:

Note também que não apareceu nenhuma mensagem de erro no Command Window, apenas uma frase dizendo que o script acabou:

Logo, o MATLAB conseguiu somar os vetores X e Y e armazenar a soma em Z , sem problemas.

Pronto! O programa está corrigido! Se quiser dar uma última verificada, apague o breakpoint clicando nele e mande o programa rodar novamente. Com as alterações feitas neste passo a passo, não deve aparecer nenhuma mensagem de erro.

Resposta

Ei, a resposta está no passo a passo :)

Exercício Resolvido #3

Copie o programa abaixo em um script do MATLAB:

O codigo acima plota a série:

∑ n = 1 ∞ 1 n 2

Para inteiros de 1 a 100 e soma os primeiros 100 elementos da série. A soma dos 100 primeiros elementos desta série é aproximadamente 1,635.

Usando o debugger do MATLAB, corrija eventuais erros do código. Verifique ao final se a soma obtida corresponde a 1,635.

Passo 1

Este exercício pede que identifiquemos os erros do programa do enunciado, usando o debugger do MATLAB. Devemos copiar o programa em um novo script e rodá-lo algumas vezes, até que não apareçam mais mensagens de erro.

O programa plota a série ∑ n = 1 ∞ 1 n 2 , para inteiros de 1 a 100, e faz a soma dos 100 primeiros elementos. Ao final, devemos checar se o resultado da soma dá 1,635.

Quando o programa rodar sem problemas e o resultado bater, todos os erros do código foram corrigidos.

Passo 2

Crie um script novo no MATLAB e copie nele o programa do enunciado.

Antes de rodarmos o programa e procurarmos eventuais erros, vamos ver o que cada linha significa:

Na linha 1, temos o comando c l e a r   a l l . Este comando limpa o Workspace do MATLAB cada vez que o programa é rodado. Como procuramos erros no código e teremos que rodá-lo várias vezes para ver se corrigimos alguma coisa, é importante limpar o Workspace a cada tentativa.

Na linha 2, o comando c l c limpa o Command Window do MATLAB cada vez que o programa é executado. Novamente, como vamos rodar o código diversas vezes, é importante limpar o Command Window a cada tentativa, para ficar mais fácil de ver qual erro foi corrigido e qual é o erro a ser corrigido na sequência, caso exista.

Para criar todos os inteiros de 1 a 100 e podermos gerar a série ∑ n = 1 ∞ 1 n 2 , é criado o vetor x na linha 4. O vetor x vai de 1 a 100, a um passo de 1.

Em seguida, na linha 5, são criados os 100 primeiros elementos da série ∑ n = 1 ∞ 1 n 2 , a partir do vetor x . Os 100 elementos são armazenados no vetor y .

Na linha 6, é gerado o gráfico da série, por meio da função p l o t ( ) .

Finalmente, na linha 7, é feita a soma dos 100 primeiros elementos da série, por meio da função s u m ( ) . A função s u m ( ) soma os elementos do vetor de entrada, no caos aqui, o vetor y .

Note que a linha 7 não termina com ponto e vírgula (;). Isso faz com que o resultado de s u m ( y ) apareça no Command Window sem nós termos que pedir.

Já sabemos o que acontece em cada linha do código, bora rodar nosso programa pela primeira vez!

Vixe, deu erro:

O MATLAB avisou que tem um erro na linha 5, dizendo que uma matriz não tem as dimensões corretas para ser elevada a uma potência. Isto quer dizer que o problema está em x ^ 2 .

Passo 3

O MATLAB só consegue elevar a uma potência matrizes quadradas. Além disso, não queremos elevar o vetor ao quadrado, mas sim cada elemento de x para criarmos a série. Para fazermos isto, coloque um ponto ao lado de x na linha 5:

Bora ver se o problema foi corrigido? Rode o programa novamente. Deve ter aparecido a seguinte mensagem de erro:

O MATLAB nos diz que há um erro na linha 5 e que este erro está relacionado à operação de divisão. Ele diz que as dimensões das matrizes não batem.

Vamos criar um breakpoint na linha 5 para vermos o que está errado. Para criar um breakpoint, clique na barra cinza à esquerda do código, na linha 5 (ou na linha onde o MATLAB indicou que o erro aparece, caso você tenha copiado o programa um pouquinho diferente).

Vai aparecer um ponto vermelho onde você clicou, este é o breakpoint:

Execute o programa novamente. O MATLAB entra em modo debugger e vai interromper a execução quando chegar na linha do breakpoint:

Podemos ver os resultados das linhas de código que estão acima da flechinha verde. Vamos ver como é o vetor x , colocando o cursor sobre ele:

O vetor x tem dimensões 1 × 100 . Não conseguimos fazer a divisão na linha 5 porque o que está no numerador é um número real.

Para conseguirmos fazer a divisão, acrescente um ponto ao lado do 1 na linha 5, como na imagem abaixo:

Passo 4

Vamos executar o programa novamente, para vermos se corrigimos o erro e se aparece algum outro. Antes disso, pare o debugger clicando em “Quit Debugging”:

Rode o programa. Seguindo o passo a passo daqui, não é para ter mais nenhum erro. É para o seguinte gráfico ser gerado:

E o resultado da soma dos elementos de y deve aparecer no Command Window:

Veja que é o mesmo valor dado no enunciado.

Pronto! O programa está corrigido!

Resposta

Ei, a resposta está no passo a passo :)

Exercício Resolvido #4

O código abaixo verifica o limite:

lim x → 0 ⁡ sin ⁡ x x = 1

Calculando sin ⁡ x x para x = 0,1 ; 0,01 ; … ; 0,00000001 . Em seguida, as posições dos elementos do vetor que armazena sin ⁡ x x para cada valor de x que estão dentro de uma dada tolerância, representada pela variável e r r o , são determinadas.

Descubra por que o programa não funciona, usando o MATLAB.

Passo 1

Este exercício pede que identifiquemos os erros do programa do enunciado, usando o MATLAB. Devemos copiar o programa em um novo script e rodá-lo algumas vezes, até que não apareçam mais mensagens de erro.

Passo 2

Em um novo script do MATLAB, copie o código do enunciado.

Antes de executarmos o programa, vamos ver o que cada linha de código faz, pois isso é necessário para identificar eventuais erros:

Na primeira linha, temos o comando c l e a r   a l l , que limpa o Workspace do MATLAB cada vez que o programa é rodado. Como procuramos erros no código e teremos que rodá-lo várias vezes para ver se corrigimos alguma coisa e encontrar mais erros, é importante limpar o Workspace a cada tentativa.

Na segunda linha, o comando c l c limpa o Command Window do MATLAB cada vez que o programa é executado. Novamente, como vamos rodar o código diversas vezes, é importante limpar o Command Window a cada tentativa, para ficar mais fácil de ver qual erro foi corrigido e qual é o erro a ser corrigido na sequência, caso exista.

Na linha 4, pedimos ao MATLAB para nos mostrar os números resultantes dos cálculos com 16 algarismos significativos.

Na linha 5, criamos um vetor x , cujo primeiro elemento será 0,1 1 , o segundo será 0,1 2 , e assim sucessivamente, até o último elemento 0,1 8 . Logo, x = 0,1 1 0,1 2 … 0,1 8 . Isto é feito elevando-se 0,1 a uma potência dada pelo vetor [ 1 : 8 ] , que vai de 1 a 8 .

Na linha seguinte, calcula-se sin ⁡ x x para cada elemento de x , e os resultados são armazenados no vetor y .

Na linha 8, calcula-se a tolerância, salva na variável e r r o . A tolerância é dada pela diferença entre 1 e o oitavo elemento do vetor x , que é muito próximo de 0 .

A tolerância é usada na linha 9 para determinar qual elemento do vetor y é maior ou igual a ela, por meio da função f i n d , que nos retorna os índices dos elementos de y que sejam maiores ou iguais a e r r o . Desta forma, determina-se os elementos de y que são o mais próximo possível de 1 , considerando a tolerância adotada.

Passo 3

Após ver o que cada linha faz, vamos executar o programa pela primeira vez para identificar o primeiro erro. O Command Window fornecerá a seguinte mensagem:

O MATLAB avisou que tem um erro na linha 5, dizendo que o operador ^ só aceita como entrada um número escalar ou uma matriz quadrada. Isto quer dizer que o problema está em 0.1 ^ [ 1 : 8 ] .

O MATLAB só trabalha com potências que sejam números ou matrizes quadradas, e a potência na linha 5 é um vetor que vai de 1 a 8 . Queremos elevar 0,1 a cada elemento do vetor [ 1 : 8 ] . Para fazermos isto, coloque um ponto ao lado de 0,1 na linha 5. Além disso, apague o ; ao final da linha, para quando executar o programa, o vetor x ser impresso automaticamente no Command Window:

Vamos ver como x ficou?

Agora x está do jeito queremos e não há mais mensagens de erro. Contudo, isso não significa que está tudo certo ainda com o programa.

Passo 4

Vamos ver se está tudo certo com a linha 6, onde se deseja calcular sin ⁡ x x para cada elemento de x e gerar um vetor y com os resultados. Se você imprimir y no Command Window, você verá que ele é um escalar, e nos queremos que ele seja um vetor:

Para que y seja um vetor com a solução de sin ⁡ x x para cada elemento do vetor x , devemos incluir um ponto à esquerda do sinal de divisão, na linha 6:

Vamos ver como ficou y agora? Rode o programa e o imprima no Command Window:

Agora temos um vetor! E veja que legal: quando o elemento de x é mais próximo de 0 , o seu elemento de y correspondente se aproxima de 1 , como indica o limite lim x → 0 ⁡ sin ⁡ x x = 1 .

Passo 5

Para finalizar, vamos ver qual o valor de e r r o :

E vamos ver as posições dos elementos de y que são maiores ou iguais a e r r o :

Para ver quais elementos de y estão nessas posições, digite no Command Window y ( c ) :

Podemos perceber que eles realmente são maiores que e r r o e muito próximos de 1 .

Resposta

Ei, a resposta está no passo a passo :)

Exercício Resolvido #5

A função abaixo serve para avaliar o polinômio quadrático g x = a 2 x 2 + a 1 x + a 0 :

Onde a a é um vetor com os coeficientes do polinômio g ( x ) a a = a 2 , a 1 , a 0 e x x é o valor de x para o qual queremos avaliar g ( x ) .

Usando o programa teste abaixo, a função apresentou erros.

Usando o debugger do MATLAB e o programa teste, identifique e corrija os erros da função a v a l i a r _ p o l i .

Passo 1

Neste exercício, vamos procurar erros na função a v a l i a r _ p o l i rodando um programa teste.

Passo 2

O primeiro passo é passar a limpo os códigos do enunciado. Em um novo script, copie a função a v a l i a r _ p o l i :

A função a v a l i a r _ p o l i tem duas entradas e uma saída. A entrada a a deve ser um vetor com os coeficientes do polinômio g x = a 2 x 2 + a 1 x + a 0 e a entrada x x , o valor de x com o qual calcularemos g ( x ) .

A saída g g é g ( x ) calculado para o valor x x .

Na linha 2, deseja-se criar um vetor de zeros por meio da função z e r o s , de mesmo comprimento de x x . Este vetor se chama g g e armazenará os valores de g ( x ) para x x .

Na linha 3, deseja-se atualizar os valores de g g , calculando g ( x ) para x x .

Em outro script em branco, copie o programa teste e salve-o na mesma pasta onde você salvou a função a v a l i a r _ p o l i :

Assim como fizemos para a v a l i a r _ p o l i , vamos ver o que cada linha faz no programa teste. Na primeira linha, o comando c l e a r   a l l limpa o Workspace do MATLAB cada vez que o programa é rodado. Como procuramos erros na função a v a l i a r _ p o l i e teremos que chamá-la várias vezes para ver se corrigimos alguma coisa e encontrar mais erros, é importante limpar o Workspace a cada tentativa.

Na segunda linha, o comando c l c limpa o Command Window do MATLAB cada vez que o programa é executado. Novamente, como vamos rodar o código diversas vezes, é importante limpar o Command Window a cada tentativa, para ficar mais fácil de ver qual erro foi corrigido e qual é o erro a ser corrigido na sequência, caso exista.

No programa teste, testamos a v a l i a r _ p o l i em três casos diferentes, mas todos com o mesmo vetor de coeficientes de g ( x ) . Na linha 4, criamos o vetor c o e f contendo os coeficientes de g ( x ) .

Na linha 5, testamos g ( x ) para x = 0 , chamando a v a l i a r _ p o l i tendo como entrada c o e f e 0 . Logo abaixo, imprimos o resultado de g ( x ) para x = 0 no Command Window por meio do comando d i s p .

Na linha 7, testamos g ( x ) para x = 5 , chamando a v a l i a r _ p o l i tendo como entrada c o e f e 5 . Novamente, na linha 8, imprimos o resultado de g ( x ) para x = 5 no Command Window usando d i s p .

Na linha 9, cria-se um vetor x que vai de - 5 a 5 , com um passo de 0,1 . Na linha 10, chamamos a função a v a l i a r _ p o l i tendo como entrada c o e f e esse vetor x .

Passo 3

Vamos executar o programa e ver qual o primeiro erro que o MATLAB encontra:

Ele nos diz que há um erro na linha 5 do programa teste, onde a função a v a l i a r _ p o l i é chamada pela primeira vez. Este erro está em a v a l i a r _ p o l i , na linha 3, e este erro é que a variável a 2 é desconhecida.

Se revermos o código de a v a l i a r _ p o l i , vemos que as variáveis da linha 3, a 2 , a 1   e a 0 , não foram definidas na função. Elas devem ser definidas a partir do vetor a a , que contém os coeficientes do polinômio. E repare: em nenhum momento em a v a l i a r _ p o l i o vetor a a foi utilizado.

Para corrigir isto, inclua no começo da função os comandos:

Pois a a = a 2 , a 1 , a 0 , como dito no enunciado. Desta forma, a função ficou com essa cara:

Passo 4

Execute o programa teste de novo para ver se corrigimos o erro:

O erro anterior sumiu, mas o MATLAB achou outro. Novamente, há um erro na linha 5 do programa teste, onde a função a v a l i a r _ p o l i é chamada pela primeira vez. Este erro está em a v a l i a r _ p o l i , na linha 7, e este erro é que g g é um vetor, e vetores não pode ter índices iguais a 0 . Isto acontece pois na linha 7 temos g g ( x x ) e x x = 0 , logo, o MATLAB vai considerar g g ( 0 ) e considerará um erro.

Para corrigir isso, simplesmente apague o ( x x ) do lado de g g na linha 7:

Passo 5

Rode o programa teste de novo para ver se finalmente conseguimos avançar além da linha 5 dele:

Opa, apareceram um 2 e um 7 ali, isso indica que o programa rodou direitinho até a linha 8 do programa do teste. O 2 e o 7 vieram do comando d i s p ( g ) das linhas 6 e 8, pois a linha 6 mostra o resultado de g 0 = 1 ∙ 0 2 - 4 ∙ 0 + 2 = 2 e a linha 8, de g 5 = 1 ∙ 5 2 - 4 ∙ 5 + 2 = 7 .

Após imprimir o 7 , o MATLAB nos diz que há um erro na linha 10 do programa teste, quando a função a v a l i a r _ p o l i é chamada pela terceira vez, tendo como entrada c o e f e o vetor x . Como x é um vetor, o MATLAB não consegue criar o vetor de zeros na linha 6 de a v a l i a r _ p o l i , pois a função z e r o s só aceita números escalares como entrada.

Podemos corrigir esse erro pensando no que a linha 10 do programa faz. Na linha 10 do programa teste, queremos aplicar a função a v a l i a r _ p o l i em um vetor x , de forma a avaliar g ( x ) para vários valores de uma tacada só. Do jeito que a v a l i a r _ p o l i está, ela só calcular g ( x ) se a entrada x x for um número, não um vetor.

Para isto, em a v a l i a r _ p o l i , apague a linha que contém g g = z e r o s ( 1 , x x ) :

Passo 6

Após apagar o comando g g = z e r o s ( 1 , x x ) , na atual linha 6 de a v a l i a r _ p o l i , onde g ( x ) é calculado, adicione um ponto à direita de x x em a 2 * x x ^ 2 , de forma que a nova sintxe fica assim:

Isso faz com que, quando x x é um vetor, cada elemento dele seja elevado ao quadrado, de forma que a saída de g g também será um vetor. Essa operação não trará problemas quando x x for simplesmente um número, como podemos ver ao executar o programa após essa alteração:

O programa roda normalmente, sem mensagens de erro. Se quiser, você pode ver o resultado da terceira aplicação de a v a l i a r _ p o l i na linha 10 do programa teste, imprimindo g no Command Window.

Pronto! Função a v a l i a r _ p o l i corrigida! E gora ela funciona tanto para a entrada x x sendo um número escalar ou um vetor ;)

Resposta

Ei, a resposta está no passo a passo :)

Exercício Resolvido #6

Entre o programa abaixo no editor do MATLAB:

Lembre de adicionar os comandos c l e a r   a l l e c l c no começo do programa.

  1. Rode o programa e corrija os erros de sintaxe;
  2. Crie um breakpoint na linha: d i s p ( v a l u e s ) ;
  3. Debugue o programa avançando linha por linha do programa e observe o Workspace e o Command Window, procurando algum erro. Corrija os erros lógicos.
  4. Limpe o breakpoint da letra b e rode o programa corrigido, observando o Workspace e o Command Window.

Passo 1

O enunciado nos deu um código que contém alguns erros e pede para nos o corrigirmos. A intenção do código é mostrar cada elemento do vetor v a l u e s no Command Window.

Na letra a, é pedido para corrigirmos erros de sintaxe. Erros de sintaxe em programação são causados quando não seguimos as regras da linguagem que estamos utilizando, no nosso caso, o MATLAB. Os erros de sintaxe impedem a execução do programa.

A letra b pede para criarmos um breakpoint, para ajudar a responder a letra c. Na letra c, nos é pedido para corrigir erros lógicos. Em programação, erros lógicos não impedem a execução do programa. Eles levam a uma saída diferente da desejada e só podem ser detectados pelo programador ou pela programadora. O debugger do MATLAB nos ajuda a encontrar erros lógicos e a corrigi-los, por isso o usaremos para responder à letra c.

Finalmente, a letra d pede para tirarmos o breakpoint criado na letra b e para rodar o programa por completo.

Passo 2

Crie um script novo no MATLAB e copie o nele o programa do enunciado. Antes de rodarmos o programa e procurarmos eventuais erros, vamos ver o que cada linha significa e o que o programa faz, pelo menos na intenção:

Na linha 1, temos o comando c l e a r   a l l . Este comando limpa o Workspace do MATLAB cada vez que o programa é rodado. Como procuramos erros no código e teremos que rodá-lo várias vezes para ver se corrigimos alguma coisa, é importante limpar o Workspace a cada tentativa.

Na linha 2, o comando c l c limpa o Command Window do MATLAB cada vez que o programa é executado. Novamente, como vamos rodar o código diversas vezes, é importante limpar o Command Window a cada tentativa, para ficar mais fácil de ver qual erro foi corrigido e qual é o erro a ser corrigido na sequência, caso exista.

Na linha 4, criamos um vetor chamado v a l u e s , com 6 elementos.

Na linha 6, começamos um laço f o r , com a intenção de mostrar no Command Window cada elemento de v a l u e s , um de cada vez.

A linha 7 imprime no Command Window o elemento da iteração corrente.

Finalmente, a linha 8 encerra o laço f o r .

Resumindo, o programa deveria imprimir um elemento de v a l u e s a cada iteração do laço f o r .

Agora que já sabemos qual é a intenção do programa, vamos rodá-lo para identificar problemas de sintaxe e resolver a letra a.

Ao tentarmos executar o programa, aparece a seguinte mensagem de erro:

Ela diz que há um erro de sintaxe na linha 6 do programa, no início do laço f o r . Isto faz com que o programa nem seja executado.

Queremos que o MATLAB varra cada elemento de values usando o laço for. Para isto, devemos alterar a linha 6 para:

Na nova linha 6, criamos uma variável de controle i , que vai de 1 até o número de elementos de v a l u e s , isto é, 6. O número de elementos de v a l u e s é dado pela função l e n g t h ( ) , que dá o número de elementos de um vetor.

Rode o programa novamente. A saída no Command Window deve ter sido esta:

A correção que fizemos na linha 6 eliminou o erro de sintaxe e o MATLAB conseguiu rodar o programa. Portanto, a letra a está resolvida. Contudo, a saída não foi exatamente o que queríamos: o vetor v a l u e s foi impresso seis vezes, em vez de um elemento de v a l u e s ser impresso a cada iteração.

Passo 3

Para conseguirmos a saída que queremos, vamos começar pela letra b: criar um breakpoint na linha d i s p ( v a l u e s ) , isto é, na linha 7. Para criar o breakpoint, clique na barra cinza à esquerda do código, no Editor do MATLAB, na linha onde se deseja criá-lo:

Pronto, letra b feita :) Bora fazer a letra c.

Passo 4

A letra c pede para debugar o programa, avançando linha por linha. Enquanto executamos linha por linha, devemos observar o Workspace e o Command Window, para achar o erro no código.

Para ativar o modo debugger do MATLAB, mande rodar o programa. O programa vai ser executado até a linha 7, onde ele será interrompido. A linha onde o programa foi interrompido é indicada por uma flechinha verde:

Olhe o seu Workspace, ele deve estar assim:

Foi criada a variável de controle i e ela por enquanto é igual a 1.

Vamos executar o programa linha por linha como o enunciado mandou. Para isso, aperte o botão “Step” ou use o atalho do teclado F10. Com isto, a flechinha verde desceu para a linha 8, indicando que a linha 7 foi executada:

A execução da linha 7 fez com que a função d i s p ( ) exibisse o vetor values no Command Window:

Vamos continuar avançando linha por linha. Aperte F10 novamente ou o botão “Step”. Como iniciamos um laço f o r , a flechinha verde voltou para a linha 7.

Vamos ver novamente o Workspace:

Repare que o valor de i foi atualizado para 2, devido ao laço f o r .

Aperte F10 novamente ou o botão “Step”. A linha 7 é executada novamente e o vetor v a l u e s é impresso no Command Window pela segunda vez:

Percebeu o padrão? Cada vez que avançamos uma iteração no laço f o r , o valor de i é atualizado e o vetor v a l u e s é impresso novamente. Como neste laço f o r o i vai de 1 a 6, após debugarmos, i será igual a 6 e v a l u e s   será impresso seis vezes no Command Window.

Isto está longe do que queremos, que é imprimir um elemento de v a l u e s a cada iteração do laço f o r . Este é o erro lógico do programa.

Passo 5

Para corrigi-lo, altere a linha 7 para:

Em vez de d i s p ( v a l u e s ) , usamos d i s p ( v a l u e s ( i ) ) , para indicar o elemento de v a l u e s que deve ser impresso. Por exemplo, no laço f o r , inicialmente i   =   1 , logo, na primeira iteração, o comando da linha 7 será na prática d i s p ( v a l u e s ( 1 ) ) . Isto fará com que o primeiro elemento do vetor v a l u e s   , 23, seja impresso. Na iteração seguinte, i = 2 e o comando da da linha 7 será na prática d i s p ( v a l u e s ( 2 ) ) . Isto fará com que o número 17 seja impresso no Comand Window, pois ele é o segundo elemento de v a l u e s . Isto acontecerá para todos os elementos de v a l u e s até i = 6 .

Vamos visualizar este processo debugando. Repare que nem tinha apagado ainda o nosso breakpoint.

Rode o programa novamente para o MATLAB entrar em modo debugger:

Vamos ver o Workspace:

Temos i   =   1 . Vamos apertar F10 ou o botão “Step” para executar a linha 7. Ao fazermos isso, o Command Window imprime v a l u e s ( 1 ) :

Note que é o primeiro elemento de v a l u e s e ele foi impresso na primeira iteração do laço f o r .

Aperte F10 novamente ou o botão “Step” e repare no valor de i no Workspace:

Temos i = 2 . Ao executarmos a linha 7 novamente, o Command Window imprime v a l u e s ( 2 ) :

Que é o segundo elemento de v a l u e s , impresso na segunda iteração.

Percebeu a diferença entre d i s p ( v a l u e s ) e d i s p ( v a l u e s ( i ) ) ? Ao incluirmos o ( i ) , um elemento de v a l u e s é impresso a cada iteração do laço f o r