Apostila Scilab

Prévia do material em texto

Introdução ao SciLab 
Fábio Pires Mourão 
UNIFEMM (Centro Universitário de Sete Lagoas) 
2014 
 
Prefácio 
 
 O objetivo deste texto é o de auxiliar alunos de cursos de Engenharias disciplinas em 
que se faz necessário um estudo numérico de problemas, como Métodos Numéricos, Cálculo 
Numérico e Computação Numérica, além de outras disciplinas relacionadas, como Geometria 
Analítica e Álgebra Linear. 
 Este texto apresenta oito capítulos, sendo que Capítulo 1 apresenta uma Introdução 
do Scilab. O Capítulo 2 apresenta o Ambiente do Scilab e os modos de acesso ao Help, de 
modo que o leitor possa se familiarizar com o ambiente. O Capítulo 3 apresenta o as 
operações básicas com números reais e complexos, além de apresentar uma vasta quantidade 
de funções intrínsecas (nativas). O Capítulo 4 é destinado ao estudo de matrizes e vetores. O 
Capítulo 5 apresenta as definições e operações com polinômios. o Capítulo 6 tem por objetivo 
apresentar as ferramentas gráficas do Scilab. O Capítulo 7 apresenta alguns modos de 
obtenção de dados externos ao Scilab. O Capitulo 8 é destinado à programação, apresentando 
conceitos básicos de estruturas de repetição e condicionais. Em cada capítulo são 
apresentados exemplos e ao fim de cada um (com exceção do Capítulo 7) são propostos 
exercícios. 
 Esta é a primeira versão do texto, o qual sofrerá modificações de acordo com revisões 
do próprio autor e de outros professores convidados a auxiliar o trabalho. Neste texto, foi 
utilizada versão 5.4.1 do Scilab. 
 
Sumário Resumido 
Capítulo 01 - Introdução ............................................................................................................... 9 
Capítulo 2 – O ambiente Scilab ................................................................................................... 10 
Capítulo 3 – Operações básicas ................................................................................................... 34 
Capítulo 4 - Vetores e Matrizes ................................................................................................... 65 
Capítulo 5 - Polinômios ............................................................................................................. 105 
Capítulo 6 - Gráficos .................................................................................................................. 111 
Capítulo 7 - Fontes externas de dados ...................................................................................... 127 
Capítulo 8 - Introdução à programação no Scilab ..................................................................... 133 
Bibliografia ................................................................................................................................ 147 
 
 
Sumário 
Capítulo 01 - Introdução ............................................................................................................... 9 
Capítulo 2 – O ambiente Scilab ................................................................................................... 10 
2.1 Apresentação gráfica do ambiente ................................................................................... 10 
2.2 Utilização do Prompt de Comandos .................................................................................. 11 
2.2.1 Hierarquia de prompts ............................................................................................... 12 
2.3 Variáveis especiais (comando Who) ................................................................................. 14 
2.3.1 Algumas variáveis especiais ....................................................................................... 14 
2.4 Arquivos e diretórios ......................................................................................................... 16 
2.4.1 Definição do diretório de trabalho ............................................................................. 16 
2.4.2 Histórico de comandos (diary) ................................................................................... 17 
2.5 Help do Scilab .................................................................................................................... 19 
2.5.1 Demonstrações do Scilab ........................................................................................... 21 
2.6 O editor Scinotes ............................................................................................................... 29 
2.7 Exercícios Propostos .......................................................................................................... 32 
Capítulo 3 – Operações básicas ................................................................................................... 34 
3.1 Operações básicas no Scilab.............................................................................................. 34 
3.1.1 Operações Básicas com variáveis reais ...................................................................... 34 
3.1.2 Operações Básicas com variáveis complexas ............................................................. 38 
3.2 Algumas funções elementares .......................................................................................... 41 
3.2.1 Funções matemáticas básicas .................................................................................... 41 
3.2.1.1 Função abs() ........................................................................................................ 41 
3.2.1.2 Função log() ......................................................................................................... 42 
3.2.1.3 Função log10() ..................................................................................................... 43 
3.2.1.4 Função log2() ....................................................................................................... 44 
3.2.1.5 Função exp() ........................................................................................................ 44 
3.2.1.6 Função sqrt() ....................................................................................................... 45 
3.2.1.7 Função sum() ....................................................................................................... 46 
3.2.1.8 Função prod() ...................................................................................................... 46 
3.2.1.9 Função primes() ................................................................................................... 47 
3.2.1.10 Função factor() .................................................................................................. 47 
3.2.1.11 Função modulo() ............................................................................................... 48 
3.2.1.12 Função real() ..................................................................................................... 48 
3.2.1.13 Função imag() .................................................................................................... 49 
3.2.2 Funções elementares de conversão ........................................................................... 49 
3.2.2.1 Função dec2bin() ................................................................................................. 49 
3.2.2.2 Função bin2dec() ................................................................................................. 50 
3.2.3 Funções trigonométricas ............................................................................................ 51 
3.2.4 Funções trigonométricas inversas .............................................................................. 52 
3.2.5 Funções de arredondamento ..................................................................................... 53 
3.2.5.1 Função round() ....................................................................................................53 
3.2.5.2 Função floor() ...................................................................................................... 54 
3.2.5.3 Função ceil() ........................................................................................................ 54 
3.2.5.4 Função int() ......................................................................................................... 55 
3.2.5.5 Função fix() .......................................................................................................... 56 
3.2.6 Funções de manuseamento de strings ...................................................................... 56 
3.2.6.1 Função convstr() .................................................................................................. 56 
3.2.6.2 Função length() ................................................................................................... 57 
3.2.6.3 Função part() ....................................................................................................... 58 
3.2.6.4 Função eval() ....................................................................................................... 58 
3.2.7 Algumas funções elementares estatísticas ................................................................ 59 
3.2.7.1 Função mean()..................................................................................................... 59 
3.2.7.2 Função stdev() ..................................................................................................... 59 
3.2.7.3 Função variance() ................................................................................................ 59 
3.2.7.4 Função mad()....................................................................................................... 59 
3.2.8 Limpeza de memória - clear ....................................................................................... 60 
3.2.9 Limpeza da tela - função clc() ..................................................................................... 62 
3.3 Exercícios Propostos .......................................................................................................... 62 
Capítulo 4 - Vetores e Matrizes ................................................................................................... 65 
4.1 Vetores .............................................................................................................................. 65 
4.1.1 Criando um vetor ....................................................................................................... 65 
4.1.2 Operações básicas com vetores ................................................................................. 66 
4.1.2.1 Soma e subtração entre dois vetores.................................................................. 66 
4.1.2.2 Multiplicação de um vetor por um escalar ......................................................... 67 
4.1.2.3 Vetor transposto ................................................................................................. 68 
4.1.2.4 Funções com vetores .......................................................................................... 68 
4.1.2.5 Operações vetoriais "elemento por elemento" .................................................. 69 
4.1.2.6 Produto Escalar ................................................................................................... 70 
4.1.2.6 Norma de um vetor ............................................................................................. 70 
4.2 Matrizes ............................................................................................................................. 71 
4.2.1 Criação de matrizes .................................................................................................... 71 
4.2.2 Operações básicas matriciais ......................................................................................... 73 
4.2.2.1 Soma matricial ......................................................................................................... 73 
4.2.2.2 Produto de uma matriz por um escalar .................................................................. 73 
4.2.2.3 Produto matricial..................................................................................................... 74 
4.2.2.4 Operações matriciais "elemento por elemento" .................................................... 75 
4.2.3 Matrizes Especiais ...................................................................................................... 76 
4.2.3.1 Matriz Identidade - função eye() ......................................................................... 77 
4.2.3.2 Matriz transposta - comando ' ............................................................................ 78 
4.2.3.2 Matrizes triangulares e triangulação .................................................................. 78 
4.2.3.3 Matriz Inversa - inv(A) ......................................................................................... 80 
4.2.4 Solução de sistemas de equações lineares utilizando a função inv()......................... 82 
4.2.5 Determinante - função det() ...................................................................................... 84 
4.3 Casos particulares de matrizes e vetores .......................................................................... 87 
4.3.1 Matrizes e vetores formados por zeros (função zeros) ou por uns (função ones) .... 87 
4.3.2 Matrizes e vetores randômicos .................................................................................. 89 
4.3.3 Matrizes e vetores simbólicos .................................................................................... 92 
4.3.4 Matrizes e vetores booleanos .................................................................................... 93 
4.3.5 Acesso e atribuição a elementos de vetores e matrizes ............................................ 93 
4.3.6 Funções size() e length() ........................................................................................... 101 
4.4 Exercícios Propostos .................................................................................................... 101 
Capítulo 5 - Polinômios ............................................................................................................. 105 
5.1 Definições ........................................................................................................................ 105 
5.2 Criando Polinômios no Scilab - função poly() .................................................................. 106 
5.3 Operações com polinômios no Scilab ............................................................................. 107 
5.4 Avaliação de polinômios - função horner() ..................................................................... 108 
5.5 Raízes de polinômios - função roots() ............................................................................. 108 
5.6 Exibindo coeficientes - função coeff() ............................................................................. 109 
5.7 Exercícios Propostos ........................................................................................................ 110 
Capítulo 6 - Gráficos .................................................................................................................. 111 
6.1 A janela gráfica ................................................................................................................ 111 
6.2 Gráficos 2D - plot2d() ...................................................................................................... 112 
6.2.1 Os atributos do gráfico ............................................................................................. 114 
6.2.2 Exemplos ..................................................................................................................116 
6.3 Outros comandos para gráficos ...................................................................................... 119 
6.3.1 Sub-gráficos - funções xsetech() e subplot() ............................................................ 121 
6.4 Gráficos 3D - plot3d(), fplot3d() ...................................................................................... 123 
6.5 Curvas de nível - contour() .............................................................................................. 125 
6.7 Exercícios Propostos ........................................................................................................ 126 
Capítulo 7 - Fontes externas de dados ...................................................................................... 127 
7.1 Lendo um arquivo texto .................................................................................................. 127 
7.2 Lendo um arquivo Excel .................................................................................................. 129 
Capítulo 8 - Introdução à programação no Scilab ..................................................................... 133 
8.1 Definindo Scripts ............................................................................................................. 133 
8.2 Comandos de interação com o usuário - input e disp ..................................................... 134 
8.3 Definindo funções ........................................................................................................... 135 
8.3.1 Definindo funções por meio de arquivos de texto ou comandos no prompt .......... 135 
8.3.2 Definindo funções por meio do comando deff ........................................................ 136 
8.4 Comandos iterativos ....................................................................................................... 138 
8.4.1 O Loop for ................................................................................................................. 138 
8.4.2 O Loop While ............................................................................................................ 139 
8.5 Estruturas condicionais ................................................................................................... 140 
8.5.1 Comando condicional if-then-else ........................................................................... 140 
8.5.2 Comando condicional select-case ............................................................................ 144 
8.6 Exercícios Propostos ........................................................................................................ 145 
Bibliografia ................................................................................................................................ 147 
 
 
 
 
Capítulo 01 - Introdução 
 O Scilab possui grande aplicação na solução de problemas numéricos, os quais podem 
ser resolvidos utilizando as funções do próprio Scilab, pacotes de ferramentas (toolboxes) 
específicos e funções ou scripts definidos pelo usuário. Além disso, os resultados podem ser 
representados e analisados utilizando as ferramentas gráficas disponíveis no software. Além 
da utilização dos comandos e funções do Scilab e da possibilidade de implementar funções, é 
possível, ainda, acessar códigos escritos em C ou Fortran. 
 O Scilab foi criado por pesquisadores do I.N.R.I.A. (Institut National de Recherce en 
Informatique et en Automatic), na França, podendo ser encontrado e descarregado 
gratuitamente pelo endereço eletrônico http://www.scilab.org. O software é distribuído 
gratuitamente desde 1.994 e a partir de 2003 tem sido mantido por um consórcio de empresas 
e instituições francesas, denominado Consórcio Scilab, (Motta, 2004). Atualmente o Scilab tem 
seu código distribuído na rede mundial de computadores, o que o classifica como open source. 
 
 
 
Capítulo 2 – O ambiente Scilab 
Este capítulo permite ao leitor uma familiarização com a ambiente gráfico do Scilab, 
apresentando conceitos básicos do ambiente, de edição de comandos, de manuseamento de 
diretórios e arquivos e uma apresentação da Ajuda do sistema. Este capítulo apresenta, ainda, 
exemplos extraídos de demonstrações do Scilab versão 5.4.1, além da execução de exemplos 
encontrados na Ajuda por meio do editor Scinotes. 
2.1 Apresentação gráfica do ambiente 
 
 O Scilab é um software voltado ao desenvolvimento de soluções aplicadas a problemas 
numéricos. Desenvolvido em 1990 por um grupo de pesquisadores do INRIA (Institute de 
Recherche en Informatique et an Automatique) e do ENPC (Ècole Nationale des Ponts et 
Chaussées), o Scilab é distribuído gratuitamente pela Internet desde 1994. 
 A tela inicial da versão 5.4.1 do Scilab é apresentada pela Figura 2.1. 
 
 
Figura 2.1: Tela inicial do Scilab 
 
Menus de controle: apresentam comandos de manuseamento de arquivos (Arquivo), edição 
(Editar), controle de processamentos (Controle), gerenciamento de aplicações e códigos 
(Aplicação) e ajuda (?). 
 
Barra de ferramentas: apresenta os botões de atalho das ferramentas mais utilizadas do Scilab; 
 
Navegação de arquivos: apresenta uma estrutura de diretórios, com a qual é possível alterar 
entre os diretórios, com o objetivo de auxiliar na busca e execução de arquivos de comandos 
no Scilab. Arquivos de comandos podem ser funções ou scripts definidos pelo usuário, 
armazenados em arquivos de texto. Acima do navegador de arquivos, é definida a pasta de 
trabalho. Esta pasta de trabalho contém os arquivos de funções definidas pelo usuário, as 
quais são executadas no prompt. 
 
Navegação de variáveis: exibe as variáveis criadas durante uma execução, bem como os 
valores dessas variáveis. 
 
Histórico de comandos: armazena o histórico de comandos digitados no prompt. 
 
Prompt de comando, Figura 2.2: 
 
 
Figura 2.2: Prompt de Comando 
 
 O Prompt de comando é a principal forma de interação entre o usuário e o Scilab. 
 
2.2 Utilização do Prompt de Comandos 
 
 O prompt de comandos permite a digitação e edição de comandos, além de chamadas 
de funções. O que se digita após // (duas barras), o Scilab interpreta como comentário. Abaixo 
um exemplo. 
 
-->a=2 
 a = 
 
 2. 
 
-->//Este é um comentário 
 
-->b=5 
 b = 
 
 5. 
 
-->a+b 
 ans = 
 
 7. 
 
Para simplificar a utilização do Prompt, a Tabela 01, apresenta uma lista de combinações de 
teclas aplicadas à edição dos comandos. 
 
Ctrl - p ou ↑ Recupera comandos digitados anteriormente 
Ctrl - n ou ↓ Recupera comandos seguintes (caso existam) 
Ctrl - b ou ← Move o cursor um caracter para a esquerda 
Ctrl - f ou → Move o cursor um caracter para a frente 
Ctrl - h ou Delete Apaga o caracter à direita 
Backspace Apaga o caracter à esquerda 
Ctrl - a Posiciona o cursor no início da linha 
Ctrl -e Posiciona o cursor no fim da linha 
Ctrl - k Apaga todos os caracteres da posição do cursor até o fim da linha 
Ctrl - u Cancela a linha 
Tabela 01: Comandos utilizados no prompt de comandos 
 
2.2.1 Hierarquia de prompts 
 No Scilab é possível utilizar ambientes distintos. Todas as variáveis definidas num 
ambiente (prompt de comando), são válidas para os ambientes posteriores. Porém, a priori, 
não se pode utilizar uma variável de um determinado ambiente em ambientes anteriores a 
este. Este fato se justifica pela hierarquia entre os prompts de comandos. 
 O uso deste recurso é justificável quando se deseja criar um novo ambiente para seja 
testado algum resultado do ambiente anterior, sem interferir nos resultados já obtidos, pois as 
variáveis criadas no ambiente novo não serão mais válidas ao se retornar.Para se criar novos ambientes é preciso utilizar a combinação de teclas Ctrl - c ou utilizar o 
comando pause. 
 
--> //Ambiente principal 
 
-1-> //Novo Ambiente criado (Ctrl - c) 
 
-2-> //Outro ambientee criado (Ctrl - c) 
 
-2-> 
 
Para retornar ao ambiente -1->, por exemplo, é preciso utilizar o comando resume ou return. 
 
-2->resume //retorna ao ambiente 1 
 
-1->resume //retorna ao ambiente pricipal 
 
--> 
 
Para verificar a relação de variáveis, foram criadas as variáveis a e b no ambiente principal e as 
mesmas foram exibidas no próximo ambiente. Em seguida, foi criada a variável c no ambiente -
1-> e , por meio do comando resume, o ambiente original foi retornado e feita a tentativa de 
exibir a variável c neste ambiente. Para simplificar o entendimento, os comandos foram 
comentados. 
 
-->a=2 //cria a variavel a e armazena o valor 2 
 a = 
 
 2. 
 
-->b=3 //cria a variavel b e armazena o valor 3 
 b = 
 
 3. 
 
-->//Ctrl - c para criar novo ambiente 
 
-1->a,b //exibir os valores de a e b no novo ambiente 
 a = 
 
 2. 
 ans = 
 
 3. 
 
-1->c=5 //criar a variavel c no novo ambiente e armazenar o valor 5 
 c = 
 
 5. 
 
-1->resume //retorna ao ambiente original 
 
-->c //tentar exibir c 
 !--error 4 
Variável indefinida: c 
 
 
-->a,b //veja que a e b continuam definidas 
 a = 
 
 2. 
 ans = 
 
 3. 
 
 
Os comandos para manipulação podem ser sintetizados: 
• Pause (Ctrl - c) - cria novo ambiente; 
• Resume ou Return - retorna ao ambiente anterior; 
• Abort - retorna todos os ambientes, voltando ao ambiente original. 
 
2.3 Variáveis especiais (comando Who) 
 
 Variáveis especiais apresentam valores pré-definidos no Scilab, sendo variáveis 
reservadas pelo sistema e não podem ser redefinidas pelo usuário, tampouco apagadas. Para 
visualizar as variáveis especiais é preciso digitar o comando who, no prompt de comandos, 
conforme apresentado pela Figura 2.3. Pode-se observar, ainda, que algumas variáveis são 
fixadas com o valor % (porcentagem). 
Figura 2.3: Apresentação das variáveis especiais após o comando Who 
 
2.3.1 Algumas variáveis especiais 
 
 Esta seção apresenta algumas variáveis especiais, bem como um exemplo para cada 
uma, com o comando digitado para se obter o resultado esperado. Vale ressaltar que o Scilab é 
-->who 
Suas variáveis são: 
 
 help makeCommand editor home 
 modules_managerlib assertlib development_toolslib scicos_autolib 
 scicos_utilslib xcoslib graphic_exportlib graphicslib 
 datatipslib guilib uitreelib scinoteslib 
 jvmlib helptoolslib tclscilib atomslib 
 atomsguilib matiolib parameterslib simulated_annealinglib 
 genetic_algorithmslib umfpacklib spreadsheetlib demo_toolslib 
 external_objectslib soundlib m2scilib compatibility_functilib 
 arnoldilib statisticslib windows_toolslib WSCI 
 timelib stringlib special_functionslib sparselib 
 signal_processinglib %z %s polynomialslib 
 overloadinglib optimsimplexlib optimbaselib neldermeadlib 
 optimizationlib interpolationlib linear_algebralib output_streamlib 
 iolib integerlib dynamic_linklib data_structureslib 
 cacsdlib fileiolib functionslib elementary_functionslib 
differential_equationlib corelib PWD %tk 
 %F %T %nan %inf 
 SCI SCIHOME TMPDIR %gui 
 %fftw $ %t %f 
 %eps %io %i %e 
 %pi 
 
 utilizando 9463 elementos de um total de 10000000. 
 e 81 variáveis de um total de 9231. 
 
Suas variáveis globais são: 
 
 %modalWarning %toolboxes %toolboxes_dir %helps 
 
 
 utilizando 27 elementos de um total de 999999. 
 e 4 variáveis de um total de 767. 
case sensitive, ou seja, as letras minúsculas e maiúsculas são diferenciadas na compilação dos 
comandos. 
 Primeiramente é válido definir a variável ans (que deriva do inglês, answer, que 
significa resposta). Esta variável armazena a resposta de um cálculo ou após uma execução de 
uma função. Como exemplo, foi realizada a soma de dois números reais, o resultado fica 
armazena na variável ans, que pode inclusive ser reutilizada. 
 
-->2+4 //soma de dois numeros 
 ans = 
 
 6. 
 
-->ans * 2 //multiplicacao da resposta por 2 
 ans = 
 
 12. 
 
%pi: apresenta uma aproximação do número π (3,1415926...); 
-->%pi 
 %pi = 
 3.1415927 
 
Para verificar que o Scilab é case sensitive, segue exemplo da digitação de %PI, em vez de %pi: 
-->%PI 
 !--error 4 
Variável indefinida: %PI 
 
%e: aproximação da constante de Euller (2,7182818...); 
-->%e 
 %e = 
 2.7182818 
 
%i: raiz imaginária i = √−1; 
-->%i 
 %i = 
 i 
 
%eps: apresenta o epsilon da máquina em que o Scilab está sendo executado. O epsilon 
corresponde ao menor número maior do que zero que a máquina pode representar. Este 
número varia, de acordo com a máquina. Qualquer valor menor ou igual ao epsilon da 
máquina é arredondado para zero. Para verificar, pode ser digitado no prompt: 
 
-->1+%eps 
 ans = 
 1. 
 
Para verificar o valor do epsilon da máquina, basta utilizar o comando: 
-->%eps 
 %eps = 
 2.220D-16 
 
%inf: representação, no Scilab, de infinito. 
-->%inf 
 %inf = 
 Inf 
 
%nan: utilizada para representar "Not a Number" (não é um número). 
-->%nan 
 %nan = 
 Nan 
 
%T e %F: variáveis com valores booleanos, sendo que representam, respectivamente, 
"verdadeiro" (true) e "falso" (false). 
 
2.4 Arquivos e diretórios 
 
2.4.1 Definição do diretório de trabalho 
 O diretório de trabalho armazena funções e scripts definidas pelo usuário e o Scilab 
compila diretamente os códigos presentes neste diretório. Por este motivo se torna 
importante definir qual será o diretório de trabalho. 
 O diretório pode ser visualizado pelo Navegador de arquivos, conforme apresentado 
pela Figura 2.4: 
 
 
Figura 2.4: Navegador de Arquivos 
 
Para visualizar o diretório de trabalho pelo prompt, é preciso digitar o comando pwd. 
 
-->pwd 
 ans = 
 D:\Fábio\Cálculo Numérico\Scilab\Arquivos 
 
Existem duas formas de alterar este diretório: 
1) utilizar a navegação de arquivos, Figura 2.4, e selecionar outra pasta; 
2) por meio da função chdir(). A sintaxe deste comando é: 
 
chdir('diretório de trabalho') 
 
Exemplo: 
-->chdir('d:\Fábio') 
 ans =T 
 
No caso, o retono "T" significa que o comando foi realizado com sucesso e a pasta foi alterada, 
conforme Figura 2.5. 
 
 
Figura 2.5: Novo diretório definido 
 
Importante: não confundir a variável pwd e PWD. PWD representa o diretório no qual o Scilab 
está sendo executado, enquanto que pwd armazena o diretório de trabalho. Os comandos 
foram executados, com o objetivo de visualizar que as pastas são distintas: 
 
-->pwd 
 ans = 
 d:\Fábio 
 
-->PWD 
 PWD = 
 D:\Usuários\Cliente\Documents 
 
É importante lembrar que o Scilab é case sensitive. 
 
2.4.2 Histórico de comandos (diary) 
 Uma opção de armazenar o histórico de comandos utilizados no Scilab é por meio do 
comando diary, com o qual se pode criar um arquivo de texto dentro do diretório de trabalho. 
 
 A utilização deste comando é sintetizada como: 
 
diary('nome do arquivo') //define o arquivo que armazenará os comandos 
Sequência de comandos 
diary(0) //finaliza a gravação dos comandos 
 
Como exemplo, foi criado um arquivo com o nome "comandos gravados". 
 
-->diary('comandos gravados') 
 ans = 
 
 1. 
 
-->a=2 
 a = 
 
 2. 
 
-->b=5 
 b = 
 
 5. 
 
-->pwd 
 ans = 
 
 d:\Fábio 
 
-->diary(0) 
 
--> 
 
A Figura 6 apresenta o arquivo gerado pelo comando diary: 
 
Figura 6: Arquivo gerado pela utilização do comando diary 
Importante: vale ressaltar que este arquivo gerado fica armazenado no diretório de trabalho. 
2.5 Help do Scilab 
 Existem duas formas de acessar o help do Scilab. A primeira é digitar o comando help 
no prompt de comandos. A segunda é clicar no menu ? e em seguida em Ajuda do Scilab (pode 
também ser pressionada a tecla F1). 
 A Figura 7 apresenta a janela de ajuda do Scilab. A navegação pode dentro desta janela 
por ser feita pela estrutura à esquerda da janela ou então pode ser feita uma busca pelo que 
se deseja consultar. 
 
 
Figura 7: Janela de ajuda do Scilab 
 
 Para exemplificar, a Figura 8 apresenta a consulta pela função fft2, presente na pasta 
Processamento de Sinais. 
 
 
Figura 8: Ajuda para a função fft2, processamento de sinais 
 
 Pode ser visto que, em seus tópicos, a ajuda do Scilab apresenta o modelo da chamada 
de função, lista de parâmetros, descrição da função e até exemplos de utilização. 
 
 A Figura 9 apresenta um exemplo de utilização da função fft2: 
 
 
Figura 9: Exemplo de utilização da função fft2 
 
 É sugerido, ao leitor, uma navegação dentro da janela ajuda e verificação de alguns 
conteúdos. 
 
OBS.: também pode ser digitado, no prompt de comandos, o comando help seguido pelo nome 
da função. 
 
Por exemplo, 
 
-->help det 
Apresenta a ajuda para a função det(), a qual se utiliza para determinar determinantes de 
matrizes quadradas. 
2.5.1 Demonstrações do Scilab 
 Ainda no menu Ajuda (?), é possível clicar em "Demonstrações do Scilab" e ter acesso a 
alguns exemplos do que pode ser feito no sistema. A Figura 2.10 apresenta a janela 
"Demonstrações do Scilab" 
 
 
Figura 2.10 - Demonstrações do Scilab 
 
 É recomendado, ao usuário, uma verificação nessas categorias de demonstrações. Por 
exemplo, dentro de Simulação/Simulação de fluxo/Black hole, pode ser simulado o fluxo de 
uma partícula, dados alguns parâmetros, como posição e velocidade, definidos pelo usuário. A 
Figura 2.11 apresenta essa simulação de fluxo. 
 
 
Figura 2.11: Simulação de fluxo Black hole 
 
Em "Aleatório", é possível verificar algumas distribuições de probabilidade para variáveis 
aleatórias, conceito este da área de Estatística. 
 A Figura 2.12 apresenta a simulação para uma variável aleatória binomial. 
 
 
Figura 2.12: Simulação de uma variável aleatória binomial 
 
 Podem ser vistas, ainda, simulações de algoritmos aplicados a otimização, como o caso 
do Algoritmo Genético (AG). Este algoritmo trabalha com a ideia da evolução de Darwin, 
partindo de uma população inicial, em que cada indivíduo da população representa uma 
solução do problema tratado e, por meio de operadores como: cruzamento entre os indivíduos 
(gerando novos soluções que "herdam" características dos "pais"), seleção entre os indivíduos, 
gerando novas populações que contém os filhos gerados e mutação nos novos indivíduos, são 
geradas novas populações, com soluções teoricamente melhores do que as soluções das 
populações anteriores. Este algoritmo leva à evolução dos indivíduos, gerando soluções cada 
vez melhores. 
 
A Figura 2.13 apresenta a execução e o gráfico do algoritmo genético é apresentado pela 
Figura 2.14, presente nessas demonstrações do Scilab. Para visualizar essa simulação, basta 
acessar, na janela de demonstrações, Otimização e Simulação/Algoritmos 
Genéticos/Algoritmos Genéticos. Ainda existem outras variações do Algoritmo Genético, as 
quais não são serão discutidas neste texto por não fazerem parte do escopo tratado. 
 
 
Figura 2.13: Algoritmo Genético sendo executado no Scilab 
 
 
Figura 2.14: Representação das soluções 
 
 No Figura 2.14, podem ser visualizadas as soluções (representadas por números reais e 
binários) e os valores máximos e mínimos da função considerada no exemplo. 
 Outro algoritmo que pode ser encontrado nesta lista de demonstrações é o Simulated 
Annealing (recozimento simulado), que é um algoritmo heurístico de otimização baseado no 
processo físico de recozimento de materiais. No processo de recozimento, a temperatura de 
um material é reduzida gradativamente, partindo de uma temperatura inicial. O algoritmo 
parte da ideia apresentada, partindo de uma solução inicial que possui um valor na função 
objetivo (temperatura inicial) e são encontradas novas soluções que levam a valores funcionais 
(temperaturas) menores. Para simular o processo de recozimento aplicado à Otimização, é 
preciso acessar, na janela de demonstrações, Otimização e Simulação/Arrefecimento 
simulado/Arrefecimento Simulado. 
 A Figura 2.15 apresenta a execução do algoritmo descrito anteriormente, em que pode 
ser observado, para a função interna implementada no exemplo, que foi atingido o valor 
ótimo. A Figura 2.16 apresenta o gráfico da execução do algoritmo. No gráfico apresentado 
pela Figura 2.16, pode ser verificado o decaimento da temperatura, que representa o valor da 
função otimizada. 
 
 
Figura 2.15: Execução do Simulated Annealing 
 
 
Figura 2.16: Gráfico da execução do Simulated Annealing 
 
 Outros exemplos de demonstrações do Scilab são encontrados em Xcos, que é um 
modelador e simulador que possui uma interface por meio de blocos, tendo aplicação em 
simulações em, por exemplo, estudos na área de Engenharia Elétrica, como Processamento de 
Sinais. 
 A Figura 2.17 apresenta uma modelagem de um circuito elétrico específico, podendo 
ser encontrada em Xcos/Sistemas Elétricos/Circuito RLC. 
 
 
Figura 2.17: Representação do circuito elétrico 
 
 Dentro de Sistemas Elétricos podem ser executadas outras demonstrações, como a da 
representação de um Transformador, apresentado pela Figura 2.18. 
 
 
Figura 2.18: Representação de um transformador 
 É sugerido, ao leitor, que execute outras demonstrações no Scilab, com o objetivo de 
se familiarizar com o software e visualizar algumas funcionalidades do sistema, como a 
simulação do movimento invertido do pêndulo, presente na Figura 2.19, ou do movimento de 
uma roda, Figura 2.20. Em particular, é sugerido, ao aluno, a visualização das demonstrações 
na Seção Gráficos. Como exemplo, a Figura 2.21 apresenta o gráfico da função � =��	
��cos 
��. Sugere-se,ainda, que o leitor fique atento aos padrões de cores utilizados 
nestes gráficos. 
 
 
 
Figura 2.19: Movimento do pêndulo invertido 
 
 
Figura 2.20: Simulação do movimento de uma roda 
 
Figura 2.21: Gráfico da função � = ��	
��cos 
��. 
2.6 O editor Scinotes 
 O Scilab apresenta um editor onde podem ser escritas as funções e scripts definidos 
pelo usuário. Neste capítulo não serão descritos os códigos utilizados para implementar estas 
funções e scripts, apenas será conhecido o ambiente do Scinotes. 
 Para acessar o ambiente Scinotes pode ser utilizado o botão presente na barra de 
ferramentas ou o menu Aplicativos/Scinotes. A tela do ambiente é apresentada pela Figura 
2.22. 
 
 
Figura 2.22: ambiente Scinotes 
 
 Os exemplos apresentados nos tópicos da Ajuda do Scilab podem ser copiados para o 
Scinotes e executados por meio do botão ou ainda pela tecla F5 (salvar e executar). É 
possível, ainda, utilizar o botão Salvar e Executar . 
 Como exemplo, foi copiado o código do exemplo da função interpln(), a qual interpola 
um conjunto de pontos (x,y) por meio de funções lineares, possibilitando fazer estimativas dos 
valores de y para cada x entre um par de pontos. 
 O primeiro passo é buscar, na ajuda, a função interpln(). Em seguida copiar o código do 
exemplo de utilização da função. Após copiar o código, é preciso colar este código no Scinotes, 
salvar e executar, conforme Figura 2.23 e 2.24. O resultado é apresentado pela Figura 2.25. 
 
 
Figura 2.23: Cópia do código do exemplo da função encontrado na Ajuda do Scilab 
 
 
Figura 2.24: Cópia do código para o Scinotes 
 
 
Figura 2.25: Interpolação linear para cada par de pontos 
 
 É sugerido, ao leitor, a busca de outros exemplos e a execução de outros códigos no 
Scinotes. 
2.7 Exercícios Propostos 
1- Crie duas variáveis, a e b, no prompt de comandos e, em seguida, armazene os valores 10 e 
3 nestas variáveis. 
a) Escreva a sequencia de comandos para criar um segundo prompt de comandos e atribua 
c=a+b. Em seguida, execute as instruções no Scilab. 
b) Escreva a sequencia de comandos para criar um terceiro prompt de comandos e faça 
d=a+b+c. Em seguida, execute as instruções no Scilab. 
c) Escreva as instruções para retornar ao segundo prompt e tentar exibir a variável d. O que 
ocorreu neste caso? Justifique o ocorrido. 
2- Explique a relação entre os prompts de comando no Scilab. 
3- Ao ser utilizado o comando Who, no Scilab, é apresentada uma lista de variáveis ditas 
especiais, as quais são variáveis reservadas no sistema e não podem ser redefinidas ou 
apagadas pelo usuário. Qual a importância dessas variáveis especiais? 
4- Escreva a diferença entre os comandos pwd e PWD do Scilab. 
5- Descreva as variáveis especiais %pi, %e, %i e %eps. 
6- Escreva o significado da variável %eps. O que ocorre ao fazer, no Scilab, 1+%eps? Explique o 
motivo do resultado obtido ao se realizar esta operação. 
6- Defina o que é o diretório de trabalho no Scilab. Qual o comando para visualizá-lo? Qual 
comando se utiliza para alterá-lo? 
7- Escreva a sequencia de comandos para: a) exibir o diretório de trabalho, b) alterar o 
diretório de trabalho para uma pasta qualquer, c) exibir novamente o diretório de trabalho, c) 
exibir o diretório no qual o sistema está sendo executado. 
8- Execute no Scilab a sequencia de comandos do exercício 7, gravando todos os comandos 
em um arquivo de log, por meio do comando diary. 
9- Suponha que, para resolver o exercício anterior, você precise consultar a ajuda para o 
comando diary. Descreva duas maneiras de consultar a ajuda para o comando. 
10- No conteúdo de demonstrações do Scilab, faça a simulação do movimento de uma 
partícula (simulação) dentro de uma superfície cilíndrica. Faça diferentes simulações, 
alterando os valores dos parâmetros. 
11- Ainda nas demonstrações do Scilab, faça uma simulação do movimento do pêndulo 
tendo como suporte uma parábola. Para isto, vá na categoria de Simulação, EADs, Sliding 
pendulum, parábola. 
12- Nas demonstrações do Scilab, acesse a categoria Gráficos, Mais superfícies e execute 
as demonstrações Sphere, Shell, Spiral Rings, Torus, Torus 1, Moebius, Tube e Blach hole. 
13- Nas demonstrações do Scilab, acesse a categoria XCos, Sistemas elétricos e execute as 
demonstrações: Circuito RLC, Retificador em ponte, Transformador, Amplificador diferencial, 
Capacitor de integração trocado, Porta lógica E e Porta Lógica Não-Ou. 
14- Ainda nas demonstrações do Scilab, na categoria Xcos, visualize o modelo de uma 
suspensão automotiva na categoria Sistemas mecânicos. 
15- Faça a simulação, utilizando as demonstrações do Scilab, da execução de uma 
algoritmo genético, na categoria Algoritmos Genéticos, dentro de Otimização e Simulação. 
16- Descreva a funcionalidade do aplicativo Scinotes. 
17- Pesquise, no Help do Scilab, a função optim_ga. Em seguida, cole o exemplo da função 
no Scinotes, salve em alguma pasta e o execute. Em seguida, responda: a) verifique qual 
função foi otimizada; b) o algoritmo genético se aproximou do mínimo da função otimizada? 
18- Ainda no Help do Scilab, pesquise pela função sound(), copie o exemplo, cole no 
prompt de comandos do Scilab e pressione enter. 
 
Capítulo 3 – Operações básicas 
O objetivo deste capítulo é o de apresentar as operações básicas do Scilab, com o objetivo de 
utilizar o sistema como máquina de calcular. 
3.1 Operações básicas no Scilab 
 Neste capítulo, o modo de interação entre o Scilab e o usuário será por meio da 
digitação no prompt de comando e, em seguida, com a utilização da tecla enter, fazendo os 
comandos digitados serem automaticamente interpretados e executados pelo Scilab. 
 
 No Scilab, a digitação do ; (ponto e vírgula) após um comando não apresenta o 
resultado obtido, Figura 3.1. 
 
 
Figura 3.1: utilização do ponto e vírgula 
3.1.1 Operações Básicas com variáveis reais 
 
 As operações elementares de soma, diferença, multiplicação e divisão podem ser 
executadas por meio dos comandos +, -, * e /. 
 Para exemplificar, serão criadas as variáveis A, B e C e as operações serão executadas 
sobre os valores armazenados nestas variáveis. 
 
-->A=5; 
 
-->B=6; 
 
-->C=2; 
 
-->A+B 
 ans = 
 
 11. 
 
-->B+A 
 ans = 
 
 11. 
 
-->(A+B)+C 
 ans = 
 
 13. 
 
-->A+(B+C) 
 ans = 
 
 13. 
 
-->B-C 
 ans = 
 
 4. 
 
-->-C 
 ans = 
 
 - 2. 
 
-->B+(-C) 
 ans = 
 
 4. 
 
-->A-B+C 
 ans = 
 
 1. 
 
-->A*B 
 ans = 
 
 30. 
 
-->B*A 
 ans = 
 
 30. 
 
-->2*A 
 ans = 
 
 10. 
 
-->C*B+C 
 ans = 
 
 14. 
 
-->C*(B+C) 
 ans = 
 
 16. 
 
-->C+B/2 
 ans = 
 
 5. 
 
-->(C+B)/2 
 ans = 
 
 4. 
 
-->A*(B+C) 
 ans = 
 
 40. 
 
-->A*A 
 ans = 
 
 25. 
 
 Nos exemplos, é importante observar que são executadas, primeiramente, as 
operações de multiplicação e divisão e, em seguida, as operações de soma e subtração. Outro 
ponto que deve ser observado é a utilizada de parênteses, estes funcionam alterando a ordem 
na qual os cálculos são executados. 
 A potenciação é definida por meio do operador ^ (acento circunflexo). Utilizando o 
operador ^, também é possível calcular raízes de qualquer grau, conforme exemplificado. 
 
-->A=3 
 A = 
 
 3. 
 
-->A^2 
 ans = 
 
 9. 
 
-->B=64 
 B = 
 
 64. 
 
-->B^(1/2) //raizquadrada de B (64) 
 ans = 
 
 8. 
 
-->A^3 
 ans = 
 
 27. 
 
-->C=27 
 C = 
 
 27. 
 
-->C^(1/3) //raiz cubica de C (27) 
 ans = 
 
 3. 
 
 Como verificado no exemplo, raízes de qualquer ordem n podem ser obtidas por meio 
da operação de potenciação. Porém, para o caso particular da raiz quadrada, existe uma 
função nativa (ou intrínseca) do Scilab, a função sqrt(). 
 Para exemplificar, será utilizada a variável B. Primeiro será verificado se, de fato, B 
armazena o valor 64, para isso é preciso digitar B no prompt de comandos. Em seguida, a raiz 
quadrada de B será calculada. 
 
-->B 
 B = 
 
 64. 
 
-->sqrt(B) 
 ans = 
 
 8. 
 
 A função sqrt é sintetizada como: 
 
sqrt(arg) 
 
 No caso, arg indica o argumento da função, o qual pode ser um número ou uma 
variável. Pode ser visualizada a utilização da função mencionada tendo um número real como 
argumento. 
 
-->sqrt(400) 
 ans = 
 
 20. 
 
 Caso se utilize um número negativo como argumento dessa função, o Scilab 
automaticamente interpreta como um número complexo, como será visto na Seção seguinte. 
 
 Outra função do Scilab muito conhecida na Matemática é a função abs(), cuja síntese 
é: 
abs(arg) 
 
 Esta função retorna o módulo (ou valor absoluto) de um número informado como 
parâmetro. O parâmetro (arg) pode ser um número real ou complexo ou, ainda, podem ser 
informadas variáveis que armazenem estes números. 
 
3.1.2 Operações Básicas com variáveis complexas 
 
 Nesta seção, serão relembrados alguns conceitos de números complexos e serão 
exemplificados alguns cálculos por meio do Scilab. 
 A raiz imaginária é obtida pela variável %i. As raízes de ordem par de números 
negativos também são interpretadas como números complexos pelo Scilab. 
 
->%i //apresentação da variável %i 
 ans = 
 
 i 
 
-->sqrt(-1) // raiz quadrada de -1 
 ans = 
 
 i 
 
-->(-16)^(1/4) //raiz quarta de -16 
 ans = 
 
 1.4142136 + 1.4142136i 
-->sqrt(-4) //raiz quadrada de -4 
 ans = 
 
 2.i 
 
 Com o objetivo de apresentar as operações básicas com números complexos, serão 
criadas as variáveis A e B, de modo que A=6+2i e B=2-i. 
 Antes de executar operações com os números complexos, vale lembrar algumas 
definições. 
 O conceito de números complexos se iniciou no século XVI, tendo como primeiras 
aplicações os estudos de equações de terceiro e quarto graus, embora muitos associem, 
erroneamente, o início dos estudos deste conjunto numérico à necessidade de se definir raízes 
quadradas de números negativos. 
 Seja um número complexo x = a + bi, de modo que a é dito "parte real" e b parte 
imaginária do número complexo x. O número complexo x também pode ser representado pelo 
par ordenado (a,b) e ainda associado ao ponto (a,b) do plano cartesiano ortogonal. 
 
 Sejam os números x = (a,b) e y = (c,d). 
 
Identidade: x = y se, e somente se, a=c e b=d. 
Soma: x+y = y+x = (a+bi) + (c+di) = (a+c) + (b+d)i 
Subtração: y-x = (a+bi) - (c+di) = (a-c) + (b-d)i 
Produto: x.y = y.x = (a+bi) . (c+di) = (ac-bd) + (bc+ad)i 
Conjugado: seja x=a+bi, o conjugado de x, denotado por �̅ é definido �̅=a-bi. 
Divisão: a divisão é feita multiplicando-se o dividendo e o divisor pelo conjugado do divisor. 
 
Exemplo de divisão: 
 
10 + 2i�: 
2 − 3i� = 
������.
�����
�����.
����� = ������� ��!�" �#�" 
 
Como $� = −1, temos: 
 20 + 30i + 4i + 6i�4 − 9i� = 20 + 30i + 4i − 64 + 9 = 1413 + 3413 i 
 
Módulo de um número complexo: dado um número complexo x = a+bi. O módulo de x, 
denotado por |x| é definido como o comprimento do segmente que liga a origem ao ponto 
P(a,b) no plano cartesiano ortogonal. Logo, 
 |x| = *a� + b� 
 
 Retornando aos exemplos, serão criadas as variáveis A e B, de modo que A=6+2i e B=2-
i. 
 Antes de criar essas variáveis, será utilizado com mando clear, o qual "limpa" as 
variáveis ditas "não globais". 
 
-->clear //"limpar" variaveis nao globais 
 
-->A= 6+2*%i; //A recebe 6+2i 
 
-->B= 2-%i; //B recebe 2-i 
 
-->A+B 
 ans = 
 
 8. + i 
 
-->B+A 
 ans = 
 
 8. + i 
 
-->A-B 
 ans = 
 
 4. + 3.i 
 
-->A*B 
 ans = 
 
 14. - 2.i 
 
-->A/B 
 ans = 
 
 2. + 2.i 
 
-->-A 
 ans = 
 
 - 6. - 2.i 
 
-->abs(B)//modulo de B 
 ans = 
 
 2.236068 
 
-->abs(A) //modulo de A 
 ans = 
 
 6.3245553 
3.2 Algumas funções elementares 
As funções apresentadas nesta Seção são ditas intrínsecas. Funções intrínsecas são aquelas 
nativas no sistema, ou seja, não precisam ser implementadas pelo usuário e podem ser 
utilizadas informando-se os parâmetros necessários. Todas essas funções podem ser 
consultadas no Help do Scilab, de modo que podem ser visualizadas as descrições e exemplos 
de utilização. As descrições e exemplos destas funções podem ser encontradas no manual do 
Scilab, (Scilab Group - Manual Scilab). 
3.2.1 Funções matemáticas básicas 
3.2.1.1 Função abs() 
 Como já mencionado anteriormente, retorna o módulo de um número real ou 
complexo. 
 Síntese da função: abs(x), em que x pode ser um número real, complexo ou uma lista 
de números. No caso de uma lista de números (vetor), a função retorna uma lista com o 
módulo de cada elemento informado como parâmetro. 
Exemplo: 
-->abs(-1) 
 ans = 
 
 1. 
 
-->abs(-3) 
 ans = 
 
 3. 
 
-->abs(-3+4*%i) //informado um numero complexo como parametro 
 ans = 
 
 5. 
 
-->x=[-1, -5, 3, -2] //criacao de uma lista (vetor) 
 x = 
 
 - 1. - 5. 3. - 2. 
 
-->abs(x) //informada uma lista como parametro 
 ans = 
 
 1. 5. 3. 2. 
 
--> 
3.2.1.2 Função log() 
 Função utilizada para retornar o logaritmo natural de um número diferente de zero. 
Caso seja informado um número real menor que zero, o retorno da função não será um 
número real. 
 Síntese da função: log(x), em que x pode representar um número diferente de zero ou 
uma lista de números. Caso o parâmetro informado seja uma lista de números, o logaritmo é 
calculo para cada elemento da lista. 
Exemplos: 
-->log(1) //observe que log(1) = 0, pois e^0 =1 
 ans = 
 
 0. 
 
-->log(0) //observe que este parametro e invalido 
 !--error 32 
Singularidade da função logarítmica ou tangente. 
 
 
-->log(2) 
 ans = 
 
 0.6931472 
 
-->log(5) 
 ans = 
 
 1.6094379 
 
-->log(-5) //observe que o retorno nao sera real 
 ans = 
 
 1.6094379 + 3.1415927i 
 
-->x=[1, 4, 5] //criando uma lista de numeros (vetor) 
 x = 
 
 1. 4. 5. 
 
-->log(x) 
 ans = 
 
 0. 1.3862944 1.6094379 
 
--> 
3.2.1.3 Função log10() 
 A função log10() pode ser utilizada para calcular um logaritmo cuja base é 10. 
 Síntese da função: log10(x), em que x pode representar um número diferente de zero 
ou uma lista de números. Caso o parâmetro informado seja uma lista de números, o logaritmo 
é calculo para cada elemento da lista. 
Exemplos: 
-->log10(1) 
 ans = 
 
 0. 
 
-->log10(100) 
 ans = 
 
 2. 
 
-->log10(1000) 
 ans = 
 
 3. 
 
-->10^log10(3) //aqui se verifica uma propriedade de logaritmo 
 ans = 
 
 3. 
-->log10(20*3) 
 ans = 
 
 1.7781513 
 
-->log10(20)+log10(3) 
 ans= 
 
 1.7781513 
 
-->log10(160/3) 
 ans = 
 
 1.7269987 
 
-->log10(160)-log10(3) 
 ans = 
 
 1.7269987 
 
-->log10(3^2) 
 ans = 
 
 0.9542425 
 
-->2*log10(3) 
 ans = 
 
 0.9542425 
3.2.1.4 Função log2() 
 Função utilizada para calcular logaritmos cuja base é 2. Sua definição e exemplos são 
similares às apresentadas na Seção 3.2.3. 
3.2.1.5 Função exp() 
 Função utilizada para calcular o valor exponencial (de base e) em relação ao parâmetro 
informado. 
 Síntese da função: exp(x), em que x pode representar um número real ou uma lista de 
números reais (também podem ser informados números complexos). Caso o parâmetro 
informado seja uma lista de números, a função é executada para cada elemento desta lista. 
Exemplos: 
-->exp(1) //valor de e^1 
 ans = 
 
 2.7182818 
 
-->exp(-3) 
 ans = 
 
 0.0497871 
 
-->exp(0) 
 ans = 
 
 1. 
 
-->exp(log(2)) // no caso um logaritmo natural e informado como parametro 
 ans = 
 
 2. 
 
-->x=[-1, log(5), 0]//lista de numeros 
 x = 
 
 - 1. 1.6094379 0. 
 
-->exp(x) 
 ans = 
 
 0.3678794 5. 1. 
3.2.1.6 Função sqrt() 
 Como já descrito anteriormente, esta função retorna a raiz quadrada de um número 
real. Caso seja informado, como parâmetro, um número negativo, o Scilab interpretará o 
resultado como um número complexo. 
 Síntese: sqrt(x), em que x é um número real ou complexo. 
Exemplos: 
-->sqrt(9) 
 ans = 
 
 3. 
 
-->sqrt(25) 
 ans = 
 
 5. 
 
-->sqrt(100) 
 ans = 
 
 10. 
 
-->sqrt(9) 
 ans = 
 
 3. 
 
-->sqrt(25) 
 ans = 
 
 5. 
 
-->sqrt(-1) //raiz imaginaria 
 ans = 
 
 i 
 
-->sqrt(2-%i)//numero complexo 2-i informado como parametro 
 ans = 
 
 1.4553467 - 0.3435607i 
 
-->sqrt(-9) 
 ans = 
 
 3.i 
 
--> 
3.2.1.7 Função sum() 
 Função utilizada para somar os valores de uma lista numérica (vetor). 
 Síntese da função: sum(x), em que x é uma lista de números a ser somada. 
Exemplo: 
-->x=[1.2 -3.4 -5.9 6.8] 
 x = 
 
 1.2 - 3.4 - 5.9 6.8 
 
-->sum(x) 
 ans = 
 
 - 1.3 
 
-->1.2+(-3.4)+(-5.9)+6.8 //verificacao do resultado 
 ans = 
 
 - 1.3 
3.2.1.8 Função prod() 
 Função utilizada para retornar o produto dos valores de uma lista numérica (vetor). 
 Síntese da função: prod(x), em que x é uma lista de números a ser somada. 
-->x=[1.2 -3.4 -5.9 6.8] //lista de valores 
 x = 
 
 1.2 - 3.4 - 5.9 6.8 
 
-->prod(x) 
 ans = 
 
 163.6896 
 
-->1.2*(-3.4)*(-5.9)*6.8 
 ans = 
 
 163.6896 
 
3.2.1.9 Função primes() 
 A função primes() retorna a sequencia de números primos até N (parâmetro informado 
na chamada da função). 
 Síntese: primes(N), em que N é um número real. 
Exemplos: 
-->primes(35) 
 ans = 
 
 2. 3. 5. 7. 11. 13. 17. 19. 23. 29. 31. 
 
-->primes(-35) 
 ans = 
 
 [] 
 
-->primes(20.5) 
 ans = 
 
 2. 3. 5. 7. 11. 13. 17. 19. 
 
--> 
3.2.1.10 Função factor() 
 Dado um número inteiro e positivo, a função factor é utilizada para decompor o 
número em um produto de números primos (fatoração). Sabe-se que atualmente não existe 
um algoritmo capaz de fatorar um número em tempo polinomial, ou seja, um algoritmo cujo 
complexidade de tempo pode ser dada por uma função polinomial. 
 Síntese da função: factor(N), em que N é um número inteiro e positivo. 
 
Exemplos: 
-->factor(10) 
 ans = 
 
 2. 5. 
 
-->factor(15) 
 ans = 
 
 3. 5. 
 
-->factor(30) 
 ans = 
 
 2. 3. 5. 
 
-->factor(520) 
 ans = 
 
 2. 2. 2. 5. 13. 
 
-->factor(1012) 
 ans = 
 
 2. 2. 11. 23. 
 
--> 
3.2.1.11 Função modulo() 
 A função modulo() retorna o resto da divisão entre dois números inteiros. 
 Síntese das funções: modulo(m,n), em que m e n são dois números inteiros. 
 
Exemplos: 
-->modulo(5,3) //note que 5=3*1+ 2 
 ans = 
 
 2. 
 
-->modulo(-5,3) //note que 5=3*(-1)+ (-2) 
 ans = 
 
 - 2. 
 
--> 
3.2.1.12 Função real() 
 Retorna a parte real de um número complexo. 
 Síntese: real(x), em que x é um número complexo. 
Exemplo: 
-->x=-2+3*%i //criacao do numero complexo 
 x = 
 
 - 2. + 3.i 
 
-->real(x) 
 ans = 
 
 - 2. 
3.2.1.13 Função imag() 
 Retorna a parte imaginária de um número complexo. 
 Síntese: imag(x), em que x é um número complexo. 
Exemplo: 
-->x=-2+3*%i //criacao do numero complexo 
 x = 
 
 - 2. + 3.i 
 
-->imag(x) 
 ans = 
 
 3. 
3.2.2 Funções elementares de conversão 
3.2.2.1 Função dec2bin() 
 Função aplicada à conversão numérica, de um número representado na base 10 para a 
base 2 (binário). 
 Síntese da função: dec2bin(x), em que x é um número inteiro e positivo ou uma lista de 
números inteiros e positivos. 
 
Exemplos: 
-->dec2bin(2) 
 ans = 
 
 10 
 
-->dec2bin(10) 
 ans = 
 
 1010 
 
-->dec2bin(95) 
 ans = 
 
 1011111 
 
--> 
 
 Outra forma de utilizar a função é por meio do comando: 
[str]=dec2bin(x[,n]) 
 
Neste caso: 
 
x: é um escalar, vetor ou matriz de números inteiros e positivos; 
str: uma string ou um vetor de strings; 
n: número inteiro e positivo que representa a quantidade de posições da string ou vetor de 
strings; 
 
Exemplos: 
-->str=dec2bin(95) //a sequencia binaria sera armazenada em uma string 
 str = 
 
 1011111 
 
-->x=95 
 x = 
 
 95. 
 
-->n=15 //a sequencia binaria sera armazenada em um vetor de strings de 15 digitos 
 n = 
 
 15. 
 
-->str=dec2bin(x,n) 
 str = 
 
 000000001011111 
 
--> 
3.2.2.2 Função bin2dec() 
 Função utilizada para conversão de número binário para a base 10. 
 Síntese: bin2dec(str), em que str é uma string que armazena uma sequência binária. 
Exemplos: 
-->bin2dec('11001') 
 ans = 
 
 25. 
 
-->str='1110010' 
 str = 
 
 1110010 
 
-->bin2dec(str) 
 ans = 
 
 114. 
 
--> 
 
OBS.: é sugerido, ao leitor, a visualização de outras funções de conversão encontradas em [1], 
como: base2dec, oct2dec, hex2dec, dec2oct e dec2hex. 
3.2.3 Funções trigonométricas 
 As funções sin(), cos(), tan(), cotg(), sec(), csc() retornam, respectivamente, o seno, co-
seno, tangente, co-tangente, secante e co-secante de um ângulo informado em radianos. 
Exemplos 
-->x=%pi/2 //x=90 graus 
 x = 
 
 1.5707963 
 
-->sin(x) 
 ans = 
 
 1. 
 
-->cos(x) 
 ans = 
 
 6.123D-17 
 
-->cotg(x) 
 ans = 
 
 6.123D-17 
 
-->sec(x) 
 ans = 
 
 1.633D+16 
 
-->csc(x) 
 ans = 
 
 1. 
 
-->sin(x)^2+cos(x)^2 
 ans = 
 
 1. 
 
-->y=(2*%pi/3) 
 y = 
 
 2.0943951 
 
-->tan(y) 
 ans = 
 
 - 1.7320508 
 
-->cotg(y) 
 ans = 
 
 - 0.5773503 
 
-->sec(y) 
 ans = 
 
 - 2. 
 
-->csc(y) 
 ans = 
 
 1.1547005 
 
-->sin(y)^2+cos(y)^2 
 ans = 
 
 1.--> 
 
 Vale ressaltar que os valores obtidos por meio de softwares são sempre aproximados, 
com uma precisão que depende de alguns fatores como, o software utilizado e a capacidade 
da máquina em representar números. Por este motivo, fazendo x=%pi/2 e calculando o co-
seno deste número o resultado foi um número muito próximo de zero, com uma precisão tal 
que se pode afirmar que o resultado é zero. 
3.2.4 Funções trigonométricas inversas 
 As funções asin(), acos(), atan(), acot(), asec() e acsc() são utilizadas para determinar o 
valor do arco, em radianos, associado ao parâmetro informado como argumento da função. 
Exemplos: 
-->acos(0) 
 ans = 
 
 1.5707963 
 
-->%pi/2 
 ans = 
 
 1.5707963 
 
-->asin(0) 
 ans = 
 
 0. 
3.2.5 Funções de arredondamento 
3.2.5.1 Função round() 
 Função utilizada para arredondar um número real para o número inteiro mais próximo. 
 Síntese da função: round(n), em que n é um número real ou uma lista de números 
reais. 
Exemplos: 
-->round(1.23) 
 ans = 
 
 1. 
 
-->round(5.98) 
 ans = 
 
 6. 
 
-->round(20.5) 
 ans = 
 
 21. 
 
-->round(20.4) 
 ans = 
 
 20. 
 
-->round(20.6) 
 ans = 
 
 21. 
 
--> 
3.2.5.2 Função floor() 
 Retorna o maior inteiro menor do que o número informado como parâmetro. Em 
outras palavras, esta função arredonda no "sentindo de menos infinito". 
 Síntese: floor(n), em que n é um número real ou uma lista de números reais. 
Exemplos: 
-->floor(20.4) 
 ans = 
 
 20. 
 
-->floor(20.5) 
 ans = 
 
 20. 
 
-->floor(20.9) 
 ans = 
 
 20. 
 
--> 
3.2.5.3 Função ceil() 
 Retorna o menor inteiro maior do que o número informado como parâmetro. Em 
outras palavras, esta função arredonda no "sentindo de mais infinito". 
 Síntese da função: ceil(n), em que n é um número real ou uma lista de números reais. 
Exemplos: 
-->ceil(2.3) 
 ans = 
 
 3. 
 
-->ceil(-2.9) 
 ans = 
 
 - 2. 
 
-->ceil(2.9) 
 ans = 
 
 3. 
 
-->ceil(2.4) 
 ans = 
 
 3. 
 
-->x=[1.2 -3.4 -5.9 6.8] //lista de valores 
 x = 
 
 1.2 - 3.4 - 5.9 6.8 
 
-->ceil(x) 
 ans = 
 
 2. - 3. - 5. 7. 
3.2.5.4 Função int() 
 Retorna a parte inteira de um número real. 
 Síntese da função: int(n), em que n é um número real ou uma lista de números reais. 
 Exemplos: 
-->int(1.2) 
 ans = 
 
 1. 
 
-->int(1.5) 
 ans = 
 
 1. 
 
-->int(1.9) 
 ans = 
 
 1. 
 
-->x=[1.2 4.5 2.9] //criacao de uma lista real (vetor) 
 x = 
 
 1.2 4.5 2.9 
 
-->int(x) 
 ans = 
 
 1. 4. 2. 
 
--> 
3.2.5.5 Função fix() 
 Arredonda o número na "direção do zero". Em linhas gerais, esta função funciona 
como a função int(). 
 Síntese da função: fix(n), em que n é um número real ou uma lista de números reais. 
 Exemplos: 
-->fix(2.3) 
 ans = 
 
 2. 
 
-->fix(2.9) 
 ans = 
 
 2. 
 
-->fix(-2.3) 
 ans = 
 
 - 2. 
 
-->fix(-2.9) 
 ans = 
 
 - 2. 
 
-->x=[1.2 -3.4 -5.9 6.8] //lista de valores 
 x = 
 
 1.2 - 3.4 - 5.9 6.8 
 
-->fix(x) 
 ans = 
 
 1. - 3. - 5. 6. 
3.2.6 Funções de manuseamento de strings 
3.2.6.1 Função convstr() 
 A função convstr() é utilizada para converter textos (strings) em letras maiúsculas ou 
minúsculas. 
 Síntese da função: convstr(str,[flag]), em que str é uma string (texto) e [flag] pode ser 
'u', para letras maiúsculas, ou 'l', para letras minúsculas. 
Exemplos: 
-->str='UniFeMm' //string 
 str = 
 
 UniFeMm 
 
-->convstr(str,'u') 
 ans = 
 
 UNIFEMM 
 
-->convstr(str,'l') 
 ans = 
 
 unifemm 
 
--> 
3.2.6.2 Função length() 
 Função utilizada para retornar o número de caracteres de uma string. 
 Síntese da função: length(str), em que str é uma string. Caso seja utilizado, como 
parâmetro da função, uma matriz ou vetor, essa função retorna a quantidade de elementos da 
matriz ou vetor. 
 Exemplos: 
-->str = 'Centro Universitário de Sete Lagoas' 
 str = 
 
 Centro Universitário de Sete Lagoas 
 
-->length(str) 
 ans = 
 
 35. 
 
-->str = 'Olá mundo!' 
 str = 
 
 Olá mundo! 
 
-->length(str) 
 ans = 
 
 10. 
 
--> 
 
3.2.6.3 Função part() 
 A função part() extrai caracteres de uma string. 
 Síntese da função: part(str,v), em que str é uma string e v é uma lista de posições a 
serem extraídas. 
Exemplos: 
 -->str = 'Centro Universitário de Sete Lagoas' 
 str = 
 
 Centro Universitário de Sete Lagoas 
 
-->length(str) 
 ans = 
 
 35. 
 
-->part(str,3) //extrai a terceira letra da string 
 ans = 
 
 n 
 
-->part(str,5) //extrai a quinta letra da string 
 ans = 
 
 r 
 
-->part(str,5:10) //extrai da quinta à decima letra da string 
 ans = 
 
 ro Uni 
 
-->part(str,[1,4,8]) //extrai a primeira, a quarta e a oitava letras da string 
 ans = 
 
 CtU 
 
-->part(str,[1:4,4,8,10]) //extrai da primeira à quarta posição, a oitava e a decima posição 
 ans = 
 
 CenttUi 
3.2.6.4 Função eval() 
 A função eval() é utilizada para avaliar uma string ou uma matriz de strings. 
 Síntese da função: eval(z), em que z é uma string ou uma matriz de strings. 
Exemplos: 
-->z='3*a-2*b^2' //criacao da string, observe que foi digitado entre '' 
 z = 
 
 3*a-2*b^2 
 
-->a=2,b=3 //atribuicao dos valores de a e b 
 a = 
 
 2. 
 b = 
 
 3. 
 
-->eval(z) //avaliacao de z, com a=2 e b=3 
 ans = 
 
 - 12. 
 
--> 
 
3.2.7 Algumas funções elementares estatísticas 
3.2.7.1 Função mean() 
 A função mean() retorna a média aritmética de uma amostra. 
 Síntese da função: mean(amostra), em que amostra é uma lista de números (vetor). 
3.2.7.2 Função stdev() 
 A função stdev() retorna o desvio padrão de uma amostra. 
 Síntese da função: stdev(amostra), em que amostra é uma lista de números (vetor). 
3.2.7.3 Função variance() 
 A função variance() retorna a variância de uma amostra. 
 Síntese da função: variance(amostra), em que amostra é uma lista de números (vetor). 
3.2.7.4 Função mad() 
 A função mad() retorna o desvio padrão absoluto de uma amostra. 
 Síntese da função: mad(amostra), em que amostra é uma lista de números (vetor). 
 
Exemplos para as Seções 3.2.7.1 a 3.2.7.4: 
-->amostra = [2 4 5 10 11 13 20 15] //media aritmetica 
 amostra = 
 
 2. 4. 5. 10. 11. 13. 20. 15. 
 
-->mean(amostra) //media 
 ans = 
 
 10. 
 
-->sum(amostra)/length(amostra) //soma dos elementos dividido pela quantidade de 
elementos do vetor amostra 
 ans = 
 
 10. 
 
-->stdev(amostra) //desvio padrao 
 ans = 
 
 6.094494 
 
-->variance(amostra) //variancia 
 ans = 
 
 37.142857 
 
-->mad(amostra) //desvio padrao absoluto 
 ans = 
 
 4.75 
 
 
IMPORTANTE: nesta Seção foram apresentados apenas alguns exemplos de funções do Scilab. 
É recomendável que o leitor procure conhecer outras funções, por meio do help do Scilab ou 
pelo manual, (Scilab Group - Manual Scilab). 
3.2.8 Limpeza de memória - clear 
 Conforme visto anteriormente,para limpar as variáveis é preciso utilizado o comando 
clear. 
 Para que o comando clear seja aplicado a uma ou mais variáveis específicas, é preciso 
indicar o nome da variável após o comando clear. Possíveis sínteses: 
 
clear, limpa todas as variáveis 
clear variáveis, limpa apenas as variáveis especificadas 
 
Exemplo: 
-->a=2,b=3,c=4, d=5, e=6, f=7 //criacao das variaveis 
 a = 
 
 2. 
 b = 
 
 3. 
 c = 
 
 4. 
 d = 
 
 5. 
 e = 
 
 6. 
 f = 
 
 7. 
 
-->a //visualizacao da variavel a 
 ans = 
 
 2. 
 
-->clear a //limpando a variavel 
 
-->a 
 !--error 4 
Variável indefinida: a 
 
 
-->b 
 b = 
 
 3. 
 
-->clear b c //limpando as variaveis b e c 
 
-->a,b,c //tentativa de exibir os valores de a, b e c 
 !--error 4 
Variável indefinida: a 
 
 
-->d,e,f 
 d = 
 
 5. 
 e = 
 
 6. 
 f = 
 
 7. 
 
-->clear //limpar todas as variaveis 
 
-->d,e,f 
 !--error 4 
Variável indefinida: d 
3.2.9 Limpeza da tela - função clc() 
 O Scilab armazena a sequencia de comandos já digitada. Em alguns casos, o usuário 
pode não desejar visualizar estes comandos. Para que os mesmos não sejam visualizados, é 
preciso utilizar a função clc(). 
 Síntese da função clc(n) ou apenas clc. Caso seja informado o parâmetro n, o Scilab 
elimina as n linhas anteriores. Caso seja digitado apenas clc, este funciona como um comando 
que elimina todas as linhas apresentadas no prompt. 
 Alternativamente, pode ser utilizado o menu Editar/Limpar o console, no Scilab 5.4.1. 
3.3 Exercícios Propostos 
Para os exercícios de 1 a 25, escreva a sequência de comandos, digite no Scilab e escreva o 
resultado. 
 
1- Limpe todas as variáveis locais, faça a=2, b=5 e c=16, em seguida calcule: 
a) a/b*c; 
b) a/(b+c); 
c) b^a; 
d) raiz quadrada de c; 
e) raiz cúbica de c. 
2- Limpe todas as variáveis locais, faça a=-27, calcule o módulo da raiz cúbica de a. 
3- Limpe todas as variáveis locais, faça a=e (utilize uma variável especial), em seguida calcule o 
logaritmo natural de a. 
4- Repita o exercício 3, porém em vez de utilizar uma variável especial, utilize a função exp() 
para calcular o valor de a. 
5- Limpe todas as variáveis especiais e calcule 10 elevado ao logaritmo de 35 na base 10. 
7- Calcule o logaritmo natural de 63/20. Em seguida faça o logaritmo natural de 63 menos o 
logaritmo natural de 20. 
8- Limpe todas as variáveis locais e calcule a raiz quadrada de e0, utilize as funções sqrt() e 
exp(). 
9- Limpe todas as variáveis locais e calcule a raiz quadrada da raiz quadrada de 64. Utilize a 
função sqrt(). 
10- Limpe todas as variáveis locais. Crie a seguinte a lista numérica x=[1 -2 4 5 -11] e utilize 
uma função intrínseca para calcular a soma e o produto de todos os valores de x. 
11- Utilize o Scilab para obter uma lista de números primos de 1 a 200. 
12- Utilize o Scilab para decompor os números 30, 60 e 115 em produto de números primos. 
13- Limpe todas as variáveis locais, crie as variáveis x=1-2i e y=2+5i. Em seguida faça x+y, x-y, y-
x, x*y, x/y e y/x. 
14- Utilizando o valor de x=1-2i, utilize funções intrínsecas do Scilab para extrair a parte real e 
a parte imaginária do número complexo x. 
15- Ainda utilizando x=1-2i, calcule o módulo de x. O que representa o módulo deste número 
complexo? 
16- Converta os números: 
a) 111011001 (de binário para decimal); 
b) 11001 (de binário para decimal); 
c) 97 (de decimal para binário); 
d) 105 (de decimal para binário, utilizando uma string de 15 dígitos para armazenar o número 
binário); 
e) 112 (de decimal para binário, utilizando uma string de 20 dígitos para armazenar o número 
binário); 
f) 112 (de decimal para hexdecimal); 
g) Converta o número 120394 de decimal para hexadecimal; 
h) Converta o número 21E de hexadecimal para decimal; 
i) Converta o número 38C de hexadecimal para binário. 
17- Determine o sen(cos(π/4)). 
18- Limpe todas as variáveis locais, faça a=π, b=π/2 e c=π/4. Em seguida determine (sen(b)-
cos(a)+tan(c))*csc(a+b). 
19- Limpe todas as variáveis locais, faça a=5π/3 e, em seguida faça b=quadrado do seno de a 
somado ao quadrado do co-seno de a. 
20- Calcule a tangente de π/2 no Scilab. O resultado apresentado é o mesmo visto em 
disciplinas matemáticas? Caso o resultado apresentado seja diferente, o que leva o Scilab a 
determinar este valor? 
21- Limpe todas as variáveis locais, faça a=5π/3. Em seguida, utilizando as funções 
apropriadas: 
a) arredonde o valor de a para o número inteiro mais próximo; 
b) arredonde o valor de a para o maior inteiro menor do que a; 
c) arredonde o valor de a para o menor inteiro maior do que a; 
d) utilize a função mais apropriada para representar a parte inteira de a; 
e) arredonde o valor de a no "sentido de zero". 
f) Em linhas gerais, existe alguma diferença entre as funções int() e fix()? Justifique. 
g) Para o exercício, a utilização da função round() e floor() retornaram o mesmo valor. Dê um 
exemplo e visualize no Scilab uma situação em que as duas funções retornam valores distintos. 
22- Determine o arco-seno e o arco-tangente de 0.5877853 e 0.7265425, respectivamente. 
23- Crie uma string (variável str1) com o texto: "EsTOU apReNDENdo SCllab". 
a) converta todas as letras para maiúsculas e armazene o resultado em uma variável chamada 
str; 
b) utilize a função apropriada para contar a quantidade de caracteres da variável str; 
c) extraia, por meio de uma função apropriada, o terceiro caractere de str; 
d) extraia, por meio de uma função apropriada, o terceiro e o sexto caracteres de str; 
e) extraia, por meio de uma função apropriada, do terceiro ao sexto caracteres de str; 
f) extraia, por meio de uma função apropriada, o terceiro, o quinto e do sétimo ao décimo 
caracteres de str. 
24- Crie a string pl, que armazenará a seguinte função: pl=2*a-b^(1/3)+a/b*5. Em seguida, 
avalie o resultado de pl para a=6 e b=4. 
25- Crie uma lista numérica(vetor) cujo nome seja amostra e que armazene os seguintes 
números: 34, 25, 67, 87, 98, 76, 54, 3, 2, 10, 11. Para esta amostra, determine, por meio de 
funções nativas: 
a) média aritmética; 
b) desvio padrão; 
c) variância; 
d) desvio padrão absoluto. 
 
Capítulo 4 - Vetores e Matrizes 
Esta Seção apresenta os conceitos de criação de vetores e matrizes, bem como os conceitos 
para manipulação e operação nestas estruturas algébricas. 
 
4.1 Vetores 
4.1.1 Criando um vetor 
 A criação de um vetor v se dá por meio da atribuição de uma lista numérica a v. Cada 
elemento dessa lista pode ser um número real, complexo, um outro vetor, uma matriz ou até 
mesmo polinômios. 
 Essa criação do vetor se dá por meio da digitação da sequência dos elementos 
separadas por vírgula ou espaço, dentro de colchetes. Neste caso é criado um vetor, 
identificado pelo Scilab como uma matriz linha. Em alguns textos o vetor é associado a uma 
matriz coluna. No entanto, para uma representação matemática mais próxima da estudada em 
Álgebra Linear, o vetor será identificado por uma matriz linha. 
Exemplos: 
-->v1= [1 -2 3] //separando por espacos 
 v1 = 
 
 1. - 2. 3. 
-->v1= [1,-2,3] //separando por vírgulas 
 v1 = 
 
 1. - 2. 3. 
 Caso os elementos sejam separados por ponto e vírgula, será criado um vetor 
transposto, identificado como uma matriz coluna. 
-->v1= [1;-2;3] //separando por ponto e virgula 
 v1 = 
 
 1. 
 - 2. 
 3. 
 Um vetor também pode ser criado por meio de uma sequência, utilizando