SciLab Programável

1
Aluísio Eustáquio da Silva
SciLab Programável
Material didático usado em aulas de Programação de Computadores, Algoritmos
e Lógica de Programação
Betim
Maio de 2012
2
PROGRAMAÇÃO
O SciLab permite que se criem programas, que são algoritmos escritos numa linguagem que
o computador possa entender e executar.
Programa de computador é um conjunto de instruções que são codificadas em linguagem de
máquina, a linguagem do computador, por um outro programa, e depois executadas. Existem dois
tipos de programas para se criar programas:
Compiladores:
codificam todo o programa para depois executá-lo
Interpretadores:
codificam e executam instrução por instrução
O SciLab está na categoria dos interpretadores.
SCRIPTS
São arquivos do tipo texto com um conjunto de instruções a serem executadas. Esses
arquivos podem ser gravados e usados toda vez que for necessário, sem necessidade de nova
digitação.
Os scripts são executadas em ordem sequencial, de cima para baixo.
Pode-se acrescentar em um programas estruturas que são executadas dependendo de
certas condições e estruturas que se repetem um número finito de vezes.
Para criar um script usaremos o próprio editor de scripts do SciLab que apresenta uma série
de facilidades, como por exemplo, a convenção de cores abaixo:
Azul claro
comandos da linguagem
Azul escuro
funções da linguagem
Verde
comentários
Marrom
strings
Rosa
parênteses
Preto
variáveis
3
ESTRUTURA DE UM PROGRAMA
Adotaremos alguns padrões, não obrigatórios, para tornar os programas simples, legíveis e
funcionais:

Todo Programa começará com um comentário onde ficará expresso de forma bem clara qual
é o objetivo do mesmo, quem o desenvolveu e a data de confecção.

Os comandos (instruções) de um programa serão delimitados em uma função com as
palavras chaves do SciLab function e endfunction.

As instruções do programa serão escritas, uma por linha

Cada linha será alinhada à esquerda, com espaços, “endentações”, nas estruturas de um
mesmo nível.

As palavras chaves do programa serão obrigatoriamente escritas com letras minúsculas

Todo identificador de variável que tiver mais de um caractere se iniciará com letra maiúscula

Os identificadores compostos terão cada palavra se iniciando com letra maiúscula e
separados por travessão (underline).
Exemplo:
//EXEMPLO 1
//PROGRAMA PARA CONVERTER POLEGADAS EM MILÍMETROS
function Polegadas_Milimetros()
//DECLARAÇÃO DE VARIÁVEIS
//inteiro Numerador_Polegada, Denominador_Polegada
//real Milimetros
printf("************************************************************");
printf("\nPrograma para converter polegadas em milímetros");
printf("\n**********************************************************\n");
//ENTRADA DE DADOS
Numerador_Polegada = input("Digite o numerador de uma medida em polegadas: ");
Denominador_Polegada = input("Digite o denominador de uma medida em polegadas: ");
//PROCESSAMENTO
Milimetros = (Numerador_Polegada / Denominador_Polegada) * 25.4;
//SAIDA DE RESULTADOS
printf("\nPolegadas: %d / %d ", Numerador_Polegada, Denominador_Polegada);
printf(" = %4.2f ", Milimetros);
return; //RETORNA À FUNÇÃO CHAMADORA
endfunction
//PROGRAMA PRINCIPAL
clc;
Polegadas_Milimetros();
//FIM PROGRAMA PRINCIPAL
4
ESTRUTURAS SEQUENCIAIS
De acordo com a sequência das ações executadas por um programa, suas estruturas podem
ser classificadas em: Estrutura Sequencial, Condicional ou de Repetição. Nas estruturas sequenciais
os comandos serão executados na ordem em que aparecem. Nas estruturas condicionais os
comandos são executados ou não, dependendo de certas condições verdadeiras ou falsas. E nas
estruturas de repetição, sequências de comandos serão repetidas dependendo de condições
verdadeiras ou falsas.
Para facilitar o desenvolvimento de programas, escreveremos todos os comandos em uma
rotina que em SciLab é denominada “function”. Depois criaremos um programa que “chama” essa
rotina. Esse programa será chamado de programa principal, apesar desse termo não existir em
SciLab.
//EXEMPLO 2
//PROGRAMA PARA TRANSFORMAR GRAUS FAHRENHEIT EM GRAUS
CELSIUS
// PROGRAMA PARA TRANSFORMAR GRAUS CELSIUS EM GRAUS
FAHRENHEIT
function Fahrenheit_Celsius()
//DECLARAÇÃO DE VARIÁVEIS
//real Fahrenheit, Celsius
printf("****************************************************");
printf("\nPrograma para converter graus Fahrenheit em Celsius");
printf("\n
e");
printf("\nPrograma para converter graus Celsius em Fahrenheit");
printf("\n***************************************************\n");
//ENTRADA DE DADOS
Fahrenheit = input("Digite uma temperatura em graus Fahrenheit: ");
//PROCESSAMENTO
Celsius =(5/9)*( Fahrenheit -32);
//SAÍDA DE RESULTADOS
printf("\nFahrenhit: %3.1f ", Fahrenheit);
printf("\nCelsius: %3.1f ", Celsius);
printf("\n\n");
Celsius = input("Digite uma temperatura em graus Celsius --> ");
Fahrenheit = 9 * Celsius / 5 + 32;
printf("\nCelsius: %3.1f ", Celsius);
printf("\nFahrenhit: %3.1f ", Fahrenheit);
return; //RETORNA À FUNÇÃO CHAMADORA
endfunction // function Fahrenheit_Celsius()
//PROGRAMA PRINCIPAL
clc;
Fahrenheit_Celsius();
//FIM PROGRAMA PRINCIPAL
5
ESTRUTURAS CONDICIONAIS
Os programas anteriores executaram apenas uma sequência de ações, uma após a outra, em uma ordem
pré-estabelecida seguindo o padrão:

Declaração de variáveis

Entrada de dados pelo teclado, sem validação dos mesmos

Processamento sequencial (sem desvios ou repetições)

Impressão de valores na tela
Nos próximos programas introduziremos comandos para controlar a ordem e o número de vezes que uma
tarefa deve ser executa.
OPERADORES RELACIONAIS
São operadores que estabelecem uma relação entre dois operandos, gerando um resultado verdadeiro ou
falso.
Matemática
Significado
SciLab
=
igual a
==
≠
diferente de
>
maior que
>
<
menor que
<
≤
menor ou igual a
<=
≥
maior ou igual a
>=
<> ou ~=
OPERADORES LÓGICOS
São operadores que estabelecem uma “conexão” entre expressões lógicas.
Utilizaremos três operadores lógicos:
NÃO
~
OU
|
E
&
O operador NÃO (~) tem apenas um operando, o OU (|) e o E (&) têm dois operandos. Esses operadores
produzem um resultado lógico (“True” = verdadeiro ou “False” = falso).
6
Para facilitar o entendimento, usa-se fazer uma tabela, chamada tabela verdade, com esses operadores.
Sejam duas proposições quaisquer p e q
p
q
~p
p | q
p & q
T
T
F
T
T
T
F
F
T
F
F
T
T
T
F
F
F
T
F
F
ESTRUTURAS CONDICIONAIS SIMPLES
if (condição) then
bloco de comandos_1
end
bloco de comandos_2
Funcionamento
Se a condição, entre parênteses, for verdadeira será executado o bloco de comandos_1, e
posteriormente o bloco de comandos_2, senão (condição falsa) a execução passará diretamente para o bloco
de comandos_2.
Exemplo:
//EXEMPLO 3
//PROGRAMA PARA VERIFICAR SE UM VALOR É MAIOR OU MENOR QUE OUTRO
function Maior_Menor()
//DECLARAÇÃO DE VARIÁVEIS
//real Valor_1, Valor_2
//LÊ UM VALOR DA VARIÁVEL Valor_1
Valor_1 = input ("Digite o primeiro valor: ");
//LÊ UM VALOR DA VARIÁVEL Valor_2
Valor_2 = input ("Digite o primeiro valor");
//VERIFICA SE Valor_1 É MAIOR QUE Valor_2
if (Valor_1 > Valor_2) then
printf("Valor_1 é maior que Valor_2"); //SE A CONDIÇÃO ACIMA É VERDADEIRA
end
//FIM DA ESTRUTURA CONDICIONAL
//VERIFICA SE Valor_1 É MENOR QUE Valor_2
if (Valor_1 < Valor_2) then
printf("Valor_1 é menor que Valor_2 "); //SE A CONDIÇÃO ACIMA É VERDADEIRA
end
//FIM DA ESTRUTURA CONDICIONAL
return;
endfunction //FIM DO FUNÇÃO Maior_Menor
//PROGRAMA PRINCIPAL
clc;
Maior_Menor();
7
ESTRUTURA CONDICIONAL DUPLA
if (condição) then
Bloco de comandos_1
else
Bloco de comandos_2
end
Funcionamento
Se a condição, entre parênteses, for verdadeira será executado o bloco de comandos_1, se for falsa
será executado o bloco de comandos_2.
Exemplo:
//EXEMPLO 4
//PROGRAMA PARA VERIFICAR SE UM VALOR É MAIOR OU MENOR QUE OUTRO
//VERSÃO 2
function Maior_Menor2()
//DECLARAÇÃO DE VARIÁVEIS
//inteiro Valor_1, Valor_2
//LÊ O VALOR DA VARIÁVEL Valor_1
Valor_1 = input("Digite o primeiro valor: ")
//LÊ O VALOR DA VARIÁVEL Valor_2
Valor_2 = input("Digite o segundo valor:")
//VERIFICA SE Valor_1 É MAIOR QUE Valor_2
if (Valor_1 > Valor_2) then
printf("Valor_1 é maior que Valor_2") //SE A CONDIÇÃO ACIMA É VERDADEIRA
else
printf("Valor_1 é menor que Valor_2") //SE A CONDIÇÃO ACIMA É FALSA
end
//FIM DA ESTRUTURA CONDICIONAL
endfunction
//PROGRAMA PRINCIPAL
clc;
Maior_Menor2();
//FIM DO PROGRAMA
8
EXEMPLOS
Alguns problemas com estruturas condicionais.
Programa para ler um número inteiro e escrevê-lo, caso seja número negativo.
Um número é negativo se é menor que zero.
//EXEMPLO 5
//FUNÇÃO PARA VERIFICAR SE UM NÚMERO É NEGATIVO, POSITIVO OU NULO
function Sinal()
//DECLARAÇÃO DE VARIÁVEIS
//real Numero
//ENTRADA DE DADOS
Numero = input("Digite um número");
//PROCESSAMENTO E SAÍDA DE RESULTADOS
printf ("%f é ", Numero)
if (Numero < 0) then
printf (" é negativo");
else
if (Numero > 0) then
printf (" positivo");
else
printf (" nulo");
end
end
return;
endfunction
//PROGRAMA PRINCIPAL
clc;
Sinal();
//FIM PROGRAMA PRINCIPAL
9
Programa para ler a idade de uma pessoa e verificar se ela é ou não, maior de idade.
Uma pessoa é maior de idade se possui 18 anos ou mais.
//EXEMPLO 6
//PROGRAMA PARA VERIFICAR SE UMA PESSOA É MAIOR DE IDADE OU NÃO
function Maioridade()
//DECLARAÇÃO DE VARIÁVEIS
//inteiro Idade
//ENTRADA DE DADOS
Idade = input("Digite idade :")
//PROCESSAMENTO E SAÍDA DE RESULTADOS
if (Idade < 18) then
printf ("Não é maior de idade");
else
printf ("É maior de idade");
end
return;
endfunction
//PROGRAMA PRINCIPAL
clc;
Programa
para resolver equação do primeiro grau
Maioridade();
//FIM DO PROGRAMA PRINCIPAL
10
Programa para resolver equação do primeiro grau
//EXEMPLO 7
// PROGRAMA PARA RESOLVER EQUAÇÃO DO PRIMEIRO GRAU
function Equacao_Primeiro_Grau()
//DECLARAÇÃO DE VARIÁVEIS
//real a, b, x
//ENTRADA DE DADOS
a = input("Digite o coeficiente a ");
b = input("Digite o coeficiente b");
//PROCESSAMENTO E SAÍDA DE RESULTADOS
if (a <> 0) then
x = -b / a;
printf("\nx = %4.2f é raiz da equação do primeiro grau %2.1fx + %2.1f =
0", x, a, b);
else
printf ("Impossível resolver equação com a = 0");
end
return;
endfunction
//PROGRAMA PRINCIPAL
clc;
Equacao_Primeiro_Grau();
//FIM PROGRAMA PRINCIPAL
2
ESTRUTURAS DE REPETIÇÃO
Uma estrutura de repetição é utilizada quando um comando ou uma sequência de comandos de um
programa deve ser repetida. Cada linguagem de programação tem suas estruturas específicas de repetição. Os
programas em SciLab oferecem duas estruturas de repetição
REPETIÇÕES DEPENDENTES DE CONDIÇÃO NO INÍCIO
ESTRUTURA “while”
NOTAÇÃO
while (condição)
bloco de comandos_1
end
bloco de comandos_2
11
Funcionamento
Enquanto a condição entre parênteses for verdadeira o bloco de comandos_1 será executado e
quando for falsa o processamento passará ao bloco de comandos_2.
Exemplo
Trecho de programa para escrever na tela os números inteiros de 0 a 9.
1.
x=0
//Valor inicial de x
2.
while (x < 10)
//Verifica se x é menor que 10
3.
printf(“%f”, x)
//Se a condição é verdadeira escreve x
4.
x=x+1
//Aumenta x em uma unidade
5.
end
6.
//Novos comandos
//Termina a repetição quando x = 10
Para facilitar o entendimento numeramos as linhas de comandos.
Comentários:
1) Atribui o valor inicial (0 – zero) à variável x.
2) Comando que verifica o valor da variável x, gerando um valor verdadeiro ou falso, que indicará se o
processamento continuará na próxima linha de comandos (linha 3) ou se desviará para a linha 6.
3) escreve o valor de x: 0, 1, 2, 3, 4, 5, 6, 7,8, 9
4) aumenta uma unidade na variável x e coloca o resultado na própria variável x que passará a ser: 1, 2,
3, 4, 5, 6, 7, 8, 9, 10 (último valor que será o responsável pelo encerramento da estrutura de
repetição).
5) limita os comandos da estrutura de repetição.
6) próximos comandos do programa, fora da estrutura de repetição.
12
PROGRAMAS EXEMPLOS DE ESTRUTURAS DE REPETIÇÃO
Programa para escrever na tela os números ímpares de 7 a 15 .
//EXEMPLO 8
//PROGRAMA PARA ESCREVER NA TELA OS NÚMEROS POSITIVOS ÍMPARES,
//MENORES QUE N (lido do teclado)
function Impares()
//DECLARAÇÃO DE VARIÁVEIS
//inteiro Numero, N
//ENTRADA DE DADOS E VALOR INICIAL
Numero = 1;
N = input ("Digite um inteiro positivo");
//PROCESSAMENTO E SAÍDA DE RESULTADOS
while (Numero <= N)
printf("%d\t", Numero);
Numero = Numero + 2;
end
endfunction // Impares()
//PROGRAMA PRINCIPAL
clc;
Impares();
//FIM DO PROGRAMA PRINCIPAL
13
Programa para escrever as letras maiúsculas de F a Q.
//EXEMPLO 9
//PROGRAMA PARA ESCREVER AS LETRAS MAIÚSCULAS DE F A Q.
function Escreve_Letras()
//DECLARAÇÃO DE VARIÁVEIS
//literal Letra
//inteiro x
//VALOR INICIAL (“INICIALIZAÇÃO”)
Letra = 'F';
//PROCESSAMENTO E SAÍDA DE RESULTADOS
x = ascii(Letra);
//CODIGO ASCII DA LETRA
while (x <= ascii('Q') )
printf("%s ", ascii(x));
x = x + 1;
end
//REPETE ENQUANTO LETRA <= Q
//ESCREVE LETRA
//SOMA 1 NO CODIGO DA LETRA
endfunction
//PROGRAMA PRINCIPAL
clc;
EscreveLetras();
//FIM DO PROGRAMA PRINCIPAL
14
Leia o nome e a altura de três pessoas.
Determine e escreva o nome e a altura da pessoa mais alta
//EXEMPLO 10
//LER O NOME E A ALTURA DE TRÊS PESSOAS.
//DETERMINAR E ESCREVER O NOME E A ALTURA DA PESSOA
//MAIS ALTA
function Maior_Altura()
//DECLARAÇÃO DE VARIÁVEIS
//real Altura, Maior_Altura
//literal Nome, Nome_do_mais_Alto
//inteiro Contador
Maior_Altura = 0;
Contador = 1;
//PROCESSAMENTO E SAÍDA DE RESULTADOS
while (Contador <= 3)
//ENTRADA DE DADOS
printf("%dª pessoa de 3", Contador);
Nome = input("Digite nome", "string");
Altura = input("Digite altura : ");
if (Altura > Maior_Altura)
Maior_Altura = Altura
Nome_do_mais_Alto = Nome;
end
Contador = Contador + 1;
end
//WHILE
printf("%s é o mais alto dos 3 e mede %f", Nome_do_mais_Alto,
Maior_Altura);
endfunction
//PROGRAMA PRINCIPAL
clc;
Maior_Altura();
//FIM DO PROGRAMA PRINCIPAL
15
ESTRUTURA DE REPETIÇÃO COM VARIÁVEL DE CONTROLE
Quando o número de repetições é conhecido, pode-se usar a estrutura:
for (Variável = Valor_Inicial: Passo: Valor_Final)
Bloco de comandos_1
end
Bloco de comandos_2
Sendo Variável uma variável cujo valor inicial é Valor_Inicial e cujo valor final é Valor_Final, e Passo é o
acréscimo dado a essa variável.
O bloco de comandos_1 será executado para cada valor de Variável.
Variável sofre um acréscimo Passo, positivo ou negativo, podendo ser omitido se a variável aumenta de 1 em 1
Alguns problemas anteriores podem ser resolvidos usando-se essa estrutura.
EXEMPLOS
Faça um programa para imprimir a tabuada de multiplicação do número inteiro 9.
//EXEMPLO 11
//IMPRIMIR A TABUADA DE 9 (MULTIPLICAÇÃO)
function Tabuada_9()
//DECLARAÇÃO DE VARIÁVEIS
//inteiro Multiplicador, Fator_Fixo, Produto
//Valor inicial
Fator_Fixo = 9;
//PROCESSAMENTO E SAÍDA DE RESULTADOS
for (Multiplicador = 0: 1: 9)
Produto = Multiplicador * Fator_Fixo;
printf("\n%d * %d = %d ", Multiplicador, Fator_Fixo, Produto);
end;
endfunction
//PROGRAMA PRINCIPAL
clc;
Tabuada_9();
//FIM DO PROGRAMA PRINCIPAL
Escreva um programa para escrever todos os números inteiros palíndromos de 4 algarismos.
Um número palíndromo ou frase “palíndroma” é aquela que é idêntica se lida da direita para a esquerda ou
da esquerda para a direita.
16
Exemplos:
“luz azul”, “acaiaca”, “ovo”, “Ana”, “arara”, “socorram-me subi no onibus em marrocos”
“12321”, “2002”
Para os números palíndromos de 4 algarismos temos o padrão X Y Y X, onde X é um número inteiro de 1 a
9 e Y um número inteiro de 0 a 9. Assim cada número inteiro palíndromo de 4 algarismos será da forma:
1000 X + 100 Y + 10 Y + X
//EXEMPLO 12
//ESCREVER OS NÚMEROS PALÍNDROMOS DE 4 ALGARISMOS
function Palindromo()
//DECLARAÇÃO DE VARIÁVEIS
//inteiro Numero, X, Y
//PROCESSAMENTO E SAÍDA DE RESULTADOS
for (X = 1: 9)
for (Y = 0: 9)
Numero = 1000 * X + 100 * Y + 10 * Y + X;
printf("\t%8d", Numero);
end;
end; //X = 1 até 9
endfunction
//PROGRAMA PRINCIPAL
clc;
Palindromo();
//FIM DO PROGRAMA PRINCIPAL
17
Programa que:
Leia um número inteiro e positivo N.
Calcule e escreva a soma dos N primeiros termos da seqüência:
1/2, 2/5, 3/8, 4/11, 5/14, 6/17, ...
//EXEMPLO 13
//PROGRAMA QUE:
//LER UM NÚMERO INTEIRO E POSITIVO N.
//CALCULAR E ESCREVER A SOMA DOS N PRIMEIROS TERMOS DA //SEQÜÊNCIA:
//1/2, 2/5, 3/8, 4/11, 5/14, 6/17, ...
function SomaSequencia()
//DECLARAÇÃO DE VARIÁVEIS
//inteiro Contador, Numerador, Denominador, N
//real Soma
Soma =0;
Numerador = 1;
Denominador = 2;
//ENTRADA DE DADOS
N = input("Numero de termos")
//PROCESSAMENTO
for (Contador = 1: N)
Soma = Soma + Numerador / Denominador;
Numerador = Numerador + 1;
Denominador = Denominador + 3;
end; //FIM FOR
//E SAÍDA DE RESULTADOS
printf ("%f", Soma);
endfunction
//PROGRAMA PRINCIPAL
clc;
SomaSequencia();
//FIM DO PROGRAMA PRINCIPAL