Curso de Scilab - pet.feq.unicamp.brpet.feq.unicamp.br/wp-content/uploads/2015/06/Apostila-Curso-de... · Curso de Scilab Nível Básico ao Intermediário Autores: Revisão: Daniela

Curso de

Scilab Nível Básico ao

Intermediário Autores: Revisão:

Daniela Josepetti Gabriel Mathews

Mariana Lopes Marco Andres Araujo

Nicole Fernanda Hanna Galassi

Vinicius Michelon

Wellick Almeida

1 Curso de Scilab – PET Engenharia Química Unicamp

Índice

1. Introdução..............................................................................3

2. Interface Gráfica....................................................................4

2.1. Interface inicial................................................................4 2.2. Variáveis especiais.........................................................7

3. Operações básicas................................................................9

4. Vetores, matrizes e listas.......................................................10 4.1. Vetores......................................................................10 4.2. Matrizes.....................................................................12 4.3. Definição de listas.....................................................19 4.4. Inserção de elementos na lista................................19 4.5. Sublistas....................................................................19 4.6. Listas tipadas.............................................................20

5. Gráficos.................................................................................21

5.1. Gráficos 2d................................................................21 5.2. Gráficos 3d................................................................22 5.3. Campo Vetorial..........................................................23 5.4. Mudança de cores, título de eixos e salvar

imagens..24

6. Funções, diferenciação e integração.................................25 6.1. Funções ‘in-line’.........................................................25 6.2. Funções ‘on-line’........................................................25 6.3. Tabela de funções.....................................................26 6.4. Diferenciação.............................................................26 6.5. Integração...................................................................2

7 6.6. Equações diferencias...............................................27

7. Polinômios e interpolação......................................................29

7.1. Polinômios.................................................................29 7.2. Operações com polinômios.......................................29 7.3. Derivação de polinômios..........................................30 7.4. Interpolação...............................................................30 7.5. Interpolações Lineares.............................................30


7.6. Interpolações por Spline cúbica...............................31 7.7. Extrapolação..............................................................31

8. Introdução à programação....................................................32

8.1. Introdução..................................................................32

8.2. Função printf.............................................................32

8.3. Função input .............................................................34 8.4. Função if-end.............................................................35 8.5. Função if-else-end.....................................................36 8.6. Função for .................................................................37 8.7. Função while..............................................................37 8.8. Vetor..........................................................................40 8.9. Matriz.........................................................................41

9. Exercícios...............................................................................43

10. Referências..........................................................................47


1. Introdução

O Scilab foi desenvolvido em 1990 por um grupo de pesquisadores do INRIA – Institut de Recherche em Informatique et en Automatique e do ENPC – Ècole Nationale des Ponts el Chaussées, ele é um ambiente utilizado no desenvolvimento de programas para a resolução de problemas numéricos. Semelhante ao Matlab, o Scilab possui a vantagem de ser um free software (gratuito) e também open source software (fornecido com o código fonte), com distribuições pré-compiladas para vários sistemas operacionais (Linux/GNU, Windows XP, Vista, 7, 8 e Mac OS X). As principais ferramentas desse ambiente de programação numérica são2:

Álgebra Linear (inclusive matrizes esparsas); Polinômios e funções racionais; Integração numérica; Métodos não lineares – Otimização e integradores de EDOs; Processamento de Sinais; Controle; Estatística; Gráficos e animação; Grafos e redes; Paralelismo – PVM; Interface com o Computer Algebra Maple; Interface com Fortran, C, C++, Java; Além dos toolboxes desenvolvidos pelo grupo Scilab, estão disponíveis

outros complementares, igualmente gratuitos, como o ANN (Artificial Neural Network), o FISLAB (Fuzzy Logic Inference) e o FRACLAB (Fractal, Multifractal and Wavelet Analisys).


2. Interface gráfica

2.1. Interface inicial Durante a execução do Scilab, várias janelas podem ser utilizadas, a janela de trabalho do Scilab na versão 5.4.1 se apresenta na forma da figura 01:

Figura 2.1.1: Janela de trabalho do Scilab na versão 5.4.1.

Podemos observar o prompt inicial, representado pelo símbolo -->, que faz

a marcação da linha de comando e o cursor, ao lado do prompt. Nesse espaço, podem ser realizados cálculos e compilados programas sem salvar alterações. Ainda na tela inicial estão presentes os menus drop down com cinco opções: Arquivo, Editar, Controle, Aplicativos e ?.

Cada menu possui seus sub-menus, valendo ressaltar:

Arquivo: Executar: executa o conteúdo de arquivos (roda o programa

implementado); Abrir um arquivo: abre o arquivo do seu programa no editor de texto do

Scilab; Carregar ambiente: carrega ambiente Scilab já existente; Salvar ambiente: arquiva ambiente atual do Scilab; Alterar o diretório atual: muda o diretório em que o Scilab foi aberto para o

diretório do Arquivo (programa); Exibir o diretório atual; Configuração de página; Imprimir; Sair.

Editar: Comandos semelhantes ao editor de texto do Microsoft Office ou

Open Office (Recortar Copiar, Colar, Esvaziar a área de transferência, Selecionar


tudo, Mostrar/Esconder barra de ferramentas, Limpar histórico, Limpar o Console, Preferências.)

Controle: A utilidade dos dois primeiros itens pode ser observada abaixo: --> //pressione Ctrl-c e <enter> -1-> //leva ao prompt de 1o. nivel -1-> //pressione Crtl-c e <enter> -2-> //leva ao prompt de 2o. nivel -2->resume //retorna ao prompt de 1o. nivel

-1-> resume //retorna ao prompt inicial --> //Ctrl-c e <enter> -1-> // Ctrl-c e <enter> -2->abort //retorna ao prompt inicial -->

Retorna: continua a execução após uma pause ter sido dada através de

um comando em uma função ou através de Stop ou Ctrl-c;

Abortar: aborta a execução após uma ou várias pause, retornando ao

prompt inicial;

Interromper: interrompe a execução do Scilab e entra em modo pause.

No prompt, equivale a um Ctrl-c.

Aplicativos: Scinotes: carrega o editor de textos do Scilab onde podem ser criados scripts de

programas e funções;

Figura 2.1.2: Primeiro passo para a programação.

Este ícone abre uma janela onde será inserida a programação.

Figura 2.1.3: Janela onde será inserida a programação.


. XCos: abre um ambiente para desenvolvimento de diagramas de blocos e interfaces gráficas segundo a imagem abaixo:

Figura 2.1.2: Interface gráfica do aplicativo Xcos.

Tradutor de Matlab para Scilab: converte arquivos e diretórios de Matlab

para Scilab; Gerenciador de Módulos – ATOMS: ATOMS( de AutomaTic modules

Management for Scilab), permite que o usuário 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: grava o histórico de comandos executados no

prompt; Navegador de arquivos.

?: Navegador de Ajuda: exibe o diretório-raiz de ajuda do Scilab, com

opção de busca. Pode também ser acessado através da digitação do comando help no prompt ou através da tecla F1. Na figura abaixo, verifica o navegador de ajuda.

Figura 2.1.3: Interface do navegador de ajuda.


Demonstrações do Scilab: exibe janela com demonstrações de comandos

do Scilab. Links da Web: Links de interesse para uso do Scilab. Scilab Entreprises Sobre Scilab

2.2. Variáveis especiais Existem variáveis que assumem valores já definidos no Scilab. Elas podem

ser vistas através do comando who. Essas variáveis são protegidas e não podem ser apagadas. Algumas destas variáveis são pré-fixadas com o caractere %. %i representa √−1 %e representa a constante de Euler %pi representa a constante π %s representa o polinômio de 1º grau s %z representa o polinômio de 1º grau z %eps é uma medida de precisão da máquina %inf representa ∞ %nan representa o objeto “Not a Number” %t (ou %T) representa a variável booleana “verdadeiro” %f (ou %F) representa a variável boolena “falso” Na imagem a seguir, imagem 2.2.1, mostra a área de trabalho do Scilab com a execução do comando who.

Figura 2.2.1: Variáveis especiais.

Temos mais duas importantes variáveis: as variáveis de localização de

diretórios SCI e PWD. SCI: diretório onde o Scilab foi instalado.


PWD: diretório onde o Scilab foi lançado, isto é, de onde seu script está rodando.

Todas as variáveis criadas durante os trabalhos no ambiente podem ser

armazenadas em um arquivo. O comando save é usado para tal, com a seguinte sintaxe:

save(‘nome_do_arquivo.dat’,variáveis)

Para recuperar os valores das variáveis, usa-se o comando load e o comando clear é usado para limpar variáveis não protegidas. O comando clc limpa toda janela de trabalho.


3. Operações Básicas

O Scilab tem como principal utilidade a resolução de problemas numéricos. A interação do usuário com o Scilab pode ocorrer de duas formas distintas:

Comandos são digitados diretamente no prompt do Scilab. Ao apertar-se a tecla enter, os comandos digitados são interpretados e imediatamente executados. Neste modo de utilização, Scilab funciona como uma sofisticada e poderosa calculadora.

Um conjunto de comandos é digitado em um arquivo texto, o SciNotes. Este arquivo, em seguida, é levado para o ambiente Scilab e executado. Neste modo, o Scilab funciona como um ambiente de programação.

É interessante ser citado algumas características importantes do Scilab,

como: É possível digitar vários comandos em uma linha;

Exemplo: --> a=1; b=4.5; c=73.2;

O “ ; ” no final de um comando inibe a apresentação de seu resultado.

--> A=1 A = 1.

-->A=1; // a variável A assume o valor de 1

O Scilab é case sensitive, sendo a variável A diferente da variável a.

Exemplo: -->a=1; -->b=1; -->A+B= !—error 4 Variável indefinida: B

As operações aritméticas simples são representadas pela tabela 3.1:

Adição + Subtração -

Multiplicação * Divisão /

Potenciação ^ Tabela 3.1: operações aritméticas simples.

Exemplo: -->((2+3)*(4-1)/(6/2))^2 ans = 25.

Se a intenção é trabalhar com números complexos, utiliza-se %i : -->(2*%i-1)*(3*%i+2) ans = -8. + i

Assim como se usa %e para número de Euler, %pi para π, entre outros.


4. Vetores, matrizes e listas 4.1. Vetores

Matrizes unidimensionais são chamadas de vetores. Em um vetor é possível armazenar vários itens em uma única variável. No exemplo a seguir, é mostrada uma variável nota contendo as notas de alunos:

-->nota = [8.1 5.2 9.2 7.2 6.5 5.2 8.5 9.5 6.5 10.0];

Vetores podem ser construídos usando os colchetes [ e ]. Os elementos são envolvidos por colchetes e separados por espaços (ou vírgula). Caso sejam separados por ponto e vírgula, irá ser alocado um vetor coluna com os elementos desejados.

Exemplo: -->x=[ 1; 2; 3] //vetor coluna. Elementos separados por ; x = ! 1. ! ! 2. ! ! 3. !

Se x é um vetor coluna, xT (lê-se “x transposto”) é um vetor linha. Essa

operação é realizada no Scilab através da utilização do símbolo ’ (apóstrofo). Exemplo:

-->x’ // x transposto = vetor linha ans = ! 1. 2. 3. !

Os elementos do vetor nota podem ser acessados da seguinte forma:

-->nota(2) ans = 5.2 -->nota(5) ans = 6.5 -->nota(8) ans = 9.5

Vetores podem ser multiplicados ou divididos por quantidades escalares. Também, vetores de mesma dimensão podem ser somados ou subtraídos. Para exemplificar algumas dessas operações, vamos considerar os vetores:

-->x = [ 1; 2; 3] //Definindo o vetor x x = ! 1. ! ! 2. ! ! 3. !

-->y = [ 4; 5; 6] //Definindo o vetor y y = ! 4. ! ! 5. ! ! 6. !


-->size(x) //Dimensao do vetor x ans = ! 3. 1. !

-->size(y) //Dimensao do vetor y ans = ! 3. 1. !

-->3 * x //Multiplicando o vetor x por uma constante ans = ! 3. ! ! 6. ! ! 9. ! -->x / 2 // Dividindo o vetor x por uma constante ans = ! 0.5 ! ! 1. ! ! 1.5 ! -->x + y // Somando os dois vetores ans = ! 5. ! ! 7. ! ! 9. ! -->z = x’ * y //Atribuindo a z o produto escalar entre x e y z = 32.

Nos exemplos a seguir, mostramos outras maneiras de construir vetores,

usando índices e algumas funções internas do Scilab:

-->v = 5: -0.5: 3 //Vetor com elementos decrementados v = ! 5. 4.5 4. 3.5 3. ! -->m=ones(1:4) //Vetor constituido de elementos iguais a 1 m = ! 1. 1. 1. 1. ! -->z=zeros(1:5) //Vetor constituido de elementos iguais a 0 z = ! 0. 0. 0. 0. 0. ! -->a=10:2.5:20 a = ! 10. 12.5 15. 17.5 20. ! -->log(a) // a função é aplicada a cada elemento ans = ! 2.3025851 2.5257286 2.7080502 2.8622009 2.9957323!

Cálculo do seno entre 0 e π com incremento de π/4:

-->sin(0:%pi/4:%pi) ans = ! 0. 0.7071068 1. 0.7071068 1.225E-16!

A função linspace gera um vetor com n valores igualmente espaçados começando em início e terminando em fim. Exemplo:

-->linspace(1,1.5,5) ans =


! 1. 1.125 1.25 1.375 1.5!

A função logspace (inicio, fim, n) gera n elementos logaritmicamente espaçados. O primeiro elemento é 10 elevado ao inicio e o último elemento é 10 elevado ao fim. Por exemplo:

-->logspace(1,2,4) ans = ! 10. 21.544347 46.415888 100. !

4.2. Matrizes Seja R o conjunto dos números reais. Dizemos que A é uma matriz de

dimensão m × n em R, se:

Cada um dos elementos ai,j ∈ R. Nessa notação, a variável m indica o número de linhas e a variável n indica o número de colunas da matriz A. Se A for uma matriz quadrada, o número de linhas é igual ao número de colunas e, então, m = n.

Vamos considerar as matrizes A e B, conforme descrito abaixo:

No Scilab, as matrizes são representadas entre colchetes, [ ]. Os elementos que constituem as linhas das matrizes são separados por espaços ou por vírgulas. A indicação de término de cada linha da matriz é feita com ponto-e-vírgula.

Nos exemplos a seguir, a matriz A é digitada com os elementos de suas linhas separados por espaços enquanto a matriz B é digitada com os elementos de suas linhas separados por vírgula. Assim,

-->//Matriz A - Elementos das linhas separados por espaco -->A = [1 2 3; 5 -8 9] A = ! 1. 2. 3. ! ! 5. - 8. 9. ! -->//Matriz B-Elementos das linhas separados por virgulas -->B = [1, 2, 3; 4, 5, 6] B = ! 1. 2. 3. ! ! 4. 5. 6. ! -->size(A) //Dimensao da matriz A ans = ! 2. 3. ! -->size(B) //Dimensao da matriz B ans = ! 2. 3. !


Outra forma de digitar matrizes no ambiente Scilab, é separando os elementos de uma linha por espaço (ou por vírgula) e as linhas separadas por enter,

-->M = [ 1 2 3 4 -->5 6 7 8 -->9 11 13 15]

M = ! 1. 2. 3. 4. ! ! 5. 6. 7. 8. ! ! 9. 11. 13. 15. !

Matrizes podem ser multiplicadas ou divididas por quantidades escalares.

Também, matrizes de mesma dimensão podem ser somadas ou subtraídas. Considerando as matrizes A e B do exemplo anterior, temos:

-->2 * A // Multiplicacao por um escalar ans = ! 2. 4. 6. ! ! 10. - 16. 18. ! -->A / 2 // Divisao da matriz A por uma constante ans = ! 0.5 1. 1.5 ! ! 2.5 - 4. 4.5 ! -->A + B // Somando as duas matrizes ans = ! 2. 4. 6. ! ! 9. - 3. 15. ! -->C = B’ // C = transposta da matriz B C = ! 1. 4. ! ! 2. 5. ! ! 3. 6. ! -->size(C) // Dimensao da matriz C ans = ! 3. 2. !

Para realizar uma multiplicação entre duas matrizes observar que, para que

possa haver a multiplicação, é necessário que o número de colunas da primeira matriz seja igual ao número de linhas da segunda matriz. Considerando as matrizes A e B a seguir, temos que:

--> A= [1 2 3; 4 5 6; 7 8 9] A = ! 1. 2. 3. ! ! 4. 5. 6. ! ! 7. 8. 9. ! -->B = [ 1 4; 2 5; 3 6] B = ! 1. 4. ! ! 2. 5. ! ! 3. 6. ! -->A * B ans = ! 14. 32. !


! 32. 77. ! ! 50. 122.!

Podemos usar funções internas do Scilab para gerar matrizes. Por exemplo,

usamos a função ones para criar a matriz D, com todos os elementos iguais a 1, -->D=ones(2,3) D = !1. 1. 1.! !1. 1. 1.!

ou a função zeros para criar a matriz E, com todos os elementos iguais a 0,

-->E=zeros(3,3) E = !0. 0. 0.! !0. 0. 0.! !0. 0. 0.!

ou, ainda, a criação de uma matriz identidade I, através da função interna eye,

-->I=eye(4,4) I = !1. 0. 0. 0.! !0. 1. 0. 0.! !0. 0. 1. 0.! !0. 0. 0. 1.!

Podemos criar matrizes a partir de elementos de outras matrizes,

-->//Definindo as matrizes A,B e C -->A=[1 2; 3 4]; -->B=[5 6; 7 8]; -->C=[9 10; 11 12]; -->//Definindo a matriz D -->D=[A B C] D = !1. 2. 5. 6. 9. 10.! !3. 4. 7. 8. 11. 12.! -->//Definindo uma matriz E a partir dos elementos de D -->E=matrix(D,3,4) E = !1. 4. 6. 11.! !3. 5. 8. 10.! !2. 7. 9. 12.!

Observar que a matriz E, com três linhas e quatro colunas, é criada usando

a função matriz. Esta função gera a matriz E a partir da organização dos elementos da matriz D por colunas. Para exemplificar acessos a elementos de matrizes, vamos considerar a matriz A com duas linhas e três colunas,

-->//Definindo uma matriz A -->A=[1 2 3; 4 5 6] A = !1. 2. 3.! !4. 5. 6.!

O acesso a um elemento dessa matriz é feito da maneira convencional: o

elemento da linha i e coluna j, ai,j, é acessado através do comando A(i,j), com i e j


tendo seus valores numéricos explicitados. Por exemplo, para acessar o elemento a1,2 da matriz A, usamos o comando A(1,2):

-->//Acessando o elemento da primeira linha e segunda coluna de A -->A(1,2) ans = 2.

O comando M=A([1 2], 2), permite construir uma matriz M, composta pelo

primeiro e segundo elementos, indicados pelo vetor[1 2], da segunda coluna da matriz A,

-->M=A([1 2], 2) M = !2.! !5.!

Se desejamos obter todos os elementos de uma determinada coluna ou

linha de uma matriz, podemos utilizar o símbolo : (dois pontos) para lê-los. Assim, A(k,:) pode ser lido como “todos os elementos da k-ésima linha da matriz A” e A(:,k) pode ser lido como “todos os elementos da k-ésima coluna da matriz A”. Considerando a matriz A do exemplo anterior, o comando A(:,3), permite acessar todos os elementos da terceira coluna da matriz A:

-->//Todos os elementos da terceira coluna da matriz A -->A(:,3) ans = !3.! !6.!

-->

Enquanto o comando A(2,:) permite acessar todos os elementos da segunda linha da matriz A:

-->//Todos os elementos da segunda linha da matriz A -->A(2,:) ans = !4. 5. 6.!

O comando A(:,3:-1:1) permite formar uma matriz constituída por todos os

elementos das colunas três, dois e um da matriz A. Lembrar que 3:-1:2 é idêntico ao vetor [3 2 1].

-->//Todos os elementos da terceira, segunda e primeira colunas de A -->A(:, 3:-1:1) ans = !3. 2. 1.! !6. 5. 4.! -->A(:, [3 2 1]) //Forma equivalente ans = !3. 2. 1.! !6. 5. 4.!

O primeiro elemento da matriz A pode ser acessado através do comando

A(1) e o quinto elemento da matriz A pode ser acessado através do comando A(5), -->//Primeiro elemento de A -->A(1) ans = 1.


-->//Quinto elemento de A -->A(5) ans = 3. -->//Todos os elementos armazenados por coluna -->A(:) ans = !1.! !4.! !2.! !5.! !3.! !6.!

É possível, caso seja necessário, alterar os valores de elementos de uma

matriz. Considerando a matriz A, podemos mudar o valor do seu elemento A(2,1) através do comando de atribuição A(1,2)=10:

-->//Atribuir a A(1,2) o valor 10 -->A(1,2)=10 A = !1. 10. 3.! !4. 5. 6.!

Depois, atribuímos os valores [-1; -2] aos primeiro e segundo elementos da

segunda coluna da matriz A: -->//A(1,2)=-1 e A(2,2)=-2 -->A([1 2], 2)=[-1; -2] A = !1. -1. 3.! !4. -2. 6.!

Finalmente, modificamos os elementos A(1,1) e A(1,2) da matriz A.

-->//A(1,1)=8 e A(1,2)=5 -->A(:, 1)=[8; 5] A = !8. -1. 3.! !5. -2. 6.!

As matrizes simbólicas também podem ser constituídas por elementos

compostos por strings de caracteres. Elas são criadas da mesma maneira que as matrizes com elementos numéricos. As strings são escritas entre apóstrofos ou entre aspas.

--> //Matriz de strings --> A = [‘x’ ‘y’; ‘z’ ‘w+v’] A = ! x y ! ! ! ! z w+y !

--> //Atribuindo valores

--> x=1; y=2; z=3; w=4; v=5; //Obtendo valores numéricos dos elementos de A --> evstr(A) ans =


! 1. 2. ! ! 3. 9. !

A Tabela 4.2.1, apresenta a sintaxe de alguns dos operadores disponíveis no ambiente Scilab que podem ser utilizados em operações com vetores ou com matrizes.

SIMBOLO OPERAÇÃO ‘ Transposta + Adição - Subtração * Multiplicação / Divisão à direita \ Divisão à esquerda ^ Exponenciação .* Multiplicação elemento-a-elemento ./ Divisão, à esquerda, elemento –a-elemento .\ Divisão, à direita, elemento –a-elemento .^. Exponenciação elemento –a-elemento .*. Produto Konecker

Tabela 4.2.1: Sintaxe de alguns operadores usados em operações vetoriais ou matriciais.

Vamos analisar a utilização do operador \. Para isso, definimos um sistema

de equações lineares,

que pode ser escrito na forma matricial, Ax = b, onde:

Nas expressões anteriores, A é a matriz dos coeficientes, x é o vetor das incógnitas e b é o vetor de termos independentes.

Resolver um sistema linear é obter o valor do vetor x. Na situação mais simples, a matriz A é não-singular (admite inversa) e a solução, única, é dada pela expressão

x=A−1b onde A−1 é a inversa da matriz A. A expressão anterior pode ser representada no Scilab como

-->x=inv(A)*b na qual inv, é uma função interna do Scilab que calcula a inversa de uma matriz. Para exemplificar , vamos considerar um sistema linear com

Temos, --> //Solucao de Ax = b usando função inv


--> A = [2 0; 0 4] //Matriz A A = ! 2. 0. ! ! 0. 4. !

--> inv(A) //A admite inversa ans = ! 0.5 0. ! ! 0. 0.25 !

--> b = [1;8] //Vetor b ! 1. ! ! 8. !

--> x = inv(A) * b //Solucao do sistema linear ! 0.5 ! ! 2. !

O mesmo resultado pode ser encontrado utilizando-se o operador \.

Temos, então, --> Resolução de Ax = b usando operador \ --> x = A\B x = ! 0.5 ! ! 2. !

É importante observar que o sÍmbolo \ não define uma divisão matricial.

Indica, apenas, uma outra forma de se obter a solução de um sistema linear.

O operador . (ponto), como pode ser visto na Tabela X.1, é utilizado com outros operadores (*, \, /, ^) para realizar operações elemento a elemento de vetores ou de matrizes. Por exemplo, vamos considerar a matriz quadrada A,

--> A = [1 2 3; 4 5 6; 7 8 9] A = ! 1. 2. 3. ! ! 4. 5. 5. ! ! 7. 8. 9. !

--> A .*A ans = ! 1. 4. 9. ! ! 16. 81. 96. ! ! 49. 64. 81. !

--> A ^ 2 ans = ! 30. 36. 42. ! ! 66. 81. 96. ! ! 102. 126. 150. !


--> A * A ans = ! 30. 36. 42. ! ! 66. 81. 96. ! ! 102. 126. 150. !

4.3. Definição de listas; Listas é outra classe de variáveis, parecida com a das matrizes, mas que permitem o agrupamento de conteúdo de diferentes tipos. São implementadas através do comando list, seguido dos elementos os quais se desejam agrupar. Essa função tem a seguinte forma geral:

L = list(a1,a2,a3,.....,an), onde a1,a2,a3,...,an são elementos da lista. Exemplo:

--> L = list(23,1+2*%i,'palavra',eye(2,2)) L = L(1) 23. L(2) 1. + 2.i L(3) palavra L(4) 1. 0. 0. 1.

4.4. Inserção de Elementos na Lista No Fim da Lista: L(n+1) = b, sendo n o número de elementos da lista. No Início da Lista: L(0) = b (note que após esta operação e está no índice 1, os elementos iniciais foram movidos para a direita). Exemplo:

--> L = list(23,1+2*%i,'palavra',eye(2,2)); L(5) = 56 L = L(1) 23. L(2) 1. + 2.i L(3) palavra L(4) 1. 0. 0. 1. L(5) 56.

4.5. Sublistas Uma operação comum quando se trabalha com listas é substituir um determinado elemento da lista por outra lista, criando uma sublista:


Exemplo:

-->L = list(1, 'w', ones(2,2)); -->L(2) = list('w', eye(2,2))

L = L(1) 1. L(2) L(2)(1) w L(2)(2) 1. 0. 0. 1. L(3) 1. 1. 1. 1.

4.6. Listas tipadas As listas tipadas são outro tipo de dado aceito pelo Scilab. As listas tipadas são definidas através da função tlist. A função tlist possui, obrigatoriamente, como primeiro argumento uma string ou um vetor de strings e os demais argumentos são os elementos da lista. Exemplo:

-->L = tlist(['Carro'; 'Cidade'; 'Valores'], 'Natal', [2,3]) L = L(1) !Carro ! ! ! !Cidade ! ! ! !Valores !

L(2) Natal L(3)

2. 3.

-->L('Cidade')

ans =

Natal

-->L('Valores')

ans =

! 2. 3. !

-->L(1)(3)

ans =

Valores


5. Gráficos

5.1 Gráficos 2d Imagem projetada está em duas dimensões, usualmente, utilizam-se eixos ‘x’ e ‘y’. Abaixo estão listados algumas principais funções dos gráficos em duas dimensões (Lembre-se para ver a sintaxe e os argumentos necessários para chamar as funções, basta digitar “help <function>”) Funções gráficas em 2d:

plot2d - esboço 2d. plot2d2 - esboço 2d (funções de degraus). plot2d3 - esboço 2d (barras verticais). plot2d4 - esboço 2d (setas). fplot2d - esboço 2d de uma curva definida por uma função. xgrid - adiciona um grid em um esboço 2d errbar - adiciona barras de erro verticais a um esboço 2d histplot - esboça um histograma Matplot - esboço 2d de uma matriz utilizando-se cores

Funçãos gráficas para superfícies projetadas em 2d:

contour2d - curvas de nível de uma superfície em um esboço 2d. fcontour2d - curvas de nível de uma superfície definida por uma função em

um esboço 2d. grayplot - esboço 2d de uma superfície utilizando-se cores fgrayplot - esboço 2d de uma superfície definida por uma função utilizando

cores Sgrayplot - esboço 2d suave de uma superfície utilizando cores Sfgrayplot - esboço 2d suave de uma superfície definida por uma função

utilizando cores

Exemplo: x=0:.01:2*%pi; y=cos(x.^(2*x)); plot2d1(x,y)


Figura 5.1.1: Imagem gráfica 2d

5.2. Gráficos 3d Imagem projetada está em duas dimensões, usualmente, utilizam-se eixos ‘x’, ‘y’ e ‘z’. Lista de funções gráficas em 3d:

plot3d - esboço 3d de uma superfície plot3d1 - esboço 3d em níveis de cinza ou de cores de uma superfície fplot3d - esboço 3d de uma superfície definida por uma função fplot3d1 - esboço 3d em escala de cinza ou colorido de nível de uma

superfície definida por uma função param3d - esboço 3d de uma curva parametrizada param3d1 - esboço 3d de curvas parametrizadas contour - curvas de nível em uma superfície 3d fcontour - curvas de nível sobre uma superfície 3d definida por uma função hist3d - representação 3d de um histograma genfac3d - computa facetas de uma superfície 3d eval3dp - computa facetas 3d de uma superfície parametrizada geom3d - projeção 3d para 2d após um esboço 3d

Exemplo: //Gráfico 3d para uma função z = f(x,y) y=[0:0.1:5]; x=y'; z=sin(x)*cos(y); plot3d(x,y,z)


Figura 5.2.1: Imagem gráfica 3d

5.3. Campo Vetorial É empregado para indicar a velocidade e a direção de fluidos se movendo

no espaço, no caso da engenharia química, utiliza-se o campo vetorial em escoamentos em dutos. Lista de funções gráficas em Campo Vetorial:

champ - esboço de campo vetorial 2d. champ1 - campo vetorial 2d com setas coloridas. fchamp - campo direcional de uma EDO 2d de primeira ordem.

champ(x,y,fx,fy)

Charmp é a função para descrever um campo vetorial 2d, sendo ‘x’ e ‘y’ vetores e ‘xx’ e ‘yy’ matrizes que descrevem o componente ‘x’ e ‘y’ do campo vetorial, respectivamente.

Exemplo: x=-2:.4:2; y=-2:.4:2; xx=-cos(x.^2)'*(y.^(2/3)); yy=(sin(x).^2)'*y; champ (x,y,xx,yy)


Figura 5.3.1: Campo Vetorial 2d. .

5.4. Mudança de cores, título de eixos e salvar imagens. Na janela gráfica, no canto superior, ir em ‘editar’ e depois ‘propriedades da

figura’ e aparecerá a janela abaixo onde é possível mudar a cor do gráfico, dos eixos, editar o título dos eixos, adicionar título ao gráfico, etc.

Figura 5.4.1: Janela gráfica para edição da imagem de gráficos.

É possível salvar o gráfico em formatos como .JPEG, .GIF, .PDF entre

outros. Para isso deve-se na janela do gráfico, ir em ‘Arquivo’, localizado no canto superior esquerdo, e depois em ‘Exportar para...


6. Funções, diferenciação e integração.

6.1. Funções ‘in-line’ As funções descrevem relações entre dois ou mais elementos, sendo que

essa relação pode ser feita através de uma equação matemática. É uma ferramenta de programação, potencializando a característica de calculadora do Scilab, mas tornando os cálculos mais rápidos e concisos.

No Scilab declaramos as funções da seguinte maneira, no SciNotes:

Figura 6.1.1: Declaração de Função

Nesse formato, x1,..., xn são parâmetros de entrada, ao passo que y1, ..., yn são parâmetros de saída. O programa pode conter várias funções, mas elas só são rodadas quando são devidamente invocadas.

Exemplo: Faça uma função que retorne os valores para x = ab +7 e y = a/b + π

No SciNotes escreve-se a função:

function [x, y]=copa(a, b)

x=a*b+7 y=a/b + %pi

endfunction

No prompt inicial digita-se:

//Teste das funções ‘x’ e ‘y’ para a=3 e b=2 [x,y]=copa(5,8)

6.2. Funções ‘on-line’

No Scilab também podemos criar funções ‘on-line’, ou seja, fora do ambiente do

Scinotes (‘in-line’). Para isso, utilizamos o comando ‘deff’, que é dado por: deff(‘[variáveis de saída] = nome da função (variáveis de entrada)’, [‘expressões a calcular’]) Exemplo: Fazer função on-line para calcular ex e cos(x): deff('[x1,x2]=fun(a,b)',['x1=%e^a';'x2=cos(b)'])


6.3. Tabela de funções Segue abaixo a tabela 6.2.1 com as principais funções matemáticas do Scilab:

abs abs(x) módulo (argumento) de x cos cos(x) cosseno de x, com x em radiano cosh cosh(x) cosseno hiperbólico de x, com x em radiano acos acos(x) arco-cosseno de x, em radianos

acosh acosh(x) arco-cosseno hiperbólico de x, em radianos cotg cotgh(x) cotangente de x, com c em radiano coth coth(x) cotangente hiperbólica de x, com c em radiano

linspace linspace(A,B,N) vetor com N pontos entre A e B inclusos log log(x) logaritmo neperiano de x

log10 log10(x) logaritmo decimal de x log2 log2(x) logaritmo na base 2 de x

logspace logspace(A,B,N) vetor de N pontos com espaço logarítmico entre A e B inclusos

exp exp(x) exponencial euleriana de x int int(N) parte inteira de N

max max(v) máximo valor contido no vetor v min min(v) mínimo valor contido no vetor v

modulo modulo(m,n) resto da divisão de m por n binomial binomial(p,n) binomial normalizado de p classe *n

ceil ceil(x) arredondamento para o maior inteiro posterior cumprod cumprod(v) produto cumulativo do vetor v cumsum cumsum(v) soma cumulativa do vetor v

diff diff(v) diferencial discreta do vetor v eval eval(s) valor numérico de uma expressão de strings fator fator(N) fatores primos de N find find(k’s’V) encontra os índices dos elementos de V que tornam

a comparação verdadeira (‘s’ ==,<,>,~=,...)

fix fix(x) arredondamento para o inteiro mais próximo de zero floor gloor(x) arredondamento para o maior inteiro anterior gsort gsort(V,’r/c’,’i/d’) ordenação dos elementos de v imag imag(z) coeficiente da parte imaginaria de z ndims ndims(M) numero de dimensões de M

pmodulo pmodulo(m,n) resto da divisão de m por n : i = n - m .* floor (n ./ m) nextpow2 nextpow2(x) potência de 2 maior e mais próxima de x

norm norm(A) norma de A perms perms(v) todas as permutações do vetor v

Tabela 5.2.1: Tabela com as principais funções do Scilab

6.4. Diferenciação Utilizamos o comando ‘derivative’ para obtermos a derivada a uma dada ordem, de uma função em um dado ponto. O comando ‘derivative’ é dado por: [Valor da derivada, J] = derivative (função definida, ponto escolhido) Exemplo: Ache a derivada da expressão: 𝑥 𝑠𝑒𝑛(𝑥) + cos (𝑥)𝑒𝑥 , no ponto x0=π/4


deff('y=f(x)','y=[x(1)*sin(x(1))+%e^(x(1))*cos(x(1))]') -->x(1)=%pi/4; -->x0=[x(1)]; -->[D]=derivative(f,x0) D = 1.2624671

6.5. Integração

O Scilab disponibiliza algumas diferentes funções para o cálculo da integrada de uma função. O comando mais simples, ‘integrate’ tem a forma:

Integrate(‘função’, ‘variável’, limite inferior, limite superior)

Exemplo: Calcule a integral da função −0.05 cos(𝑥) ∗ 𝑒𝑥 num intervalo de 0 a 50.

integrate('-0.05*cos(x)*exp(x)','x',0,50)

ans =

- 9.107D+19

Utilizando o comando ‘intg’, teremos que declarar a função anteriormente, mas devemos obter o mesmo resultado. A sintaxe é:

Intg(limite inferior, limite superior, nome da função)

Exemplo: Calcule a integral da função −0.05 cos(𝑥) ∗ 𝑒𝑥 num intervalo de 0 a 50.

deff('[y]=f(x)','y=-0.05*cos(x)*exp(x)')

-->intg(0,50,f)

ans =

- 9.107D+19

6.6. Equações diferenciais Uma equação diferencial de primeira ordem pode ser escrita da seguinte maneira:

dx/dt=f(t,x)

Na ferramenta computacional Scilab a função “ode” resolve numericamente uma equação ordinária de primeira ordem. Caso a equação seja de uma ordem maior, ela poderá sempre ser transformada em ordem primária ao se adicionar outras variáveis. Segue abaixo um exemplo.


Exemplo: 𝑑𝑥

𝑑𝑡 = cos(2t);

No ambiente do SciNotes, digite:

function dx = f (t,x) dx = cos(2*t);

endfunction

A forma mais simples de se chamar a função “ode” no Scilab é na forma:

x= ode(x0, t0, t, f) Em que x0 é o valor inicial de x no tempo t0 e t contém os pontos no tempo(ou na grandeza escolhida) que será determinada a solução e f é o nome da função feita no SciNotes para calcular a derivada. No prompt inicial digita-se então: x0= 2 t0 = 0 t = 0: 0.1 : 1,5; x = ode(x0, t0, t, f); plot2d( t , x )

Exemplo: 𝑑²𝑥

𝑑𝑡²= sen(2t);

Como não é uma EDO de primeira ordem, manipula-se a equação: z = dx/dt; dz/dt = sin(2t)

Agora se tem a EDO na forma: dx/dt = f(t ,x )

Onde x e dx são vetores: x = [z; sin(2t)] dx = [dx/dt, dz/dt]

Ao digitar essa equação no SciNotes, sabendo que agora x é um vetor, encontra-se:

function dx = f( t, x); dx(1) = x(2); dx(2) = sin(2*t);

endfunction

No prompt inicial:

t = 0: 0.01: 4*%pi; y = ode ([0; -1/2], 0, t, f);

plot2d( t , y(1,:) )

Quando estamos lidando com equações diferenciais com mais de uma variável, declararemos a equação da mesma forma que declaramos nos exemplos


anteriores e, depois, como no exemplo de EDO de ordem superior, definiremos o vetor x(n), sendo que cada entrada desse vetor será uma das variáveis do problema em questão.

7.Polinômios e interpolações. 7.1. Polinômios Os polinômios são uma classe de variáveis, tal como real ou lógica. Um polinômio é gerado no Scilab através da função poly. Caso sejam definidos dois polinômios sob a mesma variável, estes podem ser somados, subtraídos, multiplicados e divididos entre si e com números complexos. Existem duas formas de se criar um polinômio no Scilab: especificando suas raízes ou seus coeficientes. Para a primeira forma, são permitidas três sintaxes:

P=poly([a b],'s') P=poly([a b], 's', 'r')

P=poly([a b], 's', 'roots') Quando se deseja a segunda alternativa, as opções são apenas duas:

P=poly([c d], 's', 'c') P=poly([c d], 's', 'coeff')

Lembrando que a ordem dos coeficientes é : c0*s0 , c1*s1,...,cn*sn. As raízes de um polinômio podem ser obtidas com o comando roots(P) e valor numérico da função, pelo comando horner(P,N). Exemplo:

-->p = poly([1 2], 's') p = 2 2 - 3s + s² --> z = roots (p) z = 2. 1.

Exemplo:

valor = horner(p,-5) valor = 42.

7.2. Operações com Polinômios Abaixo estão alguns exemplos de operações que podem ser realizadas com polinômios:

Soma Para realizar a soma de polinômios, inicialmente definem-se os polinômios:

-->a=poly([5 2 9 8 1],"x","coeff"); //criar o polinómio a -->b=poly([5 -3 8],"x","coeff"); //criar o polinómio b


-->soma=a +b //somar os dois polinómios soma = 10 + 2x + 17x² + 8x³ + x4

Subtração -->sub=a-b //subtrair b de a sub = 5x + x² + 8x³ + x4

Multiplicação

-->mult=a*b //multiplicar os polinómios mult= 25 - 5x + 79x² + 29x³ + 53x4 + 61x5 + 8x6

Divisão

Para dividir os polinômios usamos o comando pdiv: -->div=pdiv(a,b) //dividir os dois polinômios div = 1.4394531 + 1.046875x + 0.125x²

Caso haja o interesse de se obter tanto o quociente quanto o resto, pode realizar-se a seguinte operação:

-->[r, q] = pdiv(a,b) //efetuando a divisao: q=quociente, r=resto q = r =

No caso do uso do operador de divisão (/), em vez do comando pdiv, é criado um polinômio racional:

-->div = a/b -->div = 5 + 2x + 9x² + 8x³ + x4 5 - 3x + 8x²

7.3. Derivação de Polinômios Para derivar numericamente um polinômio, utilizamos a função derivat

-->D = derivat (b) D = -3 +16x

7.4. Interpolações Utilizamos a interpolação para encontrar resultados yn para um

determinado problema, dado que temos outros pontos (x1,y1; x2,y2; ...). O Scilab possui algumas funções para interpolação, abordaremos a interp1,

que é utilizada para casos em que y só tem uma variável. Caso queira-se utilizar y dependendo de duas variáveis, basta utilizar interp2 ou até mesmo interp3 para casos com três variáveis.

7.5. Interpolações Lineares Para a interpolação linear é usado uma aproximação de polinômio do primeiro grau para os pontos. Cabe ao usuário definir se tal aproximação é a mais eficiente para o problema que possui.

O formato é definido como:


interp1(x, y, a, ‘linear’)

No qual o parâmetro ‘x’ representa um vetor de reais, ‘y’ representa a

imagem desse vetor em f(x), e ‘a’ é o valor para o qual se quer encontrar a imagem. Exemplo:

x=[1, 10, 20, 30, 40]; y=[1,30, -10,20,0]; //Função abaixo encontra o valor de y para x=8 yy=interp1(x,y,8, 'linear')

7.6. Interpolações por Spline Cúbica Dados os pontos (x1,y1; x2,y2; ...), quando a melhor aproximação para essa função são curvas, utilizaremos o ‘spline’ na nossa função interp1.

O formato fica: interp1(x, y, a, ‘spline’), no qual o parâmetro ‘x’ representa um vetor de reais, ‘y’ representa a imagem desse vetor em f(x), e ‘a’ é o valor para o qual se quer encontrar a imagem.

Exemplo:

x=linspace(0,3,20); //Linspace Indica que no intervalo 0≤x≤3 contém 20 números igualmente separados y=x.^2+4*x; //Função abaixo encontra o valor de y para x =4,66 yy=interp1(x,y,4.66,'spline')

7.7. Extrapolação Útil para encontrar um valor fora do meu intervalo ou do meu conjunto de números. Novamente utilizamos a função interp1, adicionando um quarto parâmetro, ‘extrap’. O formato fica: interp1(x, y, a, method, ‘extrap’), no qual o parâmetro ‘x’ representa um vetor de reais, ‘y’ representa a imagem desse vetor em f(x), ‘a’ é o valor para o qual se quer encontrar a imagem e ‘method’ é o método utilizado para a extrapolação (por exemplo, ‘linear’ ou ‘spline’). Exemplos:

x=[1, 10, 20, 30, 40]; y=[1,18, 5,0,21]; //Função abaixo encontra o valor de y para x=45 utilizando uma função linear yy=interp1(x,y,45, 'linear', 'extrap' ) x=[1, 10, 20, 30, 40]; y= x.^2+6*x; //Função abaixo encontra o valor de y para x = 52 yy=interp1(x,y,52,’spline’,’extrap’)

http://help.scilab.org/docs/5.3.0/pt_BR/linspace.html


8. Introdução à Programação

8.1. Introdução

A linguagem do Scilab é simples e disponibiliza a maioria das estruturas de

linguagem de programação, por isso é fácil para o usuário criar programas no Scilab.

A diferença do Scilab para outras linguagens de programação é a não necessidade de

declaração prévia de variáveis que serão utilizadas no programa.

Aprendemos como escrever e executar comandos a partir da tela inicial do

Scilab. Neste capítulo, apresentamos as principais estruturas da linguagem de

programação utilizada no Scilab. Essas estruturas são utilizadas, depois, para gerar

programas que serão executados no ambiente Scilab.

Para iniciar a programação é necessário abrir o editor de texto SciNotes.

8.2. Função Printf

A função printf é responsável por gerar uma saída que será impressa na tela.

Exemplo 1: Imprimir “Olá mundo” na tela.

Na tela do SciNotes, digitar:

printf(‘Olá Mundo\n’);

A função printf tem que ser seguida de colchetes e a mensagem que deverá

ser impressa precisa estar entre aspas simples. O símbolo \n serve para pular linha

após a impressão. O símbolo ‘;’ indica que o comando está encerrado.

Após digitar o comando na tela é necessário salvar o arquivo em um diretório,

como a figura abaixo:

Figura 8.2.1: Tela para salvar em diretório.


Assim que o arquivo é salvo, retorna-se a tela do SciNotes e clica no botão

executar:

Figura 8.2.2: Comando para executar a função printf.

A resposta será impressa na tela inicial do Scilab.

Figura 8.2.3: Tela com a resposta da execução do comando da figura 7.2.1.

A função printf também é usada para imprimir um resultado, como segue o

exemplo.

Exemplo 2: Imprima na tela o valor da variável A =20.

Na tela do SciNotes declarar o valor de A e depois utilizar a função printf para

imprimir na tela:

A=20;

printf(‘A variável A contem o valor de %g\n’,A);

Nota-se neste caso o uso do símbolo “%g” que tem a função de armazenar o

valor de uma variável já declarada. Essa variável deve ser colocada após a mensagem

e separa por uma vírgula, como no exemplo acima.

Após inserir o comando no SciNotes é necessário salvar o programa e clicar no

botão executar para que a mensagem seja impressa na página inicial do Scilab.


Figura 8.2.4: Tela com exemplo usando printf.

8.3. Função input.

A função input é utilizada para ler um valor de uma variável que será digitada

na tela inicial. Ou seja, não se define a variável no Scinotes, como feito no Exemplo 2,

quem executa o programa é quem define o valor da variável.

Exemplo: Converter graus Fahrenheit em graus Celsius.

Sabe-se que a equação que converte graus °F em °C é a seguinte:

𝐶𝑒𝑙𝑠𝑖𝑢𝑠 = (5

9) ∗ (𝐹𝑎ℎ𝑟𝑒𝑛ℎ𝑒𝑖𝑡 − 32)

Assim, precisa-se do valor da temperatura em graus Fahrenheit para ser

convertida em graus Celsius. Então se utiliza a função input para receber o valor de f .

f = input(‘Digite os graus em Fahrenheit:’);

c = (5/9)*(f-32);

printf(‘Equivale a %g graus Celsius.\n’,c);

Após digitar o comando no SciNotes, salvar o programa no diretório e clicar em

executar.

Na tela inicial do Scilab aparecerá a mensagem que solicita um número para

fazer a conversão de graus Fahrenheit em graus Celsius. Digitou-se 50 e depois

ENTER:


Figura 8.3.1: Tela da programação do exemplo sobre input.

Para inserir comentário dentro do programa basta utilizar duas barras seguidas

“//” e após elas escrever o comentário. O comentário não interfere no seu programa e

serve para deixá-lo mais completo à medida que há a necessidade de explicar alguns

comandos.

Exemplo de comentário:

f = input(‘Digite os graus em Fahrenheit:’); //a função foi utilizada para ler o

valor de uma variável.

8.4. Função if-end

A função if-end é uma condicional, ou seja, para um comando ser executado

precisa de uma condição inicial.

Exemplo: Elaborar um programa para escrever a média de duas notas. Se a

média for maior que sete, o programa deverá também escrever “Parabéns”.

Nota1 = input(‘Digite a primeira nota:’);

Nota2 = input(‘Digite a segunda nota:’);

Media = (Nota1 + Nota2)/2;

printf(‘Sua média é %g\n’,Media);

if Media>7


printf(‘Parabéns’);

end

A resposta do programa está impressa na tela inicial para Nota1=10 e Nota2=8,

como a média é maior que sete, foi impresso “Parabéns”.

Figura 8.4.1: Tela da programação do exemplo sobre if-end.

8.5. Função if-else-end

Como dito anteriormente, a função if-end é uma condicional. A função else é

complementar a função if e indica que seu comando não será executado quando ela

for satisfeita.

Neste caso utilizaremos o Exemplo 5, só que acrescentando uma mensagem

para uma média menor que sete imprime “Reprovado” e maior que sete imprime

“Aprovado”.

Nota1 = input(‘Digite a primeira nota:’);

Nota2 = input(‘Digite a segunda nota:’);

Media = (Nota1 + Nota2)/2;


printf(‘Sua média é %g\n’,Media);

if Media>7

printf(‘Aprovado’);

else printf(‘Reprovado’);

end

Assim, temos as duas condições para o exemplo acima representado na figura:

Figura 8.5.1. Exemplo de função if-else-end na tela do Scilab.

8.6. Função for

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: Elabore um programa para escrever todos os números pares inteiros

entre 1 e 50.

for i=2:2:50


printf(‘%g’,i);

end

Neste programa temos ‘i’ como a variável de controle, que inicialmente é igual

a 2, e seu valor final é igual a 50. O passou ou incremento está no meio dos valores da

variável e tem o valor 2. Isso significa que a partir do número 2 o programa irá imprimir

o próximo número com incremento 2, que será por consequência o número 4. A figura

abaixo mostra a execução do programa.

Figura 8.6.1: Exemplo de como usar a função for no Scilab.

Exemplo: Elabore um programa para calcular o fatorial para qualquer valor n

fornecido pelo usuário. Sabe-se que o fatorial de um número n é sua sequência

multiplicada n vezes. Por exemplo, fatorial de 3! = 1x2x3=6.

n = input(‘Entre com um número:’);

fat =1;

for cont=2:n

fat=fat*cont;

end

printf(‘O fatorial de %g é igual a %g\n’,n,fat);

A figura mostra como o programa é executado na tela inicial do Scilab.


Figura 8.6.2: Execução do exemplo sobre função for no Scilab

8.7. Função while

A função while é um laço controlado logicamente. Ele repete a execução de um

conjunto de comandos, mas verificando antes de executar os comandos se é permitido

repeti-los ou não, ou seja, se o comando for verdadeiro ele executará, se for falso ele

sairá do laço while.

Exemplo: Calcular a média das notas de dois alunos.

i =1;

while i<=2

nota1 = input(‘Digite a 1ª nota bimestral’);




media = (nota1+nota2+nota3+nota4)/4;

printf(‘Media = %g\n’,media);

i=i+1;

end


Figura 8.7.1: Execução do exemplo sobre função while no Scilab

8.8 Vetor.

Matrizes unidimensionais são chamadas de vetores. Em um vetor é possível

armazenar vários itens em uma única variável.

Exemplo: Calcular a média dos elementos do vetor nota dado pelo usuário.

for i=1:10

nota(i)=input(‘Digite um valor:’);

end

soma=0;

for i=1:10

soma=soma+nota(i);

end

printf(‘Media das notas = %g\n’,soma/10);


Figura 8.8.1: Execução do exemplo sobre vetor no Scilab.

8.9 Matriz.

Matrizes usam dois índices para individualizar elementos. Matrizes são

construídas usando colchetes. Cada linha da matriz é separada por um ponto e vírgula

e cada elemento de uma linha é separado por espaço (ou vírgula).

Exemplo 10: Calcular a soma dos elementos da diagonal principal da matriz A

e escrever o resultado.

a = [3 1 2 4; 5 5 8 6; 8 10 11 5; 9 1 5 7; 2 3 8 8];

soma=0;

for i=1:4

soma = soma + a(i,i);

end

printf(‘soma=%g\n’,soma);


Figura 8.9.1: Execução do exemplo sobre matriz no Scilab.


9. Exercícios

9.1. Encontre o valor da expressão: [(5e3+72+3) (9 – i)2]/3,5e2 – [ 47 e(3i + 7)3 ]

9.2 Calcular a média dos elementos do vetor nota. nota = [8.1 5.2 9.2 7.2 6.5 5.2 8.5 9.5 6.5 10.0]; soma = 0; for i=1:10 soma = soma + nota(i); end printf("Média das notas =%g\n",soma/10);

9.3 Ler dois vetores A e B de 10 elementos. Construir um vetor C tal que cada elemento de C seja o dobro da soma entre os elementos correspondentes de A com B. Escrever o vetor C.

for i=1:10 // Leitura de A e B a(i) = input("Digite um valor"); end for i=1:10 b(i) = input("Digite um valor"); end for i=1:10 c(i) = 2*(a(i)+b(i)); // Calculo de C end for i=1:10 // Escreve de C printf("%g ",c(i)); end

9.4 Ler dois vetores A e B de 10 elementos. Construir um vetor C tal que o elemento de índice ímpar de C seja igual ao elemento correspondente de A, caso contrário, seja igual ao elemento correspondente de B. Porexemplo, c[1]==a[1], c[3]==a[3],.... Mas,c[2]==b[2],b[4]==a[4],.... Escrever o vetor C.

for i=1:10 // Leitura de A e B a(i) = input("Digite um valor"); end for i=1:10 b(i) = input("Digite um valor"); end for i=1:10 if modulo(i,2)<>0 // Testa se o índice i é ímpar. c(i) = a(i); // Se for ímpar c(i) recebe o valor de a(i) else c(i) = b(i); // Se for par c(i) recebe o valor de b(i) end end for i=1:10 // Escreve o vetor C printf("%g ",c(i)); end

Comentário. A função módulo (resto de uma divisão) verifica se o índice do vetor C é ímpar ou par porque se resto da divisão entre um número qualquer e dois é diferente de zero, então ele é ímpar (não é divisível por dois).


9.5 Elaborar um programa que leia o dia, o número de mês e o ano e escreva a data no formato “D de MMM de AAAA”(ou “D de MMM de AA”). Por exemplo, se o dia é 31, o mês é 12 e o ano é 2003, então o programa deverá escrever 1 de dez de 2003.

mes = ["jan" "fev" "mar""abr" "jun" "jul" "ago" "set" "nov" "dez"]; dia = input("Digite o dia"); nunmes = input("Digite onumero do mes"); ano = input("Digite o ano"); printf("%g de %s de %g\n",dia,mes(nunmes),ano);

Comentário. Porque a variável nunmes contém o número do mês, o comando printf é capaz de escrever o nome do mês através do elemento mês (nunmes). 9.6 O que este programa escreve?

poema(1) = ’uma rosa’; poema(2) = ’é’; for a=1:3 for b=1:2 printf("%s ",poema(b)); end end printf(’%s’,poema(1));

9.7 Alguns candidatos prestaram concurso para cinco vagas em uma empresa. Os resultados das provas do concurso estão armazenadas nas seguintes matrizes:

Escreva um programa que: a) Armazene os nomes dos candidatos em um vetor nome e as notas das provas em uma matriz nota 10×3.

nome = ["Ana" "Carlos" "Francisco" ... "José" "Magali" "Marcos" ... "Maria" "Marta" "Paulo""Pedro"]; nota = [6.5 7.1 7.5; ... 8.0 8.3 7.2; ... 7.5 8.1 8.3; ... 6.1 5.2 6.0; ... 5.1 6.1 6.5; ... 4.1 5.5 5.4; ... 9.1 8.9 9.4; ...


8.8 8.5 9.0; ... 9.5 9.3 9.1; ... 8.2 8.5 7.8];

b) Calcule a média de cada candidato, armazene em um vetor media e escreva-o.

[m,n]=size(nota); for i=1:m soma = 0; for j=1:n soma = soma+nota(i,j); end media(i)=soma/3;

9.8 Verifique os valores de L(1), L(2), L(3) , L(4) e L(5) do exemplo do tópico 4.4. 9.9 Acessar termo L(2)(2)(1,2) da lista explicitada no exemplo do tópico 4.5. 9.10 Interpolar a seguinte tabela para o valor de x = 2.3 e extrapolar para x=52.5. Encontrar o gráfico dos pontos.

X 1 2 3 4 y 1.73 3.46 5.20 6.92

9.11 Encontrar o gráfico da função abaixo:

y = x3 +2x +3 9.12 Elaborar um programa Scilab para calcular a resistência equivalente entre dois resistores R1 e R2 em paralelo. Lembre-se que a resistência equivalente de dois resistores paralelos é dado por:

1Req= 1R1+ 1R2

Obs.: Lembre-se, esse exercício utilizará as funções printf e input. 9.13 Elaborar um programa Scilab para calcular a resistência equivalente entre dois

resistores R1 e R2 em paralelo. Lembre-se que a resistência equivalente entre dois

resistores em paralelo é dada por:

1

𝑅𝑒𝑞=

1

𝑅1+

1

𝑅2

Obs.: Lembre-se, este exercício utilizará as funções printf e input.

9.14 Elaborar um programa para calcular o valor da função:

𝑓(𝑥) = { 𝑥² + 16 𝑠𝑒 𝑥 ≥ 0 0 𝑠𝑒 𝑥 ˂ 0

, dado um valor x fornecido via

teclado.

Obs.: Lembre-se de utiliza as funções printf, input e if-else-end.

9.15 Elabore um programa que calcule e escreve o valor de S.

𝑆 = 1

1+

3

2+

5

3+ ⋯ +

99

50


Obs.: Note que há uma relação entre numerador e denominador da seguinte

forma:

2 x denominador - 1 = numerador

9.16 Elaborar um programa para calcular a soma de todos os inteiros entre 1 e 100.

9.17 Ler dois vetores A e B de 10 elementos. Construir um vetor C tal que cada

elemento de C seja o dobro da soma entre os elementos correspondentes de A com B.

Escrever o vetor C.

9.18 Calcular a soma dos quadrados dos elementos da segunda linha de A e escrever

o resultado.


10. Referências

1 http://www.dca.ufrn.br/~pmotta/sciport-3.0.pdf, acessado dia 17/06/2014 às 10h00min.;

2 http://www.mat.ufrgs.br/~guidi/grad/MAT01169/laminas.Intro_Scilab.pdf, acessado dia 17/06/2014 às 10h22min.;

3 http://www.dca.ufrn.br/~estefane/academica/progsci.pdf, acessado dia 17/06/2014 às 10h47min.;

4 http://euler.mat.ufrgs.br/~giacomo/Manuais-softw/SCILAB/Apostila%20de%20Scilab%20-%20atualizada.pdf, acessado dia 17/06/2014 às 11h01min.;

5 http://help.scilab.org/docs/5.3.2/pt_BR/, acessado dia17/06/2014 às 11h59min.

http://edusantos.eti.br/una/docs_algoritmos/scilab_apostila_una.pdf acessado dia 17/05/2015 às 18h23min

6

http://www.scilab.in/files/workshops/15-04-2010-mumbai/sengupta-ode.pdf

acessado dia 17/05/2015 às 18h25min

http://www.dca.ufrn.br/~pmotta/sciport-3.0.pdf

http://www.mat.ufrgs.br/~guidi/grad/MAT01169/laminas.Intro_Scilab.pdf

http://www.dca.ufrn.br/~estefane/academica/progsci.pdf

http://euler.mat.ufrgs.br/~giacomo/Manuais-softw/SCILAB/Apostila%20de%20Scilab%20-%20atualizada.pdf

http://euler.mat.ufrgs.br/~giacomo/Manuais-softw/SCILAB/Apostila%20de%20Scilab%20-%20atualizada.pdf

http://help.scilab.org/docs/5.3.2/pt_BR/

http://edusantos.eti.br/una/docs_algoritmos/scilab_apostila_una.pdf

http://www.scilab.in/files/workshops/15-04-2010-mumbai/sengupta-ode.pdf%20acessado%20dia%2017/05/2015

http://www.scilab.in/files/workshops/15-04-2010-mumbai/sengupta-ode.pdf%20acessado%20dia%2017/05/2015

Documents

Curso de Scilab - pet.feq.unicamp.brpet.feq.unicamp.br/wp-content/uploads/2015/06/Apostila-Curso-de... · Curso de Scilab Nível Básico ao Intermediário Autores: Revisão: Daniela