Minicurso: Introdução ao SciLab - Páginas Pessoais

Minicurso: Introdução ao SciLab
Regiane Slongo Fagundes (UTFPR-TD)
Suellen Ribeiro Pardo Garcia (UTFPR-TD)
Vanderlei Galina (UTFPR-TD)
Sumário
1 Apresentando o Scilab ..............................................................................1
1.1 Introdução .............................................................................................1
1.2 Algumas vantagens ................................................................................1
1.3 Instalando o Scilab .................................................................................1
1.4 Interface e menus do Scilab....................................................................2
2 Noções fundamentais................................................................................3
2.1 Usando o Scilab como uma simples calculadora....................................3
2.2 Variáveis e comando de atribuição........................................................3
2.3 Expressões aritméticas...........................................................................4
2.4 Strings.....................................................................................................8
2.5 Números complexos...............................................................................9
3 Polinômios.................................................................................................9
3.1 Operações com polinômios..................................................................10
4 Vetores....................................................................................................11
4.1 Plotando funções .................................................................................14
5 Matrizes ..................................................................................................15
5.1 Acesso a elementos de vetores e de matrizes .....................................17
5.2 Operações com vetores e matrizes .....................................................21
6 Programação no Scilab ...........................................................................24
6.1 Arquivos de Scripts ..............................................................................24
6.2 Criação de arquivos de script ...............................................................24
6.3.1 O loop for ..........................................................................................25
6.3.2 O comando de decisão if-then-else ..................................................26
6.4 Funções criadas pelo usuário ...............................................................26
6.5 Implementação Eliminação de Gauss ..................................................28
1 Apresentando o Scilab
1.1 Introdução
O Scilab é um ambiente utilizado no desenvolvimento de programas
para a resolução de cálculos científicos. O Scilab é um software para
cálculo numérico desenvolvido desde 1990 por pesquisadores do Institut
de Recherche em Informatique et en Automatique (INRIA) e da Ecole
Nationale des Ponts et Chaussees (ENPC) na França e mantido pelo Scilab
Consortium desde 2003. É distribuído gratuitamente através da internet
(http://www.scilab.org) para diversas plataformas. Inclui um grande
número de bibliotecas (toolboxes) que englobam funções gráficas,
integração numérica, álgebra linear, otimização e outras.
Além de diversas funções matemáticas, possui a possibilidade de
interação com programas em várias linguagens como o C e Fortran.
É uma plataforma em constante atualização e aperfeiçoamento
(Scilab = Scientific Laboratory : Pronúncia em sintaxe fonética
internacional é “sailæb”.)
1.2 Algumas vantagens do Scilab
 É uma poderosa ferramenta para cálculos científicos.
 É de fácil aprendizado.
 A última versão do software está sempre disponível, geralmente via
Internet.
 O software pode ser legalmente utilizado, copiado, distribuído,
modificado.
 Os resultados obtidos podem ser divulgados sem nenhuma
restrição.
 Os programas desenvolvidos podem ser transferidos para outras
pessoas sem imposições de qualquer natureza.
1.3 Instalando o Scilab
Acesse o site http://www.scilab.org/, entre em Products, escolha a
opção Scilab. Do lado esquerdo da página você encontrará a opção
Download. Agora, basta fazer a opção do seu sistema operacional.
1
1.4 – Interface e menus do Scilab
2 Noções fundamentais
2.1 Usando o Scilab como uma simples calculadora
O Scilab pode fazer operações aritméticas simples com números reais e
complexos. Os operadores aritméticos são:
2
Adição
+
Subtração
Multiplicação
*
Divisão
/
Potenciação
^
Execute o Scilab no seu sistema e procure pelo símbolo (prompt):
-->
Exemplos:
-->2+3 [ENTER]
ans =
5.
-->5+6/2 [ENTER]
ans =
8.
-->4^2 //4 elevado a potência de 2
ans =
16.
A variável ans (answer) armazena o valor do último cálculo realizado.
Exemplo:
-->4+5
ans =
9.
-->ans+ 3
ans =
12
2.2 – Variáveis e comando de atribuição
Informações são armazenas em variáveis para posterior uso. Muitos
programadores costumam interpretar variáveis como sendo um nome
para uma posição na memória do computador. Para atribuir ou modificar
a informação contida na variável é usado o comando de atribuição (=).
Exemplo:
-->a = 2 // Atribui 2 para variável a
a=
2.
-->b = 4 // Atribui 4 para variável b
b=
4.
-->area = a*b // Atribui o produto de a e b para a variável area
3
area =
8.
-->b = b+1 // Incrementa uma unidade na variável b
b=
5.
OBS.(1): Os nomes de variáveis (também conhecidos por identificadores)
devem seguir as seguintes regras:
1. Nomes de variáveis começam com uma letra, seguido de letras,
algarismos ou sublinhados.
Por exemplo: Alpha, notas, A1, B23 e cor_do_objeto;
2. Caracteres especiais não são permitidos. Isto é, não é permitido usar #,
$, &, %, ?, !, @, <, ~, etc.;
3. Caracteres acentuados não são permitidos;
4. Nomes de variáveis são sensíveis a maiúsculas e minúsculas.
Por exemplo, variável Alpha é diferente das variáveis ALPHA, alpha e
AlPhA.
OBS.(2): O resultado do seguinte comando, digitado com ponto e vírgula,
é suprimido:
-->A = 4+4^2;
-->
Se este comando é digitado sem ponto e vírgula, o resultado é visualizado:
-->A = 4+4^2
A=
20.
Mais exemplos:
-->a=2;
-->b=4;
-->area=a*b // aqui o ponto e vírgula foi suprimido porque precisamos
visualizar o resultado.
area =
8.
2.3 Expressões aritméticas
As regras importantes são: prioridade, associatividade e parênteses.
Prioridade
Operação
Associatividade
1ª
Potenciação
da direita para a esquerda
2ª
Multiplicação / Divisão
da esquerda para a direita
3ª
Adição / Substração
da esquerda para a direita
4
Exemplos:
Com relação à prioridade:
2+10/5 // 10/5 é avaliada primeiro.
A+B/C+D // B/C é avaliada primeiro.
R*3+Bˆ3/2+1 // Bˆ3 é avaliada primeiro.
Com relação à associatividade:
A-B+C+D //A-B é avaliada primeiro, porque está mais a esquerda.
A*B/C*D //A*B é avaliada primeiro, porque está mais a esquerda.
A^B^C^D //CˆD é avaliada primeiro, porque está mais a direita.
A ordem de prioridade pode ser alterada pelo uso dos parênteses:
(A+4)/3 //A+4 é avaliada primeiro devido aos parênteses
(A-B)/(C+D) //A-B é avaliada primeiro. Depois a adição. Por último, a
divisão.
R*3+B^(3/2)+1 //3/2 é avaliada primeiro.
Além dos operadores aritméticos podemos usar funções matemáticas.
Exemplos:
2+3*cos(x)
x^(2*sin(y))
2+3*tan(x)+k^2
As principais funções matemáticas do Scilab são mostradas na tabela a
seguir.
abs(x)
Valor absoluto.
acos(x)
Arco cosseno.
acosh(x)
Arco cosseno hiperbólico.
asin(x)
Arco seno.
asinh(x)
Arco seno hiperbólico.
atan(x)
Arco tangente.
atanh(x)
Arco tangente hiperbólico.
conj(x)
Conjugado.
cos(x)
Cosseno.
cosh(x)
Cosseno hiperbólico.
exp(x)
Exponencial: ex.
imag(x)
Parte imaginária de um número complexo.
log(x)
Logaritmo natural.
log10(x)
Logaritmo na base 10.
real(x)
Parte real de um número complexo.
modulo(x,y)
Resto da divisão de x por y.
sign(x)
Função sinal: retorna o valor -1, +1 seja negativo,
positivo ou nulo, respectivamente.
sin(x)
Seno.
5
sinh(x)
sqrt(x)
tan(x)
tanh(x)
Seno hiperbólico.
Raiz quadrada.
Tangente.
Tangente hiperbólica.
Exemplos de funções matemáticas:
// O número π e a base do logaritmo natural e = 2, 718281828... são
representadas pelas variáveis especiais %pi e %e.
-->cos(2*%pi) // cosseno de 2 vezes PI
ans =
1.
-->%e^2 // 2,718281828 ao quadrado
ans =
7.389056098931
-->abs(-5) // valor absoluto
ans =
5.
-->modulo(8,3) // Resto da divisão entre 8 e 3
ans =
2.
-->modulo(6,3)
ans =
0.
-->sign(-4) // Função sinal: retorna o valor -1, +1 ou zero conforme o
argumento x seja negativo, positivo ou nulo, respectivamente.
ans =
- 1.
-->sign(5)
ans =
1.
Também temos Funções de Arredondamento, como por exemplo:
-->a = 34.885;
-->fix(a) // trunca a parte fracionária
ans =
34.
-->round(a) // arredonda para o inteiro mais próximo
ans =
35.
6
-->ceil(3.1) // arredonda para mais.
ans =
4.
As principais funções de arredondamento do Scilab são mostradas na
tabela a seguir.
ceil(x)
Arredondamento na direção de mais infinito.
fix(x)
Arredondamento na direção de zero (isto é, desenvolve a
parte inteira de um número).
floor(x)
Arredondamento na direção de menos infinito.
int(x)
Mesmo que fix.
round(x)
Arredondamento para o inteiro mais próximo.
Exemplos de funções de arredondamento:
x
ceil(x)
floor(x)
1.75
2
1
1.5
2
1
1.25
2
1
-1.25
-1
-2
-1.5
-1
-2
-1.75
-1
-2
fix(x)
1
1
1
-1
-1
-1
round(x)
2
2
1
-1
-2
-2
Podemos modificar o Formato de Visualização dos Números com o
comando format modifica a quantidade de dígitos com que os números
são mostrados no Scilab.
Por exemplo, o comando
--> format(5) //fará com que todas os números sejam visualizados em 5
posições incluindo o ponto decimal e um espaço para o sinal
Exemplo:
-->sqrt(3)
ans =
1.73
Para aumentar o número de posições para 16, usa-se:
-->format(16)
-->sqrt(3)
ans =
1.7320508075689
A raiz de 3 foi mostrada ocupando 16 posições (sendo uma posição para o
ponto, um espaço reservado para o sinal, uma posição para a parte inteira
e 13 posições para a parte fracionária).
O comando format(’e’) mostra os números em notação científica.
7
Por exemplo:
-->format(’e’)
-->2*%pi/10
ans =
6.283185307E-01 //6.283185307E-01 significa 6.283185307×10^−1.
Para retornar ao formato inicial usa-se -->format(’v’) que é chamado de
“formato de variável”.
O Scilab possui Constantes Especiais do Scilab, que são várias constantes
pré-definidas.
Algumas constantes pré-definidas não podem ser alteradas. As principais
são mostradas na tabela a seguir:
%pi
O número 
%eps
Constante que representa a precisão numérica da
máquina. É o menor número que, somado a 1, resulta em
um número maior do que 1 no computador.
%inf
Representa o infinito ∞.
%i
1
%e
A base do logaritmo natural.
%t ou %T
Representa o valor booleano verdadeiro.
%f ou %F
Representa o valor booleano falso.
2.4 Strings
Strings são usados para toda e qualquer informação composta de
caracteres alfanuméricos e/ou caracteres especiais.
Exemplos
#, $, &, %, ?, !, @, <, ~, etc.
Os strings são envolvidos por aspas duplas ou simples.
Exemplos:
-->a= "Maria e Jose"
a=
Maria e Jose
Um das atividades mais comuns em programação é a concatenação de
strings.
Exemplos:
-->n = "Pedro"
n=
Pedro
-->m = "Paulo"
m=
8
Paulo
-->m + n // Concatena Paulo com Pedro sem
ans =
PauloPedro
-->m +“ “+”e”+” “+n
Paulo e Pedro
2.5 Números complexos
A unidade imaginária é representado por %i, ou seja, %i = sqrt(-1).
Exemplo:
Sejam os números imaginários x e y, como segue:
x = 3 + 4*%i e y = 1 - %i
As operações abaixo são feitas normalmente:
z1 = x - y
z2 = x * y
z3 = x / y
Bem como o uso de funções:
real(x) −Parte real de x
imag(x) −Parte imaginária de x
abs(x) −Valor absoluto do número complexo
atan(imag(x),real(x)) −Argumento do número complexo
conj(x) −Conjugado
3 Polinômios
Os polinômios são criados no Scilab através da utilização da função
poly. Por exemplo, o polinômio p = 4  3t  t 2 , que possui raízes -1 e 4,
pode ser criado através do comando,
-->p=poly([-1 4],'t')
// Polinômio definido pelas suas raízes
p =
2
- 4 - 3t + t
Com a função roots, comprovamos que as raízes de p são,
realmente, -1 e 4,
-->roots(p)
//raízes do polinômio p
9
ans =
4.
- 1.
Um polinômio também pode ser criado a partir da especificação de
seus coeficientes através do comando, ‘coeff’. Exemplo, o polinômio
m = 4t - 1
-->m=poly([-1 4],'t','coeff')
// polinômio definido pelo seus coeficientes
m =
- 1 + 4t
3.1 Operações com polinômios
Vamos definir dois polinômios p e q, de fácil manipulação algébrica
para evidenciarmos as operações entre eles.
-->p=poly([1 2 1], 't','coeff');
-->q=poly([1 1], 't','coeff');
-->p/q
ans =
1+t
----1
-->p+q
ans =
2
2 + 3t + t
-->p-q
ans =
2
t+t
10
-->p*q
//Multiplicação
ans =
2 3
1 + 3t + 3t + t
-->[r,q]=pdiv(p,q)
//Quociente e resto da divisão de p por q
q =
1+t
r =
0.
Para obter valores de polinômios, usamos a função horner,
-->horner(p,2)
ans =
9.
4 Vetores
Vamos considerar o conjunto dos números reais. Dizemos que x é
um vetor de dimensão n em , indicado por x  n , se, e somente se,
 x1 
x 
 2
x 

 
 xn 
Nessa definição, cada um dos elementos do vetor x, xi, pertence a
,
xi 
O elemento xi é o i-ésimo elemento do vetor x.
O vetor x definido anteriormente é um vetor coluna. Para explicitar
esta condição, escrevemos
x
n1
11
Essa notação indica que o vetor x possui n linhas e apenas uma
coluna.
No Scilab, os vetores são criados colocando-se seus componentes
entre colchetes, [ ]. Os elementos de um vetor coluna são separados por
ponto-e-vírgula. Assim,
-->x=[1;2;3]
// vetor coluna. Elementos separados por ;
x =
1.
2.
3.
Um vetor linha, y, de dimensão n em
y  [ y1
pode ser escrito na forma
y2 ... yn ]
O vetor y definido anteriormente é um vetor linha. Para explicitar
esta condição, escrevemos
y
1n
Essa notação indica que o vetor y possui apenas uma linha e n
colunas.
-->y=[1 2 3]
// vetor linha; Elementos separados por espaço
y=
1. 2. 3.
-->w=[4,5,6];
// vetor linha; Elementos separados por vírgula
Se x é um vetor coluna, xT (lê-se “x transposto”) ´e um vetor linha.
Essa operação é realizada no Scilab através da utilização do símbolo ’
(apóstrofo).
-->x'
// vetor transposto = vetor linha
ans =
1. 2. 3.
Para determinarmos a dimensão de um vetor, utilizamos o
comando size,
12
-->size(x')
ans =
1. 3.
Vetores podem ser multiplicados ou divididos por quantidades
escalares. Também, vetores de mesma dimensão podem ser somados ou
subtraídos.
-->3*x
//multiplicando x por uma constante
ans =
3.
6.
9.
-->w/3
// dividindo y por uma constante
ans =
1.3333333 1.6666667 2.
-->x'+w // somando dois vetores de mesma dimensão
ans =
5. 7. 9.
Dados dois vetores de mesma dimensão, x, y,  n1 define-se o
produto escalar ou produto interno entre x e y através da expressão
vetorial,
z = xT y. Assim, considerando os vetores:
1 
x   2
 3
 4
e y  5 
 6 
Temos:
-->z=x'*y
// Atribuindo a z o produto escalar entre x e y
z =
13
32.
Nos exemplos a seguir, mostramos outras maneiras de construir
vetores, usando índices e algumas funções internas do Scilab:
-->v=[3:0.5:5]
// Vetor com elementos decrementados
v =
3. 3.5 4. 4.5 5.
-->m = ones(1:4)
// Vetor constituído de elementos iguais a 1
m =
1. 1. 1. 1
-->f = zeros(1:5)
// Vetor constituído de elementos iguais a 0
f =
0. 0. 0. 0. 0.
4.1 Plotando funções
A função básica para gráficos é plot, com a seguinte estrutura:
plot ( [veto i], [vetor j] )
-->x=[1 2 3];
-->y=[4 5 6];
-->plot(x,y)
Podemos utilizar outras funções como plot2d
Reta
-->x=[-1:0.2:6];
-->y=7-3*x;
-->plot2d(x,y)
Parábola
-->x=[-4:0.1:4];
14
-->plot2d(x,x^2-2)
Senóide
-->x=[0:0.1:2*%pi];
-->y=sin(x);
-->plot2d(x,y)
Todos os comandos estão disponíveis na biblioteca Graphic Library no
Help (?) do programa.
-->apropos graphics
-->help plot
5 Matrizes
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 termino de cada linha da matriz é
feita com ponto-e-vírgula.
Nos exemplos a seguir, para fixar conceitos, 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,
-->A=[1 2 3; 5 -8 9]
espaço
// Matriz A - Elementos das linhas separados por
A =
1. 2. 3.
5. - 8. 9.
-->B=[1,2,3;4,5,6];
vírgulas
// Matriz B - Elementos das linhas separados por
-->size(A);
// Dimensão da matriz A
-->size(B);
// Dimensão da matriz B
15
Uma 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];
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;
// Multiplicação por um escalar
-->A / 2;
// Divisão da matriz A por uma constante
-->A + B;
// Somando as duas matrizes
Se A  mn ,a transposta da matriz A, indicada por AT , AT  nm . No
Scilab, a transposição é indicada pelo símbolo ’ (apóstrofo), então a
transposta de A fica A’. Considerando a matriz B do exemplo anterior,
temos:
-->size(B) ;
// Dimensão da matriz B
-->C=B';
// C = transposta da matriz B
-->size(C);
// Dimensão da matriz C
Se A 
m p
e B
p n
, podemos definir o produto das matrizes A e
B,
C  A B 
mn
Observar que, para que possa haver a multiplicação entre duas
matrizes, é necessário que o número de colunas da primeira matriz seja
igual ao número de linhas da segunda matriz.
-->A=[1 2 3;4 5 6;7 8 9];
-->B=[1 4; 2 5; 3 6];
-->size(A);
-->size(B);
16
-->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  23 , com todos os
elementos iguais a 1,
-->D = ones(2,3);
ou a função zeros para criar a matriz E 
iguais a 0,
33
, com todos os elementos
-->E = zeros(3,3);
ou, ainda, a criação de uma matriz identidade, I através da função interna
eye,
-->I = eye(4,4);
Podemos criar matrizes a partir de elementos de outras matrizes,
-->// Definido 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.
5.1 Acesso a elementos de vetores e de matrizes
O acesso a elementos de um vetor ou de uma matriz pode ser
realizado de diversas maneiras.
17
Dentre elas, podemos citar:
• a utilização explícita dos índices do elemento a ser acessado,
• a utilização do símbolo : (dois pontos)
• a utilização do símbolo $
Vamos considerar o vetor linha v = [1 2 3 4 5 6 7]. O acesso a um
elemento deste vetor é feito de forma convencional, o índice do vetor
indicando qual elemento que está sendo acessado.
Assim,
-->v= [1 2 3 4 5 6 7]
v =
1. 2. 3. 4. 5. 6. 7.
-->v(1);
// acesso ao primeiro elemento de v
O símbolo : permite definir formas compactas de acesso a
elementos de um vetor. Por exemplo,
-->v(2:4);
// acesso aos elementos 2, 3 e 4 de v
-->v(:);
// acesso a todos os elementos de v
-->v(1:2:7);
// acesso aos elementos ímpares de v
enquanto o símbolo $ permite acessar o último elemento do vetor,
-->v($)
// acesso ao último elemento de v
ans =
7.
Em relação as MATRIZES, temos:
-->// Definindo uma matriz A
-->A = [1 2 3; 4 5 6]
A =
18
1. 2. 3.
4. 5. 6.
-->A(1,2);
// Acessando o elemento da primeira linha e
segunda coluna de A
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);
Considerando a matriz A do exemplo anterior, o comando A(:,3),
permite acessar todos os elementos da terceira coluna da matriz A,
-->A(:, 3);
// Todos os elementos da terceira coluna da matriz A
enquanto o comando A(2,:) permite acessar todos os elementos da
segunda linha da matriz A,
-->A(2,:);
// Todos os elementos da segunda linha da matriz A
-->A($);
// Acesso ao último elemento de A
-->A(1);
// Primeiro elemento de A
-->A(5);
// Quinto elemento de A
-->A(:);
// Todos os elementos armazenados por coluna
É possível 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,
-->A(1,2) = 10
// Atribuir a A(1,2) o valor 10
A =
1. 10. 3.
4. 5.
6.
19
Depois, atribuímos os valores [-1; -2] aos primeiro e segundo
elementos da segunda coluna da matriz A,
-->A([1 2], 2) = [-1; -2]
// A(1,2) = -1 e A(2,2) = -2
A =
0. - 1.
0. - 2.
Finalmente, modificamos os elementos A(1,1) e A(1,2) da matriz A.
-->A(:,1) = [8;5]
// A(1,1) = 8 e A(1,2) = 5
A =
8. - 1. 3.
5. - 2. 6.
5.2 Operações com vetores e matrizes
SÍMBOLO 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
As operações envolvendo os operadores ’, +, -, * e / já foram
apresentadas em parágrafos anteriores. Os outros operadores mostrados
na Tabela serão apresentados nessa Seção. Vamos analisar a utilização do
operador \. Para isso, definimos um sistema de equações lineares,
20
a1,1 x1  a1,2 x2    a1,n xn  b1
a2,1 x1  a2,2 x2    a2,n xn  b2
...............................................
an,1 x1  an,2 x2    an, n xn  bn
Que pode ser escrito na forma matricial
Ax=b
Onde
 a1,1 a1,2
a
a2,2
2,1
A= 


 an ,1 an ,2
... a1,n 
... a2,n 
com


an,n 
 x1 
x 
2
x=  
 
 
 xn 
e
 b1 
b 
2
b=  
 
 
bn 
Nas expressões anteriores, A  nn é a matriz dos coeficientes,
x  n1 é o vetor das incógnitas e b  n1 é o vetor de termos
independentes.
Resolver um sistema linear é obter o valor do vetor x. Na situação
mais simples, a matriz A -1 é não-singular (admite inversa) e a solução,
única, é dada pela expressão:
--> x = inv(A) * b
Seja o sistema de equações dado:
 2 x1  3 x2  7

 x1  4 x2  2
Temos:
-->inv(A)
//A admite inversa
ans =
21
0.3636364 0.2727273
0.0909091 - 0.1818182
-->B=[7; -2]
// vetor B
B =
7.
- 2.
-->x=inv(A)*B
// Solução do sistema linear
x =
2.
1.
O mesmo resultado pode ser encontrado utilizando-se o operador \.
Temos, então,
-->x=A\B //Resolução de Ax = b usando o operador \
x =
2.
1.
É 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, é
utilizado com outros operadores (*, \, /, ^) para realizar operações
elemento a elemento de vetores ou de matrizes. A sessão do Scilab a
seguir mostra exemplos dessas operações utilizando vetores.
-->x = [1 3 4 6];
//Definição do vetor x
-->y = [2 4 6 8];
//Definição do vetor y
-->x .* y;
// Multiplicação elemento a elemento
-->x * y
!--error 10
Multiplicação incoerente.
22
A operação .* gera um vetor formado pelo produto dos elementos
dos vetores x e y. Apenas para fixar conceitos, verificamos que a operação
x * y não pode ser realizada. Continuando com os exemplos, usamos os
operadores ./ para dividir os elementos do vetor x pelos elementos do
vetor y,
-->x ./ y ;
// elementos do vetor x divido pelos elementos do vetor y
-->x .\ y;
// elementos do vetor y divido pelos elementos do vetor x
A utilização do operador .^ é mostrada nos exemplos apresentados
em seguida,
-->x .^ y;
-->y .^ x;
Vamos verificar também a utilização do operador . (ponto) em
conjunção com os operadores (*, \, /, ^) quando se trata de matrizes. Para
isso, vamos considerar a matriz quadrada A  33 ,
1 2 3
A   4 5 6
7 8 9 
A sessão do Scilab a seguir mostra exemplos dessas operações
utilizando matrizes.
-->A = [ 1 2 3; 4 5 6; 7 8 9];
// Definindo a matriz A
A =
1. 2. 3.
4. 5. 6.
7. 8. 9.
-->A .* A;
-->A ^ 2;
-->A * A;
-->A ./ A;
23
Para fixar conceitos, vamos considerar a matriz quadrada B 
33
2 2 2
B   2 2 2 
 2 2 2 
-->B = [ 2 2 2; 2 2 2; 2 2 2];
// Definição da matriz B
-->A ./ B;
-->A .^ B;
-->A .\ B;
que equivale á operação
-->B ./ A;
6 Programação no Scilab
6.1 Arquivos de Scripts
Um arquivo de script é um arquivo texto que contém uma sequencia de
comandos para ser executada. O Scilab executa esses comandos
automaticamente da mesma forma como se fossem digitados na linha de
comando. O editor de texto do Scilab é o SciNotes.
6.2 Criação de arquivos de script
Para criar um arquivo de script clique no botão
ferramentas ou no menu Aplicativos » SciNotes:
na barra de
Crie um arquivo script com os comandos:
24
Salve com o nome ‘Soma.sce’ no menu Arquivo » Salvar. Escolha a pasta
que preferir.
Por padrão o Scilab salva os arquivos de script na pasta onde foi instalado,
porém você pode alterar este caminho clicando em Arquivo » Alterar
diretório atual, ou no botão .
Na janela do arquivo script clique em
para executar os comandos. O
resultado aparecerá no console do Scilab:
6.3 Estruturas for e if
6.3.1 O loop for
A forma geral do comando for é:
for variável = vetor linha
instrução 1
instrução 2
...
instrução n
end
25
Por exemplo, vamos fazer a soma 1+2+3+...+10:
Clique no botão executar para ver o resultado.
6.3.2 O comando de decisão if-then-else
O comando if tem a forma geral:
if condição1 then
sequencia de instruções 1
elseif condicao2
sequencia de instruções 2
...
else
sequencia de instruções n
end
Exemplo:
26
6.4 Funções criadas pelo usuário
A forma geral de uma função é:
function [y1, y2, ..., ym]=nomedafunção(x1, x2, ..., xn)
comandos ...
endfunction
Como exemplo, vamos criar a função somadif:
No console do Scilab chamamos a função somadif(a, b) executando o
arquivo que a contém:
exec(‘somadif.sce’).
27
Depois passamos os dois parâmetros necessários para a função somadif(a,
b). Esta função retornará dois valores, a soma a  b e a diferença a  b , que
vamos armazenar nas variáveis s e d :
6.5 Implementação Eliminação de Gauss
Vamos implementar o Método da Eliminação de Gauss para resolução de
sistemas lineares. Isso será feito em duas etapas:
1) Escalonamento da matriz dos coeficientes
Algoritmo:
Para k  1,..., n  1
Para i  k  1,..., n
m
aik
akk
aik  0
Para j  k  1,..., n
aij  aij  makj
bi  bi  mbk
28
Consideremos o sistema de equações lineares:
3x1  2 x2  4 x3  1

 x1  x2  2 x3  2
4 x  3x  2 x  3
2
3
 1
 3 2 4  x1   1 

   
 1 1 2  x2    2 
 4 3 2  x   3 

 3   
Aplicando a função que acabamos de criar:
29
2) Resolução do sistema
Algoritmo:
xn  bn / ann
Para k  (n  1),..., 2,1
s0
Para j  (k  1),..., n
s  s  akj x j
xk  (bk  s) / akk
Vamos incluir o código para resolução do sistema na função elimGauss():
Chamando a função elimGauss(A, b) na console do Scilab, temos como
resultado:
30
31