Introdução ao SCILAB: características e instalação

Prévia do material em texto

SCILAB 
Introdução: 
 
 O SCILAB (iniciais em inglês para: Scientific Laboratory, sua pronúncia 
é “sailæb”) é um software para ser empregado em ambientes de cálculos 
numéricos. 
 
 É uma poderosa ferramenta para cálculos científicos, sendo usado em 
diversas áreas, tais como:engenharias, petroquímica, meteorologia, 
industria automobilística e outras. 
 
 Pode ser manipulado interativamente (“diretamente em seu console”) ou 
através de programação (execução de arquivos de scripts). 
 
 O SCILAB faz parte de um grupo de softwares que simula um ambiente 
de computação numérica, como o Matlab (Matrix Laboratory), Octave, 
Maple, Simulink, MuPad, etc. Esses softwares são proprietários, 
enquanto o Scilab é “open Source” (uso livre), assim o Scilab é uma 
plataforma em constante atualização e aperfeiçoamento. 
 
 
Histórico: 
 
 
 O desenvolvimento do SCILAB começou em 1989 na França, no Institut 
de Recherche em Informatique et en Automatique, INRIA, através do 
Projeto METALAU (Methods, algorithmes et logiciels pour l'automatique) 
e a Ecole Nationale des Ponts et Chaussees, ENPC. 
 
 
 A partir de 2003, é mantido e desenvolvido atualmente pelo Scilab 
Consortium, um consórcio com aproximadamente 20 membros, 
recebendo contribuições de programadores de todo o mundo através de 
seu site na internet. 
 
Características: 
 
 Possui centenas de funções matemáticas para diversas áreas, tais 
como: Álgebra Linear, Polinômios e Funções Racionais, Integração: 
Equações Diferencias Ordinárias e Equações Algébrico- Diferenciais, 
Estatística, etc. 
 
 Redes Neurais, Grafos e Redes (Metanet), Arquiteturas Paralelas de 
computadores, Lógica Nebulosa (Fuzzy Logic) 
 
 Possibilidade de interação (interfaces) com programas em várias 
linguagens como o C, C++, Fortran, Java, LabView, Tcl/Tk. 
 
 Modelagem e Simulação (Scicos), Automação Industrial, Controle de 
Processos, Controle clássico, robusto e otimização LMI (Linear Matrix 
Inequalities) 
 
 Processamento de Sinais e Imagens 
 
 Possui portabilidade para várias plataformas, tais como: windows, linux, 
etc. 
Instalação do SCILAB: 
 
 Para baixar a última versão do Scilab acesse: www. scilab.org 
 ( nesse curso o site foi acessado em jul/2012) 
 
 Clique em “Download Scilab” para sistema Windows (32bits) ou em 
“Other Systems” para outros sistemas. 
 
 No caso de outros sistemas, aparecerá a tela abaixo. Escolha o sistema 
instalado em seu computador, clicando sobre ele, fazendo o seu 
download. 
 Após escolher o sistema, aparecerá a tela abaixo. Clique em donwload. 
 No local onde foi efetuado o download, 
clique no ícone do Scilab 5.3.3. 
 
 
 
 
 
 
 Depois clique em executar. 
 
 
 
 
 
 
 
 
 Selecione o idioma desejado (no caso 
aqui: Português(Brasil). 
 
 Clique em Avançar e siga os passos conforme o Assistente de Instalação 
requisitar. A sequência de instalação é bastante interativa e não necessita 
de maiores detalhes. 
O Ambiente do SCILAB: 
 
 A figura abaixo mostra a janela principal do ambiente scilab, com o menu 
principal e a barra de ferramentas. 
Menu 
Principal Barra de 
Ferramentas 
 Prompt (Pronto!) do Scilab (seta+cursor): significa 
que o programa está pronto para receber instruções. 
Também chamado de linha de comando. 
 No menu principal (pronúnica “meni”, aportuguesado menu mesmo) temos as 
opções: Arquivo – Editar – Preferências – Controle – Aplicativos - ?(ajuda). 
 
 Na figura abaixo temos os sub-menus de Arquivo. 
 Executar: executa arquivos de scripts e arquivos 
com instruções de comando de um modo geral. 
 
 Abrir um arquivo: carrega arquivos de texto 
criado no ambiente scilab (.sce e .sci) com o 
editor. 
 
 Carregar ambiente: carrega arquivos binários 
(de variáveis) salvos com o comando salvar. 
 
 Salvar ambiente: salva em disco um arquivo 
binário contendo variáveis. 
 Alterar diretório atual: muda o diretório atual, redirecionando o ambiente para 
um novo local de trabalho. 
 
 Exibir diretório atual: exibe o diretório atual de trabalho. 
 
 Configuração de página: permite configurar a impressora para impressão 
 
 Imprimir: imprime documentos. 
 
 Sair: fecha a seção e sai do ambiente do scilab 
Teclas 
 de atalho 
 Na figura abaixo temos os sub-menus de Editar. 
Teclas 
 de atalho 
 Recortar: recorta um texto. 
 
 Copiar: permite copiar para o clipboard (área 
de transferência do Windows) o texto 
selecionado no ambiente. 
 
 Colar: cola o que foi previamente copiado. 
 
 Esvaziar área de transferência: limpa o 
clipboard (área de transferência) 
 
 Selecionar tudo: seleciona todo o texto atual 
do ambiente. 
 
 Na figura abaixo temos os sub-menus de Preferências. 
 Cores: permite alterar as cores utilizadas no 
ambiente do scilab (cor do console (texto) ou 
a cor de fundo). 
 
 Fonte: permite alterar a fonte (tipo, tamanho, 
etc.) 
 
 Mostrar/esconder a barra de ferramentas: 
comuta entre exibir e ocultar a barra de 
ferramentas. 
 
 Limpar histórico: limpa o histórico das 
instruções executadas no ambiente. 
 
 Limpar o console: limpa o console, mas não 
apaga os dados da memória. 
Console: unidade que permite que um operador se comunique com um sistema de computador 
 Na figura abaixo temos os sub-menus de Controle. 
 Retomar: continua a execução de uma 
instrução depois de uma pausa (pause) ter 
sido dada ou um pare (stop). 
 
 Abortar: interrompe a execução e retorna ao 
prompt normal do ambiente. 
 
 Interromper: interrompe a execução e entra 
no modo “pause” ( pode ser executada 
diretamente no prompt do ambiente 
pressionando-se Ctrl+C). 
 Na figura abaixo temos os sub-menus de Aplicativos. 
 SciNotes: carrega o editor de textos do scilab onde 
podem ser criados scripts de programas e funções. 
 
 Xcos: permite criar diagramas de blocos e interfaces 
gráficas. 
 
 Tradutor de Matlab para Scilab: oferece opções de 
conversões do Matlab para o Scilab. 
 
 Gerenciador de módulos – ATOMS: O ATOMS (de 
AutomaTic mOdules Management for Scilab), 
permite que o usuário do Scilab possa baixar, 
instalar e atualizar de forma automática, os módulos 
externos que o mesmo deseje utilizar com o 
programa 
 
 Navegador de variáveis: exibe o formato das 
variáveis no scilab. 
 
 Histórico de comandos: O Scilab grava o histórico 
de comandos executados no prompt, inclusive 
marcando as sessões utilizadas com comentários 
 Na figura abaixo temos os sub-menus de ? (ajuda). 
 Ajuda do Scilab: exibe o diretório-raiz de 
ajuda do scilab, com opção de buscas. 
 
 Demosntrações do Scilab: exibe uma janela 
de demonstrações de comandos do scilab. 
 
 Links da Web: exibe várias opções de links. 
 
 Sobre o Scilab: mostra uma janela com a 
versão da ferramenta, incluindo com 
agradecimentos à relação de pessoas que 
contribuíram para o seu desenvolvimento. 
 
OBS: A ajuda do scilab é um item muito valioso e deve ser bastante 
explorado pelo usuário. 
• Execute o Scilab no seu sistema e procure pelo símbolo (prompt): --> 
• As operações aritméticas devem ser digitados após este símbolo (->) 
que é chamado de prompt do Scilab e em seguida tecla-se [ENTER] 
Exemplo: 
-->5+6/2 
ans = 
8. 
 
 -->4^2 // 4 elevado a potência de 2 
ans = 
16. 
USANDO O SCILAB COMO UMA SIMPLES CALCULADORA 
A variável ans (abreviação da palavra inglesa answer) armazena o valor 
corrente de saída do Scilab. Pode-se usar ans para efetuarcálculos porque 
ela armazena o valor do último cálculo realizado. 
Exemplo: 
 
-->4+5 
ans = 
9. 
 
 
-->ans+ 3 
ans = 
12 
 
USANDO O SCILAB COMO UMA SIMPLES CALCULADORA 
variáveis : nome para uma posição na memória do computador. 
 
Para atribuir ou modificar a informação contida na variável é usado o comando 
de atribuição. No Scilab, usa-se o símbolo = para atribuição. 
 
OBS: O símbolo de atribuição (=) não significa igualdade matemática, uma 
vez que o comando de atribuição i = i+1 é válido, mas não representa 
igualdade matemática. 
 
Exemplo: 
-->a = 2 // Atribui 2 para variável a 
a = 
2. 
 
-->b = 4 // Atribui 4 para variável b 
a = 
4. 
 
-->area = a*b // Atribui o produto de a e b para a variável area 
area = 
8. 
VARIÁVEIS E O COMANDO DE ATRIBUIÇÃO 
OBS.(1): Regras para os nomes de variáveis (identificadores) ; 
 
1. Nomes de variáveis começam com uma letra, seguido de letras, algarismos ou sublinhados. 
2. Caracteres especiais não são permitidos. 
3. Caracteres acentuados não são permitidos; 
4. Nomes de variáveis são sensíveis a maiúsculas e minúsculas. 
Ex.: 
Nomes de variáveis válidos: ALPHA, X, B1, B2, b1, matricula e MEDIA. 
Nomes de variáveis inválidos: 5B, 1b, nota[1], A/B e X@Z. 
 
OBS.(2): A ausência ou presença do ponto e vírgula no final de um comando do Scilab visualiza ou 
suprime, respectivamente, o resultado do cálculo. 
 
-->A = 4+4^2; 
--> 
 
-->A = 4+4^2 
A = 
20. 
 
-->a=2; 
-->b=4; 
-->area=a* b// no resultado (area) o ponto e vírgula foi suprimido para se visualizar o resultado. 
area = 
8. 
VARIÁVEIS E O COMANDO DE ATRIBUIÇÃO 
A+B*C 
(NOTA1+NOTA2)/2 
1/(a^2+b^2) 
 
 PRIORIDADE: ordem de Avaliação entre Operadores Aritméticos 
EXPRESSÕES ARITMÉTICAS 
2+10/5 // 10/5 é avaliada primeiro. 
 
A+B/C+D // B/C é avaliada primeiro. 
 
R*3+Bˆ3/2+1 // Bˆ3 é avaliada primeiro. 
Associatividade é a regra usada quando os operadores têm a mesma prioridade. 
A operação mais a esquerda é avaliada primeiro. 
 
A-B+C+D //A-B é avaliada primeiro, porque está mais a esquerda 
 
ATENÇÃO!! potenciação, operação mais a direita deve ser avaliada primeiro: 
 
A^B^C^D //CˆD é avaliada primeiro, porque está mais a direita 
 
 
ATENÇÃO!! A ordem de prioridade pode ser alterada pelo uso dos parênteses 
 
(A+4)/3 //A+4 é avaliada primeiro devido aos parênteses 
 
(A-B)/(C+D) //A-B é avaliada primeiro. Depois a adição e depois a divisão 
 
R*3+B^(3/2)+1 //3/2 é avaliada primeiro 
 
 
 
 
 
EXPRESSÕES ARITMÉTICAS 
Além dos operadores aritméticos podemos usar funções matemáticas. 
Exemplo: 
 
2+3*cos(x) 
 
X^(2*sin(y)) 
 
2+3*tan(x)+K^2 
 
EXPRESSÕES ARITMÉTICAS 
Funções de Arredondamento 
EXPRESSÕES ARITMÉTICAS 
Exemplos: 
Constantes Especiais do Scilab 
EXPRESSÕES ARITMÉTICAS 
Formato de Visualização dos Números com o comando format 
 
Exemplo: 
-->sqrt(3) 
ans = 
1.73 
 Para aumentar o número de posições para 16, usa-se: 
-->format(16) 
-->sqrt(3) 
ans = 
1.7320508075689 
 
O comando format(’e’) mostra os números em notação científica. Exemplo: 
-->format(’e’) 
-->2*%pi/10 
ans = 
6.283185307E-01 (6.283185307E-01 significa 6.283185307 × 10−1) 
 
Para retornar ao formato inicial usa-se -->format(’v’) que é chamado de “formato de 
variável”. 
EXPRESSÕES ARITMÉTICAS 
Informação composta de caracteres alfanuméricos e/ou caracteres especiais 
(exemplo, #, $, &, %, ?, !, @, <, ~, etc.). 
 
Os strings são envolvidos por aspas duplas ou simples. (é melhor usar as 
aspas duplas que não possui duplo sentido e torna seu programa um 
pouco mais legível” 
 
Exemplos: 
-->a = "abcd" 
a = 
abcd 
 
-->b = ’efgh’ 
b = 
efgh 
 
-->c = "Maria e Jose" 
c = 
Maria e Jose 
STRINGS 
Concatenação:junção de dois ou mais strings 
 
-->n = "Pedro" 
n = 
Pedro 
-->m = "Paulo" 
m = 
Paulo 
-->m + n // Concatena Paulo com Pedro sem 
ans = 
PauloPedro 
 
-->m + " " + n // Concatena Paulo com Pedro inserindo espaços entre eles 
ans = 
Paulo Pedro 
-->m +“ “+”e”+” “+n 
Paulo e Pedro 
 
OBS: armazenar informações que contém as aspas=>repetir as aspas. 
 -->n = "o teorema é "“ a lados iguais opõe-se ângulos iguais “" 
n = 
o teorema é “ a lados iguais opõe-se ângulos iguais“ 
STRINGS 
Funções Principais de Manipulação de strings 
STRINGS 
Exemplos: 
-->m = "Pedro"; 
-->length(m) // Comprimento da string "Pedro" 
ans = 
5. 
-->a = "a camisa " + string(10) // Para concatenar números com strings use a função string() 
a = 
a camisa 10 
-->a = "12" + "34" // Para somar uma string com um número use evstr() 
a = 
1234 
-->evstr(a) + 10 
ans = 
1244. 
NÚMEROS COMPLEXOS 
 
As operações com números complexos são tão fáceis como nos reais. 
 
A unidade imaginária é representado por %i, ou seja, %i = sqrt(-1). 
Exemplo: 
Sejam os números imaginários x e y, como segue: 
x = 3 + 4*%i e y = 1 - %i 
As operações abaixo são feitas normalmente: 
z1 = x - y 
z2 = x * y 
z3 = x / y 
 
Uso de funções: 
real(x) −Parte real de x 
imag(x) −Parte imaginária de x 
abs(x) −Valor absoluto do número complexo 
atan(imag(x),real(x)) −Argumento do número complexo 
conj(x) −Conjugado 
sin(x) −Seno de um número complexo 
STRINGS 
clear apaga todas as variáveis do Espaço de Trabalho 
Exemplo: 
-->a = 2; 
-->b = 3; 
-->c = 4; 
-->clear b // Apaga somente b deixando as outras variáveis intactas 
-->clear // Apaga somente b deixando as outras variáveis intactas. 
 
 
As variáveis são apagadas quando o usuário termina a execução do Scilab. Para usá-las da próxima vez 
que executar o Scilab, você deve salva-las antes com o comando save(“arquivo”). 
Por exemplo, 
-->a = 2; 
-->b = 3; 
-->save("dados.dat"); 
 
O comando load(“arquivo”) é usado para recuperar variáveis que foram salvas no arquivo. Por exemplo: 
-->clear // apaga todas as variáveis 
-->a+b // variáveis a e b não existem 
!--error 4 // porque foram apagadas 
undefined variable : a 
-->load("dados.dat"); // recupera as variáveis a, b e c 
-->a+b // Ok! 
ans = 
5 
OBS.: O comando who mostra todas as variáveis do Espaço de Trabalho 
 
APAGANDO, ARMAZENANDO E RECUPERANDO VARIÁVEIS NO ESPAÇO DE TRABALHO 
CONSEGUINDO AJUDA 
 
help informa sobre comandos e funções do Scilab. 
 
Exemplo: 
help cos (Informa sobre a função que calcula o co-seno); 
help ceil −Informa sobre a função ceil. 
 
apropos procura comandos e funções utilizando uma palavra-chave. 
 
Exemplo: se não sabemos o nome da função que calcula o seno hiperbólico, 
podemos digitar (em inglês) algo como 
 
--> apropos hyperbolic 
 
e o Scilab mostrará todas a funções relacionadas com a palavra-chave 
hyperbolic. 
 
 
help() abre a ajuda do scilab pelo prompt. 
Estruturas Seqüênciais no Scilab 
ARQUIVOS DE SCRIPT 
Comando de Entrada de Dados – input 
 
input que tem duas formas básicas :uma para números e outra 
para strings 
 
A primeira forma, usada para solicitar dados numéricos, tem a 
seguinte forma: 
 <variavel> = input(<string>); 
 
Esta função mostra o texto <string> e em seguida solicita que o 
usuário digite um número. Por fim, o número digitado é 
atribuído a <variavel>. Exemplo: 
 
-->x = input("Digite um número") 
Digite um número-->10 
x = 
 10. 
 
A segunda forma do comandoinput é usada para solicitar dados do tipo 
string ao usuário. Sua forma é: 
 
<variavel> = input(<string>,"s"); 
 
Exemplo: 
 
-->a = input("Digite alguma coisa","s") Digite alguma coisa-->Olá 
a = Olá 
 
Comandos de Saída de Dados 
 
 
A forma mais simples de visualizar dados no Scilab é suprimir o ponto e 
vírgula no final do comando 
 
-->x = 3; 
 
-->y = 4; 
 
-->r = sqrt(x*x+y*y) // Com a omissão do ponto e virgula 
r = // o resultado é exibido 
 
5. 
 
 
LOGO, A SUPRESSÃO DO PONTO E VIRGULA NO SCILAB É VISTO 
COMO UM COMANDO DE SAÍDA DE DADOS. 
 
Comandos de Saída de Dados - A Função disp 
 
A função disp() é outra maneira de exibir dados. Por exemplo, 
 
-->v0 = 2; 
 -->a = 4; 
 -->t = 3; 
 -->v = v0+a*t; 
 -->disp(v) 
14. // disp não mostra o nome da variável 
 
Exemplo com strings 
 -->nome = "maria"; 
 -->disp("Seu nome é " + nome) 
Seu nome é maria 
 
A função disp é freqüentemente usada em conjunto com a função string que converte um 
número em string. Por exemplo, poderíamos ter usado a seguinte sintaxe no final do 
primeiro exemplo: 
 
-->disp("A velocidade final é " + string(v)) 
 
A velocidade final é 14 
 
Comandos de Saída de Dados - A Função printf 
 
A função printf é a forma mais flexível de exibir dados porque produz 
uma saída formatada. Ela é um “clone” da função printf da linguagem C 
 
Por exemplo, 
 
-->printf("Alô mundo\n"); 
Alô mundo 
 
O caracter \n (chamado de new line) avisa ao comando printf para gerar uma 
nova linha. Mais precisamente, \n move o cursor para o começo da linha 
seguinte. Colocando \n após o string Alô faz com que printf gere uma nova 
linha após Alô: 
 -->printf("Alô\nmundo"); Alô 
mundo 
 
A forma geral do comando printf é: printf(<formato>,<lista de dados>); 
 <formato> é uma string descrevendo a forma com que a lista de dados será 
exibida. 
Exemplo: 
 
-->A = 2; 
 
-->printf("A variável A contém o valor %g\n",A); 
 
A variável A contém o valor 2 
 
A símbolo %g (chamado de caractere de formatação) indica como cada 
variável da lista de dados será exibido dentro da string de formatação 
<formato>. No exemplo, %g é substituído pelo valor da variável A no momento 
da impressão. 
No seguinte exemplo, as variáveis A e B substituirão os caracteres de 
formatação %g nas posições correspondentes: 
 
-->A = 8/4; 
 
-->B = A + 3; 
 
-->printf("Os valores calculados foram %g e %g\n",A,B); Os valores calculados 
foram 2 e 5 
 
Observação: 
 
Se a variavel for do tipo string, usa-se o caractere de formatação %s em vez 
de %g. Por exemplo: 
 
-->nome = "Joao"; 
 
-->altura = 1.65; 
 
-->printf("A altura de %s é %g",nome, altura); 
 
A altura de Joao é 1.65 
Criando Arquivos de Scripts 
 
Um arquivo de script é um arquivo que contém um script, isto é, uma 
seqüência de comandos para ser executada pelo computador (programa) 
 
 Os comandos do arquivo de script são executados automaticamente pelo 
Scilab 
 
 
Arquivos de script são arquivos do tipo texto puro (também chamados 
arquivos ASCII) e, por isso, eles podem ser criados em qualquer editor de 
texto. 
 
 
 O Scilab já contém um editor de textos (chamado Scipad) que facilita a 
criação de arquivos de script, sendo o mais recomendável para programar no 
ambiente Scilab 
 
Criando Arquivos de Scripts 
 
Para criar Arquivos de scripts pelo 
Editor do Scilab, selecione a opção 
APPLICATIONS - EDITOR 
Digite seu programa (comandos scilab) 
Salve seu programa 
Para executar um script, Selecione EXECUTE e em seguida a opção LOAD 
INTO SCILAB.. 
 
 
OBS: Se houver erros de digitação do script então poderá ocorrer erros de 
execução. Neste caso, retorne ao Editor, corrija o erro e execute novamente. 
 
 
Uma forma alternativa de executar scripts é através do comando exec. O 
comando exec tem a forma: exec(<script>) 
 
AVISO: este comando funciona somente se o arquivo de script estiver no 
diretório de trabalho do scilab caso contrário ocorrerá um erro como este: 
 
File .............sce does not exist or read access denied 
 
Resolva este problema alterando o diretório de trabalho: selecione 
FILE|CHANGE DIRECTORY e depois escolha o diretório 
Alterando o Diretório de Trabalho: 
 
selecione FILE|CHANGE DIRECTORY e depois escolha o diretório de 
desejado. 
 
 
Alternativamente, o diretório de trabalho pode ser alterado com o comando 
chdir(ou simplesmente cd) : 
-->cd c:\exemplos; // altera o diretório corrente 
 
 
 
Use o comando pwd para visualizar o diretório de trabalho do Scilab: 
 -->pwd 
ans = 
 c:\exemplos 
 
 
 
 
 
 
A estruturas de seleção são úteis para implementar situações que 
requerem a execução de ações alternativas que dependem de certas 
condições. Exemplos: 
 
• Se a nota do aluno for maior que 7 então avise que ele foi "aprovado"; 
caso contrário informe que ele está em recuperação. 
 
• Se a lâmpada está queimada compre uma nova lâmpada; caso 
contrário acenda a lâmpada para ler o livro. 
 
• Compre ou venda ações da bolsa de valores de acordo se índices 
econômicos sobem ou descem, respectivamente. 
 
Portanto, a estrutura de seleção é um mecanismo para selecionar entre 
caminhos alternativos de execução comandos. 
Estruturas de Decisão no SCILAB 
A Seleção Simples IF-END 
 
Caracteriza-se por permitir a execução de uma seqüência de comandos 
quando certas condições, representadas por expressões booleanas, 
forem satisfeitas. A seleção simples tem a seguinte forma: 
 
if <expressão booleana> 
<sequência de comandos> 
end 
 
A seqüência de comandos só será executada se a expressão booleana 
retornar um valor verdadeiro. 
A Seleção Bidirecional IF-ELSE-END 
Caracteriza-se por selecionar entre duas seqüência de comando 
quando certas condições, representadas por expressões booleanas, 
forem satisfeitas. A seleção bidireciona tem a seguinte forma: 
 
if <expressão booleana> 
<primeira seqüência de comandos> 
else 
<segunda seqüência de comandos> 
end 
 
A primeira seqüência de comandos será executada se a expressão 
booleana devolver um valor verdadeiro, caso contrário a segunda 
seqüência de comandos será executada.. 
 
Exercício: 
Elaborar um programa para ler quatro notas, calcular a média e informar 
se o aluno passou de ano (aprovado) ou não (reprovado). A média para 
passar de ano é 6. 
Solução: 
ANINHANDO SELETORES 
 
 
Comandos de seleção podem ser aninhados de diversas formas criando 
ampla variedade de construções. 
 
Exercício: 
 
Elaborar um programa para escrever a situação do aluno. O aluno com 
média maior ou igual a 7,0 será aprovado. O aluno com média entre 5,0 
e 7,0 ficará em recuperação. Com média abaixo de 5,0, o aluno será 
reprovado 
ESTRUTURAS DE REPETIÇÃO : LAÇOS 
 
Computadores são freqüentemente usados para repetir uma mesma operação 
muitas vezes. Para fazer isso, utiliza-se uma estrutura de repetição. Ela faz 
com que um conjunto de comandos seja executado zero, uma ou mais vezes. A 
estrutura de repetição é, também, chamado de laço (do inglês, loop). O 
conjunto de comandos que se repete em um laço é denominado de corpo do 
laço. 
 
Há dois tipos de laço no Scilab: 
1. Laço controlado logicamente; 
2. Laço controlado por contador. 
 
No laço controlado logicamente, os comandos (i.e., o seu corpo)são repetidos 
indefinidamente enquanto uma certa expressão booleana for satisfeita. No 
laço controlado por contador, os comandos são repetidos um número 
predeterminado de vezes. 
 
Denomina-se iteração a repetição de um conjunto de comandos. 
Portanto, cada execução do corpo do laço, juntamente com a condição de 
terminação do laço, é uma iteração. O termo iteração é também usado como 
sinônimo de laço. 
Laço Controlado Logicamente 
 
O laço while é um laço controlado logicamente. Ele repete a execução 
de um conjunto de comandos (o seu corpo), mas verificando antes de 
executar os comandos se é permitido repeti-los ou não. O laço while 
tem a seguinte forma: 
 
while <expressão booleana> 
<conjunto de comandos> 
end 
 
Enquanto a <expressão booleana> for verdadeira o <conjunto de 
comandos> é repetido indefinidamente. No momento em que 
<expressão booleana> for falsa o <conjunto de comandos> não será 
mais repetido. 
 
Vale salientar que se <expressão booleana> for falsa da primeira vez, o <conjunto de 
comandos> jamais será executado. 
 
A elaboração de programas com laços envolve, freqüentemente, o uso de duas variáveis 
com funções especiais: os contadores e os acumuladores 
Laço Controlado por Contador 
O comando FOR é o laço controlado por contador do Scilab. Ele repete 
a execução de um conjunto de comandos (i.e., o seu corpo) um número 
pré-determinado de vezes. Na forma básica, o laço FOR possui o 
nome de uma variável (chamada de variável de controle) e 
especifica seu valor inicial e final e, opcionalmente, o tamanho do 
passo (ou incremento) da variável de controle. 
EXEMPLO: 
O seguinte programa escreve a palavra disciplina 10 vezes: 
 
for i=1:1:10 
printf("disciplina\n"); 
end 
 
Aqui a variável de controle i assume, inicialmente, o valor um e o 
printf("disciplina\n“) é executado. 
 
O tamanho do passo pode ser omitido e quando isto ocorre o passo é 
igual a um: 
 for i=1:10 (daria o mesmo resultado) 
 
Um passo igual a um indica que a variável de controle é 
incrementada 
de um em cada iteração. O laço for, repete a execução de 
printf("disciplina\n“) e a variável de controle i é incrementada para 
o valor 2. Da terceira vez que printf("disciplina\n“) é executado, a 
variável de controle i é incrementada para o valor 3 e assim por 
diante até alcançar o valor 10 que é o valor final. 
Vetores 
• Declaração de vetores: 
X = [ x1 x2 x3 ...] vetor linha 
X = [x1;x2;x3;...] vetor coluna 
• Transposição de vetores: X’ 
 
Vetores 
• A = Valor_inicial:incremento:Valor_final 
 
• Exemplos: 
• A = 1:10; 
• B = 1:2:10; 
• C = 1:0.2:10; 
• D = 10:-1:1; 
• E = 1:%pi:20; 
• F = 0:log(%e):20; 
• G = 20:-2*%pi:-10 
Operações com vetores 
• Dimensão: length(x) 
• Número de linhas e colunas: [nr,nc] = size(x) 
• Elementos iguais a 1: x = ones(N,1) 
• Vetores nulos: x = zeros(N,1) 
• Vetores com valores aleatórios: x =rand(N,1) 
• Exercício: 
1. Crie: 
• Um vetor unitário com 10 elementos 
• Um vetor nulo com 5 elementos 
• Um vetor com 10 elementos aleatórios 
• Verifique suas dimensões 
• Apaga elemento: X(i) = [] 
• Insere elemento i no final: X = [X i] 
• Acessa último elemento: X($) 
• Acessa elementos entre n e m: X(n:m) 
• Agrupa dois vetores: c = [x y]; 
Matrizes 
Uma matriz geral consiste em m*n números dispostos em m 
linhas e n colunas: 
Matrizes 
Exemplo 
No Scilab: 
 
M = [1 2 3; 4 5 6; 7 8 9] 
Matrizes com elementos unitários: A = ones(M,N) 
Matrizes com elementos nulos: B = zeros(M,N) 
Matriz identidade: A = eye(N,N) 
 
• Acesso à linha i: A(i,:) 
• Acesso à coluna j: A(:,j) 
• Insere linha no final: A = [A;linha] 
• Insere coluna no final: A = [A coluna] 
• Acesso à ultima linha: A($,:) 
• Acesso à última coluna: A(:,$) 
 
 
 
Operações com Matrizes 
Operações com Matrizes 
• Acesso a um conjunto de linhas: A(:,[i:j]) 
• Acesso a um conjunto de colunas: A([i:j],:) 
• Matriz com número aleatórios: A = rand(N,M) 
• Soma: C = A + B 
• Multiplicação: C = A*B 
• Multiplicação por um escalar: B = aA 
• Matriz complexa: C = A + B*%i (A e B reais) 
• Matriz transposta: C = A’ 
• Determinante: d = det(A) 
• Diagonal: d = diag(A). 
Polinômios 
• Função poly(a,x, ‘flag’) 
• a: matriz de número reais 
• x: símbolo da variável 
• flag: string ("roots", "coeff"), por default seu valor é "roots". 
• Definindo polinômios: 
• y = poly([1 2 3], ‘x’, ‘coeff’); y = 1 + 2x + 3x2 
• ou: x = poly(0,’x’); y = 1+2*x + 3*x^2; 
 
• roots(z): calcula as raízes de um polinômio 
• [r,q] = pdiv(y,z): efetua a divisão e calcula quociente e 
resto 
• coeff(y): retorna os coeficientes do polinômio. 
 
Matrizes de polinômios 
• Os elementos da matriz podem ser polinômios: 
• Exemplo: 
• s = poly(0, ‘s’); 
• A = [1-2*s+s^3 3*s+4*s^2; s 2*s] 
 
• Se A é uma matriz de polinômios: 
• A = A(‘num’): retorna apenas os numeradores 
• A=A(‘den’): retorna apenas os denominadores 
 
Matrizes simbólicas 
• Uma matriz simbólica pode ser construída com elementos 
do tipo string: 
• M =['a' 'b';'c' 'd'] ; 
• Se atribuirmos valores às variáveis podemos visualizar a 
forma numérica da matriz com a função evstr() 
 
Matrizes: operadores especiais 
• Operador \: divisão à esquerda. 
• Seja Ax=b um sistema de equações lineares escrito na 
forma matricial, sendo A a matriz de coeficientes, x o vetor 
da incógnitas e b o vetor dos termos independetes: 
A resolução deste sistema é x=A-1b, ou seja, basta obter a 
matriz inversa de A e multiplicá-la pelo vetor b. No Scilab isto 
pode ser feito desta forma: 
A=[1 3;3 4];b=[5;2]; 
x=inv(A)*b 
 
Esta solução pode ser obtida com o operador “divisão à 
esquerda” cujo símbolo é \: 
x=A\b 
1x + 3y = 5
3x + 4y = 2
• Operador . (ponto) 
Este operador é usado com outros operadores para realizar 
operações elemento a elemento. 
 
Exemplo: 
A = [1 2 3; 3 4 6; 7 8 9]; 
B = [2 4 6;8 10 12; 14 16 18]; 
-->A./B 
 ans = 
 0.5 0.5 0.5 
 0.375 0.4 0.5 
 0.5 0.5 0.5 
-->A.*B 
 ans = 
 2. 8. 18. 
 24. 40. 72. 
 98. 128. 162. 
Matrizes esparsas 
• Uma matriz é dita esparsa quando possui uma grande 
quantidade de elementos iguais a zero. 
• A matriz esparsa é implementada através de um conjunto 
de listas ligadas que apontam para elementos não zero. De 
forma que os elementos que possuem valor zero não são 
armazenados. 
Em Scilab: 
A = [0 0 1; 2 0 0; 0 3 0] 
-->sparse(A) 
 ans = 
( 3, 3) sparse matrix 
( 1, 3) 1. 
( 2, 1) 2. 
( 3, 2) 3. 
• Exemplo: 
• A = [0 0 1; 2 0 0; 0 3 0] ; 
• A= sparse(A); 
• B = [0 1 0; 2 0 2; 3 0 0]; 
• B = sparse(B); 
• C = A*B; 
• Para obter a matriz C na forma completa: 
• B = full(B); 
• Funções que criam matrizes esparsas: 
• sprand(n,m,fill): Matriz esparsa aleatória com n*m*fill elementos 
não nulos. 
• speye(n,n): Matriz identidade esparsa 
• spzeros(n,m): Matriz esparsa nula de dimensões nXm 
• spones(A): Coloca valor 1 onde Aij é diferente de zero 
Listas 
• Uma lista é um agrupamento de objetos não necessariamente 
do mesmo tipo. 
• Uma lista simples é definida no Scilab pelo comando list, que 
possui esta forma geral: 
L = list(a1,a2,a3… aN) 
onde a1,a2,a3… aN são os elementos da lista 
 
Exemplo: 
L = list(23,1+2*%i,'palavra',eye(2,2)) 
-->L 
 L = 
 L(1) 
 23. 
 L(2) 
 1. + 2.iL(3) 
 palavra 
 L(4) 
 1. 0. 
 0. 1. 
[23, 1+2i, ‘palavra’, 1 0
0 1
]L=
• Podemos criar sublistas, ou seja, listas dentro de listas. 
 
• Exemplo: 
 
L = list(23,1+2*%i,'palavra',eye(2,2)) 
L(4) = list('outra palavra',ones(2,2)) 
 
• Acessando elementos dentro da lista da lista: 
• L(4)(1) 
• L(4)(2) 
 
• Agrupando duas listas: 
• L1 = list(5,%pi, ‘velocidade’, rand(2,2)); 
• L2 = list(1+2*%i,ones(3,3), ‘aceleração’); 
• L = list(L1,L2); 
Funções 
• Variáveis definidas dentro do escopo da função 
(variáveis locais) não permanecem no ambiente após 
a execução da função. 
 
• Uma função pode ser definida de três formas: 
1. no ambiente Scilab; 
2. usando o comando deff ou 
3. digitando o texto no Scipad e clicando no menu 
Execute, opção load into Scilab 
Funções 
• Definição: 
 function [y1,...,yn]= nome_da_funcao(x1,...,xm) 
 instrucao_1 
 instrucao_2 
 ... 
 instrucao_p 
 endfunction 
 onde: 
• x1,...,xm são os argumentos de entrada; 
• y1,...,yn são argumentos de saída e 
• instrucão_1,...,instrucao_p são as instruções executa
das pela função. 
• Exemplo: 
1. Definir uma função que converte um número complexo 
da forma cartesiana para a polar. 
No arquivo: cart_to_polar.sci, digite: 
function [mod,ang] = cart_to_polar(re,im) 
 mod = sqrt(re^2 + im^2); 
 ang = atan(im/re) * 180/%pi; 
endfunction 
 
No arquivo program.sce (arquivo de execução) digite: 
exec(' cart_to_polar.sci'); 
z = 2 + 2*%i; 
[mod,ang] = cart_to_polar(real(z),imag(z)); 
disp(mod); 
disp(ang); 
Gráficos no Scilab 
• Para gerar gráficos bidimensionais: 
• plot2d(x,y,style) 
• Onde x e y são vetores. 
• Exemplo: 
• x = [-2*%pi:0.1:2*%pi]; 
• y = sin(x); 
• plot2d(x,y); 
Syle: tipo de linha do gráfico. Valores inteiros positivos definem linhas 
contínuas, valores negativos definem linhas tracejadas. 
• plot2d(x,y,-1); 
• plot2d(x,y,2); 
 
 
• y pode ser uma matriz, sendo que o número de linhas 
de y deve ser igual ao número de elementos de x 
• Exemplo: 
x = [0:0.1:2*%pi]; 
y = [sin(x)’ cos(x)’]; 
plot2d(x,y); 
 
 
 
• x e y podem ser matrizes de mesma dimensão 
• Exemplo: 
t = [-5:0.1:5]; 
x = [t’ t’]; 
y = [(t^2)’ (t^3)’]; 
plot2d(x,y); 
 
 
 
• Comandos básicos: 
• clf: limpa a tela, evitando que o próximo gráfico se 
sobreponha ao anterior: 
• Exemplo: 
• y = sin(x); 
• plot2d(x,y); 
• z = cos(x); 
• plot2d(x,z); 
• Mas: 
• clf;plot2d(x,y); 
 
• Comandos básicos: 
• xtitle (‘titulo’): apresenta o título do gráfico 
• legend(‘legenda1’, ‘legenda2’,…) 
• Exemplo: 
• t = 0:0.1:10; 
• S = 5 + 10*t + 0.5*2*t.*t; 
• V = 10 + 2*t; 
• plot2d(t,S,-2); 
• plot2d(t,V,-4); 
• xtitle(‘Cinematica’); 
• legend(‘Posição’, ‘Velocidade’); 
• Comandos básicos: 
• subplot: divide um janela de um gráfico em sub-
graficos 
• Exemplo: 
subplot(221) 
plot2d(x,sin(x)) 
subplot(222) 
plot2d(x,cos(x)) 
subplot(223) 
plot2d(x,tan(x)) 
subplot(224) 
plot2d(x,sin(x).*cos(x)) 
• Comandos básicos: 
• logflag: define escala linear ou logarítmica 
• “nn” – linear x linear 
• “nl” – linear x logarítmica 
• “ll” – logarítmica x logarítmica 
Exemplo: 
x =1:100; 
subplot(1,2,1); 
plot2d(x,y, logflag='nn'); 
xtitle(‘Escala linear’); 
subplot(1,2,2); 
plot2d(x,y, logflag='ll'); 
xtitle(‘Escala log-log’); 
• Gráficos tridimensionais 
• meshgrid: cria matrizes ou vetores 3D 
Exemplo: 
-->[x y] = meshgrid(-1:0.5:4,-1:0.5:5) 
 
• Gráficos tridimensionais 
• mesh: gera gráficos em 3D 
• Exemplo: 
[X,Y]=meshgrid(-5:0.1:5,-4:0.1:4); 
Z=X.^2-Y.^2; 
xtitle('z=x2-y ^2'); 
mesh(X,Y,Z); 
• Campo vetorial 
• champ – mostra campos vetoriais 
• Exemplo: 
Velocidade da água em movimento circular 
 
 
[x,y] = meshgrid(1:0.5:10,1:0.5:10); 
vx = y./(x.*x + y.*y); 
vy = -x./(x.*x + y.*y); 
champ(x(1,:),y(:,1),vx,vy); 
• Curvas paramétricas 
• param3d: Gera uma curva paramétrica em 3D 
• Exemplo: 
 
t=0:0.1:5*%pi; 
param3d(sin(t),cos(t),t/10,35,45,"X@Y@Z",[2,3]) 
 
• Matplot: Mostra matrizes em 2D usando cores. 
• Exemplo: 
-->Matplot([1 2 3;4 5 6]) 
-->A = round(rand(5,5)*10) 
 A = 
 
 4. 7. 4. 10. 5. 
 3. 5. 7. 5. 8. 
 1. 3. 9. 5. 8. 
 6. 7. 2. 6. 10. 
 3. 1. 4. 6. 8. 
 
--> Matplot(A) 
 
• Colormap: Define o mapa de cores 
• Exemplo: 
--> xset("colormap",graycolormap(32)) 
--> Matplot(A) 
-->xset("colormap",hotcolormap(32)) 
--> Matplot(A)