Apostila LMC-scilab

L ABORAT ÓRIO DE M ATEM ÁTICA C OMPUTACIONAL – S CILAB
Luiza Amalia Pinto Cantão

luiza@sorocaba.unesp.br
Sumário
1 Introdução ao Ambiente Scilab 2

1.1 O Ambiente Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Variáveis Especiais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Arquivos *.sce de Comandos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 Álgebra Linear Numérica 7

2.1 Vetores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2.1 Matrizes Padrão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3 Acesso aos elementos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.4 Matemática Matricial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.5 Uso de Scilab na Solução de Sistemas Lineares: Métodos Diretos . . . . . . . . . . . . . . . . . 14
2.6 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3 Projeto de Programação 17
3.1 Operadores Relacionais e Lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.1.1 Operadores Relacionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.1.2 Operadores Lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2 O Loop for e while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.3 Estrutura if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.4 Definição de Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.5 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4 Gráficos no Scilab 27
4.1 A Janela Gráfica do Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.2 Gráficos Bi-dimensionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.2.1 Outros Comandos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.3 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5 Ajuste de Curvas em Ambiente Scilab 35

5.1 Definindo a Função de Ajuste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.2 Spline Cúbicas em Ambiente Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.3 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
6 Gráficos Tri-Dimensionais 44
6.1 Gráficos Tri-dimensionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.1.1 Gráficos 3-D Especiais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.2 Detalhes da Função plot3d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
6.2.1 Função eval3d e eval3dp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
6.2.2 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
6.2.3 Outro Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
6.3 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
7 Exercı́cios Adicionais 50
Referências Bibliográficas 53
1
CAPÍTULO 1
Introdução ao Ambiente Scilab
1.1 O Ambiente Scilab

O Scilab é um ambiente utilizado no desenvolvimento de programas para a resolução de problemas numéricos.
Vamos conhecer um pouco mais sobre o seu ambiente de trabalho.
Tendo iniciado o programa (isto depende do sistema operacional), você verá mensagens do fabricante e um
pequeno “prompt” de comando aguardando alguma ação sua:
-----------------------------------------------
scilab-5.0.3
Consortium Scilab (DIGITEO)

Copyright (c) 1989-2008 (INRIA)
Copyright (c) 1989-2007 (ENPC)
------------------------------------------------
Startup execution:
loading initial environment
-->
A flecha --> indica que o Scilab está pronto para receber comandos e o cursor é o prompt inicial. Na janela
do Scilab há um menu horizontal com seis opções: File, Edit, Preferences, Control, Applications e ?. Utilizando
o mouse escolha uma das opções.
• File – possui oito sub-opções (apresentaremos as quatro mais importantes):
– Execute: executa o conteúdo de arquivos (roda o programa implementado).

– Open a file: Abre o arquivo do seu programa no editor de texto do Scilab.
– Change current directory: Muda o diretório em que o Scilab foi aberto para o diretório do arquivo
(programa).
– Quit: permite sair do ambiente Scilab de forma natural.
Variáveis Especiais CAPÍTULO 1. INTRODUÇÃO AO AMBIENTE SCILAB
• Edit – comandos semelhantes ao editor de texto do Microsoft Office ou Open Office (cut, copy, paste,
select all);
• Preferences – o comando mais importante desta opção é o Clear Console que limpa a janela de execução
do ambiente Scilab.
• Control – possui três sub-opções cuja utilidade dos dois primeiros itens pode ser observada na seqüência
de comandos abaixo:
--> // pressione Ctrl-c e <enter>

-1-> // leva ao prompt de 1o. nivel
-1-> // pressione Ctrl-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
-->
– Interrupt – interrompe a execução de um programa.
• Applications – aplicativos do ambiente Scilab:
– Editor – abre um editor de texto próprio para programação em ambiente Scilab.
• ? – informações e ajuda sobre o ambiente Scilab. Esta possui quatro sub-opções:
– Scilab Help: informações sobre os comandos do ambiente Scilab.

– Scilab Demonstration: Demonstração de alguns comandos deste ambiente de trabalho.
– Web Links: sites relacionados ao Scilab.
– About Scilab: mostra a licença de uso do programa.
Ainda na janela do Scilab há alguns icones abaixo do menu descrito acima. Estes icones são atalhos para
as funções mais usadas no menu acima.
1.2 Variáveis Especiais

Algumas variáveis assumem valores pré-definidos no Scilab e podem ser vistas usando o comando who.
--> who
Your variables are:
help about home matiolib

parameterslib simulated_annealinglib genetic_algorithmslib umfpacklib
fft scicos_pal %scicos_menu %scicos_short
%scicos_help %scicos_display_mode modelica_libs scicos_pal_libs
%scicos_lhb_list %CmenuTypeOneVector %scicos_gif %scicos_contrib
scicos_menuslib scicos_utilslib scicos_autolib spreadsheetlib
demo_toolslib development_toolslib scilab2fortranlib scipadinternalslib
scipadlib soundlib texmacslib with_texmacs
3
Variáveis Especiais CAPÍTULO 1. INTRODUÇÃO AO AMBIENTE SCILAB
tclscilib m2scilib maple2scilablib metanetgraph_toolslib

metaneteditorlib compatibility_functilib statisticslib timelib
stringlib special_functionslib sparselib signal_processinglib
%z %s polynomialslib overloadinglib
optimizationlib linear_algebralib jvmlib iolib
interpolationlib integerlib dynamic_linklib guilib
data_structureslib cacsdlib graphic_exportlib graphicslib
fileiolib functionslib elementary_functionlib differential_equationlib
helptoolslib corelib PWD %F
%T %nan %inf COMPILER
SCI SCIHOME TMPDIR MSDOS
%gui %pvm %tk %fftw
$ %t %f %eps
%io %i %e %pi
using 34531 elements out of 5000000.

and 88 variables out of 9231.
Your global variables are:
%modalWarning demolist %helps %helps_modules

%driverName %exportFileName LANGUAGE %toolboxes
%toolboxes_dir
using 2966 elements out of 10999.

and 9 variables out of 767.
-->
Vejamos o significado das variávies mais recorrentes:
Variável O que significa Variável O que significa

p
%i Valor de (−1) %pi π = 3, 1415926...
%e Constante de Euler e = 2, 7182818... %eps precisão da máquina no qual o Scilab está instalado.
%inf Infinito %nan Not a number
Para saber em qual diretório o Scilab foi instalado, use a variável SCI e para saber em qual diretório o
Scilab foi aberto, use PWD. O resultado depende do sistema operacional em que o Scilab foi instalado.
-->SCI // Diretorio onde o Scilab foi instalado

SCI =
/home/luiza/scilab-5.0.3/share/scilab
-->PWD // Diretorio onde o Scilab foi lancado

PWD =
/home/luiza
4
Arquivos *.sce de Comandos CAPÍTULO 1. INTRODUÇÃO AO AMBIENTE SCILAB
-->home // Mesmo valor da variavel PWD

home =
/home/luiza
-->
1.3 Arquivos *.sce de Comandos

Para problemas simples, é mais rápido e eficiente introduzir seus comandos no prompt do Scilab. Mas,
se o número de comandos é grande, ou se você deseja mudar o valor de uma ou mais variáveis e re-executar
alguns comandos, pode ser trabalhoso e/ou tedioso introduzir os comandos no prompt. O Scilab apresenta
uma solução simples para esse problema: você pode colocar os comandos do Scilab em um arquivo de texto
simples (pode-se fazer uso do Editor do Scilab) e depois abrir este arquivo e executá-lo no Scilab.
Atenção: no Scilab, ponto-e-vı́rgula no final de um comando inibe a apresentação de seu resultado e,
qualquer caracter após o uso de // é ignorado pelo Scilab pois este é interpretado como comentário. Também
é importante salientar que os comentários (e os nomes das variáveis e funções utilizados no Scilab) NÃO
devem ter qualquer tipo de acentuação.
Abra o Editor de texto SciPad através do menu do Scilab e digite os comandos abaixo.
// Erro e Estabilidade
// LMC -- 1o. programa
x = input(’Entre com o valor de x’); // Entrada do valor de x via teclado!

S = 0; // Variavel que recebera o valor somatorio.
format(’v’, 100); S // no. de elementos na representacao de ’S’

// ’v’: formato padrao de uma variaval numerica
for (i = 1:30000) // somatorio de 1 ate 30000
S = S + x;
end // Final do ’for’
Salve este arquivo no diretório LMC que foi criado. Para isso, clique com o mouse no menu File e selecione
Save as. Atribua o nome soma ex4.sce e volte ao ambiente Scilab executando os passos abaixo:
-->pwd // verifique se esta no diretorio onde gravou o 1oTeste.sce
-->exec(’soma.sce’) // executa o programa ’1oTeste.sce’
O comando exec(’nome-do-arquivo.sce’) executa o programa gerado.

Execute o programa acima para x = 0.5 e x = 0.11 !
√ √
Tarefa: Desenvolva um programa em Scilab para calcular ( 3 · 3) usando o comando format com 100
dı́gitos.
Um outro programinha para se testar com uma estrutura diferente da apresentada abaixo, é para calcular o
número de faltas possı́veis no semestre (faltas.sce)!
5
Arquivos *.sce de Comandos CAPÍTULO 1. INTRODUÇÃO AO AMBIENTE SCILAB
// Primeiro teste de LMC -- Controle de presenca

// Uso de uma ’Regra de Tres Simples’ para este calculo
a = 2; // a = aulas por semana

b = 15; // b = semanas de aulas no semestre
c = a*b; // c = horas-aulas do semestre
x = (30*c)/100 // 30 --- porcentagem de faltas permitidas

// 100 -- porcentagem total de aulas
// x ---- no. de aulas que o aluno pode faltar
y = int(x/2) // y ---- no. de dias que o aluno pode faltar

// int(.) no. inteiro de dias (em cada dia de aula sao dadas duas aulas)
Teste o programa acima para diferentes valores de a (outras disciplinas) !!!! Por exemplo, para a disciplina
de Cálculo Numérico e Computacional.
6
CAPÍTULO 2
Álgebra Linear Numérica
Vamos começar com as estruturas sobre as quais toda a filosofia Scilab (e linguagens numéricas) está
baseada.
2.1 Vetores
Para criar um vetor no Scilab é muito simples. Apenas deve ser tomado cuidado com a diferenciação entre
vetores linha e vetores coluna. Experimente:
--->v = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

v
! 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. !
Você acaba de criar um vetor linha! Neste caso, as vı́rgulas são desnecessárias; poderı́amos simplesmente
usar
--->v = [1 2 3 4 5 6 7 8 9 10]
v
! 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. !
que o resultado seria o mesmo.

Para os vetores coluna temos três opções: criá-los diretamente, usar o operador de transposição, ’ (apóstrofo)
ou simplesmente pular uma linha para cada elemento. Acompanhe:
--->v = [1; 2; 3]
v
! 1. !
! 2. !
! 3. !
ou ainda
-->v = [1 2 3]’
v
! 1. !
! 2. !
! 3. !
Vetores CAPÍTULO 2. ÁLGEBRA LINEAR NUMÉRICA
e finalmente
-->v = [1
-->2
-->3]
v
! 1. !
! 2. !
! 3. !
Note que neste último caso, o Scilab ficou esperando que se completasse o vetor com “ ] ”.
Um jeito prático de criar vetores igualmente espaçados é usando o operador “ : ”. Observe:
-->u =1:10
u
! 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. !
ou ainda
-->u = 0:0.1:1
u
column 1 to 10
! 0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 !
column 11
! 1. !
onde podemos especificar um incremento (no caso, 0.1). Observe que, neste caso temos: u = inicio:incremento:final
ou u = inicio:decremento:final (teste u = 1:-0.1:0).
Uma outra maneira de construir um vetor linha é usando a função linspace cujos elementos desta função
são:
linspace( primeiro_valor, ultimo_valor, numero_de_elementos )
Se o número de elementos é omitido, a função gera automanticamente 100 elementos.
--> x = linspace( 0, %pi)

--> x = linspace( 0, %pi, 11)
Veja que, a notação “ : ” permite especificar o intervalo entre os pontos, mas não o número de pontos. Por
outro lado, a função linspace permite especificar o número de elementos mas não o intervalo entre os pontos.
Comandos Descrição
x = inicio:fim Cria um vetor linha começando em inicio, incrementa em um
e pára em fim (ou antes).
x = inicio:incremento:fim Cria um vetor linha começando em inicio, incrementa em incremento
e pára em fim (ou antes).
x = linspace(inicio,fim,n) Cria um vetor linha, com espaçamento linear, começando em inicio
e terminando em fim com n elementos.
x = linspace(inicio,fim) Cria um vetor linha, com espaçamento linear, começando em inicio
e terminando em fim com cem (100) elementos.
Tabela 2.1: Comandos básicos para a construção de vetores.
8
Matrizes CAPÍTULO 2. ÁLGEBRA LINEAR NUMÉRICA
2.2 Matrizes
O caso matricial é igualmente simples. Siga o exemplo:
-->A = [1 2 3 4
-->5 6 7 8
-->9 10 11 12]
A
! 1. 2. 3. 4. !
! 5. 6. 7. 8. !
! 9. 10. 11. 12. !
-->size(A)
ans
! 3. 4. !
-->
onde acabamos de criar uma matriz 3 × 4. A função size(.) mostra o tamanho da sua matriz ou vetor.
Note que podemos utilizar o operador “ : ” em combinação com o que foi visto até agora. Tente o comando
--> A = [1:5, 9:-1:5; 0:0.25:1, 1:-0.25:0]
Interprete o que aconteceu!
2.2.1 Matrizes Padrão

Dada a utilidade deste tipo de matrizes, o Scilab contém funções para a criação de matrizes padrão. Esse
tipo de matriz inclui aqueles cujos elementos são todos iguais a zero ou a um, matriz identidade, matrizes de
números aleatórios, matrizes diagonais e cujos elementos são uma constante dada.
-->A = ones(3,2) // ones(.) gera uma matriz com todos os elementos iguais a 1
A
! 1. 1. !
! 1. 1. !
! 1. 1. !
-->B = zeros(2,6) // zeros (.) gera matrizes com todos os elementos iguais a 0
B
! 0. 0. 0. 0. 0. 0. !
! 0. 0. 0. 0. 0. 0. !
-->C = eye(3,3) // eye(.) gera uma matriz identidade

C
! 1. 0. 0. !
! 0. 1. 0. !
! 0. 0. 1. !
-->D = eye(2,4)
D
! 1. 0. 0. 0. !
9
Matrizes CAPÍTULO 2. ÁLGEBRA LINEAR NUMÉRICA
! 0. 1. 0. 0. !
-->E = eye(4,2)
E
! 1. 0. !
! 0. 1. !
! 0. 0. !
! 0. 0. !
-->A = rand(5,5)
A
! 0.2113249 0.6283918 0.5608486 0.2320748 0.3076091 !
! 0.7560439 0.8497452 0.6623569 0.2312237 0.9329616 !
! 0.0002211 0.6857310 0.7263507 0.2164633 0.2146008 !
! 0.3303271 0.8782165 0.1985144 0.8833888 0.312642 !
! 0.6653811 0.0683740 0.5442573 0.6525135 0.3616361 !
O comando rand(m, n) cria uma matriz m × n com entradas aleatórias no

intervalo [0, 1).
-->a = 1:4 // Comece com um vetor simples

a
! 1. 2. 3. 4. !
-->diag(a) // diag(.) coloca os elementos na diagonal principal

ans
! 1. 0. 0. 0. !
! 0. 2. 0. 0. !
! 0. 0. 3. 0. !
! 0. 0. 0. 4. !
-->diag(a,1) // Coloca os elementos uma posicao acima da diagonal

ans
! 0. 1. 0. 0. 0. !
! 0. 0. 2. 0. 0. !
! 0. 0. 0. 3. 0. !
! 0. 0. 0. 0. 4. !
! 0. 0. 0. 0. 0. !
-->diag(a,-2) // Coloca os elementos duas posicoes abaixo da diagonal

ans
! 0. 0. 0. 0. 0. 0. !
! 0. 0. 0. 0. 0. 0. !
! 1. 0. 0. 0. 0. 0. !
! 0. 2. 0. 0. 0. 0. !
! 0. 0. 3. 0. 0. 0. !
! 0. 0. 0. 4. 0. 0. !
10
Acesso aos elementos CAPÍTULO 2. ÁLGEBRA LINEAR NUMÉRICA
A função diag(.) cria matrizes diagonais em que um vetor determinado pode ser colocado em qualquer
posição paralela à diagonal principal ou na própria diagonal principal.
Com essas matrizes padrão, há várias formas de se criar uma matriz em que todos os elementos apresentam
o mesmo valor. Execute os próximos comandos e verifique o que acontece!
--> d = %e; // Escolha do numero ’e’ para este exemplo

--> d*ones(3,4) // Metodo mais lento (multiplicacao de vetor por escalar)
--> d+zeros(3,4) // Metodo mais lento (adicao de escalar a vetor)
--> d(ones(3,4)) // Metodo mais rapido (enderecamento vetorial)
Função Propósito
zeros(n) Gera uma matriz n × n com elementos iguais a zero.
zeros(n,m) Gera uma matriz n × m com elementos iguais a zero.
one(n) Gera uma matriz n × n com elementos iguais a um.
one(n,m) Gera uma matriz n × m com elementos iguais a um.
eye(n) Gera uma matriz identidade n × n.
eye(n,m) Gera uma matriz identidade n × m.
diag(v) Gera uma matriz cujos elementos do vetor v ficam na diagonal principal.
rand(n,m) Gera uma matriz n × m com valores aleatórios em (0, 1);
size(.) Retorna dois valores, especificando o número de linhas e o de colunas de uma matriz ou vetor em (.).
Tabela 2.2: Funções Scilab para gerar matrizes padrão.
2.3 Acesso aos elementos

O Scilab dá ao usuário vários modos de acesso aos vetores e matrizes. O mais simples deles é sim-
plesmente digitando o nome do vetor/matriz criado. Caso você não se lembre do que criou, use o comando
whos.
Há duas formas de usar o comando whos:
• whos(): Lista todas as funções do Scilab, apresentando o nome da função, o tipo (constante, variável,
booleana, e assim por diante), o tamanho e os bytes usado para a função apresentada.
• whos: Neste caso é preciso especificar o tipo de função que você deseja verificar (veremos um exemplo
no final desta seção).
--> A
A
! 1. 2. 3. 4. !
! 5. 6. 7. 8. !
! 9. 10. 11. 12. !
Para acessar a matriz um elemento por vez, use parênteses:
--> v = [7; 19; 21];

-->v(2)
ans
19.
-->A(2,3)
ans
7.
-->A(3,2)
11
Matemática Matricial CAPÍTULO 2. ÁLGEBRA LINEAR NUMÉRICA
ans
10.
-->A(5,7)
!--error 21
invalid index
--> whos -type constant
Name Type Size Bytes
ans constant 1 by 1 24
v constant 3 by 1 40
A constant 3 by 4 112
%scicos_display_mode constant 1 by 1 24
%scicos_contrib constant 0 by 0 16
%nan constant 1 by 1 24
%inf constant 1 by 1 24
%eps constant 1 by 1 24
%io constant 1 by 2 32
%i constant 1 by 1 32
-->
Note que se você tenta acessar elementos que não existem, o programa reclama.
Porém, a forma mais poderosa de acesso (e mais rápida) é usando o conceito de sub-matrizes. Para
usarmos partes de matrizes em operações, usamos novamente o operador “ : ”. Suponha que criamos uma
matriz do tipo:
-->A = rand(6,6)
A
! 0.0437334 0.7783129 0.8415518 0.5618661 0.3873779 0.2615761 !
! 0.4818509 0.2119030 0.4062025 0.5896177 0.9222899 0.4993494 !
! 0.2639556 0.1121355 0.4094825 0.6853980 0.9488184 0.2638578 !
! 0.4148104 0.6856896 0.8784126 0.8906225 0.3435337 0.5253563 !
! 0.2806498 0.1531217 0.1138360 0.5042213 0.3760119 0.5376230 !
! 0.1280058 0.6970851 0.1998338 0.3493615 0.7340941 0.1199926 !
Podemos trabalhar em partes isoladas da matriz. Experimente:
-->A(2:4, 3:5)
Descreva o que ocorreu.

Naturalmente este processo pode ser usado para atribuição de matrizes (ou vetores). Porém, antes de
executar, tente prever o resultado.
-->A(3, 3:5) = [1 2 3]
2.4 Matemática Matricial

Para executar operações algébricas matriciais, seguiremos os seguintes exemplos:
12
Matemática Matricial CAPÍTULO 2. ÁLGEBRA LINEAR NUMÉRICA
Comandos Descrição
A (r,c) Fornece a sub-matriz A cujas linhas são definidas pelo vetor
de ı́ndice r e cujas colunas são definidas pelo vetor c.
A (r,:) Fornece a sub-matriz A cujas linhas são definidas pelo vetor
de ı́ndice r e inclui todas as colunas.
A (:,c) Fornece a sub-matriz A cujas colunas são definidas pelo vetor
de ı́ndice c e inclui todas as linhas.
A (:) Fornece todos os elementos de A em um vetor coluna, coluna a coluna.
Tabela 2.3: Referência a sub-matrizes de uma matriz.
--> A = rand(5, 3); //Exemplos de operacoes vetoriais/matriciais

--> B = rand(3, 5);
--> v1 = rand(5, 1);
--> v2 = rand(1, 5);
// soma, subtracao, multiplicacao e transposicao

--> C = A*A’+B’*B
--> D = A’*A*v1(1:3)
--> E = v1 * v2
// operacoes elemento a elemento

--> v3 = v1 + v2’
--> v4 = v1 .* v2’
--> v5 = v2 .^ 2
--> F = A .* B’
// sub-matrizes!
--> G = C(2:4, 2:4) * v2(2:4)’
--> C(1:3, 2) = G
Analise os resultados e certifique-se que entendeu o endereçamento das matrizes e vetores! Isto é muito
importante!!!
Observe a tabela 2.4.
Operações com elementos Dados representativos

de vetores e matrizes A = [a1 a2 . . . an ]
dados B = [b1 b2 . . . bn ], c ∈ R
Adição a escalar A + c = [a1 + c a2 + c . . . an + c]
Subtração por escalar A − c = [a1 − c a2 − c . . . an − c]
Multiplicação por escalar A ∗ c = [a1 ∗ c a2 ∗ c . . . an ∗ c]
Divisção por escalar A/c = [a1 /c a2 /c . . . an /c]
Soma de vetores A + B = [a1 + b1 a2 + b2 . . . an + bn ]
Multiplicação de vetores A. ∗ B = [a1 . ∗ b1 a2 . ∗ b2 . . . an . ∗ bn ]
Divisão de vetores pela direita A./B = [a1 ./b1 a2 ./b2 . . . an ./bn ]
Divisão de vetores pela esquerda B.\A = [a1 ./b1 a2 ./b2 . . . an ./bn ]
Potenciação de vetores A.ˆc = [a1 ˆc a2 ˆc . . . an ˆc]
c.Â = [câ1 câ2 . . . cân ]
A.ˆB = [a1 ˆb1 a2 ˆb2 . . . an ˆbn ]
Tabela 2.4: Operações básicas aplicadas a elementos de vetores e matrizes.
Tomando
1 2 3 4 5 6
A= , B= , e c=2
3 2 1 6 5 4
13
Uso de Scilab na Solução de Sistemas Lineares: Métodos Diretos
CAPÍTULO 2. ÁLGEBRA LINEAR NUMÉRICA
execute as operações apresentadas na Tabela 2.4.
2.5 Uso de Scilab na Solução de Sistemas Lineares: Métodos

Diretos
Considere o sistema Ax = b, associado à matriz A e ao vetor b, definidos como segue:
--> A = [ 3 -2 2; 1 1 1; 2 1 -1 ];
--> b = [ -3 -4 -3 ]’
Apresentamos a seguir algumas funções definidas no Scilab relacionados à Solução de Sistemas Lineares
– Métodos Diretos. Mais informações podem ser obtidas pelo recurso help seguido da função de interesse (por
exemplo, help lu mostra detalhes sobre o cálculo da decomposição LU de uma matriz quadrada).
Para resolver o sistema acima, temos algumas maneiras:
1. Usando o operador \ : Este operador é interno ao Scilab e funciona de forma muito simples:
--> x = A \ b // Calcula a solucao do sistema Ax = b (se existir!).
2. Outra forma é usando a Decomposição LU . Para obter a decomposição A = LU , e resolver o sistema a

partir dela use:
-->[ L, U ] = lu(A)
--> y = L \ b
--> x = U \ y
Note que o Scilab não confundiu U com u, o que indica que o programa é sensı́vel ao caso (maiúsculas
e minúsculas). Repare também na forma como o Scilab retornou dois argumentos (L e U ) da função,
o que é uma caracterı́stica incomum em linguagens de programação, porém corriqueira em linguagem
numérica, como o Scilab. Também poderı́amos ter feito a operação de forma direta:
--> x = U \ ( L \ b )
Ou ainda:
--> [ L, U, P ] = lu(A) // Calcula a decomposicao LU de A
Neste caso P é a matriz de permutação do pivoteamento usado no cálculo dos fatores L e U . A matriz P
multiplicada por A tem o efeito das trocas de linhas efetuadas quando o pivoteamento é realizado.
3. Cálculo da função inversa da matriz A: Um Sistema Linear tem solução única se a matriz A for inversı́vel.
Uma maneira de testar esta condição é usando a função inv(.) do Scilab:
--> IA = inv(A)
--> IA * A
--> x = IA * b
4. Uma outra função do Scilab interessante é a que calcula o valor do determinante de uma matriz (det(.)):
-->d = det(A)
Pergunta: Qual a relação existente entre det(A) e det(U) ?
14
Exercı́cios CAPÍTULO 2. ÁLGEBRA LINEAR NUMÉRICA
(a) Construa um vetor linha r1 com elementos

2.6 Exercı́cios 2, −1, 5.
1. Digite as seguintes matrizes no ambiente (b) Construa um vetor linha r2 com elementos
Scilab: 7, 9, −3 .

4 −3
 
1 2 4
 
5
 (c) Construa uma matriz M cujas linhas são r1
A= 2 1 , B =  2 4 1 , C =  8  e r2 sem repetir a entrada de dados feita
0 6 0 1 5 7 anteiormente.
(d) Descreva o resultado de: 3 · r1.
(a) Mostre somente a segunda coluna de A; (e) Descreva o resultado de: r1 + r2.
(b) Mostre o elemento (3, 2) de A; (f) Descreva o resultado de: [r1; r1 − r2; r2].
(c) Mostre somente a terceira coluna de B; 5. Responda às questões seguintes considerando a
(d) Mostre as duas primeiras colunas de B; matriz abaixo.
(e) Mostre as duas últimas linhas de A;

 
1.1 −3.2 3.4 0.6
c =  0.6 1.1 −0.6 3.1 
2. Considere as matrizes A, B e o vetor C do
1.3 0.6 5.5 0.0
exercı́cio anterior. Defina uma nova matriz D
com o mesmo conteúdo de A. Faça a mudança (a) Qual o tamanho de c ?
ou execute a operação - solicitada: (b) Qual o valor de (2, 3) ?
(a) Atribua ao elemento (1, 1) de D o valor 12; (c) Apresente todos os ı́ndices cujo valor seja
0.6.
(b) Atribua ao elemento (3, 2) de D o valor −8;
6. Determine o tamanho das seguintes matrizes.
(c) Execute o comando E = [D C]. Descreva o
Verifique suas respostas criando as matrizes no
conteúdo de E em termos de D e C;
Scilab.
(d) Execute o comando F = [D B]. Descreva o
conteúdo de F em termos de D e B; (a) u = [10 20*(%i) 10+20];
(b) v = [-1; 20; 3];
(e) Execute o comando G = [E; B]. Descreva
o conteúdo de G em termos de E e B; (c) w = [1 0 -9; 2 -2 1; 1 2 3];
(d) x = [u’ v];
3. Para criar um vetor coluna no Scilab digita-se
(e) y(3,3) = -7;
da seguinte maneira: [1; 2; 3]. Execute os co-
(f) z = [zeros(4,1) ones(4,1) zeros(1,4)’];
mandos abaixo no Scilab:
(g) v(4) = x(2,1);
(a) Construa um vetor coluna c1 com elemen-
7. Qual o valor de w(2,1) ?
tos: 0, −1, 3, 5;
(b) Construa um vetor coluna c2 com elemen- 8. Qual o valor de x(2,1) ?
tos: 4, −2, 0, 7; 9. Qual o valor de y(2,1) ?
(c) Construa uma matriz H cujas colunas são 10. Qual o valor de v(3) após a execução da ex-
c1 e c2 sem repetir a entrada dos elemen- pressão (g)?
tos;
11. Considere a matriz do exercı́cio (1). Determine o
(d) Construa uma matriz K onde as duas pri-
conteúdo das seguintes submatrizes:
meiras colunas são compostas pelos ele-
mentos de c1 e a terceira coluna com ele- (a) c(2,:)
mentos de c2. Novamente, execute o solici- (b) c(6)
tado sem repetir a entrada de dados. (c) c(1:2, 2:4)
4. Para criar um vetor linha fazemos: [1 2 3]. Exe- (d) c([1,3],2)
cute no Scilab os comandos abaixo: (e) c([2 2], [3 3])
15
Exercı́cios CAPÍTULO 2. ÁLGEBRA LINEAR NUMÉRICA
(f) c([2 2 2], [3 3 3]) 15. Duas quantias de dinheiro x1 e x2 somam

(g) c([1 2 2], [3 3]) $600, 00. A quantia x1 é o dobro de x2 . Resolva
o sistema usando a função LU do Scilab.
12. Determine o conteúdo da matriz a após a exe-
cução das seguintes declarações: 16. São investidos $8000, 00. Parte a 6% de taxa de
juros e parte a 11% de taxa de juros. Quanto de-
(a) a = [1 2 3; 4 5 6; 7 8 9]; veria ser investido em cada modalidade se um to-
a([3 1], :) = a([1 3],:); tal de 9% é desejado ? Resolva o sistema usando
(b) a = [1 2 3; 4 5 6; 7 8 9]; a função LU do Scilab.
a([1 3], :) = a([2 2],:); Resposta: x1 = $3200, 00 para 6% e x2 =
(c) a = [1 2 3; 4 5 6; 7 8 9];
$4800, 00 para 9%.
a([2 2],:); 17. Encontre a, b e c tais que o gráfico do cı́rculo com

equação x2 + y 2 + ax + bx + c = 0 passe pelos
13. Determine o conteúdo da matriz a após a
pontos (1, 5), (4, 4) e (3.1). Resolva o sistema
execução das seguintes declarações:
usando a função LU do Scilab.
(a) a = eye(3,3); Resposta: a = −4, b = −6 e c = 5.
b = [1 2 3];
a(2,:) = b; 18. A quantia de $16500, 00 foi investida em três con-
tas, resultando um lucro anual de 5%, 8% e 10%,
(b) a = eye(3,3); respectivamente. A quantia investida a 5% era
b = [4 5 6]; igual á quantia investida a 8% mais o dobro da
a(:,3) = b’; quantia investida a 10%. Quanto foi investido
(c) a = eye(3,3); em cada conta se o total dos juros sobre o in-
vestimento foi de $1085, 00 ? Resolva o sistema
b = [7 8 9];
usando a função LU do Scilab.
a(3,:) = b([3 1 2]);
Resposta: $9500, 00 a 5%, $4500, 00 a 8% e
14. Resolva o seguinte sistema linear Ax = b, onde: $2500, 00 a 10%.
1 1 19. Encontre a, b e c tais que a equação da parábola
aij = , bi = , i, j = 1 : n
i+j−1 i y = ax2 +bx+c passe pelos pontos (1, 4), (−1, 6)
use n = 5, 10 e 15. Você pode explicar os e (2, 12). Resolva o sistema usando a função LU
resultados? Observe que a solução exata é do Scilab.
(1, 0, 0, . . . , 0)t Resposta: a = 3, b = −1 e c = 2.
16
CAPÍTULO 3
Projeto de Programação
Programar é fácil. Saber o que programar é difı́cil.a

a Citação de [3].
Uma das caracterı́sticas da linguagem numérica é a facilidade com que o usuário cria seus próprios progra-
mas.
Apesar de simples, a linguagem numérica disponibiliza a maioria das estruturas das linguagens de programação
convencionais. A diferença principal é que, na programação Scilab, não há necessidade da declaração prévia
dos tipos das variáveis que serão utilizadas ao longo do programa.
As linguagens numéricas, como é o caso do Scilab, é um interpretador de comandos. Os programas
escritos em linguagem numérica são executados em um tempo maior que os programas semelhantes escri-
tos em linguagens compiláveis. Por outro lado, a vantagem de linguagens numéricas advém da facilidade de
prototipação de programas e da disponibilidade de uma poderosa biblioteca de funções gráficas.
Neste propósito, abordaremos aqui a estrutura de programação em ambiente numérico, em especial, no
ambiente Scilab. Na seção 3.1 serão abordados os operadores relacionais e lógicos, na seção 3.2 a estrutura
de Loop, na seção 3.3 a estrutura if (condicional) e na seção 3.4 a definição de manipulação de funções em
ambiente Scilab.
3.1 Operadores Relacionais e Lógicos

Além das operações matemáticas convencionais, o Scilab também inclui operações relacionais e lógicas,
cuja finalidade é o de fornecer respostas do tipo verdadeiro ou falso a perguntas, usadas em estruturas de Loops
e condicionais.
No ambiente Scilab, a resposta para expressões lógicas produzem T se a resposta é verdadeira (true) e F
se a resposta for falsa (false)1 .
3.1.1 Operadores Relacionais

Os operadores relacionais do Scilab incluem todas as comparações habituais e são listados na Tabela 3.1.
Atenção: Os sı́mbolo = e == têm significados diferentes! O sı́mbolo == compara duas variávies e retorna T
se forem iguais e F se forem diferentes; o sı́mbolo = é usado para atribuir o resultado de uma operação a uma
variável.
Os operadores relacionais do Scilab podem ser usados para comparar dois vetores de mesmo tamanho ou
para comparar vetores com escalar (ou ainda, escalar com escalar). Interprete os comandos abaixo:
1 Em outros ambientes de programação a reposta para uma sentença verdadeira é 1 e 0 para uma resposta falsa.
Operadores Relacionais e Lógicos CAPÍTULO 3. PROJETO DE PROGRAMAÇÃO
Operador Descrição
< Menor que
<= Menor ou igual a
> Maior que
>= Maior ou igual a
== Igual a
<> ou ~= Diferente de
Tabela 3.1: Operadores relacionais.
--> A = 1:9
--> B = 10 - A
--> vf = (A==B)
--> vf = (A~=B)
--> vf = A >= 4
--> vf = A < 4
Observe também que o teste de igualdade às vezes produz resultados confusos para operações em ponto
flutuante. Execute as operações abaixo.
-->vf = (-0.08 + 0.5 - 0.42) == (0.5 - 0.42 -0.08)

-->vf = (-0.08 + 0.5 - 0.42) ~= (0.5 - 0.42 -0.08)
-->vf = (-0.08 + 0.5 - 0.42) - (0.5 - 0.42 -0.08)
É possı́vel combinar expressões relacionais com expressões matemáticas:

--> B = 9 - A;
--> B = B + (B==0)*(%eps)
é uma maneira de substituir os elementos iguais a zero em um vetor pelo número %eps2. Essa expressão em
particular é, algumas vezes, útil para evitar a divisão por zero, como segue no exemplo abaixo.
--> x = (-3:3)/3
--> y = ones( x )
--> vf = x ~= 0 // encontra posicoes com valores nao-nulos
--> y(vf) = sin( x(vf) )./x( vf ) // trabalha apenas com valores nao-nulos
3.1.2 Operadores Lógicos

Os operadores lógicos permitem que se combinem ou se neguem expressões relacionais. Os operadores
lógicos do Scilab são dados na Tabela 3.2.
Operador Descrição
& E
| OU
~ NÃO
Tabela 3.2: Operadores lógicos.
--> A = 1:9;
--> vf = A > 4 // Encontra o que e maior que 4
--> vf = ~(A>4) // Nega o resultado anterior
--> vf = (A > 2) & (A < 6) // Retorna T para valores maior que 2 e menor que 6
--> vf = (A < 3) | (A > 5) // Retorna T para valores menor que 3 ou para valores maior que 5
2O número %eps, em Scilab, é a menor diferença entre dois números que é possı́vel representar.
18
O Loop for e while CAPÍTULO 3. PROJETO DE PROGRAMAÇÃO
3.2 O Loop for e while

O loop for possibilita que uma série de comandos seja repetida por um número de vezes fixo e pré-
determinados. A forma geral do loop for é:
for x = vetor
comandos ...
end
Os comandos entre as instruções for e end são executados uma vez para cada coluna de vetor. A cada
iteração, atribui-se a x a próxima coluna de vetor, isto é, durante o n-ésimo ciclo do loop temos que x =
vetor(:,n).
--> for n = 1:10

--> x(n) = cos( n*(%pi)/10 );
--> end
--> x
Traduzindo, a primeira instrução diz: “para n igual a 1 até 10, calcule todas as instruções atá a próxima instrução
de end”. No primeiro ciclo de for, n = 1, no segundo, n = 2, e assim por diante, até n = 10. Depois do ciclo
para n = 10, o loop for termina e os comandos após a instrução end são executados e as componentes de x
são apresentados, conforme o exemplo acima.
Naturalmente, pode-se inserir um loop for dentro do outro, sucessivamente, tantos quantos desejados:
--> for n = 1:5

--> for m = 5:-1:1
--> A(n,m) = n^2 + m^2;
--> end
--> disp(n)
--> end
--> A
Uma maneira de tornar um programa mais eficiente é através da pré-alocação de memória. Ou seja, os
vetores devem ser pré-alocados antes de um loop for (ou while) seja executado. Por exemplo:
--> x = zeros(1,10); // memoria pre-alocacao para x

--> for n = 1:10
--> x(n) = cos( n*(%pi)/10 );
--> end
--> x
No primeiro caso, todas as vezes que os comandos dentro do loop for são executados, o tamanho da variável
x é incrementada de 1. Isso força o Scilab a gastar tempo para alocar mais memória para x todas as vezes
que o loop é percorrido.
Ao contrário do loop for, que executa um grupo de comandos um número fixo de vezes, o loop while
executa um grupo de comandos um número indefinido de vezes, até que uma certa condição seja satisfeita. A
forma geral do loop while é:
while CONDICAO
comandos ...
end
Os comandos ... entre as instruções while e end são executados enquanto TODOS os elementos de CONDICAO
forem verdadeiros.
19
Estrutura if CAPÍTULO 3. PROJETO DE PROGRAMAÇÃO
--> num = 0; EPS = 1;

--> while (1+EPS) > 1
--> EPS = EPS/2;
--> num = num + 1;
--> end
--> num
--> EPS = EPS*2
Nesse exemplo, EPS começa em 1. Enquanto (1+EPS) > 1 for verdadeiro, os comandos dentro do loop while
são executados. Uma vez que EPS é continuamente divivido em dois, em algum momento ele se tornará tão
pequeno que, somando-se EPS a 1, esse resultado será menor (ou igual) que 1. Nesse momento, (1+EPS) > 1
torna-se falso e o loop while termina. Finalmente, multiplica-se EPS por 2 porque a última divisão por 2 o tornou
pequeno demais.
3.3 Estrutura if
Em diversas situações, as seqüências de comandos têm de ser executadas condicionalmente, com base em
um teste relacional. Nas linguagens de programação, essa lógica é implementada por meio de uma das diversas
formas de estrutura if-else-end, cuja estrutura mais simples é:
if expressao
comandos ...
end
Os comandos ... entre as funções if e end são executados se todos os elementos na expressao forem
verdadeiros.
Nos casos em que expressao envolve muitas subexpressões lógicas, apenas as subexpressões
necessárias para determinar o valor lógico da expressao são executadas. Por exemplo,
se expressao é (expressao1 | expressao2), então expressao2 é executada somente se
expressao1 for falsa. Da mesma maneira, se expressao é (expressao1 & expressao2), então
expressao2 só é executada se expressao1 for verdadeira.
Considere o seguinte exemplo:
--> peras = 10; // numero de peras

--> custo = peras*25 // custo de peras
--> if peras > 5 // fonece 20% de desconto em compras maiores
--> custo = (1 - 20/100)*custo;
--> end
--> custo
Nos casos em que há duas alternativas, a estrutura if-else-end passa a ser:
if expressao
comandos executados se verdadeira
else
comandos executados se falsa
end
Aqui, o primeiro grupo de comandos é executado se expressao for verdadeira; o segundo grupo é executado se
expressao for falsa.
Quando houver três ou mais alternativas, a estrutura if-else-end toma a forma:
20
Definição de Funções CAPÍTULO 3. PROJETO DE PROGRAMAÇÃO
if expressao1
comandos executados se expressao1 for verdadeira
elseif expressao2
elseif expressao3
...
else
comandos executados se nenhuma outra expressao for verdadeira
end
Nessa última forma, somente os comandos associados à primeira expressão verdadeira encontradas são exe-
cutados; as expressões relacionais seguintes não são testadas e o resto da extrutura if-else-end é ignorada.
Além disso, n~
ao é necessário que o comando final else esteja presente.
Por fim, vamos ver uma maneira possı́vel de interromper ou sair de loops for e while.
--> num = 0; EPS = 1;

--> for num = 1:1000
--> EPS = EPS/2;
--> if (1+EPS) <= 1
--> EPS = EPS*2
--> break
--> end // if
--> end // for
--> num
Note que, o loop for executaria um grande número de vezes. A estrutura if-else-end testa; quando EPS fica
suficiente pequeno, o comando break força o loop for a terminar prematuramente.
Desenvolva um programa em Scilab para encontrar as raı́zes de uma equação do tipo ax2 + bx + c =
0.
3.4 Definição de Funções

Uma função obedece a uma estrutura da forma:
function [y1, y2, ..., yn] = foo(x1, x2, ..., xm)

instrucao_1
instrucao_2
...
instrucao_p
endfunction
onde foo é o nome da função, xi, para i = 1, 2, ..., m, são os seus argumentos de entrada, yj, para j =
1, 2, ..., n são argumentos de saı́da e instrucao i, para i = 1, 2, ..., p, representa a seqüência de
instruções que devem ser executados pela função.
Toda função no Scilab é executada chamando seu nome seguido de seus argumentos. No exemplo, a
função foo é executada através do comando:
--> foo(x1, x2, ..., xm)
Como pode ser observado, uma função possui uma estrutura pré-determinada. As principais caracterı́sticas de
uma função são:
21
Definição de Funções CAPÍTULO 3. PROJETO DE PROGRAMAÇÃO
• As variáveis definidas na função, chamadas de variáveis locais, não permanecem no ambiente Scilab
após a execução da função;
• As entradas e saı́das do programa são claramente definidas, e
• Uma função, após ser definida, pode ser chamada a qualquer tempo.
Uma função pode ser criada usando um dos seguintes procedimentos:
1. Digitando no próprio ambiente,
--> Digitando uma funcao no ambiente Scilab
--> function[y1, y2] = exemplo(x1, x2)

--> // Entrada: x1, x2
--> // Saida: y1, y2
--> y1 = x1 + x2
--> y2 = x1 * x2
--> endfunction
--> [a, b] = exemplo(2, 3)
2. Usando o comando deff,
--> Usando deff
--> deff(’[y1, y2] = exemplo(x1, x2)’, ’y1 = x1 + x2, y2 = x1 * x2’)

--> [a, b] = exemplo(3, 4)
3. Digitando o texto da função em um arquivo e, em seguida, carregando esse arquivo no ambiente Scilab.
Por convenção, as funções definidas pelo usuário possuem extensão sci e são carregadas no ambiente
Scilab através do comando:
--> getf(’nome_do_arquivo_de_comandos.sci’)
22
Exercı́cios CAPÍTULO 3. PROJETO DE PROGRAMAÇÃO
3.5 Exercı́cios
1. Assuma que a, b, c e d sejam conforme dado, e avalie as seguintes expressões a seguir.
a = 20; b = -2; c = 0; d = 1;
(a) a > b; (c) a > b & c > d; (e) a & b > c;

(b) b > d; (d) a == b; (f) ~~b.
2. Assuma que a, b, c e d sejam conforme dado, e avalie as seguintes expressões a seguir.
a = 2; b = [1 -2; 0 10]; c = [0 1; 2 0];

d = [-2 1 2; 0 1 0];
(a) ~(a > b); (b) a > c & b > c; (c) c <= d.
3. Assuma que a, b, c e d sejam conforme dado. Explique a ordem de avaliação de cada uma das seguintes
expressões, e especifique os resultados em cada caso.
a = 2; b = 3; c = 10; d = 0;
(a) a*b^2 > a*c; (b) d | b > a.
4. O custo de enviar um pacote por Sedex é de $10,00 para o primeiro quilo e $3,75 para cada quilo acima. Se
o pacote pesar mais de 35 quilos, uma taxa de peso adicional de $10,00 é adicionada ao custo. Nenhum
pacote com mais de 50 quilos é aceito. Escreva um programa que aceite o peso do pacote em quilos e
calcule o custo de enviar o pacote. Inclua o caso dos pacotes acima do peso.
5. Escreva um programa para calcular a função f (x, y) para quaisquer dois valores reais, dado pelo usuário
para x e y , como segue:
x+y x≥0 e y≥0


 x + y2 x ≥ 0 e y < 0

f (x, y) =

 x2 + y x < 0 e y ≥ 0
 2
x + y2 x < 0 e y < 0
6. Examine os laços for a seguir e determine quantas vezes cada laço será executado.
(a) for index = 7:10 (c) for index = -10:3:-7

(b) for jj = 7:-1:10 (d) for kk = [0 5; 3 3]
7. Examine os laços a seguir e determine o valor em ires no final de cada um.
(a) ires = 0; end

for index = 1:10
ires = ires + 1; (c) ires = 0;
end for index1 = 1:10
for index2 = index1:10
(b) ires = 0; if index2 == 6
for index = 1:10 break;
ires = ires + index; end
23
ires = ires + 1; (d) Calcule os valores da função:

end
end sen(t) ∀t tal que sen(t) > 0
f (t) =
0 caso contrário
para −6π < t < tπ com intervalos de π/10.
8. O n-ésimo número de Fibonacci é definido pelas equações recursivas abaixo:
f (1) = 1
f (2) = 2
f (n) = f (n − 1) + f (n − 2)
Portanto, f (3) = f (2) + f (1) = 2 + 1 = 3 e assim por diante, para números maiores. Escreva um arquivo
fib.sci para calcular e imprimir o n-ésimo número de Fibonacci para n > 2, onde n é fornecido pelo
usuário.
9. Uma matriz An×n é dita diagonalmente dominante se

n
X
|aii | > |aij |, i=1:n
j6=i
Escreva uma função que, dada uma matriz qualquer n × n, retorne T se a matriz for diagonalmente domi-
nante e F caso contrário.
P.S.: O comando read, como mostra o exemplo que segue, AB = read(’nome do arquivo.txt’, no de linhas,
no de colunas)), lê um arquivo de dados para execução no ambiente Scilab, onde AB é a variável que
contém a matriz.
10. A localização de um ponto em um plano cartesiano pode ser expressa por coordenadas retangulares
(x, y) ou coordenadas polares (r, θ). A relação entre esses dois conjuntos de coordenadas é dada por
estas equações:
y
x = r cos θ
y = rpsin θ y
r
r = x2 + y 2
θ = tg −1 y
x

θ
x x
Escreva duas funções, rect2polar e polar2rect,

que convertam coordenadas de retangular para po-
lar e vice-versa, com o ângulo θ expresso em graus.
11. O método da bissecção serve para o cálculo aprimado de raı́zes de equações do tipo f (x) = 0, com
f : R → R.
O método é bastante simples: dado um intervalo inicial [a, b] contendo uma raiz, divide-se este intervalo
ao meio. Por exemplo, m = (a + b)/2. Temos agora dois intervalos: [a, m] e [m, b]. Daı́ basta continuar o
processo até a precisão desejada.
Assim:
(a) Encontre as raı́zes de f (x) = x3 − 2x − 5 = 0.
24
(b) Calcule as raı́zes negativas de P (x) = x3 − 3x2 − 6x + 8 = 0, com ǫ ≥ 0.05 (erro absoluto) que está
no intervalo [−3.83, −0.62].
12. Um sistema linear pode ser dado por:
a11 x1 + a12 x2 + . . . + a1n xn = b1




 a21 x1

+ a22 x2 + . . . + a2n xn = b2
.. .. .. .. ..


 . . . . .

an1 x1 + an2 x2 + . . . + ann xn = bn
na matricial como Ax = b, ou ainda:

 
n
X
x1 = b1 − a1j xj  /a11
j=2
..
.  
n
X
xi = bi − aij xj  /aii (3.1)
j6=i
..
.  
n−1
X
xn = bn − anj xj  /ann
j=1
O método de Gauss-Seidel é um processo que usa a forma (3.1), a partir de uma solução inicial e atualiza
os valores de x até obter uma precisão requerida. Esta atualização usa as componentes que está sendo
(k+1) (k+1)
calculada. Assim, o valor recém calculado para x1 será usado no cálculo de x2 . O Algoritmo 1
mostra os passos deste método.
(0)
Dado n, An×n , bn×1 e xn×1 , max, ǫ
1: Para k = 0 até k = max faça
2: Para i = 1 até i = n faça !
i−1 n
(k+1) 1 X (k+1)
X (k)
3: xi = bi − aij xj − aij xj
aii j=1
˛ j=i+1 ˛
˛ (k+1) (k) ˛
˛
˛ (k+1)
˛ ˛x i − x i ˛
(k) ˛
4: Se max ˛xi − xi ˛ < ǫ ou ˛ ˛ < ǫ então
1≤i≤n ˛ (k+1) ˛
˛xi ˛
5: x = x(k+1)
6: else
7: Se k = max então
8: PARE: não houve convergência.
9: Fim do condicional
11: Fim do laço
12: Fim do laço
Algoritmo 1: Método de Gauss-Seidel
Implemente o método de Gauss-Seidel e resolva o sistema:
5 2 0 −1 x1 6
   
 1 8 −3 2   x2
    10 
 = 
 0 1 6 1   x3   −5 
1 −1 2 9 x4 0
25
com ǫ < 10−3 e max = 50. Antes de iniciar o algoritmo acima, verifique se o sistema é diagonalmente
dominante, usando a função implementada no exercı́cio 9 (usando o Scilab, é claro!).
13. Equilibrar a reação quiı́mica:

KMnO2 + H2 SO4 + NaNO2 → K2 SO4 + MnSO4 + NaNO3 + H2 O.
Modelagem Matemática
O balanceamento de uma equação quı́mica é baseada na lei de conservação da massa de Lavoisier: Em
um sistema quı́mico isolado, a massa permanente conservante, quaisquer que sejam as transformações
que nele se processem. A lei de Lavoisier também pode ser expressa na forma: Em uma reação quı́mica,
a soma das massas dos reagentes é igual à soma das massas dos produtos resultantes. Conclui-se,
então, que os elementos têm de estar nos dois membros da equação em igual quantidade.
O método algébrico de balanceamento consiste em atribuir coeficientes literais xi às substâcias que apa-
recem na equação, os quais constituem as incógnitas. Aplicando a lei de Lavoisier e comparando os ele-
mentos membro a membro, constrói-se um sistema de equações algébricas lineares, onde as incógnitas
são os coeficientes estequiométricos xi da reação quiı́mica. Se houver mais incógnitas do que equações,
atribui-se um valor arbitrário a uma delas:
x1 KMnO2 + x2 H2 SO4 + x3 NaNO2 → x4 K2 SO4 + x5 MnSO4 + x6 NaNO3 + x7 H2 O
A Tabela 3.3 sistematiza a equação acima.
K: x1 = 2x4
Mn: x1 = x5
O: 2x1 + 4x2 + 2x3 = 4x4 + 4x5 + 3x6 + x7
H: 2x2 = 2x7
S: x2 = x4 + x5
Na: x3 = x6
N: x3 = x6
Tabela 3.3: Transformação da equação quı́mica em equações.
Como as duas últimas expressões são iguais, elimina-se uma delas. Deste modo, tem-se um sistema
linear com 6 equações e 7 incógnitas. Atribuindo um valor arbitrário a uma delas, por exemplo, x7 = 1,
obtém-se o seguinte sistema linear de ordem 6:
    
1 0 0 −2 0 0 x1 0

 1 0 0 0 −1 0   x
 2



 0 

2 4 2 −4 −4 −3   x3 1
    
 = 
   
0 2 0 0 0 0   x4 2
  
   
    
 0 1 0 −1 −1 0   x5   0 
0 0 1 0 0 −1 x6 0
(a) Resolva o sistema acima usando a função LU do Scilab e com o método de Gauss-Seidel imple-
mentado (faça a troca de linhas necessárias para a melhor execução deste método).
(b) Compare as soluções obtidas em relação a precisão de cada método.
(c) Faça uma análise do resultado obtido.
26
CAPÍTULO 4
Gráficos no Scilab
Começamos aqui a explorar alguns dos recursos gráficos bi-dimensionais do ambiente Scilab. Informações
mais detalhadas sobre todos os comandos disponı́veis na biblioteca gráfica do Scilab (acessem o help).
4.1 A Janela Gráfica do Scilab

Todas as saı́das gráficas de comandos do Scilab são apresentadas em uma janela gráfica. Note que, esta
janela tem um menu horizontal com cinco opções:
1. File: possui sete sub-opções que permitem manipular arquivos relacionados com gráficos gerados: Clear,
Select, Print, Export, Save, Load e Close.
2. Zoom: permite a ampliação de uma parte do gráfico. Escolhendo esta opção e delimitando uma área, a
parte do gráfico dentro da área escolhida será expandida.
3. UnZoom: desfaz as manipulações realizadas através da opção Zoom.
4. 3D Rot.: permite efetuar rotações em gráficos bi-dimensionais e tri-dimensionais.
5. Edit: possui sete sub-opções que permite manipular o gráfico gerado: Select, Redraw, Erase, Figure
Properties, Current Axes Properties, Start Entity Picker, Stop e Entity Picker.
No Scilab, gráficos sucessivos são sobrepostos em uma janela gráfica. Para evitar que isto ocorra, podemos
utilizar dois comandos: clf() ou xbasc(). Estes dois comandos limpam a janela gráfica.
As janelas gráficas podem ser manipuladas através da função scf(). Por exemplo:
--> // Manipulacao de janelas graficas

--> scf(0) // Acesso a janela grafica 0 (default)
--> scf(1) // Acesso a janela grafica 1
4.2 Gráficos Bi-dimensionais

Gráficos bi-dimensionais podem ser gerados através da utilização da função plot2d(). A forma mais simples
desta função é:
--> plot2d( [ x ], y )
onde x e y podem ser matrizes ou vetores reais. Os colchetes [ e ], envolvendo x indicam que este parâmetro
é opcional. Vejamos algumas considerações sobre este parâmetros:
Gráficos Bi-dimensionais CAPÍTULO 4. GRÁFICOS NO SCILAB
1. Se x e y são vetores, a função plot2d() permite traçar o gráfico de y em função de x. É importante

observar que os dois vetores devem ter a mesma dimensão, isto é, os dois vetores devem ter o mesmo
número de elementos.
2. Se x é um vetor e y é uma matriz, a função plot2d() permite traçar o gráfico de cada coluna da matriz y
em função de x. Neste caso, o número de elementos das colunas da matriz deve ser igual ao número
de elementos do vetor x.
3. Se x e y são matrizes, a função plot2d permite traçar o gráfico de cada coluna da matriz y em função de
cada coluna da matriz x. Neste caso, as matizes devem ter as mesmas dimensões.
4. Se y é um vetor, a função plot2d() permite traçar o gráfico do vetor y em função do vetor [1:size(y)].
5. Se y é uma matriz, a função plot2d() permite traçar o gráfico da matriz y em função do vetor [1:size(y)].
Vamos apresentar exemplos de gráficos gerados para cada uma das opções de entrada x, y apresentados
anteriormente. Os gráficos serão gerados no intervalo [0, 2π], com incremento 0.1. As atividades abaixo podem
ser feitas no Scipad ou diretamente no ambiente Scilab.
--> // Item 1: x = vetor, y = vetor

--> x = [ 0:0.1:2*%pi ]; // Definindo o vetor das abcissas, x
--> y = sin( x );
--> // x e y devem ter a mesma dimensao!!!!!!!!
--> size( x )
--> size( y )
--> plot2d( x, y )
--> // Item 2: x = vetor, y = matriz

--> clf() // Limpa a tela grafica - evitar sobreposicao
--> Y = [ sin( x )’ cos( x )’ ]; // Definindo a matriz Y
--> size (Y) // Observar que a matriz Y possui 63 elementos em cada coluna
--> plot2d( x, Y )
--> // Item 3: x = y = matrizes

--> clf()
--> clear
--> t = [ 0:0.1:2*%pi ] // Definindo uma variavel auxiliar
--> X = [ t’ t’ ] // Criando a matriz X
--> size( X ) // A matriz X possui 63 elementos em cada coluna
--> Y = [ cos( t’ ) sin( t’ ) ];
--> size( Y ) // A matriz Y possui 63 elementos em cada coluna
--> plot2d( X, Y )
--> // Item 4: y = vetor (sem x explicito)

--> clf()
--> x = [ 0:0.1:2*%pi ];
--> plot2d( sin( x ) )
--> // Item 5: Y = matriz (sem x explicito)

--> clf()
--> plot2d( Y )
28
Verifique que, após a execução de cada gráfico, limpamos a tela através do comando clf(), para evitar que
o próximo gráfico se sobreponha ao anterior.
Vejamos agora alguns comandos para melhorar a sua janela gráfica:
• xtitle( titulo ): acrescenta o tı́tulo em cada um dos gráficos gerados, cujo argumento é uma string.
• xsetech( [ x, y, largura, altura] ): Sub-divide a janela gráfica do Scilab.

A janela gráfica é definida com largura e altura iguais a 1 e com o seu sistema de referências com origem
(0, 0) no canto superior esquerdo da janela. O eixo x possui valores crescentes para a direita e o eixo y
possui valores crescentes para baixo. Ambos os eixos possuem valores máximos iguais a 1.
Vamos re-escrever os comandos acima dentro do Scipad (graf 2d.sci) usando os comandos xtitle() e
xsetech().
clear // Limpar a memoria do Scilab

clf() // Limpar a janela grafica
// Item 1: x = vetor, y = vetor
x = [ 0:0.1:2*%pi ]; // Definindo o vetor das abcissas, x

y = sin( x );
// xsetech( [abcissa, ordenada, largura, altura] ) do grafico
xsetech( [0, 0, 0.3, 0.5] );

xtitle(‘‘Item 1’’);
plot2d( x, y )
// Item 2: x = vetor, y = matriz
Y = [ sin( x )’ cos( x )’ ]; // Definindo a matriz Y
xsetech( [0.35, 0, 0.3, 0.5] );

plot2d( x, Y )
// Item 3: x = y = matrizes
clear
t = [ 0:0.1:2*%pi ] // Definindo uma variavel auxiliar
X = [ t’ t’ ] // Criando a matriz X
Y = [ cos( t’ ) sin( t’ ) ];
xsetech( [0.7, 0, 0.3, 0.5] );

plot2d( X, Y )
// Item 4: y = vetor (sem x explicito)
29
x = [ 0:0.1:2*%pi ];
xsetech( [0, 0.5, 0.5, 0.5] );

plot2d( sin( x ) )
// Item 5: Y = matriz (sem x explicito)
xsetech( [0.5, 0.5, 0.5, 0.5] );

plot2d( Y )
A forma geral da função plot2d() inclui um terceiro argumento: plot2d( [x], y, <opt args> ), onde
<opt args> é uma seqüência de opções que determinam as caracterı́sticas do gráfico bi-dimensional:
< opt args > := opcao1 = valor1 , opcao2 = valor2 , . . . , opcaon = valorn
As opções podem ser:
• style: é utilizada para especificar o padrão da curva (ou curvas) que estão sendo traçadas. O valor
associado à essa opção dever ser um vetor com valores inteiros positivos ou negativos. Se o valor for
positivo, a curva é contı́nua e defina-se a cor da curva traçada. Se o valor for negativo ou zero, a curva
será desenhada usando marcadores.
• logflag: define a escala, logarı́tmica ou linear, a ser utilizada nos eixos x e y do gráfico. Os valores
associados à essa opção são strings, “nn”, “nl”, “ln” ou “ll”, onde l indica a escala logarı́tmica, n a escala
normal, na seqüência xy. O valor padrão desta opção é “nn”, isto é, escala normal com graduação normal
dos eixos (omite-se esta opção).
• rect: é utilizada para estabelecer os limites do gráfico. O valor associado à essa opção úm vetor real com
quatro entradas [xmin, ymin, xmax, ymax], onde xmin, xmax, ymin e ymax indicam os valores mı́nimos
e máximos para os eixos x e y, respectivamente.
• frameflag: é utilizada para controlar a escala dos eixos coordenados. O valor associado à essa opção é
um número inteiro entre 0 e 8, inclusive.
• axesflag: especifica como os eixos serão traçados. O valor associado à essa opção é um número inteiro
entre 0 e 5, inclusive;
• leg: permite definer as legendas das curvas. O valor associado à esse parâmetro é uma string de carac-
teres para cada gráfico traçado.
Um exemplo com estas opções é apresentado a seguir (opt plot.sci).
--> x = [ -%pi:0.1:%pi ]
--> y = [ sin(x)’ cos(x)’ ]
--> plot2d( x, y, style = [2, -1], rect = [-%pi, -1.5, %pi, 1.5], ...
--> axesflag = 5, leg = ‘‘sen( x )@cos( x )’’ )
Uma maneira de traçar gráficos bidimensionais polares é usando a função polarplot(rho, theta, <opt args>),
como segue no exemplo a seguir (cardeoide.sce).
30
clear
clf()
xsetech([0, 0, 0.5, 0.5])
t = linspace(0, 2*%pi);
a = 2;
r = a*(1 + cos(t));
polarplot(t,r, 5)
xtitle(’Cardeoide’)
xsetech([0.5, 0, 0.5, 0.5])
a = 0.25;
t = linspace(-(%pi)/4, (%pi)/4);
r1 = a*sqrt( cos(2*t) );
r2 = -( a* sqrt( cos(2*t) ) );
polarplot([t, t], [r1, r2], 22)

xtitle(’Lemniscata de Bernoulli’)
xsetech([0, 0.5, 0.325, 0.5])
t = linspace(-2*%pi, 2*%pi);
a = 1;
x = a*(t - sin(t));
y = a*(1 - cos(t));
plot2d(x, y, 2, frameflag = 3, rect = [-6.2, -0.1, 6.2, 2.1])

xtitle(’Cicloide’)
xgrid(3)
xsetech([0.325, 0.5, 0.325, 0.5])
t = linspace(0, 2*%pi);
a = 2;
x = a*( cos(t) + t.*sin(t) );

y = a*( sin(t) - t.*cos(t) );
plot2d(x, y, 5, frameflag = 3, rect = [-10, -15, 4, 10])

xgrid(2)
xtitle(’Evolvente da circunferencia’)
xsetech([0.65, 0.5, 0.35, 0.5])
31
a = 2;
t = linspace(-4*%pi, 4*%pi);
x = (3*a*t)./(1 + t^3);
y = (3*a*(t^2))./(1 + t^3);
plot2d(x, y, 2)
xgrid(3)
xtitle(’Folio de Descartes’)
O comando plot2d() apresenta algumas variações, como apresentado na Tabela 4.1.
Comando Tipo de Gráfico

plot2d2() gráficos 2-D linearizados.
plot2d3() gráficos 2-D com barras verticais.
plot2d4() gráficos 2-D com setas.
Tabela 4.1: Variações do comando plot2d.
Uma outra maneira de gerar gráficos bi-dimensionais é usando o comando fplot2d() (graf fplot.sci).
Consulte o help do Scilab para maiores detalhes.
--> clear
--> clf()
--> deff( ’y = f(x)’, ’y = sin(x)’ )
--> x = linspace( -%pi, %pi )
--> fplot2d( x, f )
--> xgrid(2)
4.2.1 Outros Comandos

Existem comandos que podem ser utilizados para melhorar a apresentação de um gráfico (dem subplot.sci).
Dentre eles, destacamos:
• xgrid(): coloca uma grade em um gráfico bi-dimensional;
• titlepage: coloca um tı́tulo no meio de uma janela gráfica.
• subplot(m,n,p): divide a janela gráfica do Scilab em uma matriz m × n (m linhas e n colunas). Em

cada um dos elementos da matriz, especificado por p, pode ser colocado num gráfico.
// Demonstracao do comando subplot

clf()
subplot(2,2,1)
champ // Chamada do demo da funcao champ
subplot(2,2,2)
histplot // Chamada do demo da funcao histplot
subplot(2,2,3)
errbar // Chamada do demo da funcao barr
32
subplot(2,2,4)
grayplot // Chamada do demo da funcao grayplot
Observem que, no menu horizontal da janela gráfica temos a opção File e sub-opção Export. Esta sub-opção
permite exportar a figura gerada no formato: *.gif, entre outros !
Executem o programa (plot2d opt.sce) que segue abaixo e compare com os comandos listados na Tabela
4.1.
clear
clf()
subplot(2,2,1)
x = [-2.9:0.1:2.9]’;
y = exp(-x.*x);
t = x;
plot2d(t, y);
errbar(t,y, 0.02*ones(t), 0.1*ones(t))
xtitle("Barra de erros: variacao inferior e Superior")
subplot(2,2,2)
plot2d2(t, y, style = 2)
xtitle("Funcao escada: visualizacao discreta dos dados")
subplot(2,2,3)
plot2d3(t, y, style = 3)
xtitle("Barras verticais: analise de frequencia")
subplot(2,2,4)
x = linspace(1, 1000);
y = log(x);
plot2d(x, y, logflag = "ln") // l == escala logaritmica

// n == escala normal
xgrid(3);
xtitle("logflag: escala logaritmica")
33
Exercı́cios CAPÍTULO 4. GRÁFICOS NO SCILAB
1
(i) f (x) = (x−4)2 ;
4.3 Exercı́cios
(j) f (x) = −(4 + x2 );
1. Acompanhe o que foi feito, para funções po- x
(k) f (x) = |x| ;
lares (plot2d opt), e faça um (ou mais) pro-
√
grama(s) para as funções que segue. Nem to- (l) f (x) = 2 − x;
das as funções listadas abaixo precisam usar (m) f (x) = ln(x) (mude o tipo de escala);
polarplot! Atenção ao definir os domı́nios de
cada função. (n) f (x) = e−x (mude o tipo de escala).
(a) Cissóide de Diocles: 3. Através da estrutura function, escreva cada

uma das funções abaixo e escreva um programa
at2

(para cada uma ou para todas) e que chame as
 x = 1 + t2

x3

y2 = ou funções (usando a função getf()) e faça os seus
a−x  at3 respectivos gráficos:
y=


1 + t2
(a)
a+x

−1 se x<0
(b) Estrofóide: y 2 = x2 f (x) =
a−x 1 se x≥0
2 2 2
(c) Hipociclóide (atróide): x 3 + y 3 = a 3 ou
(b)
3

x = a cos (t) 
y = a sen3 (t)  −5 se x < −5
f (x) = x se −5 ≤ x ≤ 5
5 x>5

(d) Espiral de Arquimedes: r = a ϕ, r ≥ 0. se
a
(e) Espirial hiperbólica: r = , r ≥ 0. (c)
ϕ  2
(f) Espiral logaritmica: r = ea ϕ .  x se x ≤ −1
f (x) = x3 se |x| < 1
(g) Rosa de três pétalas: r = a sen(3ϕ), r ≥ 0.
2x x≥1

se
(h) Rosa de quatro pétalas: r = a | sen(2ϕ)|
(d)
2. Trace o gráfico das funções abaixo (cuidado com
o domı́nio de cada função !!!!). 1 se x é inteiro
f (x) =
0 se x não é inteiro
(a) f (x) = x3 ;
√
(b) f (x) = x − 1; (e) 
(c) f (x) = |x|;
 −x se x<0
f (x) = 2 se 0≤x<1
1
(d) f (x) =x;
 2
x se x≥1
√
(e) f (x) = 4 − x2 ;
(f)
(f) f (x) = |x − 4|; 
 x se x≤1
(g) f (x) = x + |x|; f (x) = −x2 se 1≤x<2
√ 
x se x≥2
(h) f (x) = x2 − 4;
34
CAPÍTULO 5
Ajuste de Curvas em Ambiente Scilab
Manipulação de Arquivos – Comando read

Para a leitura de um arquivo no formato de matriz, o Scilab usa o comando read:
--> A = read(’nome_do_arquivo.txt’, numero_de_linhas, numero_de_colunas)
O arquivo contendo a matriz a ser lida deve conter apenas os elementos da matriz disposto de maneira
usual.
Manipulação de Arquivos – Comandos save e load

As variáveis, vetores ou matrizes criadas no ambiente Scilab podem ser armazenadas em um arquivo.
Considere os vetores:
--> x = [0:0.1:2];
--> y = [5.8955 3.5639 ... 0.1704 0.2636];
--> dd = [x; y];
onde
y= [ 5.8955 3.5639 2.5173 1.979 1.899 1.3938 1.1359

1.0096 1.0343 0.8435 0.6856 0.61 0.5392 0.3946
0.3903 0.5474 0.3459 0.137 0.2211 0.1704 0.2636 ]
Para salvar x e y em um arquivo chamado valores.dat, usamos o comando save com a sintaxe:
--> save(’valores.dat’, dd)
O comando save cria o arquivo valores.dat no diretório de trabalho. O arquivo valores.dat é um arquivo
binário. Para recuperar os valores x e y , usamos o comando load:
--> clear
--> x
--> y
--> load(’valores.dat’, ’dd’)
--> dd
Definindo a Função de Ajuste CAPÍTULO 5. AJUSTE DE CURVAS EM AMBIENTE SCILAB
5.1 Definindo a Função de Ajuste

A função de ajuste desenvolvida para ambiente Scilab basea-se no método dos Quadrados Mı́nimos. Lem-
brando que, quando aplicamos este método minimizamos o resı́duo ao quadrado (ou seja, a diferença entre o
valor ajustado e o valor real ao quadrado), que pode ser escrito da seguinte forma:
m
2
X
< r, r > = (yi − g(xi )) (5.1)
i=1
onde yi são elementos do vetor y que fornecem os valores reais a serem ajustados e g(x) a função a ser
aproximada para estes valores. O nosso objetivo é o de encontrar os coeficientes da função g(x) de maneira
que r seja o menor valor possı́vel (minimização do resı́duo).
Para os dados do exemplo da Seção 5, uma função que pode fornecer um bom ajuste é do tipo:
g(x) = c1 ec2 x +c3 (5.2)
A função (5.1), para o ambiente Scilab, retorna dois tipos de informação (como veremos abaixo): um vetor
com os coeficientes de (5.2) e o resı́duo. Assim (curvas.sce):
// Exemplo de ajuste de dados usando Scilab.
clear
load(’valores.dat’, ’dd’)
// Definindo a funcao residuo. Supondo que a funcao a ser ajustada

// tenha parametros c_1, c_2, ... c_n, definimos a funcao residuo como:
//
// erro = x_n+1 - g( x, c_1, c_2, ..., c_n )
deff( ’erro = g(c,dd)’, ’erro = dd(2) - c(1)*exp( c(2)*dd(1) ) - c(3)’ )

Nesta função r, os elementos dd(1) e dd(2) correspondem a primeira e segunda linha da matriz armaze-
nada em valores.dat, ou seja, aos valores de x e y do exemplo da Seção 5. O método de Quadrados Mı́nimos
no Scilab sempre segue este padrão: a última componente do vetor sempre corresponde a y.
A Função datafit
O ambiente Scilab possui a função datafit que ajusta qualquer tipo de função pelo método dos Quadrados
Minı́mos. Esta precisa de três informações: a função a ser ajustada g(c,dd) (definida nos padrões da seção
anterior), os elementos do arquivo valores.dat, que foram armazenados em dd e um chute inicial para o cálculo
dos coeficientes de (5.2). No nosso caso:
c0 = [ 1; -1; 0 ]; // Chute inicial para os parametros.
// Calculando o ajuste. A variavel "c" corresponde aos parametros

// ajustados e a variavel "e" ao erro quadratico de ajuste.
[c,e] = datafit(g, dd, c0);

onde c é um vetor coluna contendo os coeficientes da função G(x) e e é o resı́duo final.
Após a execução deste passo, já é possı́vel definir a função G(x) com os coeficientes calculados por datafit
(note que o Scilab não confunde g com G):
36
Spline Cúbicas em Ambiente Scilab CAPÍTULO 5. AJUSTE DE CURVAS EM AMBIENTE SCILAB
// Definindo a funcao de ajuste.
deff( ’y1 = G(x)’, ’y1 = c(1) * exp( c(2) * x ) - c(3)’ );
// Fazendo os graficos dos dados e da funcao obtida!
x = dd(1, :);
y = dd(2, :);
xsetech([0, 0, 0.48, 0.48])

xtitle("Pontos para ajuste")
plot2d(x, y, style = [-1])
xsetech([0.5, 0, 0.48, 0.48])

xtitle("Curva ajustada")
fplot2d(x, G, 2)
xsetech([0, 0.5, 1, 0.48])

xtitle("Ajuste x pontos")
plot2d(x, y, style = [-1])
fplot2d(x, G, 2)
5.2 Spline Cúbicas em Ambiente Scilab

A interpolação utilizando polinômios de ordem elevada muitas vezes produz resultados mal comportados.
Existem vários métodos para eleminar esse problema. Dentre eles, as Splines Cúbicas são muito populares. No
Scilab, a interpolação por splines cúbicas é executada pelas funções splin e interp. No help do Scilab, os
detalhes para o uso destas funções estão disponı́veis.
A Função splin
A função splin toma os dados x e y e os valores desejados xi (normalmente xi ∈ [x0 , xn ]), encontra o
polinômio da interpolação por spline cúbica que se adequa a x e y , e então calcula os polinômios para encontrar
os valores de yi correspondente a cada valor xi .
• Notação: d = splin( x, y, ’tipo de spline’ ), onde:
x : vetor (linha ou coluna) com, no mı́nimo, 2 elementos;

y : vetor (linha ou coluna) no mesmo formato de x;
tipo de spline : seleção do tipo de spline a ser calculada;
d : vetor no mesmo formato de x (di é a derivada da spline em xi ).
• Descrição: a função splin calcula a spline cúbica (ou sub-spline) s que interpola os pontos (xi , yi ), isto
é, temos s(xi ) = yi , ∀i = 0 : n. A spline resultante s é completamente definida pelos pontos (x, y, d),
onde d é um vetor com as derivadas de xi : s′ (xi ) = di (conhecida como forma de Hermite).
O cálculo das splines em alguns pontos tem de ser feitos pela função interp.
• Tipos de Splines: podemos calcular diferentes tipos de splines cúbicas, aqui vamos ver as sintaxe das
splines cúbicas natural e restrita:
37
’natural’ : a spline cúbida é cálculada supondo s′′ (x0 ) = s′′ (xn ) = 0. Assim, a função pode ser dada por:
d = splin( x, y, ’natural’)
’clamped’ : a spline cúbica é cálcula usando s′ (x0 ) = f ′ (x0 ) e s′ (xn ) = f ′ (xn ). Neste caso, temos de passar
um vetor com estes valores, como segue:
d = splin( x, y, ’clamped’, [f’(x0) f’(xn)] )
A Função interp
A função interp calcula a spline cúbica.
• Notação: yp = interp( xp, x, y, d ), onde:
xp : vetor dos números reais definida em [x0 , xn ];

x, y, d : vetores de números reais, definindo uma spline cúbica;
yp : vetor de números reais de mesmo tamanho de xp, com os valores de s(xi ) (yp(i) = s( xp(i) )).
• Descrição: Dado 3 vetores (x, y, d) definidos pela função splin com f (xi ) = s(xi ) e di = s′ (xi ), esta
função calcula s em xp(i).
Exemplos
Veremos aqui, dois exemplos para o uso das funções splin e interp.
// Exemplo (spline_teste.sce)
clear
x = [0 1 2];
y = [1 2 -1];
plot2d(x, y, -2)
d = splin(x, y, ’natural’)
xx = linspace(0, 2);
yy = interp(xx, x, y, d);
plot2d(xx, yy, 2, rect = [-1, -2, 3, 3])
Tomemos agora o problema abaixo.
Exemplo 5.2.1. Construa as splines cúbicas para os dados abaixo, como é solicitados nos itens (1) e (2).
xi 0.1 0.2 0.3 0.4

yi -0.62049958 -0.28398668 0.00660095 0.2484244
1. Natural (s′′ (x0 ) = s′′ (xn ));
38
2. Restrita, com f ′ (0.1) = 3.58502082 e f ′ (0.4) = 2.16529366.

// Spline (spline_aula.sce)
clear
clf()
getf(’ex_aula_nat.sce’)
getf(’ex_aula_rest.sce’)
x = [0.1 0.2 0.3 0.4];

y = [-0.62049958 -0.28398668 0.00660095 0.2484244];
xx = linspace(0.1, 0.4);
subplot(2,2,1)
xtitle(’Interpolacao Natural via Scilab’)

plot2d(x, y, -5, rect = [0.08, -0.7, 0.45, 0.3])
dnat = splin(x, y, "natural");

ynat = interp(xx, x, y, dnat);
plot2d(xx, ynat, 2)
subplot(2,2,2)
xtitle(’Interpolacao manual’)
plot2d(x, y, -5, rect = [0.08, -0.7, 0.45, 0.3])
fplot2d(xx, ex_aula_nat, 3)
subplot(2,2,3)
xtitle(’Interpolacao Restrita via Scilab’)

plot2d(x, y, -4, rect = [0.08, -0.7, 0.45, 0.3])
t = [3.58502082 2.16529366];
drest = splin(x, y, "clamped", t);

deff(’yrest = frest(xx)’, ’yrest = interp(xx, x, y, drest)’);
fplot2d(xx, frest, 2)
subplot(2,2,4)
xtitle(’Interpolacao Restrita Manual’)

plot2d(x, y, -4, rect = [0.08, -0.7, 0.45, 0.3])
fplot2d(xx, ex_aula_rest, 3)
A função ex aula nat.sce segue abaixo.
function[y] = ex_aula_nat(x)
39
if (x >= 0.1 & x < 0.2)
y = -0.62049958 + 3.4550869*(x - 0.1) - 8.9957933*(x - 0.1)^3;
elseif (x >= 0.2 & x < 0.3)
y = -0.28398668 + 3.1852131*(x - 0.2) - 2.698738*(x - 0.2)^2 - 0.9463033*(x - 0.2)^3;
elseif (x >= 0.3 & x <= 0.4)
y = 0.00660095 + 2.6170764*(x - 0.3) - 2.982629*(x - 0.3)^2 + 9.9420967*(x - 0.3)^3;
else
y = 0;
end // if
endfunction
E a função ex aula rest.sce é apresentada aqui.
function[y] = ex_aula_rest(x)
if (x >= 0.1 & x < 0.2)
y = -0.62049958 + 3.5850208*(x - 0.1) - 2.1498408*(x - 0.1)^2 - 0.4907741*(x - 0.1)^3;
elseif (x >= 0.2 & x < 0.3)
y = -0.28398668 + 3.1403294*(x - 0.2) - 2.297073*(x - 0.2)^2 - 0.4745836*(x - 0.2)^3;
elseif (x >= 0.3 & x <= 0.4)
y = 0.00660095 + 2.6666773*(x - 0.3) - 2.4394481*(x - 0.3)^2 + 0.4498015*(x - 0.3)^3;
else
y = 0;
end // if
endfunction
40
Exercı́cios CAPÍTULO 5. AJUSTE DE CURVAS EM AMBIENTE SCILAB
5.3 Exercı́cios
1. Seja a tabela:
i 1 2 3 4 5 6 7 8 9 10
xi 5 6 7 8 9 10 11 12 13 14
yi 0.01 0.05 0.08 0.14 0.18 0.26 0.44 0.51 0.79 1.02
(a) Salve os dados da tabela acima usando o comando save e carregue-o no ambiente Scilab usando
load.
(b) Faça o gráfico da dispersão dos dados da tabela acima.
(c) Use a função datafit para obter os seguintes polinômios:
i. p1 (x) = a + bx;
ii. p2 (x) = a + bx + cx2 ;
iii. p3 (x) = a + bx + cx2 + dx3 ;
iv. y = axb ;
v. y = abx .
(d) Use a função splin - natural para ajustar os dados da tabela acima.
(e) Qual dos casos é o melhor ? Por quê ?
2. Seja a tabela contendo o tempo de germinação de sementes (dias) em função da temperatura média do
solo (◦ C) para doze locais de plantio:
Temperatura (◦ C) 14 6 3 6 7 6 7 4 8 7 6 4
Germinação (dias) 10 26 41 29 27 27 19 28 19 31 29 33
(a) Faça o diagrama da dispersão dos dados;

(b) Use a função datafit para determinar uma relação entre temperatura e o tempo de germinação das
sementes;
(c) Faça o gráfico com a função encontrada e o diagrama de dispersão.
3. Um automóvel, viajando por uma estrada reta, é cronometrado em diversos pontos. Os dados dessas
observações são apresentados na tabela a seguir:
Tempo (s) 0 3 5 8 13
Distância (ft) 0 225 383 623 993
Velocidade (ft/s) 75 77 80 74 72
Use um spline cúbico restrito para prever a posição do automóvel e sua velocidade quanto t = 10s.
4. Suspeita-se que o alto conteúdo de tanino existente nas folhas maduras do carvalho inibe o crescimento
das larvas da mariposa de inverno, que danificam severamente essas árvores em certos anos. A tabela a
seguir relaciona o peso médio de duas amostras de larvas em vários momentos durante o perı́odo de 28
dias após o nascimento. A primeira amostra foi cultivada em folhas de carvalho novas e a segunda, em
folhas maduras da mesma árvore.
(a) Faça o gráfico de dispersão dos dados;
41
Dia 0 6 10 13 17 20 28
Peso médio da amostra 1 (mg) 6.67 17.33 42.67 37.33 30.1 29.31 28.74
Peso médio da amostra 2 (mg) 6.67 16.11 18.89 15 10.56 9.44 8.89
(b) Use um spline cúbico natural para aproximar a curva de peso médio de cada amostra;
(c) Encontre uma aproximação do peso médio máximo para cada amostra determinando o ponto máximo
do spline;
(d) Faça um gráfico com as duas curvas, em cores diferentes e com legenda para cada curva, juntamente
com a dispersão dos dados.
5. O custo do seguro saúde nos Estados Unidos para os anos de 1994–2001, em bilhões de dólares, é dado
pela tabela:
Ano 1994 1995 1996 1997 1998 1999 2000 2001

Seguro Saúde 55.8 58.0 56.6 59.3 63.6 65.7 70.6 75.0
(a) Faça o gráfico de dispersão dos dados;

(b) Use a função datafit para ajustar uma curva que melhor modelo o custo do seguro saúde ao longo
dos anos;
(c) Gere um gráfico com a função encontrada e a dispersão dos dados.
6. O Consumer Price Index (CPI) é uma medida da média de preços, num determinado perı́odo, de serviços
e produtos. Para estabelecer uma base para comparação, a média anual de preços mensais nos anos de
1982–84 é usada para gerar os dados que segue na tabela abaixo para produtos derivados do tabaco. A
tabela representa a porcentagem de consumo deste produto.
Ano 1970 1975 1980 1985 1990 1995 1999 2000 2001
Tabaco (CPI) 43.1 54.7 72.0 116.7 181.5 225.7 355.8 374.9 425.2
(a) Faça o gráfico da dispersão destes dados;

(b) Usando a função datafit ajuste a melhor curva para estes dados;
(c) A curva pode ser uma reta ? Por quê ?
(d) Acrescente no gráfico do item (a) a curva obtida;
(e) Usando a curva obtida, qual será o CPI do tabaco em 2010 ?
7. Anualmente, o governo dos Estados Unidos gasta boa parte do seu dinheiro com a dı́vida interna. A
tabela que segue mostra a porcentagem destinada para o pagamento da dı́vida interna para os anos de
1991–2002.
Ano 1991 1993 1995 1997 1999 2001 2002

% gasta 21.6 20.8 22.0 22.2 20.7 19.3 16.4

(b) Usando a função datafit ajuste a melhor curva para estes dados;
42
(c) Acrescente no gráfico do item (a) a curva obtida;

(d) Usando a curva obtida, qual será o gasto com a dı́vida interna em 2010 ?
8. O census nos Estados Unidos é realizado a cada 10 anos. A tabela abaixo mostra o census realizado
desde 1940 até 2000 (em milhão).
Ano 1940 1950 1960 1970 1980 1990 2000

População U.S. 132 151 179 203 227 249 281

(b) Usando a função datafit ajuste para uma curva linear;
(d) Usando a curva obtida, estime a população em 2010 e 2020;
(e) Usando a curva obtida, estime o ano que a população atingirá 320 milhões.
9. A empresa Delta Airlines publicou uma tabela mostrando a temperatura (em F◦ ) fora do avião quando este
troca de altitude (em 1000 pés).
x (Altitude em 1000 pés) 1 5 10 15 20 30 36.087

y (Temperatura) 56 41 23 5 -15 -47 -69

(b) Usando a função datafit ajuste para uma curva linear;
(d) Usando a curva obtida, determine a temperatura a 40000 pés.
43
CAPÍTULO 6
Gráficos Tri-Dimensionais
6.1 Gráficos Tri-dimensionais

O comando plot3d() permite traçar gráficos de superfı́cies z = f (x, y).
Na notação Scilab, as variáveis independentes x e y são vetores de dimensão n1 e n2, respectivamente,
e a variável z é uma matriz de dimenção n1 x n2. Então, por essa definição, o elemento z(i,j) é o valor da
superfı́cie no ponto ( x(i), y(j) ).
Para exemplificar o uso de plot3d(), vamos considerar a função f (x, y) = cos(x) · sen(y) no intervalo [0, 2π],
com incremento 0.1 (graf tri.sci).
x = [0:0.1:2*%pi]’;
y = x;
z = cos(x)*sin(y’);
plot3d(x, y, z)
Além da função plot3d(), e de suas variações, o Scilab implementa outras funções que permitem traçar
gráficos tri-dimensionais. Dentre elas, destacamos:
• fplot3d: permite traçar gráficos de superfı́cies por funções, como no exemplo abaixo (graf fplot3d.sci):
clear
clf()
deff( ’z = f(x, y)’, ’z = x.^4 - y.^4’ )
x = linspace(-3,3, 30);
y = x;
fplot3d( x, y, f, alpha = 5, theta = 31 )
• fplot3d1: permite traçar gráficos de superfı́cies definidas por funções, como no caso anterior. Neste caso,
as superfı́cies são apresentadas em uma graduação de cores diferente do comando acima.
6.1.1 Gráficos 3-D Especiais

As seguintes funções permitem traçar gráficos tri-dimensionais especiais:
• param3d: permite traçar curvas paramétricas.
• hist3d: permite traçar histogramas 3-D.

Gráficos Tri-dimensionais CAPÍTULO 6. GRÁFICOS TRI-DIMENSIONAIS
• contour: permite traçar curvas de nı́vel para uma função 3-D.
// Exemplos de graficos 3-D especiais (graf_3dEsp.sci)
subplot(1,2,1)
param3d
subplot(1,2,2)
hist3d
Devo ressaltar que a sintaxe de todos os comandos pode ser verificada usando o help do Scilab.
Acompanhe mais este exemplo (param.sci) com algumas funções especiais para gráficos 3-D.
clear
clf()
subplot(2,2,1)
x = linspace(0, 10*%pi);
param3d(sin(x), cos(x), x)
subplot(2,2,2)
clear
x = linspace(0,3*%pi)’;
z1 = sin(x);
z2 = sin(2*x);
z3 = sin(3*x);
y1 = zeros(x);
y3 = ones(x);
y2 = y3/2;
param3d1([x, x, x], [y1, y2, y3], list([z1, z2, z3], [2 3 4]))

// list([z1, z2, ..., zn], [colors]): o segundo elemento serve para
// atribuir cores para cada curva.
subplot(2,2,3)
clear
x = %pi*[-10:10]/10;
y = x;
deff(’z = f(x, y)’, ’z = sin(x)*cos(y)’)

fcontour(x, y, f, 8) // ultimo elemento: no. de curvas de nivel
subplot(2,2,4)
clear
t = linspace(-2,2);
45
Detalhes da Função plot3d CAPÍTULO 6. GRÁFICOS TRI-DIMENSIONAIS
deff(’z = f(x, y)’, ’z = 3*x - x^3 - 3*x*(y - 5)^2’)

z = feval(t, t, f);
contour(t, t, z, 15)
Qual a diferença entre param3d e param3d1 ? E entre contour e fcontour ?
6.2 Detalhes da Função plot3d

Apresentamos aqui algumas ferramentas adicionais para a execução de gráficos 3D em ambiente Scilab,
uma vez que a função plot3d inclui os seguintes formatos:
• plot3d( x, y, z, [theta, alpha, leg, flag, ebox] );
• plot3d( x, y, z, <opt args> ) (neste caso, possui as mesmas opções da função plot2d);
• plot3d( xf, yf, zf, [theta, alpha, leg, flag, ebox] );
• plot3d( xf, yf, zf, <opt args> );
• plot3d( xf, yf, list(zf, colors), [theta, alpha, leg, flag, ebox] );
• plot3d( xf, yf, list(zf, colors), <opt args> ).
onde:
• x, y, z são as coordenadas dos eixos x, y e z , respectivamente;
• theta e alpha são valores dados para a visualização da janela gráfica 3D (o ângulo usado para visualização
da figura);
• leg é usado para definir uma legenda para cada eixo, separado por @, por exemplo: X@Y@Z;
Atenção: Na função plot2d, leg é usado para atribuir uma legenda em casa curva disposta na mesma
janela gráfica.
• xf, yf e zf são matrizes de tamanho (nf, n), onde define-se as faces usadas para desenhar a superfı́cie.
No caso, existem n faces, e cada face é definida por uma malha com nf nós.
• flag é um vetor com três números: flag = [mode, type, box], sendo:
– mode usa um valor inteiro para colorir a superfı́cie desenhada (veja o help para explorar a escala de
cores – surface properties);
– type ajusta automaticamente a escala da figura, usadondo valores inteiros de 0 a 6;
– box modela o tipo de escala da figura (veja axes properties).
• ebox estabelece os limites do gráfico. O valor associado à essa opção é um vetor real com seis entradas
[xmin, xmax, ymin, ymax, zmin, zmax], onde xmin, xmax, ymin, ymax, zmin e zmax indicam os valores
mı́nimos e máximos para os eixos x, y e z, respectivamente.
46
6.2.1 Função eval3d e eval3dp

As funções eval3d e eval3dp criam uma malha para fazer o gráfico de uma função em três dimensões.
• z = eval3d(funcao, x, y):
– funcao: uma função que aceita vetores como argumento;

– x, y; vetores de tamanhos (1, n1) e (1, n2), mas é aconselhável que os argumentos x e y tenham
o mesmo tamanho;
– z: matriz de tamanho (n1, n2) (malha de nós pela intersecção dos vetores x e y).
– Exemplo (ex eval3d.sce):
x=-5:5;y=x;
deff(’z = f(x,y)’, ’z = x.*y’);
z=eval3d(f,x,y);
plot3d(x,y,z);
• [xf, yf, zf] = eval3dp(funcao, p1, p2), calcula as faces de uma superfı́cie paramétrica 3D, onde:
– [xf, yf, zf]: matrizes de tamanho ( 4, (n-1)*(m-1) ). O elementos xf(:, i), yf(:, j) e
zf(:, i) são as coordenadas dos eixos x, y e z , respectivamente, de 4 pontos dos 4 lados de cada
face;
– funcao: uma função implementada em ambiente Scilab;
– p1: um vetor de tamanho n;
– p2: um vetor de tamanho m;
– Exemplo (ex eval3dp.sce):
p1=linspace(0,2*%pi,20);
p2=linspace(0,2*%pi,20);
deff("[x,y,z] = sp(p1,p2)", ["x=p1.*sin(p1).*cos(p2)";..
"y=p1.*cos(p1).*cos(p2)";..
"z=p1.*sin(p2)"])
[xf,yf,zf]=eval3dp(sp,p1,p2);
plot3d(xf,yf,zf)
6.2.2 Exemplo
// spline_solido.sce
clear
clf()
x = [0:0.2:4];
y = sqrt( 4 - (x - 2)^2 );
subplot(2,2,1)
plot2d(x, y, -1, rect = [-0.1 -0.1 4.1 2.1])
b = splin(x, y, ’natural’);
xx = linspace(0,4);
yy = interp(xx, x, y, b);
47
plot2d(xx, yy, 2)
xtitle(’Grafico da Interpolacao por vetores’)
subplot(2,2,2)
deff(’ys = fs(xs)’, ’ys = interp(xs, x, y, b)’);
plot2d(x, y, -1, rect = [-0.1 -0.1 4.1 2.1])

fplot2d(xx, fs, 3)
xtitle(’Grafico da Interpolacao por funcao’)
subplot(2,2,3)
deff( ’[xa,ya,za] = revol(zp, theta)’, [’xa = fs( zp ) .* cos( theta )’,...

’ya = fs( zp ) .* sin( theta )’,...
’za = zp’] );
// A nova discretizacao
zp = linspace( min( x ), max( x ), 30 );
theta = linspace( 0, 2*%pi, 30 );
// Faces do poligono (coisa de computacao grafica...)

[xf, yf, zf] = eval3dp( revol, zp, theta );
// O grafico, finalmente!
plot3d( xf, yf, zf, alpha = 88, theta = 35 );
xtitle(’Solido de revolucao’)
subplot(2,2,4)
plot3d( xf, yf, zf, alpha = 85, theta = 30, flag = [30, 2, 3] )
xtitle(’Solido de revolucao com outra cor!’)
6.2.3 Outro Exemplo

// solido_ex.sce
clear
clf()
subplot(1,2,1)
deff(’y = f(x)’, ’y = exp(-x.^2)’)
x = linspace( -2, 2 );
fplot2d( x, f, 2, rect = [-2, 0, 2, 1.2] )
subplot(1,2,2)
deff(’[xs, ys, zs] = rev(r, t)’, [’xs = f(r) .* cos(t)’, ...
’ys = f(r) .* sin(t)’, ’zs = r’])
r = linspace( -2, 2, 30 );
t = linspace( 0, 2*%pi, 30 );
48
[xf, yf, zf] = eval3dp( rev, r, t );
plot3d( xf, yf, zf, alpha = 82, theta = 50, flag = [17, 2, 3] )
6.3 Exercı́cios
1. Faça o gráfico das funções abaixo:
p
(a) f (x, y) = x2 + y 2 ; (g) f (x, y) = 1 − x2 − y 2 ;
(b) f (x, y) = xy + 3x; p
(h) f (x, y) = x2 + y 2 ;
(c) f (x, y) = x2 + y 2 − 1;
(i) f (x, y) = y − sen(x);
(d) f (x, y) = 5;
(e) f (x, y) = y 2 + 3x; (j) f (x, y) = x2 − y ;
(f) f (x, y) = xy 3 + 4x2 − 2; (k) f (x, y) = 4x2 + y 2 .
2. Esboce graficamente as curvas de nı́vel associadas a f :
(a) f (x, y) = y 2 − x2 ;
(b) f (x, y) = xy ;
(c) f (x, y) = 3x − 2y ;
(d) f (x, y) = x2 + y 2 .
3. Faça o sólido de revolução das seguintes funções (escolha o intervalo e o eixo de rotação adequada-
mente):
1
(a) f (x) = x3 ; (g) f (x) = (x−4)2 ;
√
(b) f (x) = x − 1; (h) f (x) = −(4 + x2 );
(c) f (x) = |x|; √
1 (i) f (x) = 2 − x;
(d) f (x) = x;
√ (j) f (x) = ln(x);
(e) f (x) = 4 − x2 ;
√
(f) f (x) = x2 − 4; (k) f (x) = e−x .
49
CAPÍTULO 7
Exercı́cios Adicionais
1. Podemos definir as funções seno, cosseno e tangente hiperbólicos como:
ex − e−x ex + e−x ex − e−x

sinh (x) = , cosh (x) = , tanh (x) =
2 2 ex + e−x
• Escreva três funções no Scilab que implementem o seno, o cosseno e a tangente hiperbólicos;
• Escreva um programa que utilize suas funções para desenhar a forma das funções seno, cosseno e
tangente hiperbólicos numa mesma janela gráfica.
2. O produto vetorial × entre dois vetores V1 e V2 é definido como:
V1 × V2 = (Vy1 Vz2 − Vy2 Vz1 ) i + (Vz1 Vx2 − Vz2 Vx1 ) j + (Vx1 Vy2 − Vx2 Vy1 ) k
onde V1 = Vx1 i + Vy1 j + Vz1 k e V2 = Vx2 i + Vy2 j + Vz2 k.
• Escreva uma função para calcular o produto vetorial de dois vetores V1 e V2 . Note que essa função
retorna um vetor real como resultado;
• Utilize a função para calcular o produto vetorial dos vetores V1 = [−2, 4, 0.5] e V2 = [0.5, 3, 2].
3. Escreva uma função chamada “min max” que tente localizar os valores máximos e mı́nimos de uma função
real f (x) arbitrária dentro de um intervalo fixo [a, b]. Os argumentos de entrada de min max devem ser:
• func – O nome da função;

• prim val – O primeiro valor de x (a, no intervalo de busca);
• ult val – O último valor de x (b, no intervalo de busca);
• passos – O número de passos de busca.
Os seguintes argumentos de saı́da devem ser:
• xmin – O valor de x no qual o mı́nimo foi encontrado;

• min value – O mı́nimo encontrado de f (x);
• xmax – O valor de x no qual o máximo foi encontrado;
• max value – O máximo encontrado de f (x).
4. Escreva um programa de teste para a função min max criada no exercı́cio anterior. O programa deve
passar para min max uma função definida pelo usuário f (x) = x3 − 5x2 + 5x − 2, e encontrar o mı́nimo e
o máximo com 200 passos no intervalo −1 ≤ x ≤ 3. Os valores resultantes de mı́nimo e máximo devem
ser impressos.
5. A derivada de uma função contı́nua f (x) é definida pela equação:
d f (x + ∆x) − f (x)
f (x) = lim
dx ∆x→0 ∆x
Em uma função amostrada, a definição se torna:
f (xi+1 ) − f (xi )
f ′ (xi ) = (7.1)
∆x
onde ∆x = xi+1 − xi . Suponha que um vetor vect contém nsamp amostras de uma função espaçadas de
dx.
• Escreva uma função que calcule a derivada desse vetor usando a aproximação em (7.1). A função
deve verificar se dx é maior que zero para previnir erros de divisão por zero na função.
• Para verificar sua função, você deve gerar um conjunto de dados cuja derivada seja conhecida e
comparar o resultado da função com a resposta correta. Uma boa escolha para uma função de teste
é f (x) = sen(x). Do cálculo elementar, sabemos que f ′ (x) = cos(x). Gere um vetor com 100 valores
da função f (x) = sen(x), iniciando com x = 0 e utilizando um passo ∆x = 0.05. Calcule a derivada
do vetor com a sua função e compare os resultados com a resposta correta.
• Faça um gráfico com os valores calculados pela equação (7.1) de maneira discretizada e um gráfico
da função f (x) = cos(x) contı́nua.
Quão próximo ficou a sua função do cálculo da resposta correta para a derivada ?
6. A força gravitacional F entre dois corpos com massas m1 e m2 é dada pela equação:
G m1 m2
F =
r2
onde G é a constante gravitacional 6.672 × 10−11 N m2 /kg 2 , m1 e m2 são as massas dos corpos em

quilogramas e r é a distância entre os dois corpos. Escreva uma função para calcular a força gravitacional
entre dois corpos dadas as suas massas e a distância entre eles. Teste a sua função determinando a
força sobre um satélite de 800 kg em órbita a 38000 km da superfı́cie da Terra. (A massa da Terra é de
5.98 × 1024 kg .)
7. Suponha que você tenha uma quantidade de dinheiro P em um investimento no banco (usamos P para in-
dicar valor presente). Se o banco pagar os juros com taxa de i% ao ano e compuser os juros mensalmente,
a quantidade de dinheiro que você terá no banco depois de n meses será dada pela equação:
n
i
F =P 1+
1200
i
onde F é o valor futuro da conta e é a taxa de juros mensal (o fator extra de 100 no denominador
12
converte a taxa de interesse de porcentagens para frações). Escreva um programa para ler uma quantia
inicial P e uma taxa de juros anual i, calcular e gerar uma matriz do valor futuro do investimento a cada
mês dos próximos cinco anos.
51
CAPÍTULO 7. EXERCÍCIOS ADICIONAIS
√
8. Os antigos babilônios usavam a seguinte aproximação (baseada no Método de Newton) para calcular a:

1 a
xk+1 = xk +
2 xk
√
Escreva uma função para calcular a usando a aproximação acima:
• A sua função deve receber um chute inicial para a raiz;

• Execute o cálculo acima até que |xk+1 − xk | < ǫ, onde ǫ é um valor suficientemente pequeno;
√ √ √
• Use a sua função para calcular 25, 21 e 5000, e compare com os valores fornecidos pela calcu-
ladora e/ou pelo Scilab.
√
9. Usando o método de Newton, podemos calcular a raiz p a, a ≥ 0 através da seguinte fórmula de recorrêcia:
!
1 a
xx+1 = (p − 1)xk + p−1 , com x0 > 0.
p xk
√
Escreva uma função para calcular p
a usando a aproximação acima:
• A sua função deve receber um chute inicial para a raiz e a sua potência (p);
• Execute o cálculo acima até que |xk+1 − xk | < ǫ, onde ǫ é um valor suficientemente pequeno;
√ √ √
• Use a sua função para calcular 3 125, 4 14641 e 3 14, e compare com os valores fornecidos pela
calculadora e/ou pelo Scilab.
10. O Método de Newton pode ser aplicado a qualquer equação contendo funções cujas derivadas possam
ser calculadas. Por exemplo, ache uma aproximação para o recı́proco de um número positivo C , definindo
a função f (x) = x1 − C e aplicando o Método de Newton.
Observação: O Método de Newton aplicado a essa função nos permite calcular o inverso de um número
sem efetuar nenhuma divisão! Este método é útil porque, na maioria dos computadores de alta velocidade,
a operação de divisão consume mais tempo do que várias multiplicações e adições juntas.
• Escreva uma função (no inverso.sci)para este problema onde devemos fornecer apenas o número
C.
• Escreva um programa que leia a função no inverso.sci e execute a função para um dado C .
Dado x0 , f (x), f ′ (x), max e ǫ

1: Para k = 0 até k = max faça
f (xk )
2: xx+1 = xk − ′
f (xk )
3: Se |f (xk+1 )| ≤ ǫ ou |xk+1 − xk | ≤ ǫ então
4: PARE, x = xk+1
6: Se k = max então
7: PARE, o método não converge para a solução.
9: Fim do laço
Algoritmo 2: Método de Newton-Raphson
52
Referências Bibliográficas
[1] R. L. Burden, J. D. Faires. Análise Numérica. Pioneira Thomson Learning, 2003.
[2] F. F. Campos Fo. Algoritmos Numéricos. LTC Editora, 2001.
[3] S. J. Chapman. Programação em Matlab para Engenheiros. Pioneira Thomson Learnin, 2003.
[4] D. Hanselman, B. Littlefield. Matlab 6 – Curso Completo, Pearson Prentice Hall, 2003.
[5] D. R. Hill, D. E. Zitarelli. Linear Algebra Labs with Matlab. Third Edition, Pearson Prentice Hall, 2004.
[6] E. Y. Matsumoto. Matlab 7: Fundamentos. Editora Érica, 2004.
[7] P. S. M. Pires. Introdução ao Scilab: versão 3.0. http://www.dca.ufrn.br/~pmotta
[8] www.rau-tu.unicamp.br/scilab/
[9] http://www.scilab.org
53

Apostila LMC-scilab

Enviado por

Direitos autorais:

Formatos disponíveis

Apostila LMC-scilab

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila LMC-scilab

Enviado por

Direitos autorais:

Formatos disponíveis

L ABORAT ÓRIO DE M ATEM ÁTICA C OMPUTACIONAL – S CILAB

Luiza Amalia Pinto Cantão

1 Introdução ao Ambiente Scilab 2

2 Álgebra Linear Numérica 7

5 Ajuste de Curvas em Ambiente Scilab 35

Introdução ao Ambiente Scilab

1.1 O Ambiente Scilab

Consortium Scilab (DIGITEO)

• File – possui oito sub-opções (apresentaremos as quatro mais importantes):

– Execute: executa o conteúdo de arquivos (roda o programa implementado).

--> // pressione Ctrl-c e <enter>

– Interrupt – interrompe a execução de um programa.

• Applications – aplicativos do ambiente Scilab:

– Editor – abre um editor de texto próprio para programação em ambiente Scilab.

• ? – informações e ajuda sobre o ambiente Scilab. Esta possui quatro sub-opções:

– Scilab Help: informações sobre os comandos do ambiente Scilab.

1.2 Variáveis Especiais

Your variables are:

help about home matiolib

tclscilib m2scilib maple2scilablib metanetgraph_toolslib

using 34531 elements out of 5000000.

Your global variables are:

%modalWarning demolist %helps %helps_modules

using 2966 elements out of 10999.

Vejamos o significado das variávies mais recorrentes:

Variável O que significa Variável O que significa

-->SCI // Diretorio onde o Scilab foi instalado

-->PWD // Diretorio onde o Scilab foi lancado

-->home // Mesmo valor da variavel PWD

1.3 Arquivos *.sce de Comandos

x = input(’Entre com o valor de x’); // Entrada do valor de x via teclado!

format(’v’, 100); S // no. de elementos na representacao de ’S’

for (i = 1:30000) // somatorio de 1 ate 30000

end // Final do ’for’

-->pwd // verifique se esta no diretorio onde gravou o 1oTeste.sce

-->exec(’soma.sce’) // executa o programa ’1oTeste.sce’

O comando exec(’nome-do-arquivo.sce’) executa o programa gerado.

// Primeiro teste de LMC -- Controle de presenca

a = 2; // a = aulas por semana

x = (30*c)/100 // 30 --- porcentagem de faltas permitidas

y = int(x/2) // y ---- no. de dias que o aluno pode faltar

Álgebra Linear Numérica

--->v = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

que o resultado seria o mesmo.

! 0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 !

linspace( primeiro_valor, ultimo_valor, numero_de_elementos )

Se o número de elementos é omitido, a função gera automanticamente 100 elementos.

--> x = linspace( 0, %pi)

--> A = [1:5, 9:-1:5; 0:0.25:1, 1:-0.25:0]

Interprete o que aconteceu!

2.2.1 Matrizes Padrão

-->C = eye(3,3) // eye(.) gera uma matriz identidade

O comando rand(m, n) cria uma matriz m × n com entradas aleatórias no

-->a = 1:4 // Comece com um vetor simples

-->diag(a) // diag(.) coloca os elementos na diagonal principal

-->diag(a,1) // Coloca os elementos uma posicao acima da diagonal

-->diag(a,-2) // Coloca os elementos duas posicoes abaixo da diagonal

--> d = %e; // Escolha do numero ’e’ para este exemplo

2.3 Acesso aos elementos

(a) ab^2 > ac; (b) d | b > a.