Entre o programa abaixo no editor do MATLAB:

Lembre de adicionar os comandos e no começo do programa.

1. Rode o programa e corrija os erros de sintaxe;
2. Crie dois breakpoints, nas linhas:
3. 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.
4. Limpe os breakpoints da letra b e rode o programa corrigido.

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 . 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 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 , que contém 30 números inteiros entre -10 e 100, gerados de forma aleatória. O vetor é criado usando duas funções do MATLAB: e . A função serve para gerar números reais aleatórios, dentro do intervalo [0,1]. Já a função 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 tem a seguinte estrutura:

Ela retorna uma matriz com e , composta por números aleatórios, que vão de 0 a 1.

A função tem o formato:

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

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

• A primeira parte da linha que é executada é , 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 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 .

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

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

A linha 8 adiciona um elemento positivo de , 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 .

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

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 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 . Isso quer dizer que a linha 8 não foi executada. Para encontrarmos a fonte do problema, devemos debugar nosso programa.

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:

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 ;)

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 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 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 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 será respeitada, fazendo com que a variável não seja criada nem atualizada.

Isto acontece devido à forma como a condição do da linha 7 foi escrita: nela, o vetor inteiro 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 tenha pelo menos um elemento negativo, avaliando ele no todo, a condição 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.

Para corrigir o erro lógico da linha 7, adicione à direita da , na condição do , como na imagem abaixo:

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

Note que na linha 8 também temos um vetor , que está sendo somado a . 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 à direita de 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 :

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

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 . Isto porque ela não foi definida antes da linha 8.

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

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

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 foi definida. Continue executando o código linha por linha e você verá que a variável muda a cada iteração.

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

Lembre que a sua variável com certeza vai ser diferente da minha, pois é 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.

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 é criado de forma aleatória.