Bacharelado Interdisciplinar em Ciência e Tecnologia

UFERSA

Cálculo numérico
Prof. Matheus Menezes

Guia de Laboratório 01
Introdução ao OCTAVE

Índice
1. Introdução.................................................................................................................. 1
2. Objetivos.................................................................................................................... 1
3. Introdução ao OCTAVE................................................................................................ 2
3.1. O que é o OCTAVE............................................................................................................................................. 2
3.2. Visão Geral do Ambiente OCTAVE................................................................................................................. 2
3.3. Operações Simples............................................................................................................................................ 3
3.4.Definindo o tipo da variável............................................................................................................................. 4
3.5.Funções Pré-definidas........................................................................................................................................ 6
3.6. Vetores................................................................................................................................................................. 6
3.7. Funções................................................................................................................................................................. 7
3.8. Gráficos................................................................................................................................................................. 9
3.8.1. Inserindo mais de uma função no mesmo gráfico...................................................................................10

1. Introdução

O curso de Bacharelado Interdisciplinar em Ciência e Tecnologia ora em prática na UFERSA –

Universidade Federal Rural do Semi-Árido, visa capacitar profissionais aptos a atuar nas áreas que
englobam o uso de ciência e tecnologia agregadas, além de dar o embasamento acadêmico para
alguns cursos de segundo ciclo.

A carga teórica aplicada nas disciplinas ministradas na universidade serve de embasamento para o
conhecimento científico. Contudo, devido a limitação de carga horária e da própria ementa das
disciplinas, a aplicação prática muitas vezes é renegada a segundo plano, deixando a formação do
aluno incompleta no que diz respeito à tecnologia aplicada para resolver vários tipos de problemas.

A simulação numérica e computacional é uma realidade no mercado de trabalho, principalmente nas

empresas de engenharia e tecnologia. Através da simulação, é possível investigar detalhadamente os
aspectos e consequências referentes à implantação de algum processo ou empreendimento,
avaliando o impacto de suas variáveis no sistema final. Desta forma, este conhecimento prático é de
fundamental importância para o futuro egresso do curso.

2. Objetivos

A presente guia de laboratório tem por objetivo apresentar alguns conceitos básicos de utilização do
programa OCTAVE, de forma a servir de embasamento para o desenvolvimento de atividades na
disciplina de cálculo numérico.
Ao fim dessa aula, é esperado que o aluno tenha noções básicas de utilização do programa,
possibilitando assim aplicar métodos numéricos para a resolução dos problemas propostos na
disciplina. Vale salientar que este conhecimento pode ter sua aplicação estendida a várias outros
componentes curriculares do curso, e posteriormente a sua utilização em desenvolvimento de
pequisas e no mercado de trabalho.
Ao concluir esta guia de laboratório, é esperado que o aluno seja capaz de:
(a) Ter uma visão geral sobre o programa OCTAVE.
(b) Executar comandos simples e usar o prompt como uma calculadora básica.
(c) Usar algumas funções pré-definidas do programa
(d) Criar um vetor a partir de suas componentes e também a criação de vetores com valores
igualmente espaçados;
(e) Criação de funções;
(f) Criação de gráficos bidimensionais simples.

3. Introdução ao OCTAVE

3.1. O que é o OCTAVE

O OCTAVE é um ambiente de programação matemática que inclui suporte a computação algébrica

bastante flexível. Faz parte do projeto GNU, sendo um software livre sob os termos da licença GPL.
Possui versões para Linux, Windows e macOS, podendo ser encontrado para download no seguinte
endereço: https://www.gnu.org/software/octave/

O OCTAVE possui como principais facilidades:

• Janela de comandos (prompt de comandos);

• Editor de variáveis;
• Várias funções matemáticas já implementadas;
• Definição de tipos básicos de variáveis matemáticas como vetores, matrizes e polinômios;
• Linguagem de fácil aprendizado;
• Possui geração de gráficos integrada;
• Permite a definição de funções e scripts;
• Sistema de documentação (ajuda do OCTAVE) de fácil utilização.
• Possui alto grau de compatibilidade com o MATLAB

3.2. Visão Geral do Ambiente OCTAVE

A interface de programação do ambiente OCTAVE é simples e intuitiva. As principais funções estão

divididas em janelas que se encaixam na página principal da interface (Figura 1).

O Navegador de Arquivos permite que você navegue entre os diretórios de seu computador. O
Diretório Atual é definido logo acima da janela de comandos. O prompt de comandos fica localizado
na janela de comandos e permite a inserção e execução imediata de códigos. As variáveis criadas e
suas propriedades são listadas no Ambiente de Trabalho e os comandos usados recentemente ficam
acessíveis no Histórico de Comandos. Vamos falar inicialmente como operar o OCTAVE através da
sua janela de comandos.
 Figura 1: Visão Geral do Ambiente OCTAVE

3.3. Operações Simples

O prompt de comandos serve para que se possa inserir diretamente os comandos que serão
interpretados pelo OCTAVE. Para começar a utilização, no prompt de comando, digite a seguinte
expressão:

3 + 2 

O resultado será:

ans = 5

Ou seja, a variável de sistema ans está armazenando o valor da última operação realizada que é igual
a 5. Agora digite a seguinte sequência de comandos:

a= 3 
b= 2 
c= a + b 

Observe que agora estamos utilizando variáveis para armazenar os valores. A variável c tem o valor 5
armazenado, que é o resultante da operação de soma dos valores das variáveis a e b. Essas variáveis
podem ser visualizadas também na janela Ambiente de Trabalho.
Os operadores aritméticos utilizados no OCTAVE são os seguintes:

“+” → soma “ * ” → multiplicação “^” → exponenciação

“-” → subtração “ / ” → divisão

Para limpar a tela sem apagar as variáveis, utilizamos o comando

clc 

Para apagar uma variável da memória, utilizamos o comando clear “nome da variável” Por
exemplo, temos que a variável c armazena o valor 5; podemos constatar esse fato digitando o
comando c  . Para apagar a variável c da memória, digitamos o comando.

clear c 

O ponto e vírgula ( ; ) ao fim de uma linha de comando suprime a apresentação do resultado.

Observe a diferença inserindo os comandos:

c = a + b 
c = a + b ; 

Os nomes de variáveis (também conhecidos por identificadores) devem obedecer às seguintes

regras:

1. Nomes de variáveis começam com uma letra seguido de letras, algarismos ou sublinhados.
Por exemplo: Alpha, notas, A1, B23 e cor_1;
2. Caracteres especiais não são permitidos;
3. Caracteres acentuados não são permitidos;
4. Há diferença entre maiúsculas e minúsculas. Por exemplo, variável Teste é diferente das
variáveis TESTE, teste e TestE.

De acordo com as regras acima, os seguintes nomes de variáveis são válidos: ALPHA, X, B1, B2,
b1, matricula e Media. Porém, estes nomes de variáveis são inválidos: 5B, Nota[1], A/B,
X@Z, média.

3.4.Definindo o tipo da variável

Como você deve ter observado, ao criar uma variável, não foi necessário definir o tipo do dado. Se
você digitar no prompt, por exemplo:

t = ‘abc1’ 
t = abc1

O Octave irá criar automaticamente a variável t do tipo char (caractere, ou melhor, um vetor de
caracteres, mas falaremos disso adiante). Isso ocorre pois o Octave é uma linguagem fracamente tipada,
ou seja, não é preciso definir o tipo das variáveis ao declará-las, e o tipo da variável pode ser alterado
a qualquer momento. Por exemplo, ao digitar no prompt:

t = 3 
t = 3

A variável t irá assumir o valor 3 e será definida como tipo double (confira na janela do ambiente de
trabalho). Então, o que devemos fazer se quisermos definir o tipo da variável t como inteiro?
Podemos ‘forçar’ o tipo digitando o comando

t = int32(t) 
t = 3

Aparentemente, nada mudou em relação ao resultado exibido no prompt, porém, na janela do

ambiente de trabalho pode ser verificada a mudança no tipo de dado. Tente executar, por exemplo, o
comando:

d = t /2 
d = 2

O valor esperado é 1.5, correto? Não se desespere. A explicação para isso é bem simples: O Octave
fez uma divisão do tipo inteira e o resultado também é atribuído a um número inteiro. (Não vamos
complicar muito agora. Falaremos sobre os conversões de dados de forma mais específica em outro momento).

Normalmente as constante numéricas são criadas considerando o valor “double precision (binary64)
floating-point format“ definido na norma IEEE 754. Para estes casos o resultado é exibido no prompt
do OCTAVE com cinco algarismos significativos.

Contudo, apesar de exibir dessa forma, o Octave trabalha internamente com uma precisão bem maior.
Por isso, é uma boa prática de programação armazenar os resultados em variáveis, no lugar de digitar
novamente os valores mostrados, para evitar erros nos resultados.

Existem dois outros resultados reconhecidos pelo Octave: Infinito (Inf) que resulta da divisão de um
número por zero, e o Not a Number (NaN) que é o resultado da divisão de zero por zero e outras
operações que geram resultados indefinidos.

Finalmente, é importante ter cuidado com os resultados de certas operações. Nem sempre o
resultado analítico coincide com o resultado numérico. Por exemplo

1-0.2-0.2-0.2-0.2-0.2 
ans = 5.5511e-17

Apesar do valor resultante ser bem pequeno, não é igual a zero. Uma das prováveis razões para isso é
que a conversão do número decimal 0.2 para a base binária (que é a base que os computadores trabalham
internamente para realizar os cálculos) é uma dízima e o resultado gerado é apenas uma aproximação do
resultado analítico.
3.5.Funções Pré-definidas

O OCTAVE possui um conjunto de funções pré-definidas e prontas para uso. Por exemplo, para
encontrar o valor do cosseno de c (que já está na memória armazenando um valor), inserimos o seguinte
comando.

cos(c) 

O que deveríamos fazer para atribuir este valor a uma variável?

As principais funções pré-definidas são listadas a seguir, lembrando que na ajuda (help) do programa,
temos uma lista detalhada de todas as funções disponíveis.

Tabela 1. Algumas funções predefinidas do OCTAVE

Função OCTAVE Descrição
abs(x) valor absoluto de x.
sin(x) seno de x.
asin(x) arco cujo seno é x.
cos(x) cosseno de x
acos(x) arco cujo cosseno é x
tan(x) tangente de x
atan(x) arco cuja tangente é x.
cotg(x) cotangente de x.
exp(x) exponencial de x.
log(x) logaritmo de x na base e.
log10(x) logaritmo de x na base 10.
log2(x) logaritmo de x na base 2.
sqrt(x) raiz quadrada de x.
mod(x,y) resto da divisão inteira de x por y
factorial(x) cálculo de x!

Que tal dar uma espiada nas funções do OCTAVE? Basta ir na guia DOCUMENTAÇÃO e buscar no índice de funções.

3.6. Vetores

Um vetor é definido com suas variáveis escritas entre colchetes e separadas por espaços ou por
vírgulas. Para criar um vetor coluna separamos os elementos por ponto e vírgula. Digite a sequência
de comandos a seguir para criar os vetores (o caractere % serve para delimitar um comentário e é ignorado
pelo programa):
 v1 = [1 -5 3 6]  %(vetor linha)
v2 = [2 ,5 , -1]  %(vetor linha)
v3 = [1; -5; 3; 6]  %(vetor coluna)

Para acessar qualquer elemento do vetor, deve-se utilizar o índice do elemento, por exemplo, para
acessar o valor -5 do vetor v1, devemos utilizar v1(2), pois estamos acessando a segunda posição
deste vetor.

O comando length( v1 ) retorna o número de elementos do vetor v1.

Um tipo de vetor bastante útil para utilização em tabelamento de funções é o vetor de índices, que
possui a seguinte forma geral:

variável = valor_inicial : incremento : valor_final

Para criar um vetor de índices, chamado I, no intervalo [1,3], com início em 1 e fim em 3, e
utilizando ainda um espaçamento de 0.5, digite o seguinte comando:

I = 1: 0.5: 3 

3.7. Funções

Funções são procedimentos no OCTAVE e servem para sintetizar várias operações em um só

comando. A definição de uma função inclui a recepção de dados por meio de uma lista de parâmetros
de entrada, e retorna resultados por uma lista de parâmetros de saída. As variáveis utilizadas nas
funções são locais, portanto, não interferem nas variáveis já em uso no programa. A forma geral de
uma função é:

function [y1,y2,...,ym] = nomedafuncao (x1,x2,...,xn)

<comandos>...
endfunction

Onde:
function Palavra reservada que indica o inicio de uma função.
nomedafuncao o nome da função é definido pelo usuário.
x1, x2,..., xn parâmetros de entrada.
y1, y2,..., ym parâmetros de saída.
<comandos> Comandos do OCTAVE a serem executados pela função.

Na função a seguir, temos que a entrada se dá pelos parâmetros a e b, enquanto o resultado

armazenado nas variáveis x e y são retornadas para a chamada.
function [x, y]=minhaF(a, b)
x=a+b
y=a-b
endfunction
No caso dessa função, após sua chamada, a variável x armazena o valor da soma dos parâmetros de
entrada, enquanto a variável y armazena a subtração dos mesmos. Após a definição da função, digite
no prompt:

a = 3;
c = 4;
[z,w]=minhaF(a,c) 
z 
w 

Observe que os parâmetros de entrada e as variáveis de saída não necessariamente possuem o

mesmo “nome”. Ao chamar a função minhaF(a,c), estamos passando ao programa dois
parâmetros, que são a = 3 e c = 4; O resultado da soma será armazenado na primeira variável de
retorno (z) e o resultado da subtração será armazenado na segunda variável de retorno (w).

Uma função pode ser criada no ambiente de trabalho, ou a partir de um arquivo de texto contendo a
função e salvo no diretório de trabalho. O arquivo deve ter o mesmo nome dado à função e a
extensão “.m” para que quando essa função for chamada dentro do programa o OCTAVE possa
localizá-la sem necessidade de nenhum comando adicional.

Podemos definir funções mais simples de duas outras maneiras:

• Utilizando o comando inline : Possui a sintaxe nome_func=inline(“corpo_da_função”). O

corpo_da_função deve ser uma variável string. Exemplo do uso do comando inline para definir
f=a+b:

f = inline("a+b") 
f = f(a, b) = a+b

f(2,3) 
ans = 5

• Utilizando o comando @ (): Possui a sintaxe: nome_func=@(var) corpo_da_função; O

corpo_da_função deve ser uma variável normal (não string). Exemplo do uso do comando @() para
definir g=a*b:

g = @(a,b) a*b ; 

g(2,3) 
ans = 6
3.8. Gráficos

Para construir gráficos simples em duas dimensões no OCTAVE, utilizamos o comando plot cuja
sintaxe básica é :

plot ([x],y)

onde x e y devem ser vetores de mesma dimensão. Nessa caso, o comando plot irá traçar o gráfico
de y em função de x.

Para construir o gráfico da função y=cos(x) no intervalo de [-3,3], com espaçamento de 0.1,
utilizamos os comandos:

x = -3:0.1:3 
plot (x,cos(x)) 

O comando grid insere linhas de grade no gráfico. Para mudar o tipo e a cor da linha do gráfico,
podemos utilizar o comando

plot (x,cos(x),”r--”) 

Onde o r indica que a cor será vermelho (red em inglês) e o “--” indica que a linha será tracejada. As
tabelas a seguir mostram as cores e os tipos de linha disponíveis.

Tabela 2 – Cores disponíveis para Linhas de Gráfico

Especificação Cor
r Vermelho (red)
g Verde (green)
b Azul (blue)
c Ciano (cyan)
m Magenta
y Amarelo (yellow)
k Preto (black)

w Branco (white)

Tabela 3 – Tracejados disponíveis para linhas de Gráfico

Especificação Estilo da linha
- Linha cheia (padrão)
-- Linha tracejada
: Linha pontilhada
-. Linha cheia com ponto
Para fazer o gráfico de p(x) = x3 – 9x + 5 no intervalo de [-5,5] com espaçamento 0.5,
podemos utilizar as seguintes instruções:

vx = -5:0.5:5 
plot (vx,vx.^3 - 9*vx + 5) 

Observe que utilizamos um ponto antes da exponenciação para que todos os elementos do vetor vx
sejam utilizados na operação. Uma outra forma de fazer o gráfico é definindo a função através do
comando @().

vx = -5:0.5:5 
f = @(x) x.^3-9*x + 5 ; 
plot (vx,f(vx)) 

Que tal testar a construção do gráfico utilizando outras formas de definir a função?

3.8.1. Inserindo mais de uma função no mesmo gráfico

Existem situações em que desejamos inserir mais de uma função no mesmo gráfico. Porém, por
padrão, o OCTAVE considera a exibição apenas do último gráfico enviado. Por exemplo:

vx = -4:0.5:4
plot (vx,cos(vx));
plot (vx,sin(vx));
grid

O código define a criação de um vetor denominado vx no intervalo de -4 a 4 com espaçamento de

0.5 e cria o gráfico do cosseno e do seno aplicado a este intervalo. Porém, apenas o último gráfico é
exibido (Ver figura 2A).

Para que as duas funções sejam exibidas no mesmo gráfico devemos utilizar o comando hold on.
Este comando faz com que o OCTAVE “espere” pela próxima função antes de finalizar o gráfico (Ver
figura 2B). E este comando é cumulativo, ou seja, vai inserir as funções no gráfico até que você insira
o comando hold off.

vx = -4:0.5:4
plot (vx,cos(vx));
hold on
plot (vx,sin(vx));
grid
 Figura 2. Exemplo de aplicação do comando hold

2A 2B