Upload
ledang
View
216
Download
0
Embed Size (px)
Citation preview
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
EXERCÍCIOS PROPOSTOS ..................................................................................................................................................... 23
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
EXERCÍCIOS PROPOSTOS ..................................................................................................................................................... 29
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
EXERCÍCIOS PROPOSTOS ..................................................................................................................................................... 35
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.
5
Introdução ao Scilab Prof. Dr. Daniel A. Furtado
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
Introdução ao Scilab Prof. Dr. Daniel A. Furtado
-->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
Introdução ao Scilab Prof. Dr. Daniel A. Furtado
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
Introdução ao Scilab Prof. Dr. Daniel A. Furtado
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
Introdução ao Scilab Prof. Dr. Daniel A. Furtado
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.
Exercícios Propostos
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
Introdução ao Scilab Prof. Dr. Daniel A. Furtado
-->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
Introdução ao Scilab Prof. Dr. Daniel A. Furtado
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
Introdução ao Scilab Prof. Dr. Daniel A. Furtado
Exercícios Propostos
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
Introdução a Algoritmos Prof. Dr. Daniel. A. Furtado
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
Introdução a Algoritmos Prof. Dr. Daniel. A. Furtado
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
Introdução a Algoritmos Prof. Dr. Daniel. A. Furtado
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
Introdução a Algoritmos Prof. Dr. Daniel. A. Furtado
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
Introdução a Algoritmos Prof. Dr. Daniel. A. Furtado
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
Entrada e Saída utilizando o SciNotes Prof. Dr. Daniel. A. Furtado
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
Entrada e Saída utilizando o SciNotes Prof. Dr. Daniel. A. Furtado
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:
lado = input("Informe a medida do lado de um quadrado: ");
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.
lado = input("Informe a medida do lado de um quadrado: ");
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.
lado = input("Informe a medida do lado de um quadrado: ");
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
Entrada e Saída utilizando o SciNotes Prof. Dr. Daniel. A. Furtado
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
Entrada e Saída utilizando o SciNotes Prof. Dr. Daniel. A. Furtado
Exercícios Propostos
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
Estrutura Condicional if-then-else Prof. Dr. Daniel. A. Furtado
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
Estrutura Condicional if-then-else Prof. Dr. Daniel. A. Furtado
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
Estrutura Condicional if-then-else Prof. Dr. Daniel. A. Furtado
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
Estrutura Condicional if-then-else Prof. Dr. Daniel. A. Furtado
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
Estrutura Condicional if-then-else Prof. Dr. Daniel. A. Furtado
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
Exercícios Propostos
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
Estrutura Condicional if-then-else Prof. Dr. Daniel. A. Furtado
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
Operações com Vetores Prof. Dr. Daniel A. Furtado
-->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
Operações com Vetores Prof. Dr. Daniel A. Furtado
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
Operações com Vetores Prof. Dr. Daniel A. Furtado
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
Operações com Vetores Prof. Dr. Daniel A. Furtado
Exercícios Propostos
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
Construção de Gráficos Prof. Dr. Daniel A. Furtado
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
Construção de Gráficos Prof. Dr. Daniel A. Furtado
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
Construção de Gráficos Prof. Dr. Daniel A. Furtado
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
Construção de Gráficos Prof. Dr. Daniel A. Furtado
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
Construção de Gráficos Prof. Dr. Daniel A. Furtado
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 = gca(); // obtém o manipulador de eixos
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 = gca(); // obtém o manipulador de eixos
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
Construção de Gráficos Prof. Dr. Daniel A. Furtado
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
Construção de Gráficos Prof. Dr. Daniel A. Furtado
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
Construção de Gráficos Prof. Dr. Daniel A. Furtado
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
Construção de Gráficos Prof. Dr. Daniel A. Furtado
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
Construção de Gráficos Prof. Dr. Daniel A. Furtado
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
Operações com Matrizes Prof. Dr. Daniel A. Furtado
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] (define uma matriz M)
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] (define uma matriz M)
M =
1. 2. 3.
4. 5. 6.
49
Operações com Matrizes Prof. Dr. Daniel A. Furtado
-->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
Operações com Matrizes Prof. Dr. Daniel A. Furtado
-->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
Operações com Matrizes Prof. Dr. Daniel A. Furtado
-->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
Operações com Matrizes Prof. Dr. Daniel A. Furtado
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
Operações com Matrizes Prof. Dr. Daniel A. Furtado
-->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
Operações com Matrizes Prof. Dr. Daniel A. Furtado
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
Estruturas de Repetição Prof. Dr. Daniel. A. Furtado
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
Estruturas de Repetição Prof. Dr. Daniel. A. Furtado
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
Estruturas de Repetição Prof. Dr. Daniel. A. Furtado
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.
N = input('Informe o valor de N: ');
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
Estruturas de Repetição Prof. Dr. Daniel. A. Furtado
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
Valor da variável i: 2
Valor da variável i: 3
Valor da variável i: 4
Valor da variável i: 5
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.
N = input('Informe o valor de N: ');
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.
N = input('Informe o valor de N: ');
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
Estruturas de Repetição Prof. Dr. Daniel. A. Furtado
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.
N = input('Informe o valor de N: ');
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
Estruturas de Repetição Prof. Dr. Daniel. A. Furtado
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