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 . Sem o ( i ) , o vetor inteiro é impresso a cada iteração.

Após terminar de debugar, executando linha por linha, o resultado será todos os elementos de v a l u e s impressos no Command Window, sendo que um elemento é impresso por vez:

No Workspace, i estará igual 6:

O erro lógico está corrigido, portanto, a letra c está respondida.

Passo 6

A letra d para eliminar o breakpoint e rodar o programa normalmente. Ela pede também para ver o Command Window e o Workspace.

Apague o breakpoint clicando nele e rode o programa. O seu Command Window deve ter ficado assim:

E o Workspace, assim:

Eles estão da mesma forma que ficaram ao terminarmos de debugar. Isto ocorre pois não pedimos ao MATLAB para executar e avaliar linha por linha nosso código, nós pedimos para o MATLAB executá-lo de uma vez, chegando diretamente ao resultado final.

Resposta

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

Exercício Resolvido #7

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 dois breakpoints, nas linhas:
  3. f o r   k   =   1 : 1 : l e n g t h ( v )     e     r e s u l t   =   r e s u l t   +   v

  4. Debugue o programa avançando linha por linha do programa e observando o Workspace e o Command Window, procurando algum erro. Corrija os erros lógicos.
  5. Limpe os breakpoints da letra b e rode o programa corrigido.

Passo 1

O enunciado nos deu um código que contém alguns erros e pede para nós o corrigirmos. A intenção do código é gerar um vetor de 30 elementos e somar somente os elementos positivos. Mas calma que eu já vou explicar isso em detalhes no próximo passo. Vamos entender o que o enunciado quer primeiro.

Na letra a, é pedido para corrigirmos erros de sintaxe. Erros de sintaxe em programação são erros 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 dois breakpoints, 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 os breakpoints criados na letra b e para rodar o programa por completo.

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 e o que o programa faz (ou o que deveria fazer):

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 , que contém 30 números inteiros entre -10 e 100, gerados de forma aleatória. O vetor v é criado usando duas funções do MATLAB: r a n d ( ) e r o u n d ( ) . A função r a n d ( ) serve para gerar números reais aleatórios, dentro do intervalo [0,1]. Já a função r o u n d ( ) serve para arredondar números quebrados para o inteiro mais próximo.

Vamos ver como é a estrutura de cada uma destas duas funções. A função r a n d ( ) tem a seguinte estrutura:

A   =   r a n d ( n _ l i n h a s ,   n _ c o l u n a s )

Ela retorna uma matriz A com n _ l i n h a s e n _ c o l u n a s , composta por números aleatórios, que vão de 0 a 1.

A função r o u n d ( ) tem o formato:

Y   =   r o u n d ( X )

Ela arredonda cada elemento de X para o inteiro mais próximo.

Logo, na linha 4, o vetor v é criado seguindo estas etapas:

  • A primeira parte da linha que é executada é r a n d ( 1,30 ) , que gera um vetor com 30 elementos aleatórios, entre 0 e 1. O vetor resultante é multiplicado por 110. Assim passamos a ter 30 elementos variando entre 0 e 110;
  • Em seguida, -10 é somado ao vetor resultante. Isto é feito para que os elementos de v no final tenham um valor entre -10 e 100;
  • Finalmente, cada elemento do vetor gerado na etapa acima é arredondado para o inteiro mais próximo, por meio da função r o u n d ( ) .

Na linha 6, iniciamos um laço f o r , para varrer cada elemento do vetor v . É criada uma variável de controle k , que vai de 1 até o número de elementos de v , isto é, 30, com um passo de 1. O número de elementos de v é dado pela função l e n g t h ( ) , que retorna a quantidade de elementos de um vetor.

Na linha 7, criamos uma condição para avaliar cada elemento de v , verificando se ele é maior ou igual a 0, isto é, positivo. Fazemos isso para pegarmos somente elementos de v que sejam positivos, para fazer a soma na linha seguinte.

A linha 8 adiciona um elemento positivo de v , a cada iteração, à soma obtida na iteração anterior.

A linha 9 encerra a condição da linha 7 e a linha 10 encerra o laço f o r .

A linha 12 apresenta no Command Window do MATLAB a soma dos elementos positivos de v .

Agora que sabemos o que cada linha significa, vamos executar o programa para encontrar os erros de sintaxe e resolver a letra a do exercício.

Ao rodarmos o programa, aparece a seguinte mensagem no Command Window:

Note que apareceu a string dentro do comando d i s p ( ) da linha 12. Isso quer dizer que não há erros de sintaxe, já que o programa foi executado.

Contudo, há outros erros. Veja que o MATLAB indicou que há um erro na linha 12: ele não reconheceu a variável r e s u l t . Isso quer dizer que a linha 8 não foi executada. Para encontrarmos a fonte do problema, devemos debugar nosso programa.

Passo 3

Para começarmos a debugar, precisamos criar breakpoints, para o MATLAB entrar em modo debugger. Por isso, neste passo vamos responder a letra b do exercício.

Na letra b, é pedido para criar dois breakpoints, nas linhas:

f o r   k   =   1 : 1 : l e n g t h ( v )     e     r e s u l t   =   r e s u l t   +   v

Que são as linhas 6 e 8 do programa. Para criar os breakpoints, clique na barra cinza à esquerda do código, na janela do Editor do MATLAB, nas linhas onde queremos que a execução programa seja interrompida temporariamente. Aparecerão duas bolas vermelhas:

Essas duas bolas vermelhas são os breakpoints.

Pronto, a letra b do exercício está feita ;)

Passo 4

Com os breakpoints criados, podemos debugar o programa e fazer a letra c do exercício. A letra c pede para executar o programa linha por linha e, enquanto executamos, 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 6, onde ele será interrompido. A linha onde o programa foi interrompido é indicada por uma flechinha verde:

Olhando o Workspace, vemos que a variável v foi criada sem problemas:

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 7, indicando que a linha 6 foi executada:

Observe o Workspace: a variável de controle k foi criada e é igual a 1.

Vamos executar outra linha novamente. Aperte F10 ou botão “Step”. Ao fazer isso, a flechinha pulou da linha 7 para a linha 9, indicando que a condição do i f não foi respeitada:

Continue executando linha por linha, até atingir as 30 iterações. Você vai perceber que em nenhum momento a condição i f será respeitada, fazendo com que a variável r e s u l t não seja criada nem atualizada.

Isto acontece devido à forma como a condição do i f da linha 7 foi escrita: nela, o vetor inteiro v foi avaliado, e não somente um elemento dele. O que a gente queria era analisar os 30 elementos do vetor (procurando pelos positivos) e foi por isso que criamos um loop. Mas estamos fazendo outra coisa. Estamos analisando 30 vezes se o vetor inteiro é positivo.

Um vetor é positivo se todos os seus elementos são positivos. E, como é muito provável que o vetor v tenha pelo menos um elemento negativo, avaliando ele no todo, a condição v > = 0 será sempre falsa e a linha 8 não será executada em momento algum. Encontramos aqui o primeiro erro lógico do programa.

Interrompa o debugger clicando em “Quit debugging” para corrigirmos o erro da linha 7.

Passo 5

Para corrigir o erro lógico da linha 7, adicione ( k ) à direita da v , na condição do i f , como na imagem abaixo:

Fazendo isso, um elemento de v será avaliado por vez na linha 7. Quando o laço for iniciar, k = 1 e a linha 7 vai avaliar v ( 1 ) , que é o primeiro elemento de v . Na segunda iteração, k = 2 e v ( 2 ) será avaliado na condição do i f , e assim sucessivamente. A cada iteração o elemento v ( k ) , que ocupa a posição k , é avaliado.

Note que na linha 8 também temos um vetor v , que está sendo somado a r e s u l t . Novamente temos o vetor inteiro, onde deveria ser apenas um dos seus elementos. Como queremos que seja somado um elemento positivo por vez, vamos colocar um ( k ) à direita de v nesta linha também:

Bora ver o que acontece se executarmos o programa de novo? Ele vai ser interrompido novamente na linha 6, por causa do breakpoint. Execute a linha 6 apertando F10 ou o botão “Step”, para irmos para a linha 7 e execute esta linha em seguida. Perceba que agora conseguimos entrar no bloco do i f :

Como é a primeira iteração, k   =   1 , e a condição do i f foi atendida, isto quer dizer que o primeiro elemento de   v é positivo. Como conseguimos entrar pelo menos uma vez no bloco i f e atingir a linha 8, isto significa que corrigimos o primeiro erro de lógica. Ufa! Então vamos continuar!

Passo 6

Execute a linha 8 apertando F10 ou “Step”. Aparecerá a seguinte mensagem de erro no Command Window:

O MATLAB nos avisa que há um erro na linha 8: ele não reconheceu a variável r e s u l t . Isto porque ela não foi definida antes da linha 8.

Para corrigirmos o erro, interrompa o debugger, crie a variável r e s u l t na linha acima do laço f o r e diga que ela é igual a 0:

A variável r e s u l t representa a soma dos elementos positivos de v . Ela começará no programa como r e s u l t = 0 e será atualizada a cada iteração do laço f o r , quando a linha 8 for executada. Ela receberá ela mesma somada com o elemento de v da iteração corrente. Desta forma, quando o laço f o r estiver concluído, r e s u l t terá a soma de todos os elementos positivos de v .

Vamos testar novamente. Rode o programa para o MATLAB entrar em modo debugger e execute uma linha por vez até que a linha 8 seja atingida. Com a alteração que fizemos, não aparecerá mais o erro, pois a variável r e s u l t foi definida. Continue executando o código linha por linha e você verá que a variável r e s u l t muda a cada iteração.

Passo 7

Continue executando o programa linha por linha até o final. Quando o laço f o r terminar, a linha 12 do código é executada e a variável r e s u l t é impressa no Command Window:

Lembre que a sua variável r e s u l t   com certeza vai ser diferente da minha, pois v é criado de forma aleatória.

Como chegamos até o final do programa sem erros, o programa foi corrigido e podemos fazer a letra d do exercício.

Passo 8

A letra d do exercício pede para apagar os breakpoints e rodar o programa. Para apagá-los, clique neles e eles desaparecerão. Ou clique em “Breakpoints” -> “Clear all”:

Isto também fará com que todos os breakpoints sumam.

Executando o programa, temos o seguinte resultado no Command Window:

Note que ele é diferente do passo anterior, pois v é criado de forma aleatória.

Resposta

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

Exercício Resolvido #8

Entre o programa abaixo no editor do MATLAB:

O programa pede ao usuário informar o número de transações a serem efetuadas. Em seguida, ele lê a entrada, em reais, de cada transação e controla o valor total das transações. Ao final, ele apresenta a soma, em reais, dos valores de cada transação.

Crie breakpoints onde achar necessário e debugue o programa, corrigindo erros de sintaxe e de lógica.

Passo 1

O enunciado nos passou um código que intencionalmente tem erros e nos pede para corrigi-lo. Existem no programa erros de sintaxe e de lógica.

Erros de sintaxe em programação são erros 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.

Em programação, erros lógicos não impedem a execução do programa. Eles levam a uma saída diferente da desejada (às vezes incorreta) 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 nos é pedido para criar breakpoints e para debugar o programa.

Passo 2

Crie um script novo no MATLAB e copie o nele o programa do enunciado. O enunciado nos informou o que este programa deve fazer: ele pede para o usuário entrar com o número de transações que ele deseja fazer, para pedir, em seguida, o valor de cada transação. O programa controla o valor total das transações e informa ao final o valor total das transações.

Antes de rodarmos o programa e procurarmos eventuais erros, vamos ver o que cada linha significa para ver o que o programa faz para atingir seu objetivo:

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.

Uma variável chamada t o t a l é criada na linha 4 e ela é igual a 0 .

Na linha 5, pedimos ao usuário para informar o número de transações, por meio do comando i n p u t ( ) . O número de transações é armazenado em n _ t r a n s a c o e s .

Na linha 7, se inicia um laço w h i l e . O bloco do laço w h i l e é executado enquanto a condição k   < =   n _ t r a n s a c o e s for verdadeira. k é uma variável de controle que conta quantas vezes o bloco do w h i l e foi executado, isto é, conta o número de iterações.

Na linha 8, é pedido ao usuário para informar o valor de uma transação, também usando o comando i n p u t ( ) . O valor da transação é armazenado na variável q t d e _ t r a n s a c a o .

Na linha 9, o valor total das transações é atualizado, utilizando a variável t o t a l criada na linha 4. A variável t o t a l é atualizada considerando o valor informado pelo usuário na linha 8.

Na linha 10, a variável de controle k é atualizada, adionando 1 ao valor que k tinha na iteração anterior.

A linha 11 indica que o bloco do w h i l e se encerra ali.

A linha 13 imprime no Command Window o resultado da soma das transações, usando a função d i s p ( ) .

Agora que já sabemos o que cada linha faz, vamos rodar o programa pela primeira vez. Apaecerá no Command Window a seguinte mensagem:

O MATLAB exibiu a string do comando i n p u t ( ) da linha 5, indicando que o programa foi executado. Isto significa que o programa não possui erros de sintaxe, já que o MATLAB conseguiu rodá-lo.

Passo 3

Vamos informar um número de transações para o programa continuar rodando, para vermos se não identificamos algum erro. Vou dizer que quero fazer duas transações, entrando o valor 2 no Command Window. Desta forma, fica mais fácil de eu verificar se o resultado final estará certo.

Ao entrar o valor 2 no Command Window, aparece a seguinte mensagem de erro:

O MATLAB nos informa que há um erro na linha 7, onde se inicia o w h i l e . Ele não reconheceu a variável k . Se olharmos o código atentamente de novo, percebemos que a variável k não foi definida antes da linha 7 e é por isso que o MATLAB não a reconhece.

Para corrigirmos este erro, vamos definir a variável k na linha 6 e dizer que ela é igual a 0 :

Fizemos k = 0 antes de iniciar o laço w h i l e porque ele serve para contar quantas vezes o bloco w h i l e foi executado. Perceba que na primeira iteração do while, k vai ficar igual a 1 ao passarmos pela linha 10, que diz que k = k + 1 . Na segunda iteração, k vai se transformar em 2 pois a execução da linha 10 adicionar 1 ao valor de k da iteração anterior. Esse processo acontece a cada iteração do w h i l e .

Passo 4

Vamos rodar o programa novamente para ver se achamos outro erro. Vamos informar novamente que queremos fazer 2 transações, isto é, n _ t r a n s a c o e s = 2 .

A mensagem de erro do passo anterior não aparece mais. O MATLAB nos pede o valor da transação, indicando que a linha 8 do código foi executada normalmente. Vamos dizer que queremos fazer uma transação de R $ 20,00 :

O MATLAB nos pede novamente para informar um valor de transação, já que pedimos para fazer duas transações. Vamos dizer que queremos fazer mais uma transação de R $ 30,00 :

Perceba que já há indícios que temos algum erro de lógica no código: o MATLAB pediu para entrarmos um terceiro valor de transação, sendo que nós dissemos que queríamos fazer somente duas transações. Vamos interromper a execução do código usando o atalho do teclado C t r l   +   C e criar um breakpoint para debugar o programa.

Crie um breakpoint na linha 10, onde a variável k é atualizada, clicando na barra cinza à esquerda do código, no Editor do MATLAB:

A bolinha vermelha que apareceu é o brekpoint que definimos. Vamos rodar o programa novamente e ativar o modo debugger do MATLAB. O programa é executado até a linha 9 e é interrompido na linha 10:

Note que eu informer novamente que queremos fazer duas transações e já informei que a primeira transação é de R $ 20,00 . Na janela do Editor, apareceu uma flechinha verde na linha onde foi criado o breakpoint, indicando a interrupção do programa:

Antes de executar o programa linha por linha para identificarmos o erro, vamos ver como está nosso Workspace:

Perceba que, por enquanto, k = 0 . Vamos executar a linha 10, usando o atalho do teclado F10 ou apertando o botão “Step”. Em seguida, olhe o Workspace novamente:

Agora, k   =   1 . Perceba que k   <   n _ t r a n s a c o e s , por isso o bloco do w h i l e   será executado novamente. Continue executando o programa linha por linha até chegar na linha 10 novamente. Neste momento, seu Command Window estará assim:

O MATLAB nos pediu para informar o valor da segunda transação, novamente eu disse que quero fazer uma transação de R $ 30,00 . Vamos ver como está o Workspace:

k ainda não foi atualizado e continua igual a 1 porque ainda não executamos a linha 10. Ao fazermos isto, ele se tornará igual a 2 :

Note que, neste momento, k = n _ t r a n s a c o e s e se continuarmos executando o programa linha por linha, o bloco w h i l e será rodado novamente, pois a condição dele é k < = n _ t r a n s a c o e s .

Contudo, não queremos que o bloco w h i l e seja executado mais uma vez, pois isso significa que estaremos fazendo uma terceira transação, sendo que só queremos fazer duas.

Aqui percebemos um erro de lógica no código: o laço w h i l e não pode ser executado quando k = n _ t r a n s a c o e s , para não fazermos uma transação a mais do que a gente pediu. Para corrigirmos este erro, interrompa o debugger apertando o botão “Quit debugging” e mude a condição do w h i l e na linha 7 para k   <   n _ t r a n s a c o e s :

Desta forma, o bloco do w h i l e não será executado quando k   =   n _ t r a n s a c o e s .

Vamos testar novamente? Apague o breakpoint da linha 10, clicando nele, rode o programa e peça para fazer duas transações, uma de R $ 20,00 e outra de R $ 30,00 .

O seu Command Window deve ter ficado assim. Perceba que o problema de o MATLAB fazer uma transação a mais do que o pedido foi corrigido, pois ele pediu para informarmos o valor de uma transação duas vezes. Contudo, apareceu outra mensagem de erro, que diz que há um erro na linha 13.

Passo 5

A mensagem de erro diz que o MATLAB não reconheceu a variável ou função ‘ d i d p ’ na linha 13. Se olharmos para o teclado de nossos computadores, descobrimos este erro se trata de um erro de digitação: quem escreveu o programa queria ter digitado d i s p em vez de d i d p , mas acabou apertando a tecla d   em vez da s , que estão lado a lado no teclado.

Na linha 13, substitua d i d p ( t o t a l ) por d i s p ( t o t a l ) e rode o programa novamente, para vermos se não há mais algum erro. Novamente, vamos entrar com n _ t r a n s a c o e s   =   2 e pedir que a primeira transação seja de R $ 20,00 e a segunda, de R $ 30,00 . Seu Command Window deve ter ficado assim:

Oba! Nenhuma mensagem de erro! O programa foi executado até o final sem problemas!

Pera, mas viu o valor total das transações que o MATLAB nos informou? Ele disse que o valor total das transações é de 30 , mas deveria ser de 50 , não? Isto quer dizer que ainda há um erro lógico em nosso programa.

Passo 6

É na linha 13 que o valor total das transações é impresso no Command Window:

Veja que ela imprime primeiro uma string e, em seguida, a variável t o t a l , que representa a soma de todas as transações.

Para identificar o erro, vamos ver o valor que t o t a l   assumiu ao final do programa:

Perceba que t o t a l está igual à q t d e _ t r a n s a c a o , qua assumiu ao final do programa o valor de 30 . Contudo, t o t a l   deveria ser a soma da primeira e da segunda transação, logo, t o t a l   deveria ser igual a 50 no final do programa.

O problema deve estar na linha 9, onde a variável t o t a l é atualizada dentro do bloco w h i l e . Vamos criar um breakpoint na linha 9 para vermos como a variável total está sendo atualizada. Para isto, clique na barra cinza à esquerda do código, na janela Editor do MATLAB, sobre a linha 9. O breakpoint aparece representado pela bolinha vermelha.

Vamos debugar o programa novamente. Rode-o e diga quer quer fazer duas transações novamente, sendo que a primeira é de R $ 20,00 . A execução do programa será interrompida na linha 9 e seu Command Window estará assim:

Vamos ver o Workspace? Por enquanto, t o t a l   =   0 pois a variável ainda não foi atualizada:

Vamos agora rodar o programa linha por linha. Execute a linha 9 apertando F10 ou o botão “Step” e veja o valor que t o t a l assumiu no Workspace:

Agora, t o t a l   =   20 , que é igual ao valor da primeira transação que fizemos, que foi armazenado na variável q t d e _ t r a n s a c a o . Por enquanto, está tudo certo.

Continue a executar o programa linha por linha, até atingir a linha 9 novamente. Não a execute ainda. Durante este processo, o MATLAB vai pedir o valor da segunda transação, de R $ 30,00 . Seu Command Window deve estar assim:

Vamos ver o Workspace:

A variável q t d e _ t r a n s a c a o foi atualizada para 30 e a variável t o t a l ainda não foi atualizada. Vamos executar a linha 9 e observar o Workspace:

O t o t a l ficou igual a q t d e _ t r a n s a c a o , em vez de somar 30 ao valor da primeira transação isto é, 20 . Temos um problema no cálculo da atualização da variável t o t a l .

Note que na linha 9, t o t a l é atualizado pelo comando:

Que diz que t o t a l   é igual a q t d e _ t r a n s a c a o . Mas não é isso que queremos, queremos que t o t a l armazene a soma das transações. Para que isso seja feito, altere a linha 9 para:

Desta forma, t o t a l é atualizada ao somar o valor que t o t a l tinha na iteração anterior com o valor que a variável q t d e _ t r a n s a c a o acabou de assumir.

Vamos ver se funcionou? Apague o breakpoint e rode o programa novamente.

Passo 7

De novo, diga que quer fazer duas transações, a primeira de R $ 20,00 e a segunda de R $ 30,00 . Seu Command Window deve estar assim:

Agora a soma dos valores das transações está correto: R $ 50,00 . Se olharmos o Wokspace, veremos que t o t a l está diferente de q t d e _ t r a n s a c a o e que t o t a l   =   50 :

Pronto! Programa corrigido! Se quiser, pode fazer mais alguns testes, mudando o número de transações e os valores das transações. Com as correções que fizemos, o programa vai rodar sem problemas.

Resposta

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