Introdução ao Scilab e à Programação de …§ãoScilab...Esta apostila foi escrita por Daniel...

Introdução ao Scilab e à Programação de Computadores

Cursos de Engenharia Versão 1.1

Daniel A. Furtado

Uberlândia 2014

Esta apostila foi escrita por Daniel A. Furtado e não pode ser reproduzida ou apropriada, total ou

parcialmente, sem a permissão do autor.

SUMÁRIO

C A P Í T U L O 1 INTRODUÇÃO AO SCILAB ........................................................................................................... 4

1.1 AMBIENTE DE TRABALHO E CONSOLE ................................................................................................................................. 4

1.2 OPERAÇÕES E EXPRESSÕES MATEMÁTICAS ......................................................................................................................... 5

1.3 PRECEDÊNCIA DOS OPERADORES ...................................................................................................................................... 6

EXERCÍCIOS PROPOSTOS ....................................................................................................................................................... 7

1.4 VARIÁVEIS .................................................................................................................................................................... 8

1.5 VARIÁVEIS ESPECIAIS DO SCILAB ....................................................................................................................................... 9

1.6 NOMES DE VARIÁVEIS..................................................................................................................................................... 9

EXERCÍCIOS PROPOSTOS ....................................................................................................................................................... 9

1.7 FUNÇÕES PREDEFINIDAS ................................................................................................................................................. 9

EXERCÍCIOS PROPOSTOS ..................................................................................................................................................... 12

C A P Í T U L O 2 INTRODUÇÃO A ALGORITMOS .................................................................................................13

2.1 ALGORITMO COMO UMA DESCRIÇÃO NARRATIVA .............................................................................................................. 14

2.2 ALGORITMO EM FLUXOGRAMA....................................................................................................................................... 15

2.2.1 Estrutura Condicional em Fluxograma ............................................................................................................ 17

C A P Í T U L O 3 ENTRADA E SAÍDA UTILIZANDO O SCINOTES ............................................................................19

3.1 FUNÇÕES INPUT E DISP .................................................................................................................................................. 20

3.2 FUNÇÃO PRINTF .......................................................................................................................................................... 21

3.3 COMENTÁRIOS ............................................................................................................................................................ 22


C A P Í T U L O 4 ESTRUTURA CONDICIONAL IF-THEN-ELSE .................................................................................24

4.1 ESTRUTURA CONDICIONAL SIMPLES ................................................................................................................................ 26

4.2 ESTRUTURA CONDICIONAL ANINHADA ............................................................................................................................. 26

4.3 OPERADORES RELACIONAIS ........................................................................................................................................... 28

4.4 OPERADORES LÓGICOS ................................................................................................................................................. 28


C A P Í T U L O 5 OPERAÇÕES COM VETORES ......................................................................................................31

5.1 ACESSANDO OS ELEMENTOS DE UM VETOR ....................................................................................................................... 31

5.2 MODIFICANDO UM VETOR ............................................................................................................................................ 32

5.3 UTILIZANDO O OPERADOR “:” PARA DEFINIR VETORES ....................................................................................................... 32

5.4 UTILIZANDO A FUNÇÃO LINSPACE .................................................................................................................................... 33

5.5 OPERAÇÕES COM VETORES ............................................................................................................................................ 34

5.6 OUTRAS FUNÇÕES APLICADAS A VETORES ........................................................................................................................ 34


C A P Í T U L O 6 CONSTRUÇÃO DE GRÁFICOS .....................................................................................................36

6.1 GRÁFICOS DE FUNÇÕES ................................................................................................................................................. 36

6.1.1 Opções do Gráfico ........................................................................................................................................... 37

6.1.2 Título, Rótulos dos Eixos, Legenda e Linhas de Grade ..................................................................................... 39

6.1.3 Outras Opções do Gráfico ............................................................................................................................... 40

6.2 O COMANDO SUBPLOT ................................................................................................................................................. 42

6.3 OUTROS TIPOS DE GRÁFICOS ......................................................................................................................................... 45

C A P Í T U L O 7 OPERAÇÕES COM MATRIZES ....................................................................................................47

7.1 ACESSO AOS ELEMENTOS DA MATRIZ .............................................................................................................................. 48

7.2 ADICIONANDO E REMOVENDO LINHAS E COLUNAS ............................................................................................................. 49

7.3 OPERAÇÕES DE SOMA, SUBTRAÇÃO E MULTIPLICAÇÃO ....................................................................................................... 50

7.4 OUTRAS FUNÇÕES APLICADAS A MATRIZES ....................................................................................................................... 51

7.5 RESOLUÇÃO DE SISTEMAS LINEARES ................................................................................................................................ 53

C A P Í T U L O 8 ESTRUTURAS DE REPETIÇÃO.....................................................................................................55

8.1 ESTRUTURA DE REPETIÇÃO WHILE (ENQUANTO) ................................................................................................................. 55

8.2 ESTRUTURA DE REPETIÇÃO FOR (“REPITA PARA”) ............................................................................................................... 58

4

Introdução ao Scilab Prof. Dr. Daniel A. Furtado

Capítulo 1

Introdução ao Scilab

Scilab é um software livre, de computação numérica, que oferece um poderoso ambiente

computacional para aplicações científicas e de engenharia. O software é mantido e

distribuído pela Scilab Enterprises e pode ser baixado gratuitamente pela Internet

(www.scilab.org). Atualmente, o Scilab é utilizado em diversos centros educacionais e

industriais pelo mundo. Algumas das várias atividades que podem ser realizadas no Scilab

são:

Operações e simulações matemáticas,

Operações com polinômios,

Construção de gráficos,

Processamento de sinais,

Cálculos estatísticos,

Operações com matrizes,

Resolução de equações diferenciais,

Interpolação e aproximação,

Projeto e análise de sistemas de controle.

1.1 Ambiente de Trabalho e Console

O ambiente de trabalho padrão da versão 5.4.0 do Scilab é apresentado a seguir. O ambiente

é organizado em um conjunto de janelas menores que são encaixadas na janela principal. São

elas: Navegador de arquivos, Console do Scilab, Navegador de variáveis e Histórico de comandos. A

janela Console do Scilab é utilizada para a execução de operações diversas.

http://www.scilab-enterprises.com/

http://www.scilab.org/

5


Figura 1.1 - Tela inicial do Scilab

O sinal de prontidão “-->” indica que o Scilab aguarda a digitação de um comando ou

expressão, que deve ser finalizado pela tecla ENTER. Exemplos:

-->5+10

ans =

15.

-->10/4

ans =

2.5

Observe que o resultado é precedido por “ans” de answer (resposta).

1.2 Operações e Expressões Matemáticas

As operações básicas da matemática podem ser realizadas no Scilab por meio dos seguintes

operadores:

+ Soma

- Subtração

* Multiplicação

/ Divisão

^ Potenciação (

Exemplos:

-->2*6

ans =

12.

6


-->2^3

ans =

8.

-->3+5-1

ans =

7.

Se necessário, o comando clc (de clear console) pode ser utilizado para limpar o console.

1.3 Precedência dos Operadores

Quando uma expressão envolve diversos operadores, o Scilab considera a ordem de

precedência dos mesmos para avaliar a expressão:

Prioridade Operação

1ª Potenciação: ^

2ª Multiplicação e divisão: *, /

3ª Soma e subtração: +, -

Exemplos:

-->4*3^2

ans =

36.

Como o operador de potenciação tem maior prioridade em relação ao

de multiplicação, a operação 3^2 é avaliada primeiro e o seu resultado

(9) é multiplicado por 4.

-->10+4/2

ans =

12.

4/2 é avaliado primeiro, pois o operador de divisão tem prioridade

sobre o de adição. O resultado é então somado com 10.

-->2+3*4-1

ans =

13.

3*4 é avaliado primeiro.

A ordem de avaliação das operações pode ser definida utilizando-se os parênteses. Por

exemplo, caso seja necessário resolver a expressão matemática a seguir, os parênteses se

tornam essenciais.

Expressão matemática:

Expressão equivalente no Scilab: -->(10+4)/2

Repare que, se os parênteses não fossem utilizados, a expressão 10+4/2 no Scilab seria

equivalente à expressão matemática

, que é diferente da expressão anterior (a primeira

expressão resulta em 7, enquanto a segunda resulta em 12).

7


Outros exemplos:

Expressão Matemática Expressão correspondente no Scilab

-->1/2 + 3/5 - 5/8

-->(3+2^5)/5

-->(5*(4+2)–1)/(10+3^2)

-->(2^4+2^6)/(2^5-1)+20

Quando uma expressão envolve operadores de mesma prioridade, o Scilab avalia primeiro a

operação mais à esquerda. Por exemplo, na expressão 5-3+1, os operadores de soma e

subtração possuem a mesma prioridade. Assim, a operação 5-3 é calculada primeiro e o

resultado (2) é então somado com 1, resultando em 3. Repare que o resultado seria diferente

caso a operação de adição fosse feita antes da subtração. O mesmo acontece com expressão

10/5*2. A operação 10/5 é calculada primeiro, pois está mais à esquerda, e o resultado é

multiplicado por 2. Esta regra é denominada de associatividade à esquerda.

Exercícios Propostos

Elabore expressões no SciLab correspondentes às expressões matemáticas a seguir. Utilize o

menor número de parênteses possível.

a) 10 + 20

b) 2 ∙ 45

c) (resp: 7,2)

d) + 1 (resp: 17)

e) (resp: 32)

f)

(resp: 0,9)

g)

(resp: 2,2)

h)

+ 7 (resp: 53,5)

i)

(resp: 1,538...)

j)

8


1.4 Variáveis

Em computação, uma variável corresponde a uma posição na memória do computador que é

associada a um nome de identificação. As variáveis são comumente utilizadas para armazenar

dados temporariamente, como números, resultados de expressões, cadeia de caracteres ou

valores lógicos. No Scilab, as variáveis podem ser definidas e utilizadas diretamente no

console. Veja o exemplo:

-->a = 10

a =

10.

A expressão “a = 10” é utilizada para definir uma variável de nome “a” a fim de

armazenar o valor 10. O símbolo de igualdade é denominado de operador de atribuição, uma

vez que atribui (armazena) o valor à variável. Após ser definida, a variável permanece

disponível até que o Scilab seja fechado ou até que o usuário apague a mesma manualmente

(pode-se digitar o comando clear seguido do nome da variável).

Outros exemplos:

-->b = 2 + 3

b =

5.

Define uma variável de nome b para armazenar o resultado da

expressão 2 + 3.

-->b

b =

5.

Acessa o conteúdo da variável b, definida anteriormente.

-->c = 2*b + 1

c =

11.

Define uma nova variável c para armazenar o resultado de (2*b + 1),

que resulta em 11.

-->soma = b + c

soma =

16.

Define uma nova variável de nome soma para armazenar a soma das

variáveis b e c.

-->b = b + 1

b =

6.

Altera o valor da variável b, adicionando 1 ao seu conteúdo.

-->t = 'teste'

t =

teste

Também é possível criar variáveis para armazenar cadeias de

caracteres (strings), desde que eles sejam especificados entre aspas.

-->d = 30;

Define a variável d. OBS: O ponto-e-vírgula é utilizado para suprimir

a resposta imediata do Scilab.

-->d Mostrar o conteúdo da variável d

-->clear b Apaga apenas a variável b.

-->clear Apaga todas as variáveis definidas pelo usuário.

9


1.5 Variáveis Especiais do Scilab

O Scilab disponibiliza ao usuário um conjunto de variáveis pré-definidas. Algumas delas são

as variáveis %pi e %e que armazenam os valores da constante matemática e do número de

Euler, respectivamente:

-->%pi

%pi =

3.1415927

-->%e

%e =

2.7182818

1.6 Nomes de Variáveis

Os nomes das variáveis devem ser escolhidos com atenção. Algumas regras são:

O nome da variável não deve começar com um algarismo;

Não são permitidos acentos, espaços ou caracteres especiais como: ç, !, ?, @ , etc;

Entretanto, o caractere sublinha “_” é permitido;

O Scilab faz distinção entre letras minúsculas e maiúsculas.

Exemplos de nomes inválidos para variáveis: &a, 5_a, +2, área, núm, var@, área total.


1. Defina uma variável de nome x para armazenar o valor 8.

2. Acesse o conteúdo da variável x.

3. Defina uma variável de nome y como sendo igual a 2x + 1.

4. Atualize a variável y acrescentando 2 ao seu conteúdo.

5. Acesse o conteúdo da variável y.

6. Defina três variáveis a, b e c para armazenar valores de sua escolha.

7. Defina uma variável de nome delta para armazenar o resultado de

8. Defina uma variável z como sendo igual ao produto de x por y. Utilize o ponto-e-

vírgula no final da expressão e verifique a diferença entre utilizá-lo ou não.

1.7 Funções Predefinidas

O Scilab disponibiliza ao usuário uma vasta coleção de funções que realizam cálculos

diversos e podem ser utilizadas diretamente no console. Por exemplo, a função sqrt calcula a

raiz quadrada de um número (do inglês, square root - sqrt):

-->sqrt(9)

ans =

3.

10


-->y = sqrt(49)

y =

7.

Outros exemplos são as funções trigonométricas sin e cos que calculam o seno e o cosseno,

respectivamente, de um ângulo em radianos.

Exemplos:

-->cos(%pi)

ans =

- 1.

-->sin(%pi/2)

ans =

1.

Para executar uma função no Scilab, utiliza-se frequentemente a seguinte sintaxe:

nomeDaFunção ( argumentos_de_entrada )

Observe que os argumentos de entrada da função devem ser passados entre parênteses, logo

após o nome da função. No Scilab, há funções que operam sobre zero, um ou vários

argumentos de entrada. A função sqrt apresentada anteriormente exige um único

argumento. Já a função max, responsável por calcular o maior dentre dois ou mais números,

é capaz de operar sobre diversos argumentos de entrada. Neste caso, eles devem ser

separados por vírgula:

-->max(3,4)

ans =

4.

-->max(6,3,5)

ans =

6.

-->max(2,6,3,5,12,8)

ans =

12.

Outros exemplos de funções:

Função Descrição Exemplos

abs Calcula o valor absoluto de um número ou expressão.

-->abs(-5)

ans =

5.

round Arredonda um número para o inteiro mais próximo.

-->round(5.1)

ans =

5.

-->round(7.6)

ans =

8.

-->round(2.5)

ans = 3.

11


floor Arredonda um número para o próximo inteiro menor. Se o valor já for inteiro, retorna o próprio.

-->floor(5.1)

ans =

5.

-->floor(7.6)

ans =

7.

-->floor(12)

ans =

12.

-->floor(-4.9)

ans =

-5.

ceil Arredonda um número para o próximo inteiro maior. Se o valor já for inteiro, retorna o próprio.

-->ceil(5.1)

ans =

6.

-->ceil(7.6)

ans =

8.

-->ceil(12)

ans =

12.

min Calcula o menor número de uma lista de números.

-->min(3,8,5,2,7)

ans =

2.

sin, cos, tan Calculam, respectivamente, o seno, o cosseno e a tangente de um ângulo (em radianos).

-->sin(%pi/2)

ans =

1.

-->cos(%pi)

ans =

-1.

-->tan(45 * %pi/180)

ans =

1.

sind, cosd, tand

Calculam, respectivamente, o seno, o cosseno e a tangente de um ângulo em graus.

-->sind(90)

ans =

1.

asin, acos, atan

Calculam, respectivamente, o arco-seno, o arco-cosseno e o arco-tangente, com o resultado em radianos.

-->asin(1)

ans =

1.5707963

log, log10, log2

Calculam, respectivamente, o logaritmo de um número na base e (logaritmo natural), na base 10 e na base 2.

-->log(%e)

ans =

1.

-->log10(100)

ans =

2.

modulo Calcula o resto da divisão inteira de um número por outro.

-->modulo(6,2)

ans =

0.

-->modulo(5,2)

ans =

1.

12



1. Elabore expressões no Scilab que sejam equivalentes às expressões matemáticas a seguir:

a) √ Resp.: 16

b) Resp.: 2.4771213

c) Resp.: 9

d) Resp.: 3.2188758

e) Resp.: 0.9396926

f) Resp.: 0.8660254

g) Resp.: 6.2831853

h) Resp.: 1

i)

Resp.: 0.7071068

j)

Resp.: 1

k) Resp.: 145

l)

Resp.: 166.5

m)

√ Resp.: -484.99032

n) |√ | Resp.: 120.52786

o)

√

√ Resp.: 14.202356

p) √

(

) Resp.: 27.897856

2. Calcule o resto da divisão inteira de 25 por 7. Resp.: 4

3. Calcule o resto da divisão inteira de 11 por 2. Resp.: 1

4. Forneça a expressão para arredondar o número 9.75 para o inteiro mais próximo.

5. Forneça a expressão para arredondar o número 9.75 para 9.

13

Introdução a Algoritmos Prof. Dr. Daniel. A. Furtado

Capítulo 2

Introdução a Algoritmos

Os programas de computador podem ser desenvolvidos para solucionar problemas de

diversas áreas do conhecimento. Durante o desenvolvimento desses programas, é sempre

desejável a busca por soluções eficientes, que possam ser executadas pelo computador de

forma a atender os requisitos do problema e ao mesmo tempo minimizar o uso de recursos,

como o processador e a memória da máquina. Neste contexto, é comum a busca pelas

soluções que envolvam os melhores algoritmos.

Embora não exista uma definição formal universalmente aceita para algoritmo, o termo pode

ser definido informalmente como uma sequência de instruções que levam à solução de um

dado problema. Por exemplo, uma simples sequência de passos que descreve o processo de

preparação de um sanduíche pode ser vista como um algoritmo, pois tais passos

correspondem às instruções que devem ser seguidas para que o problema “fazer o

sanduíche” seja resolvido. No mundo real, muitos problemas de engenharia e de

computação são resolvidos desenvolvendo-se, inicialmente, um ou um conjunto de

algoritmos que solucionam o problema em questão. Posteriormente, tais algoritmos são

implementados em software utilizando-se uma linguagem de programação, como C++, C#

ou Java.

Conforme verificado por Donald Knuth, um algoritmo deve ter cinco

propriedades/capacidades:

1) Finitude. Um algoritmo deve sempre terminar após um número finito de instruções.

2) Clareza. Cada passo do algoritmo deve ser especificado com clareza, precisão e sem

ambiguidade.

3) Entrada. Um algoritmo geralmente possui um ou mais elementos de entrada, que

devem ser fornecidos para a execução adequada das instruções.

4) Saída. Um algoritmo produz um ou mais elementos de saída (ou resultado).

14


5) Eficácia. Um algoritmo deve ser eficaz. Todas as suas instruções devem ser passíveis

de execução em tempo finito.

Um algoritmo pode ser especificado de três formas principais, que são: (1) descrição

narrativa, (2) fluxograma e (3) linguagem algorítmica (pseudocódigo). Cada uma dessas

formas apresenta suas próprias vantagens e desvantagens e a escolha adequada pode

depender do tipo e da complexidade do problema a ser resolvido. Nesta capítulo,

apresentamos brevemente as formas (1) e (2).

2.1 Algoritmo como uma Descrição Narrativa

Quando um algoritmo é especificado na forma de uma descrição narrativa, utiliza-se a

linguagem natural (o próprio português) para descrever os seus passos.

Exemplo 1. Considere o problema “preparar um misto quente”. A sequência de passos a

seguir constitui um algoritmo em descrição narrativa que o soluciona:

1) Preparar os ingredientes: manteiga, duas fatias de pão, uma de queijo e uma de

presunto;

2) Passar a manteiga em ambas as fatias de pão;

3) Colocar o presunto sobre uma fatia de pão e o queijo sobre a outra;

4) Juntar as duas fatias, fechando o sanduíche;

5) Colocar o sanduíche em uma sanduicheira e aguardar até o pão tostar;

6) Retirar o sanduíche da sanduicheira.

Repare que o algoritmo é composto por um conjunto finito de passos e tem um início e um

fim. Os elementos de entrada são os ingredientes (manteiga, pão, queijo e presunto) e a saída

é o sanduíche pronto. Os passos são claros e passíveis de realização.

Exemplo 2. Considere o problema “Dadas as dimensões (em metros) de uma piscina

retangular, calcule a sua capacidade em litros de água”. Um algoritmo que o soluciona é:

1) Receber as três dimensões da piscina: largura, comprimento e profundidade;

2) Calcular o volume da piscina, em metros cúbicos, multiplicando: largura x

comprimento x profundidade;

3) Calcular o volume da piscina em litros, multiplicando o volume em m3 por 1000;

4) Apresentar o volume em litros.

Exemplo 3. Considere o seguinte problema:

“Dadas as três notas de um aluno correspondentes a três provas semestrais, calcular a sua nota final

(somatório das três notas) e apresentar a sua situação, que pode ser: APROVADO, caso a nota final

seja maior ou igual a 70; ou REPROVADO, caso a nota final seja inferior a 70.”

A sequência de passos a seguir constitui um algoritmo que o soluciona:

15


1) Receber as três notas do aluno;

2) Calcular a nota final do aluno somando as três notas recebidas;

3) Verificar se a nota final é maior ou igual a 70;

4) Caso a nota final seja maior ou igual a 70, apresentar a mensagem APROVADO;

5) Caso contrário (ou seja, nota final menor que 70), apresentar a mensagem

REPROVADO.

As principais vantagens e desvantagens de um algoritmo em descrição narrativa são:

Vantagem

Utiliza a linguagem natural, já conhecida.

Desvantagens

Impreciso,

Possível ambiguidade,

Extenso.

2.2 Algoritmo em Fluxograma

Um algoritmo também pode ser especificado por meio de um diagrama. Neste caso, vários

símbolos gráficos são utilizados para a sua composição:

Nome Símbolo Significado

Oval (início/fim)

Indica o início ou o fim do algoritmo.

Retângulo (processo)

Indica um processo ou operação do algoritmo.

Losango (decisão)

Indica que uma decisão deve ser tomada e que a execução deve seguir por uma de duas possíveis direções.

Paralelograma (entrada/saída)

Indica uma operação de entrada ou saída.

Círculo (conector) Utilizado como ponto de junção de dois ou mais ramos de execução.

Seta Indica a direção do fluxo de operações.

O algoritmo do Exemplo 1 apresentado anteriormente pode ser especificado, em fluxograma,

da seguinte forma:

16


O algoritmo do Exemplo 2, já apresentado em descrição narrativa, pode ser especificado em

fluxograma da seguinte forma:

Início

Fim

Entrada: comprimento, largura e profundidade da piscina

VolumeM3 comprimento * largura * profundidade

VolumeL VolumeM3 * 1000

Saída: VolumeL

Início

Fim

Entrada: manteiga, 2 fatias de pão, 1 fatia de queijo e 1 de presunto

Passar a manteiga em ambas as fatias de pão

Colocar o presunto sobre uma fatia de pão e o queijo sobre a outra

Juntar as duas fatias, fechando o sanduíche

Colocar o sanduíche em uma sanduicheira e aguardar até o pão tostar

Retirar o sanduíche da sanduicheira

Saída: sanduíche pronto

17


No fluxograma anterior, a etapa “Entrada: comprimento, largura, profundidade” é utilizada

para expressar o fato de, nesse momento, as três dimensões da piscina precisam ser

fornecidas, de alguma forma, para que a execução do algoritmo possa prosseguir. A partir

desse passo, as três medidas de dimensões serão representadas pelos termos comprimento,

largura e profundidade.

Ao invés de “Entrada: comprimento, largura, profundidade”, também é comum o uso da

expressão “LEIA comprimento, largura, profundidade”, a qual mantém o mesmo significado.

Observe o passo:

A seta para a esquerda () é empregada para indicar que, a partir desse ponto no algoritmo,

o termo VolumeM3 representará o resultado da expressão comprimento * largura * profundidade.

Esse termo é utilizado no passo seguinte, onde o volume em litros é calculado a partir do

volume em metros cúbicos:

2.2.1 Estrutura Condicional em Fluxograma

Um algoritmo em fluxograma correspondente ao Exemplo 3 (problema para determinar a

situação final de um aluno) é apresentado a seguir. Neste caso, utilizamos o símbolo

condicional losango ( ). Este símbolo deve ser empregado quando uma decisão precisa

ser tomada com base na análise de uma condição. No exemplo citado, o losango indica que a

condição “NotaFinal ≥ 70?” deve ser avaliada. Caso ela seja verdadeira, então a execução do

algoritmo deve seguir pelo ramo indicado pela seta “SIM”. Caso contrário (condição falsa),

então a execução deve seguir pelo ramo indicado pela seta “NÃO”.

VolumeM3 comprimento * largura * profundidade

VolumeL VolumeM3 * 1000

18


Exemplo 4. Desenvolver um algoritmo, em fluxograma, para calcular e apresentar as raízes

de uma equação do segundo grau (ax2 + bx + c = 0). O algoritmo deve receber os três

coeficientes da equação, a, b e c, e apresentar mensagens adequadas de acordo com as

possíveis raízes.

Fim

Mostrar mensagem

“Raízes distintas:”, x1, x2

Início

LEIA a, b, c

D b2 – 4 · a · c

D > 0? SIM

NÃO

D = 0? SIM

NÃO

x1 (-b + √ ) / (2· a)

x2 (-b - √ ) / (2· a) x (-b) / (2· a)

Mostrar mensagem

“Raízes iguais:”, x Mostrar mensagem

“Não há raízes reais”

Início

Fim

Entrada: nota1, nota2, nota3

NotaFinal nota1 + nota2 + nota3

NotaFinal ≥ 70? Mostrar “Aprovado”

Mostrar “Reprovado”

SIM

NÃO

19

Entrada e Saída utilizando o SciNotes Prof. Dr. Daniel. A. Furtado

Capítulo 3

Entrada e Saída utilizando o SciNotes

Todas as operações e funções apresentadas no Capítulo 1 foram executadas utilizando o

console do Scilab. Em geral, o console é utilizado quando se deseja executar sequências de

operações não muito complexas ou extensas, ou quando se deseja obter um resultado

imediato dessas operações. Entretanto, há situações em que é necessário executar uma série

de operações envolvendo testes lógicos, repetições de cálculos e interações com o usuário.

Nesses casos, pode ser necessário o desenvolvimento de um programa propriamente dito,

que poderá ser salvo em um arquivo e executado quando necessário. No Scilab, tais

programas (ou scripts) podem ser feitos utilizando o seu próprio editor de textos, o SciNotes.

Para abrir o SciNotes, clique na janela do console e depois no ícone (ver Figura 3.1).

Figura 3.1 – Abrindo o editor SciNotes

20


Figura 3.2 - Editor SciNotes

Assim que o SciNotes é aberto, pode-se escrever a sequência de comandos correspondente ao

programa e executá-lo (basta clicar no ícone ou pressionar a tecla F5).

3.1 Funções input e disp

Antes de apresentar um primeiro programa como exemplo, é importante descrever duas

funções básicas que são utilizadas com frequência no SciNotes:

input – realiza uma operação de entrada de dados. Possibilita que um dado seja

solicitado ao usuário do programa (para que seja processado).

disp – realiza uma operação de saída de dados. Permite exibir mensagens de texto na

tela ou valores de variáveis (geralmente os resultados obtidos).

O programa a seguir solicita ao usuário a medida do lado de um quadrado e então calcula e

apresenta a sua área. Para testá-lo, copie os comandos para o editor SciNotes, salve o arquivo

e clique em executar . Em seguida, ative a janela do console do Scilab para acompanhar a

sua execução. Forneça um valor qualquer e pressione ENTER.

Exemplo 1a. Programa para calcular a área de um quadrado.

lado = input("Informe a medida do lado de um quadrado: ");

area = lado * lado;

disp("A área do quadrado é: ");

disp(area);

21


Os comandos que compõem um programa feito no SciNotes serão executados pelo

computador sequencialmente, na ordem de suas linhas. Por exemplo, quando o programa

anterior for executado, o computador começará processando a expressão:


Tal expressão é responsável pela operação de entrada de dados que solicita a medida do lado

do quadrado ao usuário. Essa operação envolve três ações básicas:

1. Exibe a mensagem “Informe a medida do lado de um quadrado” na tela;

2. Aguarda até que o usuário informe um dado e pressione a tecla ENTER;

3. Armazena o dado informado pelo usuário na variável lado.

Quando o usuário pressionar ENTER, o computador prosseguirá com a execução do

programa. A segunda linha é responsável pelo cálculo da área em si, cujo resultado é

armazenado na variável area. As duas últimas linhas foram utilizadas para a apresentação

do resultado obtido (operação de saída). Na terceira linha, a função disp tem o papel de

exibir a mensagem “A área do quadrado é:”. Em seguida, ela é utilizada para apresentar o

conteúdo da variável area.

3.2 Função printf

No programa do Exemplo 1a, poderíamos ter utilizado a função printf ao invés da função

disp. Vejo o exemplo:

Exemplo 1b. Utilizando a função printf.


area = lado * lado;

printf("A área do quadrado é: %f", area);

A diferença é que, com a função printf, podemos apresentar a mensagem de texto juntamente

com o valor da variável, de maneira formatada e utilizando um único comando. O termo %f

foi utilizado para que o valor da variável area pudesse ser adicionado à mensagem.

Poderíamos apresentar ao usuário uma mensagem de resultado um pouco mais elaborada,

incluindo, por exemplo, a medida do lado do quadrado para o qual a área foi calculada.

Execute o programa a seguir e observe a alteração.

Exemplo 1c.


area = lado * lado;

printf("A área do quadrado de lado %f é %f", lado, area);

Observe que, neste caso, foi necessário colocar o termo %f em dois locais da mensagem,

exatamente onde se deseja inserir os valores das variáveis. Entretanto, as variáveis em si

devem ser especificadas após o fechamento das aspas, na ordem adequada. Para cada %f

22


inserido na mensagem de texto, é necessário especificar uma variável ou expressão que o

substituirá na mensagem final:

printf("A área do quadrado de lado %f é %f", lado, area);

Além de %f, outras formas comuns são:

%d – utilizado quando a variável ou expressão resulta em um número inteiro (ou

quando se deseja apresentar apenas a parte inteira de um número com casas

decimais)

%.2f – o número será apresentado com duas casas decimais (ao invés de seis casas,

quantidade padrão quando se utilizada apenas %f).

Exemplo 2a. Programa que solicita ao usuário as medidas de uma sala retangular, em

metros, e calcula e apresenta a sua área, em metros quadrados.

l = input("Informe a largura da sala, em metros: ");

c = input("Informe o comprimento da sala, em metros: ");

a = l * c;

printf("A área da sala de largura %.2f e comprimento %.2f é %.2f m2", l, c, a);

Exemplo 3. Programa que solicita ao usuário as medidas de uma piscina retangular, em

metros, e calcula e apresenta a sua capacidade, em litros.

l = input("Informe a largura da piscina, em metros: ");

c = input("Informe o comprimento da piscina, em metros: ");

p = input("Informe a profundidade da piscina, em metros: ");

v = l * c * p * 1000;

printf("A capacidade da pisc. de dimensões %.2f x %.2f x %.2f é %.2f L.", l,c,p,v);

3.3 Comentários

Comentários são utilizados para documentar o programa, pois eles não são avaliados pelo

computador durante a sua execução. No Scilab, todo o texto que é colocado à frente de “//”

é tido como um comentário de linha. O programa a seguir desempenha a mesma função

daquele do Exemplo 2a, mas com a diferença de possuir alguns comentários que o descreve.

Exemplo 2b.

// Programa que solicita ao usuário as medidas de uma sala retangular,

// em metros, e calcula e apresenta a sua área, em metros quadrados.

l = input("Informe a largura da sala, em metros: ");

c = input("Informe o comprimento da sala, em metros: ");

a = l * c; // faz o cálculo da área

printf("A área da sala de largura %.2f e comprimento %.2f é %.2f m2", l, c, a);

23



Resolva os exercícios a seguir utilizando o editor SciNotes do Scilab.

1. Faça um programa que receba do usuário uma medida de temperatura, em Fahrenheit, e

converta para graus Celsius. Utilize a fórmula

.

2. Faça um programa que receba do usuário as medidas da base e da altura de um triângulo

retângulo e calcule e apresente a sua área.

3. Faça um programa que receba do usuário a medida do raio de um círculo e calcule e

apresente a sua área.

4. Faça um programa que receba do usuário o diâmetro e a profundidade (em metros) de

uma piscina redonda. O programa deve calcular e apresentar o volume da piscina em

metros cúbicos e em litros ( , onde e

).

5. Faça um programa que receba do usuário a largura, o comprimento e a profundidade de

uma piscina retangular (em metros) e calcule e apresente a quantidade total de azulejos

(em m2) necessária para cobrir a superfície interna da piscina.

24

Estrutura Condicional if-then-else Prof. Dr. Daniel. A. Furtado

Capítulo 4

Estrutura Condicional if-then-else

A estrutura condicional if-then-else (if = se; then = então; else = senão) é utilizada quando se

deseja executar um bloco de operações ou outro, dependendo de uma condição ser

verdadeira ou falsa, respectivamente. A sua forma geral no Scilab é ilustrada a seguir:

if (cond) then

Comando C1;

Comando C2;

⁞

Comando Cn;

else

Comando D1;

Comando D2;

⁞

Comando Dm;

end

Os termos C1, C2, ..., Cn e D1, D2, ..., Dm no código acima representam comandos quaisquer,

como uma operação de soma ou um cálculo de raiz quadrada e o termo cond representa uma

condição lógica qualquer, como raio > 0. A estrutura if-then-else indica que os comandos C1,

C2, ..., Cn devem ser executados pelo computador apenas quando a condição cond for

verdadeira e que os comandos D1, D2, ..., Dm devem ser executados apenas quando a

condição cond for falsa.

E outras palavras, ao executar um programa contendo o código anterior, o computador irá

verificar se a condição cond é verdadeira ou falsa. Se cond for verdadeira então (then) o

computador partirá para a execução do primeiro bloco de comandos (C1, C2, ..., Cn – os

comandos que antecedem a palavra else). Mas se cond for falsa, o computador executará apenas o

segundo bloco de comandos (D1, D2, ..., Dm − os comandos que estão entre a palavra else

e a palavra end (fim)).

25


Exemplo 1. Deseja-se elaborar um programa que receba do usuário a medida do lado de uma

sala quadrada e calcule e apresente a sua área. Entretanto, o programa deve calcular a área da

sala apenas quando o valor informado pelo usuário for maior do que zero, pois não há sala com lado

negativo ou nulo. Caso o usuário informe um valor inválido (negativo ou zero), o programa

deve apenas apresentar uma mensagem notificando o fato.

lado = input("Informe a medida do lado da sala: ");

if (lado > 0) then

area = lado * lado;

printf("A area da sala é %f", area);

else

printf("O valor informado é inválido! ");

end

Execute o programa anterior pelo menos duas vezes. Na primeira execução, informe um

valor positivo e verá a área calculada. Da segunda vez, informe um valor negativo (ou zero),

e receberá apenas uma mensagem notificando a medida incorreta.

Ao ser executado, o programa inicialmente solicita a medida ao usuário (linha 1). Assim que

o usuário digita o valor e pressiona a tecla ENTER, o computador armazena esse dado na

variável lado. Na sequência, o computador testará a condição lado > 0. Se o usuário digitou

um valor positivo, tal condição será verdadeira. Assim, os comandos:

area = lado * lado; (faz o cálculo da área e armazena na var. area)

printf("A area da sala é %f", area); (mostra na tela o resultado)

serão executados e o programa será encerrado. Por outro lado, se o usuário informar um

valor negativo, então os dois comandos do bloco then NÃO serão executados, mas sim o

único comando do bloco else-end (pois a condição lado > 0 passa a ser falsa).

Exemplo 2. Programa que recebe do usuário dois números quaisquer e em seguida verifica

se os números fornecidos são iguais ou não.

n1 = input("Informe o primeiro número: ");

n2 = input("Informe o segundo número: ");

if (n1 == n2) then

printf("Os números fornecidos são iguais");

else

printf("Os números fornecidos são diferentes");

end

Observe que foi utilizado o operador relacional de igualdade do Scilab (“==”) para verificar

se os valores das variáveis n1 e n2 são iguais. Diferente do operador de atribuição (que tem

um único “=”), dois iguais são utilizados para fins de comparação.

26


4.1 Estrutura Condicional Simples

O bloco else da estrutura if não é obrigatório. Há situações em que é necessário executar uma

série de comandos caso uma condição seja verdadeira, mas que não é necessário executar

nada em especial caso essa condição seja falsa. Considere, por exemplo, que seja preciso

calcular a área de um quadrado quando o lado informado pelo usuário for válido, mas que

não seja necessário apresentar nenhuma mensagem caso o usuário digite um valor inválido.

Isto é feito no código a seguir. Neste caso, não colocamos o bloco else.

lado = input("Informe a medida do lado da sala: ");

if (lado > 0) then

area = lado * lado;

printf("A area da sala é %f", area);

end

4.2 Estrutura Condicional Aninhada

É possível utilizar a estrutura condicional if dentro de outra, tanto no bloco then quando no

bloco else. Uma vez iniciado outro if, bastar seguir as mesmas regras descritas anteriormente.

Exemplo 3. Deseja-se elaborar um programa para calcular as raízes reais de uma equação do

2º grau, caso elas existam. O programa deve solicitar ao usuário os coeficientes a, b e c que

definem a equação ( .

Neste exemplo, há três possibilidades para se tratar:

1. A equação pode ter duas raízes distintas;

2. A equação pode ter duas raízes iguais (uma raiz distinta);

3. A equação pode não ter raízes reais

Portanto, será necessário o emprego de duas estruturas condicionais:

a = input("Informe o coeficiente a da equação: ");

b = input("Informe o coeficiente b da equação: ");

c = input("Informe o coeficiente c da equação: ");

delta = b^2 – 4*a*c;

if (delta > 0) then

// Neste caso, há duas raízes que precisam ser calculadas

x1 = (-b + sqrt(delta))/(2*a);

x2 = (-b - sqrt(delta))/(2*a);

printf("As raízes da equação são %.2f e %.2f", x1, x2);

else

if (delta == 0) then

// Neste caso, há apenas uma raiz distinta

x = (-b)/(2*a);

printf("Duas raízes iguais: %.2f", x);

else

printf("Não existem raízes reais!");

end

end

27


O programa apresentado solicita os três coeficientes ao usuário e em seguida calcula o valor

do discriminante ( , que é armazenado na variável delta. Na sequência, a primeira

estrutura if verifica se a condição delta > 0 é verdadeira. Caso seja, então as duas raízes são

calculadas e o resultado é apresentado. Caso contrário (else), tem-se ainda duas

possibilidades (delta = 0 ou delta < 0) e para trata-las utilizou-se o segundo if.

É importante observar que as condições tratadas no programa anterior poderiam ter sido

verificadas em uma ordem diferente, desde que a sequência lógica das operações se

mantivesse correta. O código a seguir ilustra outra possibilidade:

a = input("Informe o coeficiente a da equação: ");

b = input("Informe o coeficiente b da equação: ");

c = input("Informe o coeficiente c da equação: ");

delta = b^2 – 4*a*c;

if (delta < 0) then

// Neste caso, não há raízes reais

printf("Não existem raízes reais!");

else

if (delta == 0) then

// Neste caso, há apenas uma raiz distinta

x = (-b)/(2*a);

printf("Duas raízes iguais: %.2f", x);

else

// Neste caso, temos duas raízes distintas

x1 = (-b + sqrt(delta))/(2*a);

x2 = (-b - sqrt(delta))/(2*a);

printf("As raízes da equação são %.2f e %.2f", x1, x2);

end

end

Exemplo 4. Deseja-se elaborar um programa que receba do usuário a altura e o sexo de uma

pessoa e calcule e apresente o seu peso ideal. As seguintes fórmulas devem ser utilizadas

(onde h é a altura em metros):

Para homens: peso ideal = (72.7 * h) – 58

Para mulheres: peso ideal = (62.1 * h) – 44.7

Para indicar o sexo masculino, o usuário deverá informar o número 1. Para indicar o

feminino, o usuário deverá informar o número 2. Caso um valor diferente de 1 e 2 seja

fornecido, então o programa deverá apresentar uma mensagem notificando o dado inválido.

O programa também deverá verificar se a altura informada pelo usuário é válida (maior do

que zero).

28


Solução:

clc;

h = input("Informe a altura da pessoa, em metros: ");

if (h > 0) then

sexo = input("Informe 1 para masculino ou 2 para feminino: ");

if (sexo == 1) then

pesoIdealM = (72.7 * h) – 58;

printf("O peso ideal é: %.2f", pesoIdealM);

else

if (sexo == 2) then

pesoIdealF = (62.1 * h) – 44.7;

printf("O peso ideal é: %.2f", pesoIdealF);

else

printf("Valor inválido para o sexo!");

end

end

else

printf("Altura inválida!");

end

4.3 Operadores Relacionais

O Scilab disponibiliza ao usuário um conjunto de operadores relacionais, que inclui os já

utilizados == e >. Esses operadores são ilustrados na Erro! Fonte de referência não encontrada..

Operador Significado

== Igual a

~= Diferente de

> Maior que

>= Maior ou igual a

< Menor que

<= Menor ou igual a

Tabela 4.1 - Operadores relacionais do Scilab

4.4 Operadores Lógicos

Em todos os exemplos anteriores, na estrutura condicional if, utilizou-se uma expressão

lógica simples (if delta > 0, if n1 == n2, etc.). Entretanto, os operadores lógicos do Scilab

podem ser utilizados para a formação de expressões lógicas mais complexas (que envolvem,

por exemplo, duas ou mais condições). Tais operadores são apresentados na Tabela 4.2.

29


Operador Lógico Significado Exemplo Significado

& “e” lógico if (a > 0 & a < 10)... Verifica se o valor da variável a é maior que 0 e menor que 10.

| “ou” lógico if (a == 0 | b == 0) ... Verifica se alguma das variáveis (a ou b) tem valor igual a zero.

~ Negação if ~(a < 0) ... Verifica se o valor da variável a NÃO é menor que zero. Isto é equivalente à condição a >= 0

Tabela 4.2 - Operadores lógicos do Scilab

A B A & B A | B ~A

V V V V F

V F F V F

F V F V V

F F F F V

Tabela 4.3 - Tabela verdade dos operadores lógicos


1) Faça um programa para calcular a situação final de um aluno com base nas suas três

notas semestrais. O programa deve solicitar as três notas, soma-las e informar se o aluno

está aprovado (quando a soma das notas é maior ou igual a 70) ou reprovado (soma das

inferior a 70).

2) Faça um programa que receba do usuário dois números e apresente o menor deles.

3) Faça um programa que receba do usuário dois números e em seguida apresente esses

números na ordem crescente.

4) Analise os programas a seguir (sem executá-los no computador) e informe qual seria a

sua saída caso fossem executados.

a) a = 2; b = 3; c = 1;

if (a > b) then

printf("%d",a);

else

if (b > c) then

printf("%d",b);

else

printf("%d",c);

end

end

b) a = 10; b = 20; c = 10;

if (a == b | a == c) then

printf("%d",a);

else

printf("%d",b);

end

30


c) a = 10; b = 10; c = 20;

if (a == b & a == c) then

printf("%d",a);

else

printf("%d",c);

end

d) a = 1; b = 2; c = 3;

if (a < b & b > c) then

printf("%d",a);

printf("%d",b);

else

if (b < c) then

d = b + c;

printf("%d",d);

else

printf("%d",c);

end

printf("%d",a);

end

e = a + b + c;

printf("%d",e);

31

Operações com Vetores Prof. Dr. Daniel A. Furtado

Capítulo 5

Operações com Vetores

No Scilab, os vetores (arrays) são utilizados para armazenar uma lista de elementos, como

números ou caracteres, os quais podem ser acessados por meio de um índice. Um vetor pode

ser do tipo linha ou do tipo coluna e pode ser definido por meio dos caracteres [ e ]. No caso

de um vetor linha, os elementos devem ser separados por vírgula ou espaço. Já um vetor

coluna deve ter os elementos separados por ponto-e-vírgula.

Exemplos:

-->a = [1 2 3 4] (define um vetor linha de nome a contendo 4 elementos)

a =

1. 2. 3. 4.

___________________________________________________________________________________

-->b = [10, 20, 30] (define um vetor linha de nome b contendo 3 elementos)

b =

10. 20. 30.

___________________________________________________________________________________

-->v1 = [5; 8; 1] (define um vetor coluna de nome v1 contendo 3 elementos)

v1 =

5.

8.

1.

5.1 Acessando os Elementos de um Vetor

Os elementos de um vetor linha ou coluna podem ser acessados individualmente por meio

de um índice. Deve-se colocar o nome do vetor seguido da posição do elemento entre

parênteses.

Exemplos:

-->a = [7, 4, 12, 9] (define um vetor)

a =

7. 4. 12. 9.

32


-->a(3) (acessa o terceiro elemento do vetor)

ans =

12.

___________________________________________________________________________________

-->a(1) (acessa o primeiro elemento do vetor)

ans =

7.

5.2 Modificando um Vetor

Também é possível modificar os elementos de um vetor, adicionar novos elementos ou até

mesmo excluí-los.

Exemplos:

-->a = [6 4 8 3] (define um vetor linha de nome a contendo 4 elementos)

a =

6. 4. 8. 3.

___________________________________________________________________________________

-->a(4) = 15 (altera o quarto elemento do vetor a para o valor 15)

a =

6. 4. 8. 15.

___________________________________________________________________________________

-->a(1) = a(1) + 2 (adiciona 2 ao primeiro elemento do vetor a)

a =

8. 4. 8. 15.

___________________________________________________________________________________

-->a = [a, 17] (adiciona o elemento 17 no final do vetor a)

a =

8. 4. 8. 15. 17.

___________________________________________________________________________________

-->a = [13, a] (adiciona o elemento 13 no início do vetor a)

a =

13. 8. 4. 8. 15. 17.

___________________________________________________________________________________

-->a(7) = 6 (adiciona o elemento 6 no final do vetor a (outra forma))

a =

13. 8. 4. 8. 15. 17. 6.

___________________________________________________________________________________

-->a(3) = [] (apaga o terceiro elemento do vetor a)

a =

13. 8. 8. 15. 17. 6.

5.3 Utilizando o Operador “:” para Definir Vetores

Vetores com elementos sequenciais podem ser definidos por meio do operador “:” (dois

pontos). Neste caso, deve-se especificar o incremento ou o decremento desejado para que os

elementos do vetor sejam calculados automaticamente. Sua forma geral é:

[inicio : incremento (ou decremento) : valor limite ]

33


Exemplos:

-->a = [0:2:10] (cria um vetor a partir de zero, de dois em dois, até 10)

a =

0. 2. 4. 6. 8. 10.

___________________________________________________________________________________

-->b = [1:5:28] (a partir de um, de cinco em cinco, limitado por 28)

b =

1. 6. 11. 16. 21. 26.

___________________________________________________________________________________

-->c = [-1:0.2:1] (a partir de -1, com espaçamento de 0.2, até 1)

c =

- 1. -0.8 -0.6 -0.4 -0.2 0. 0.2 0.4 0.6 0.8 1.

___________________________________________________________________________________

-->d = [5:-1:1] (de 5, com decremento de -1, até 1)

b =

5. 4. 3. 2. 1.

Entretanto, o incremento pode ser omitido quando se deseja o valor 1. Exemplos:

-->a = [2:6] (a partir de 2, de um em um, até 6)

a =

2. 3. 4. 5. 6.

___________________________________________________________________________________

-->b = [-2:2] (a partir de -2, de um em um, até 2)

b =

-2. -1. 0. 1. 2.

5.4 Utilizando a Função linspace

A função linspace do Scilab pode ser utilizada para definir vetores contendo um número

específico de elementos igualmente espaçados dentro de um intervalo. Neste caso, não é

necessário saber o incremento (ou decremento), pois o mesmo será calculado

automaticamente. Sua forma geral é:

linspace(início, fim, número_de_elementos)

Exemplos:

-->x1=linspace(1, 3, 5) (vetor com 5 elementos igualmente espaçados de 1 a 3)

x1 =

1. 1.5 2. 2.5 3.

___________________________________________________________________________________

-->x2=linspace(-5, 5, 30) (vetor de 30 elementos igualmente espaçados de -5 a 5)

x2 =

-5. -4.6 -4.3 -3.9 -3.6 ... 3.9 4.3 4.6 5.

___________________________________________________________________________________

-->x3=linspace(-%pi, %pi, 40) (vetor com 40 elementos espaçados de - a )

x3 =

-3.14 -2.98 ... 2.98 3.14

34


5.5 Operações com Vetores

Os operados matemáticos e diversas funções do Scilab também podem ser aplicados a

vetores. O resultado das operações dependerá do contexto empregado.

OBS: Para os casos de operações de potenciação, multiplicação e divisão por escalares,

recomenda-se adicionar o ponto antes do operador (.^, .*, ./). Isto deixa claro para o Scilab

que a operação deve ser executada para cada elemento do vetor.

Exemplos:

-->a = [1 2 3 4] (define um vetor de nome a)

a =

1. 2. 3. 4.

-->b = 2.*a (cada elemento do vetor b terá o dobro do respectivo elemento de a)

b =

2. 4. 6. 8

-->c = a + b (os respectivos elementos são somados para a composição do vetor c)

c =

3. 6. 9. 12.

-->d = 2.*a + 1 (cada elemento do vetor a é multiplicado por dois e somado com 1)

d =

3. 5. 7. 9.

__________________________________________________________________________________

-->x = [-3:3]

x =

-3. -2. -1. 0. 1. 2. 3.

-->y = x.^2

y =

9. 4. 1. 0. 1. 4. 9.

___________________________________________________________________________________

-->x = [-%pi/2, 0, %pi/2]

x =

-1.57 0 1.57

-->y = sin(x) (a função seno será aplicada a cada valor de x)

y =

-1 0 1

5.6 Outras Funções Aplicadas a Vetores

O Scilab disponibiliza um conjunto de funções que podem ser aplicadas a vetores. Algumas

dessas funções são:

length – retorna o número de elementos de um vetor.

sum – calcula o somatório dos elementos de um vetor.

prod – calcula o produto dos elementos de um vetor.

norm – calcula a norma de um vetor.

35



1. Defina um vetor linha de nome para conter os valores 3, 8, 1, 5, 2.

2. Aplique a função matemática a todos os elementos do vetor x definido

anteriormente e armazene o resultado em um vetor y1.

3. Aplique a função a todos os elementos de x e armazene o resultado em

um vetor y2.

4. Defina um vetor coluna de nome x2 contendo os elementos 1, 10, 100, 1000.

5. Aplique a função aos elementos de x2 e armazene o resultado no vetor y2.

6. Defina um vetor de nome v1 contendo os números inteiros no intervalo [5, 100].

7. Defina um vetor de nome v2 contendo a sequência de números 1, 4, 7, 10, 13, ..., 97.

Utilize os recursos adequados.

8. Defina um vetor de nome v3 contendo a sequência de números 90, 84, 78, 72, ..., 12.

Utilize os recursos adequados.

9. Defina um vetor de nome v4 contendo números de – a espaçados de 0.15.

10. Defina um vetor de nome v5 contendo 80 números igualmente espaçados no intervalo

[ ]. Utilize os recursos adequados.

36

Construção de Gráficos Prof. Dr. Daniel A. Furtado

Capítulo 6

Construção de Gráficos

O Scilab disponibiliza uma série de recursos que possibilitam a construção de diversos tipos

de gráficos, incluindo gráficos de funções matemáticas, gráficos de barras e gráficos do tipo

pizza. Este capítulo faz uma breve introdução a alguns desses recursos.

6.1 Gráficos de Funções

Gráficos de funções de uma variável podem ser construídos no Scilab por meio da função

plot. Os valores das abcissas (x) e os valores das ordenadas (y) a serem utilizados no gráfico

podem ser especificados em vetores. Por exemplo, o gráfico da função para os

valores de apresentados na tabela a seguir, pode ser construído pela sequência de

comandos do Exemplo 1.

p1 p2 p3 p4 p5 p6 p7

-3 -2 -1 0 1 2 3

9 4 1 0 1 4 9

Exemplo 1. Construção de um gráfico pela especificação de uma série de pares ordenados.

x = [-3, -2, -1, 0, 1, 2, 3];

y = [9, 4, 1, 0, 1, 4, 9];

plot(x, y);

Ao executar tal sequência de comandos, seja no console ou no SciNotes, é criada uma janela

gráfica, conforme ilustrado na Figura 6.1. A função plot pressupõe que os elementos das

respectivas posições dos dois vetores constituem os pares ordenados, os quais são

interligados por uma linha.

Antes de executar novamente o comando plot, pode ser necessário limpar a janela gráfica

para evitar que os gráficos se sobreponham. Isto pode ser feito com o comando clf (de clear

figure). A janela gráfica pode ser fechada pelo comando close.

37


Figura 6.1 – Gráfico da função construído com a função plot do Scilab. Foram considerados 7 pontos no intervalo [-3, 3].

Uma maneira mais prática de construir o gráfico de uma função é utilizar os recursos do

Scilab de definição e manipulação de vetores, ao invés de definir explicitamente todos os

pontos em x e y. O gráfico pode ser criado em três passos:

1. Cria-se um vetor para armazenar os pontos de interesse em x utilizando o operador

“:” ou a função linspace;

2. Aplica-se a função matemática de interesse sobre o vetor x, o que permitirá a

obtenção do vetor y;

3. Utiliza-se a função plot em conjunto com os vetores x e y criados anteriormente.

Por exemplo, o gráfico anterior poderia ter sido criado pela sequência de comandos:

x = [-3:3]; // define o vetor x. Neste caso, com pontos de -3 a 3, espaçados de 1.

y = x.^2; // o valores de y são calculados a partir de x

plot(x, y);

6.1.1 Opções do Gráfico

É possível alterar diversas características do gráfico, como o tipo de linha, a cor e o tipo de

marcador. Tais opções são comumente especificadas entre aspas, da seguinte forma:

plot(vetor x, vetor y, 'opções')

onde “opções” representa um conjunto caracteres que define os detalhes do gráfico.

Algumas das opções aceitas pelo Scilab são apresentadas na Tabela 6.1. Elas podem ser

especificadas em qualquer ordem, desde que estejam dentro das aspas.

38


Símbolo Significado

Marcador

* Asterisco.

+ Símbolo +

o Círculo (Letra „o‟)

d Losango – diamond

s Quadrado – square

^,>,< ou v Tipos de triângulos

Linha

- Linha sólida

-- Linha tracejada

: Linha pontilhada

Cor

r Cor vermelha - red

g Cor verde – green

b Cor azul – blue

y Cor amazela - yellow

k Cor preta – black

Tabela 6.1 - Algumas opções da função plot

Exemplo Descrição Resultado

x = [-5:0.5:5];

y = x.^2;

plot(x, y, '*');

Os pontos aparecem com o

marcador *. Não há linha. Cor

azul (padrão).

x = [-5:0.5:5];

y = x.^2;

plot(x, y, '*-')

Gráfico com o marcador * e

com linha sólida conectando os

pontos.

39


Exemplos Descrição Resultado

x = [-5:0.5:5];

y = x.^2;

plot(x, y, '--ro');

Linha tracejada, na cor

vermelha, com o marcador

„o‟.

x = [-%pi:0.2:%pi];

y1 = sin(x);

plot(x,y1,'-*g');

y2 = cos(x);

plot(x,y2,'-dr');

Dois gráficos sobrepostos

utilizando duas vezes o

comando plot. Função seno

(verde) e cosseno

(vermelho). Valores de x no

intervalo [ ],

espaçados de 0.2.

x=linspace(1,10,50);

y = log2(x);

plot(x,y,'-sk');

Gráfico da função

para 50

pontos igualmente

espaçados no intervalo

[1,10]. Marcador

„quadrado‟ e cor preta.

6.1.2 Título, Rótulos dos Eixos, Legenda e Linhas de Grade

O gráfico, seus eixos e as curvas podem receber rótulos de identificação por meio das funções:

xtitle – insere um título para o gráfico

xlabel – insere um rótulo para o eixo

Ylabel – insere um rótulo para o eixo

legend – insere uma legenda para identificação das séries

xgrid – insere linhas de grade horizontais e verticais

40


Exemplo:

clf

x = [0:0.1:4*%pi];

y1 = sin(x);

y2 = cos(x);

plot(x,y1,'-*b');

plot(x,y2,'-dr');

xtitle('Funções seno e cosseno'); // insere o título

xlabel('Eixo X'); // insere o rótulo do eixo horizontal x

ylabel('Eixo Y'); // insere o rótulo do eixo vertical y

legend('Seno', 'Cosseno'); // insere uma legenda para identificar,

// na respectiva ordem, as duas curvas

Resultado:

OBS: É possível desenhar o gráfico de diversas funções utilizando o comando plot uma única

vez. Para o exemplo anterior, poderíamos ter utilizado:

plot(x,y1,'-*b', x,y2,'-dr');

6.1.3 Outras Opções do Gráfico

Detalhes sobre os eixos podem ser especificados por meio da função gca (get current axes),

que retorna uma variável especial para manipulação dos eixos do gráfico. Tal variável dá

acesso às diversas propriedades dos eixos, que podem ser configuradas pelo usuário.

Algumas dessas propriedades são:

x_location – posição do eixo x. Pode ser „top’, „middle’, „bottom’ ou „origin’;

y_location – posição do eixo y. Pode ser „left’, „middle’, „right’ ou „origin’;

41


axes_visible – indica se os eixos devem ser mostrados ‘on’ ou não ‘off’;

isoview – utiliza escalas isométricas para os eixos. Pode ser „on’ ou „off’;

Exemplo:

clf

x = [0:0.1:2*%pi];

y1 = sin(x);

y2 = cos(x);

plot(x,y1,'-*b', x,y2,'-dr');

xtitle('Funções seno e cosseno – Escalas isométricas');

legend('Seno', 'Cosseno');

a = gca(); // obtém o manipulador de eixos

a.isoview = 'on'; // utiliza escalas isométricas

a.x_location = 'middle'; // o eixo x será mostrado no centro

Resultado:

OBS: Para que os eixos X e Y sejam exibidos na posição natural do plano cartesiano, é

necessário definir as propriedades x_location e x_location do gráfico para o valor

„origin’:


a.x_location = 'origin'; // posiciona o eixo x na origem do sist. de coordenadas

a.y_location = 'origin'; // posiciona o eixo y na origem do sist. de coordenadas

Exemplo:

clf

x = [-3:0.1:3];

y = x .^ 2 + 2;

plot(x,y,'-*r', x,y,'-*r');

xtitle('Função f(x) = x² + 2 – Eixos na origem');


a.isoview = 'on'; // utiliza escalas isométricas

a.x_location = 'origin'; // posiciona o eixo x na origem do sist. de coordenadas

a.y_location = 'origin'; // posiciona o eixo y na origem do sist. de coordenadas

xgrid // ativa as linhas de grade

42


Resultado:

Algumas das propriedades dos eixos e de outros elementos do gráfico podem ser

configuradas visualmente. Bastar acessar a opção Editar Propriedades dos eixos da

janela do gráfico. A janela de configuração exibida pelo Scilab é apresentada na Figura 6.2.

6.2 O Comando subplot

O comando subplot é utilizado para inserir diversos gráficos em uma mesma janela. O

comando divide a janela gráfica em uma matriz de m x n células, onde em cada célula é

possível inserir um gráfico. Sua forma de uso é:

subplot(m, n, p)

onde:

m – número de linhas em que se deseja dividir a janela gráfica

n – número de colunas em que se deseja dividir a janela gráfica

p – posição da matriz a ser ativada, contada da esquerda para a direita, linha a linha.

Todos os comandos voltados para a inserção e configuração de gráficos terão efeito

sobre o gráfico dessa posição.

43


Figura 6.2 - Janela de configuração das propriedades dos eixos

No exemplo a seguir, seis gráficos são colocados em uma mesma janela gráfica. Eles são

organizados em uma matriz de duas linhas e três colunas. Repare que a função subplot é

utilizada diversas vezes para ativar cada uma das posições de plotagem. O número de linhas e

o número de colunas permanecem inalterados (pois não desejamos alterar essa disposição),

mas a posição ativa de plotagem é atualizada para cada novo gráfico.

Exemplo:

// vetor x

x = [-3:0.1:3];

// Gráfico 1

y1 = x.^2;

subplot(2,3,1); // A janela será div. em 2 linhas e 3 colunas. A 1ª pos. é ativada

plot(x,y1,'*-');

xtitle('Gráfico 1: função quadrática');

// Gráfico 2

y2 = x.^3;

subplot(2,3,2); // Ativa a segunda posição de plotagem

plot(x,y2,'+-');

xtitle('Gráfico 2: função cúbica');

// Gráfico 3

y3 = sin(x);

subplot(2,3,3);

plot(x,y3,'o-');

xtitle('Gráfico 3: função seno');

// Gráfico 4

y4 = -x^2;

subplot(2,3,4);

44


plot(x,y4,'d-');

xtitle('Gráfico 4: função quadrática 2');

// Gráfico 5

y5 = -x.^3;

subplot(2,3,5);

plot(x,y5,'p-');

xtitle('Gráfico 5: função cúbica 2');

// Gráfico 6

y6 = cos(x);

subplot(2,3,6);

plot(x,y6,'x-');

xtitle('Gráfico 6: função cosseno');

Resultado:

Figura 6.3 - Inserindo diversos gráficos na mesma janela com a função subplot.

45


6.3 Outros Tipos de Gráficos

O Scilab também disponibiliza funções para a construção de outros tipos de gráficos,

incluindo gráficos de barras verticais, gráficos de barras horizontais e gráficos do tipo pizza.

As funções são:

bar – para gráficos de barras verticais;

barh – para gráficos de barras horizontais;

pie – para gráficos do tipo pizza.

Tais funções são comumente utilizadas da seguinte forma:

bar(vetor_de_números, <largura_das_barras>)

barh(vetor_de_números, <largura_das_barras>)

pie(vetor_de_números, <espaçamento_fatias>, <rótulos_fatias>)

onde:

vetor_de_números: vetor contendo os valores que definem, de maneira

proporcional, o comprimento de cada barra (ou o tamanho de cada fatia da „pizza‟);

largura_das_barras: número entre 0 e 1 que determina a largura das barras (0 =

largura mínima, 1 = largura máxima). Este dado é opcional.

espaçamento_fatias: vetor de números que especificam se a respectiva fatia da

„pizza‟ deve aparecer afastada (número diferente de 0) ou „grudada‟ no centro da

„pizza‟ (valor 0);

rótulos_fatias: vetor contendo os rótulos, entre aspas, correspondentes às fatias

da „pizza‟.

Exemplos:

Comandos Gráfico Resultante

clf;

x = [1,2,3,4];

bar(x, 0.5);

46


clf;

x = [1,2,3,2];

bar(x, 0.9);

clf;

x = [1,2,3,4];

barh(x, 0.5);

clf;

pie([18,4,3],[0,1,0],['Aprovados',

'Rep. por falta', 'Rep. por

nota']);

47

Operações com Matrizes Prof. Dr. Daniel A. Furtado

Capítulo 7

Operações com Matrizes

Matrizes podem ser definidas no Scilab de maneira semelhante aos vetores. Os elementos

devem ser especificados entre colchetes. As linhas podem ser separadas por ponto-e-vírgula

ou ENTER e os elementos de uma mesma linha podem ser separados por vírgula ou espaço.

Exemplos:

[

] [

] *

+

-->A = [1,2,3; 2,5,1; 7,4,9]

A =

1. 2. 3.

2. 5. 1.

7. 4. 9.

-->B = [2 1; 3 2; 4 3]

B =

2. 1.

3. 2.

4. 3.

-->C = [9 8 7 6

-->1 2 3 4]

C =

9. 8. 7. 6.

1. 2. 3. 4.

O operador “:” pode ser utilizado para especificar uma sequência de elementos dentro de

uma mesma linha. Por exemplo, a matriz:

[

]

pode ser definida pelo comando:

--> D = [1:5; 6:10; 12:2:20]

48


7.1 Acesso aos Elementos da Matriz

Após definir a matriz, um elemento específico pode ser acessado utilizando-se a notação

, onde A é o nome da matriz, i é o número da linha e j é número da coluna onde o

elemento se encontra.

Exemplos:

-->M = [4,9,5; 7,3,8] (define uma matriz M)

M =

4. 9. 5.

7. 3. 8.

-->M(1,3) (Acessa o elemento da 1ª linha e 3ª coluna de M)

ans =

5.

-->x = M(2,1) (Acessa o elemento da 2ª linha e 1ª coluna de M e o armazena em x)

x =

7.

-->M(1,2) = 10 (Altera o elemento da 1ª linha e 2ª coluna de M para o valor 10)

M =

4. 10. 5.

7. 3. 8.

Acessando uma Linha Inteira

Especifica-se o número da linha e coloca-se “:” para a coluna.


M =

1. 2. 3.

4. 5. 6.

-->M(2,:) (acessa toda a 2ª linha de M)

ans =

4. 5. 6.

-->M(2,:) = [7,8,9] (altera toda a 2ª linha de M. Repare no novo vetor linha)

M =

1. 2. 3.

7. 8. 9.

Acessando uma Coluna Inteira

Especifica-se o número da coluna e coloca-se “:” para a linha.


M =

1. 2. 3.

4. 5. 6.

49


-->M(:,3) (acessa toda a 3ª coluna de M)

ans =

3.

6.

-->M(:,2) = [20; 30] (altera toda a 2ª coluna de M. [20;30] é um vetor coluna)

M =

1. 20. 3.

4. 30. 6.

Acessando uma Submatriz

Também é possível acessar uma parte da matriz envolvendo mais de uma linha ou coluna.

Neste caso, deve-se especificar o intervalo de linhas e o intervalo de colunas que envolvem a

parte desejada. No exemplo a seguir, acessamos a submatriz de A indicada pela linha

tracejada.

[

]

-->A = [1 9 6 0; 6 7 8 9; 5 1 6 8; 4 0 9 3]

A =

1. 9. 6. 0.

6. 7. 8. 9.

5. 1. 6. 8.

4. 0. 9. 3.

-->A(1:3,2:4) (acessa a submatriz de A: da linha 1 à 3, da coluna 2 à 4)

ans =

9. 6. 0.

7. 8. 9.

1. 6. 8.

7.2 Adicionando e Removendo Linhas e Colunas

Adicionando Linhas à Matriz

-->A = [3 2 1; 6 5 4] (define uma matriz A)

A =

3. 2. 1.

6. 5. 4.

-->A = [A; [1,2,3]] (adiciona a linha [1,2,3] no final da matriz A)

A =

3. 2. 1.

6. 5. 4.

1. 2. 3.

50


-->A = [[5,5,5]; A] (adiciona a linha [5,5,5] no início da matriz A)

A =

5. 5. 5.

3. 2. 1.

6. 5. 4.

1. 2. 3.

Adicionando uma Nova Coluna

-->B = [1, 2; 3, 4] (define uma matriz B)

B =

1. 2.

3. 4.

-->B = [B, [5;6]] (adiciona a coluna [5;6] no final da matriz B)

B =

1. 2. 5.

3. 4. 6.

-->B = [[0;1], B] (adiciona a coluna [0;1] no início da matriz B)

B =

0. 1. 2. 5.

1. 3. 4. 6.

Removendo uma Linha ou Coluna

-->C = [1, 2; 3, 4; 5, 6] (define uma matriz C)

C =

1. 2.

3. 4.

5. 6.

-->C(2,:) = [] (exclui a 2ª linha da matriz C)

C =

1. 2.

5. 6.

-->C(:,1) = [] (exclui a 1ª coluna da matriz C)

C =

2.

6.

Observe que quando uma linha ou coluna é excluída, as demais são reorganizadas para

ocupar o seu lugar.

7.3 Operações de Soma, Subtração e Multiplicação

As operações de soma, subtração e multiplicação de matrizes podem ser realizadas com os

próprios operadores matemáticos +, - e *, respectivamente. Entretanto, é preciso que as

matrizes operadas sejam compatíveis, de acordo com as restrições matemáticas.

Exemplos:

51


-->A = [1,2; 3,4] (define uma matriz A)

A =

1. 2.

3. 4.

-->B = A (define uma matriz B igual à matriz A)

B =

1. 2.

3. 4.

-->C = A + B (calcula a soma das matrizes A e B e armazena em C.

C = As matrizes precisam ter as mesmas dimensões)

2. 4.

6. 8.

-->D = A – B (calcula a diferença das matrizes A e B)

D =

0. 0.

0. 0.

-->E = A * B (calcula o produto matricial de A por B.

E = O número de colunas da primeira deve ser igual ao

7. 10. número de linhas da segunda)

15. 22.

-->F = 2 * A + 1 (operação com escalares. Cada elemento da matriz A é

F = multiplicado por 2 e somado com 1, resultando em uma

3. 5. nova matriz F)

7. 9.

7.4 Outras Funções Aplicadas a Matrizes

length(A) – retorna o número total de elementos da matriz A;

sum(A) – calcula o somatório dos elementos de A;

det(A) – calcula o determinante da matriz quadrada A;

inv(A) – calcula a inversa da matriz quadrada A (se houver);

A' – calcula a matriz transposta de A;

diag(A) – retorna a diagonal principal da matriz A na forma de um vetor coluna;

size(A) – retorna as dimensões de A (o número de linhas e o número de colunas);

eye(m,n) – define uma matriz contendo 1‟s na diagonal principal e 0‟s nas

demais posições (matriz identidade);

zeros(m,n) – define uma matriz nula de tamanho ;

ones(m,n) – define uma matriz onde todos os elementos são iguais a 1;

rand(m,n) – define uma matriz de números aleatórios entre 0 e 1.

52


Exemplos:

-->A = [3,7,1;8,5,0] (define uma matriz A)

A =

3. 7. 1.

8. 5. 0.

-->length(A) (obtém o número total de elementos de A)

ans =

6.

-->size(A) (obtém o número de linhas e o número de colunas de A)

ans =

2. 3.

-->[L,C]=size(A) (obtém as dimensões de A, armazenando nas vars. L e C)

C =

3.

L =

2.

-->A = [A;[2,1,3]] (adiciona uma nova linha em A)

A =

3. 7. 1.

8. 5. 0.

2. 1. 3.

-->det(A) (calcula o determinante de A)

ans =

- 125.

-->A' (calcula a matriz transposta de A)

ans =

3. 8. 2.

7. 5. 1.

1. 0. 3.

-->inv(A) (calcula a matriz inversa de A)

ans =

-0.12 0.16 0.04

0.192 -0.056 -0.064

0.016 -0.088 0.328

-->eye(3,3) (matriz identidade 3 x 3)

ans =

1. 0. 0.

0. 1. 0.

0. 0. 1.

-->ones(3,3) (matriz 3 x 3 contendo apenas o valor 1)

ans =

1. 1. 1.

1. 1. 1.

1. 1. 1.

53


-->zeros(3,3) (matriz nula 3 x 3)

ans =

0. 0. 0.

0. 0. 0.

0. 0. 0.

-->rand(3,3) (matriz 3 x 3 de números aleatórios)

ans =

0.2113249 0.3303271 0.8497452

0.7560439 0.6653811 0.6857310

0.0002211 0.6283918 0.8782165

7.5 Resolução de Sistemas Lineares

Para resolver um sistema de equações lineares no Scilab, pode-se considerá-lo como uma

multiplicação de matrizes e realizar o cálculo da matriz inversa. Por exemplo, considere o

seguinte sistema:

{

Esse sistema pode ser representado pela multiplicação de matrizes:

(

) ( ) (

)

que pode ser representada, de forma sucinta, por:

onde A é a matriz dos coeficientes, b é o vetor coluna dos termos independentes e s é o vetor

solução ( ). Ao multiplicar os dois lados da equação pela matriz inversa de A, obtemos:

que resulta na equação:

Assim, para encontrar o vetor solução de um sistema linear, pode-se multiplicar a inversa da

matriz dos coeficientes do sistema (caso ela exista) pelo vetor coluna de seus termos

independentes. Por exemplo, o sistema linear anterior pode ser resolvido pelo programa:

A=[2,3;1,-1]; // define a matriz dos coeficientes

b=[19;-3]; // define o vetor coluna dos termos independentes

s=inv(A)*b; // resolve o sistema linear

printf("x=%.1f, y=%.1f", s(1), s(2)); // apresenta a solução do sistema

Entretanto, o sistema será possível e determinado apenas quando a matriz dos coeficientes

possuir inversa, o que acontece quando o seu determinante é diferente de zero. Assim,

convém verificar o determinante da matriz dos coeficientes antes de utilizar a função inv.

Isto é feito no exemplo a seguir.

54


Exemplo 1. Faça um programa que receba do usuário uma matriz 3x3 correspondente aos

coeficientes de um sistema linear e um vetor coluna correspondente aos termos

independentes. O programa deve encontrar e apresentar a solução do respectivo sistema,

caso ele seja possível e determinado. Caso contrário, uma mensagem adequada deve ser

apresentada.

A=input('Informe a matriz 3x3 dos coeficientes do sistema: ');

b=input('Informe o vetor coluna dos termos independentes: ');

if (det(A) ~= 0) then

s=inv(A)*b;

printf("x=%.1f, y=%.1f, z=%.1f", s(1), s(2), s(3));

else

printf('Sistema impossível ou indeterminado');

end

Um sistema linear da forma também pode ser resolvido no Scilab utilizando-se o

operador “\”. Neste caso, a solução é dada por: s = A \ b.

55

Estruturas de Repetição Prof. Dr. Daniel. A. Furtado

Capítulo 8

Estruturas de Repetição

8.1 Estrutura de Repetição while (enquanto)

A estrutura de repetição while (em português, “enquanto”) é utilizada quando se deseja

repetir a execução de um bloco de comandos enquanto uma determinada condição for

verdadeira. Sua forma geral de uso no Scilab é:

while (condição)

comando 1

comando 2

...

comando n

end

Antes dos comandos serem executados pela primeira vez, a condição é verificada. Caso ela

seja falsa, então o bloco de comandos não será executado nenhuma vez. Caso seja

verdadeira, então o bloco de comandos será executado enquanto a condição permanecer

verdadeira. Dessa forma, após a execução do último comando dentro do bloco (comando n, no

exemplo acima), a condição é novamente verificada, o que determina se os comandos

deverão ser executados novamente ou não. O diagrama a seguir ilustra a lógica de

funcionamento da estrutura while.

56


Exercícios Resolvidos

Exemplo 1. Faça um programa que receba o valor do raio de um círculo e calcule a sua área.

Caso o usuário informe um valor menor ou igual a 0 para o raio, o programa deverá solicitar

repetidamente outro valor, até que o usuário informe um número positivo.

r = input('Informe o valor do raio do círculo: ');

while (r <= 0)

printf('Valor inválido!');

r = input('Informe um valor positivo para o raio: ');

end

area = %pi * r^2;

printf('A área do círculo de raio %d é %d', r, area);

Exemplo 2. Faça um programa para exibir na tela a mensagem “Olá” 100 vezes.

i = 1;

while (i <= 100)

printf('\nOlá!');

i = i + 1;

end

Exemplo 3. Utilizando a estrutura while, faça um programa para ler números inteiros do

teclado até que o número 0 seja lido. Ao término da leitura, o programa deverá apresentar a

soma de todos os números informados.

total = 0;

x = input('Digite o primeiro número: ');

while (x ~= 0)

total = total + x;

x = input('Digite o próximo número (ou 0 para encerrar): ');

end

printf('A soma dos números informados é: %d', total);

Estrutura while

57


Exemplo 4. Utilizando a estrutura while, faça um programa para ler números inteiros do

teclado até que o número 0 seja lido. Ao término, o programa deverá apresentar o maior

número lido (desconsiderando o valor 0).

x = input('Digite o primeiro número: ');

maior = x;

while (x ~= 0)

if (x > maior) then

maior = x

end

x = input('Digite o próximo número (ou 0 para encerrar): ');

end

printf('O maior número lido é: %d', maior);

Exemplo 5. Utilizando a estrutura while, faça um programa para calcular o somatório da série

1 + 2 + 3 + ... + N. O valor N deve ser solicitado ao usuário.

N = input('Informe o valor de N: ');

i = 1;

soma = 0;

while (i <= N)

soma = soma + i;

i = i + 1;

end

printf('O somatório é %d', soma);

Exemplo 6. Faça um programa que apresente na tela o seguinte menu de opções:

Menu de Opções

1 – Calcular a área de uma sala retangular 2 – Calcular a área de uma redonda 3 – Sair

Informe a opção desejada:

O programa deverá voltar ao menu após a execução da opção escolhida pelo usuário e deverá

ser encerrado apenas quando o usuário escolher a opção 3 (sair). Quando a opção 1 for

escolhida, por exemplo, o programa deverá solicitar as dimensões da sala retangular,

calcular e mostrar a sua área.

58


op = 0;

while (op ~= 3)

clc;

printf(' Menu de Opções \n');

printf('\n 1 - Calcular a área de uma sala retangular');

printf('\n 2 – Calcular a área de uma redonda');

printf('\n 3 – Sair \n\n');

op = input('Informe a opção desejada: ');

clc;

if (op == 1) then

b = input('Informe a largura da sala (em metros): ');

a = input('Informe o comprimento da sala (em metros): ');

area = b * a;

printf('A área da sala de larg. %d e comp. %d é %d m2', b, a, area);

else

if (op == 2) then

d = input('Informe o diâmetro da sala (em metros): ');

r = d / 2;

area = %pi*r^2;

printf('A area da sala é %f m2', area);

end

end

input('Pressione ENTER para continuar');

end

printf('Fim do programa');

Exemplo 6. Faça um programa para calcular o somatório dos números pares menores que

um dado número N fornecido pelo usuário.


i = 2;

soma = 0;

while (i <= N)

soma = soma + i;

i = i + 2;

end

printf('O somatório é %d', soma);

8.2 Estrutura de Repetição for (“repita para”)

A estrutura de repetição for é comumente empregada quando se deseja repetir a execução de

um bloco de comandos para cada valor que uma variável assume a partir de uma expressão.

A forma geral de utilização da estrutura for no Scilab é:

for variável = expressão

comando 1

comando 2

...

comando n

end

59


A expressão utilizada no laço for geralmente define um vetor de números inteiros, que

indica o valor que a variável receberá durante cada ciclo de execução. Por exemplo, o

programa a seguir exibe na tela os valores que a variável i receberá ao longo de sua execução.

for i = 1:5

printf('\nValor da variável i: %d', i);

end

O programa anterior produz o seguinte resultado:

Valor da variável i: 1





Embora o comando for possa ser empregado também em outros contextos, a forma ilustrada

a seguir é a mais comum:

for variável = valorInicial : incremento(ou decremento) : limiteSuperior(inferior)

comando 1

comando 2

...

comando n

end

Exercícios Resolvidos

Exemplo 1. Faça um programa utilizando a estrutura for para apresentar na tela todos os

números inteiros do intervalo [1, N], onde N é um número inteiro informado pelo usuário.


for i = 1:N

printf('\n %d', i);

end

Exemplo 2. Faça um programa utilizando a estrutura for para apresentar na tela todos os

números inteiros pares do intervalo [0, N], onde N é informado pelo usuário.


for i = 0:2:N

printf('\n %d', i);

end

Exemplo 3. Faça um programa utilizando a estrutura for para apresentar na tela a sequência

de valores 100, 95, 90, 85, ..., 15, 10.

for i = 100:-5:10

printf('\n %d', i);

end

60


Exemplo 4. Utilizando a estrutura for, faça um programa para calcular o somatório 20 + 21 +

22 + ... + 2N. O valor N deve ser informado pelo usuário.


soma = 0;

for i = 0:N

soma = soma + 2^i;

end

printf('A soma dos valores é %d', soma);

Exemplo 5. Utilizando a estrutura for, faça um programa para ler um vetor de números

inteiros e em seguir calcular o produto de todos os elementos do vetor.

v = input('Informe um vetor de valores: ');

n = length(v); // a função length calcula o número de elementos de um vetor

produto = 1;

for i = 1:n

produto = produto * v(i);

end

printf('O produto dos elementos do vetor é %d', produto);

Exemplo 6. Utilizando a estrutura for, faça um programa para somar todos os elementos da

matriz A = rand(50,100).

A = rand(50,100);

soma = 0;

for i = 1:50

for j = 1:100

soma = soma + A(i,j);

end

end

printf('A soma dos números aleatórios gerados é %d', soma);

61


Referências

1. BAUDIN, Michael. Introduction to Scilab. The Scilab Consortium, 2010.

2. KNUTH, D. E. Art of Computer Programming, Volume 1: Fundamental Algorithms. 3.

ed. Reading, Massachusetts: Addison-Wesley, 1997.

3. ASCENCIO, A. F. G. & CAMPOS, E. A. V. Fundamentos da programação de

computadores: Algoritmos, Pascal e C/C++. São Paulo: Pearson Prentice Hall, 2002.

4. www.scilab-enterprises.com

5. www.scilab.org

http://www.scilab.org/

Introdução ao Scilab e à Programação de …§ãoScilab...Esta apostila foi escrita por Daniel...

Documents

Transcript of Introdução ao Scilab e à Programação de …§ãoScilab...Esta apostila foi escrita por Daniel...