Minicurso de Octave_Matlab

Prévia do material em texto

 Home
Minicurso Octave/Matlab
Prof. MsC. Carlos de Castro
Bem vindos ao minicurso de Octave/Matlab.
Sumário
Conhecendo o programa
Principais janelas
Operações básicas
Matrizes e Vetores
        Operações com Matrizes e Vetores
Strings
Algumas funções especiais
Sistema linear
Plotando gráficos
Cálculo
        Instalação
        Limite
        Derivada
        Integral
        Gráficos das funções simbólicas
Programação
        Algoritmo
        Comando lógico-relacionais
        Laço FOR
        Laço WHILE
        If, Elseif e Else
        Switch, case, otherwise
        Funções
Conhecendo o programa
GNU Octave é uma linguagem de alto nível, construída inicialmente para computação numérica. Ela provê uma interface de linha de comando para resolver problemas lineares e não lineares numericamente e
executa outros experimentos numéricos que são compatíveis com MATLAB.
https://www.ime.usp.br/~carlos.castro/index.html
A imagem a seguir é a interface do MATLAB e OCTAVE.
Instalação
Acessar Site (lá tem tudo o que precisa saber, para todos os sistemas operacionais).
Principais janelas
Gerenciador de arquivos
https://www.gnu.org/software/octave/download]
É o local onde estarão os scripts e funções que você irá desenvolver para o Octave. Você pode alterar a localização da pasta, navegando no gerenciador.
Janela de Comandos
É o local onde onde podemos escrever e executar os programas, funções e fórmulas matemáticas.
Editor
No editor é onde você escreve seus scripts e funções, e salva-os na pasta. Esse arquivo salvo terá extensão .m e aparecerá no gerenciador de arquivos (caso você salve lá). Você poderá executar suas funções
chamando-as pelo nome na Janela de comandos ou clicando com o botão direito no arquivo, em gerenciador de arquivos, e clicar em Executar.
Para criar um script novo, clique no botão que fica no canto superior esquerdo, com o nome de Novo script
Ambiente de Trabalho
Essa janela irá aparecer todas as variáveis que estão ativas. Nele você pode ver o nome da variável, a classe (se é char - caractere, double - ponto flutuante real com dupla precisão, int - inteiro, etc), a
dimensão ( - vetor 'deitadinho' de 1 linha e 3 colunas) e o valor.
Histórico de comandos
Nesse ambiente, você poderá ver o histórico de comandos feitos, desde o momento da primeira abertura do programa.
Janela de troca de ambiente
Essa janelinha fica logo abaixo do editor ou da Janela de Comandos. Nela, você consegue trocar entre esses ambientes.
1 × 3
Aqui no Notebook, tanto os scripts, quanto a janela de comando são representadas na mesma célula, como a que vemos abaixo:
In [1]:
ans = 1.7321
x = 3
x = 9
x = 729
x = 2.8243e+11
x = 1.7970e+57
Na janela do octave:
Aqui no Jupyter, posso fazer tudo em uma mesma célula:
In [2]:
ans = 5
ans = 5
ans = 13
ans = 12
x = 5
Ou podemos fazer separadamente, pra ficar igual à janela de comando.
In [3]:
ans = 5
x = 3;
sqrt(3)
for i=1:5
 x = x**i
end
3+2
x=3;
y=2;
x+y
x+10
10+y
x=3+2;
x
3+2
In [4]:
In [5]:
In [6]:
ans = 5
In [7]:
ans = 13
In [8]:
ans = 12
In [9]:
In [10]:
x = 5
Como as células aqui do Jupyter são a mistura do editor de funções com a janela de comando, vamos utilizar apenas uma célula, quando conveniente, a partir de agora. :)
Caso queira rodar o kernel do Octave no Jupyter Notebook, acesse o git: https://github.com/Calysto/octave_kernel e veja como instalar no seu computador. Caso ainda não tenha jupyter, instala o Anaconda
por aqui https://anaconda.org/anaconda/jupyter e volta lá no Git do Octave_kernel para instalar.
Perceberam uma coisa interessante? O caractere ; faz com que você controle o que aparece ou o que não aparece na janela de comando. Vamos fazer um teste.
Na célula a seguir, vou fazer uma soma em looping, ou seja, vou pedir pro octave fazer uma soma de números naturais, de 1 até um n determinado. Para isso, usarei um loop for , que veremos mais pra
frente.
In [11]:
n = 15
soma = 0
soma = 1
soma = 3
soma = 6
soma = 10
soma = 15
x=3;
y=2;
x+y
x+10
10+y
x=3+2;
x
% Aqui eu vou esquecer o ;. O que vai acontecer?
n=15
soma = 0
for i = 1:n
 soma = soma + i
end
print = ['A soma de 1 até ' int2str(n) ' é ' int2str(soma) '.']
disp(print)
https://github.com/Calysto/octave_kernel
https://anaconda.org/anaconda/jupyter
soma = 21
soma = 28
soma = 36
soma = 45
soma = 55
soma = 66
soma = 78
soma = 91
soma = 105
soma = 120
print = A soma de 1 até 15 é 120.
A soma de 1 até 15 é 120.
Apareceu um monte de coisa que eu não queria. Como fazer para não aparecer? 
In [12]:
A soma de 1 até 100 é 5050.
Operações básicas
Operação Símbolo Exemplo
Adição 
Subtração 
Multiplicação 
Divisão usual 
n=100;
soma = 0;
for i = 1:n
 soma = soma + i;
end
print = ['A soma de 1 até ' int2str(n) ' é ' int2str(soma) '.'];
disp(print)
+ 3 + 2 = 5
− 3 − 2 = 1
∗ 3 ∗ 2 = 6
/ 3 / 2 = 1.5
Operação Símbolo Exemplo
Divisão ivertida* 
Potênciação ^ ou ^ 
Módulo (ou resto sob divisão Euclidiana) mod( , ) mod( , ) 
* jajá veremos para que isso serve.
Formato de número em ponto flutuante
Ao trabalhar com ponto flutuante (double ou float), é possível obter diversas visualizações desses números com o Octave. A seguir, vemos uma lista de alguns formatos possíveis:
Sintaxe formato Exemplo( )
format short precisão simples 3.1416
format long precisão dupla 3.14159265358979
format short precisão simples 3.1416e+00
format long precisão dupla 3.14159265358979e+00
format hex Hexadecimal 400921fb54442d18
format bank 2 casas decimais 3.14
Sintaxe formato Exemplo( )
format rat Quociente
Erro relativo 8.4914
Alguns comandos interessantes
help: Ao digitar >> help <function> na janela de comando do octave/matlab, aparecerá na mesma janela os detalhes acerca da função procurada.
Exemplo
In [13]:
'sin' is a built-in function from the file libinterp/corefcn/mappers.cc
 -- sin (X)
 Compute the sine for each element of X in radians.
 See also: asin, sind, sinh.
Additional help for built-in functions and operators is
available in the online version of the manual. Use the command
'doc <topic>' to search the manual index.
Help and information about Octave is also available on the WWW
∖ 3 ∖ 2 = 0.¯̄̄6
∗∗ 3 2 = 9
a b 3 2 = 1
π
e e
e e
≈ π
355/113
×10−8
help sin
at http://www.octave.org and via the help@octave.org
mailing list.
lookfor: O comando lookfor procura por um determinado texto na biblioteca do Octave/MatLab.
Exemplo
In [14]:
eig Compute the eigenvalues (LAMBDA) and optionally the right e
 igenvectors (V) and the left eigenvectors (W) of a matrix o
 or a pair of matrices.
ordschur Reorders the real Schur factorization (U,S) obtained with t
 he 'schur' function, so that selected eigenvalues appear in
 n the upper left diagonal blocks of the quasi triangular Sc
 chur matrix.
qz QZ decomposition of the generalized eigenvalue problem
condeig Compute condition numbers of a matrix with respect to eigen
 values.
polyeig Solve the polynomial eigenvalue problem of degree L.
eigs Calculate a limited number of eigenvalues and eigenvectors 
 of A, based on a selection criteria.
- Clc e Clear: O comando Clc e Clear apagam as informações da Janela de comando e da lista de variáveis no
"Ambiente de trabalho", respectivamente.
Who: lista todas as variáveis do "Ambiente de trabalho";
Quit: Sai do Octave/Matlab
Outros comandos
comando resulta em
pi
 ou se não foi usado como outra variável, 
eps Menor número tal que . Aqui na minha máquina: 
realmin Menor representação em ponto flutuante: 
realmax Maior representação em ponto flutuante: 
inf Infinito
NaN Not-a-number. Por ex.: 
Matrizes e vetores
lookfor eigenvalue
π
i j i = j = √−1
1 + eps > 1 eps = 2.2204e − 16
realmin = 2−1022
realmax = 21024
00
A construção de matrizes e vetores no Octave já está inclusa na instalação padrão do programa. Na sintaxe, o vetor é representado como um conjunto de números, separados em linhas e colunas, organizados
entre [] , de modo que:
A separação por espaço ` ou vírgula ,` representa números em uma mesma linha da matriz;
A separação por ; , nesse caso, representa números em diferentes linhas.
Exemplo
1) Para construir um vetor linha , basta criar a lista com seus elementos separados por , ou por espaço :
In [15]:
x =
 1 2 3 4
x =
 1 2 3 4
Exemplo
2) Para construir um vetor coluna , basta criar a lista com seus elementos separados por ; : (não se preocupe, o ponto e vírgula no final do vetor continua existindo).
In [16]:
y =
 1
 2
 3
 4
Exemplo
3) Para construir uma matriz de 3 linhas e 4 colunas, teremos que usar todos os separadores vistos anteriormente:
In [17]:
M =
 1 2 3
 4 5 6
x
x=[1 2 3 4]
x=[1,2,3,4]
y
y=[1;2;3;4]
z=[1;3;2;4];
M
M = [1 2 3;4,5,6;7,8 9]
%Para deixar mais bonito, sugiro sempre fazer da seguinte forma
M = [1 2 3;
 4 5 6;
 7 8 9];
 7 8 9
Obs: O Octave/Matlab aceita variáveis como entrada das matrizes.
Exemplo
In [18]:
M =
 10.00 100.00 3.16
 15.59 3.95 1.56
 3.14 6.28 0.00
Vetores linearmente espaçados
Na Álgebra Linear, Processamento de Sinais, Análise Numérica, etc, é comum utilizar de vetores com uma padronização entre os seus elementos. Essa padronização pode ser obtida de algumas maneiras,
especialmente
vetores linearmente espaçados, isto é, a se , então e 
A sintaxe para criar esses vetores é simples: Se quisermos um vetor , indo de até no máximo , com a distância entre seus elementos , basta fazermos
Exemplo
In [19]:
n = 0.20000
m = 0.50000
q = 0.029781
x1 =
 Columns 1 through 8:
 0.20000 0.22978 0.25956 0.28934 0.31912 0.34891 0.37869 0.40847
 Columns 9 through 11:
 0.43825 0.46803 0.49781
format bank
k=10;
x=sqrt(3)^5;
M = [k k^2 sqrt(k);
 x sqrt(x) x/k;
 pi 2*pi sin(pi)]
x = [x1,x2, ⋯ ,xk]T xi − xi−1 = r, r ∈ R ∀i ∈ [1, k].
x n ∈ R m ∈ R q ∈ R
x = [n : q : m].
format short
n=0.2
m=0.5
q=1/sqrt(1127.5)
x1=[n:q:m]
Vetores linearmente espaçados, determinado o número de elementos do vetor.
Aqui, usaremos a função >>linspace(n, m, N) , em que é o primeiro elemento do vetor, é o último elemento do vetor e é o número de elementos do vetor.
Exemplo
In [20]:
n = 0.20000
m = 0.50000
N = 11
x2 =
 Columns 1 through 8:
 0.20000 0.23000 0.26000 0.29000 0.32000 0.35000 0.38000 0.41000
 Columns 9 through 11:
 0.44000 0.47000 0.50000
OBS: Veja que os dois métodos construíram vetores diferentes, com o mesmo número de elementos e determinados o mesmo e .
In [21]:
erro = 0.0042938
ERRO =
 Columns 1 through 6:
 0.0000000 -0.0002188 -0.0004377 -0.0006565 -0.0008753 -0.0010942
 Columns 7 through 11:
 -0.0013130 -0.0015318 -0.0017507 -0.0019695 -0.0021883
Acessando elementos de matrizes e vetores
Dada uma matriz
como podemos acessar os elementos da matriz? Isto é, caso precisamos obter o elemento que se encontra na linha 3 , coluna 2 da matriz, acessamos a partir do Octave.
As sintaxes para acesso dos elementos de matrizes e vetores , para algum , no Octave/Matlab é
n ∈ R m ∈ R N ∈ N
n=0.2
m=0.5
N=11
x2=linspace(n,m,N)
n m
format short
erro=norm(x1-x2)
ERRO=x1-x2
A =
⎛
⎜
⎝
m11 m12 m13
m21 m22 m23
m31 m32 m33
⎞
⎟
⎠
(M ∈ Cn×n) (v ∈ Cn) n ∈ N
em que são os índices da(o) matriz/vetor. No caso de vetores, a sintaxe pode ser tanto
ou
Para acessar linhas ou colunas inteiras, ou até partes da matriz, é possível utilizar as sintaxes :
Voltando à matriz , podemos criar o seguinte esquema:
Antes de passarmos para operações entre matrizes e vetores, vamos fazer uns exercícios.
Obs: Para excluir uma linha ou coluna de uma matriz, basta fazer (para excluir a -ésima coluna da matriz, ou para excluir a -ésima linha.
Exercícios
1) Escolha , para criar uma matriz aleatória .
In [23]:
2) Altere a primeira coluna e a primeira linha da matriz por um vetor com números aleatórios de a (utilize a função ).
3) Escolha uma submatriz da sua matriz e substitua por uma matriz de identidade (Use a função eye ).
In [24]:
4) Altere o elemento da linha e coluna para o número (randi é uma função que devolve um número inteiro aleatório de a ).
In [25]:
5) Separe sua matriz em vetores coluna e vetores linha. (por exemplo, se
M/v(ℓ, c),
ℓ, c ∈ N
v(ℓ, 1) ou v(ℓ) (para o caso de vetor coluna)
v(1, c) ou v(c) (para o caso de vetor linha).
M(:, c) (para acessar todos os elementos da coluna c - resultando em um vetor coluna com n elementos)
M(ℓ, :) (para acessar todos os elementos da linha ℓ - resultando em um vetor linha com n elementos)
M(a : b, p : q)(para acessar os elementos que estão entre as linhas a e b as colunas p e q - resultando em uma matriz M ′ ∈ R(b−a)×(q−p))
A
A =
⎛
⎜
⎝
m11 m12 m13
m21 m22 m23
m31 m32 m33
⎞
⎟
⎠
=
⎛
⎜
⎝
A(1, 1) A(1, 2) A(1, 3)
A(2, 1) A(2, 2) A(2, 3)
A(3, 1) A(3, 2) A(3, 3)
⎞
⎟
⎠
=
⎛
⎜
⎝
A(1, :)
A(2, :)
A(3, :)
⎞
⎟
⎠
=
⎛
⎜⎜
⎝
A(:, 1) A(:, 2) A(:, 3)
⎞
⎟⎟
⎠
.
M(:, p) = [] p M(q, :) = [] q
m,n ∈ N 3 ≤ m,n ≤ 10 M ∈ Rm×n
m = 5; % Mude esse número, se quiser.
n = 5; % Mude esse número, se quiser.
M = rand(m,n); % A função ones é nativa do Octave/Matlab que cria uma matriz em que todos os elementos são iguais a 1
0 1 rand()
M ′ ∈ R2×2 M I2×2 (⋅)
% Faça a parte 2 e 3 aqui
m − 2 2 NUM = randi(m ∗ n) 0 m ⋅ n
% Faça a parte 4 aqui
M
então teremos os vetores coluna
e os vetores linha
In [26]:
Operações com matrizes e vetores
Para efetuar operações com matrizes e vetores, é preciso ter um pouco de cuidado. Devemos, aqui, lembrar da álgebra linear antes de sair fazendo produto de vetores e matrizes.
Lembrando que em um espaço vetorial qualquer definido sobre um corpo , definimos a soma e o produto por escalar entre os elementos desse espaço, isto é, se e é um espaço vetorial,
então e , qualquer que seja . Da mesma forma, o Octave/Matlab não vai saber o que fazer se eu pegar e , com e espaços vetoriais tais que e fizer
 ou .
Podemos definir, aqui, algumas operações possíveis entre vetores, matrizes e escalares.
Se e e :
 (no octave, utiliza-se para efetuar a soma).
 (no Octave, utiliza-se para efetuar a operação).
 (esse produto é conhecido como Produto de Hadamard e, no Octave, utiliza-se ).
 (a operação de transposição de um vetor pode ser feita utilizando ' , isto é, .
 (o produto interno pode ser calculado, no matlab, utilizando a função ou, .
obs: Se e e a operação resulta em um número real, o que acontece se fizermos ? Ainda é possível fazer essa operação, mas o resultará em uma matriz que mora em 
Por exemplo: se e , então
Ou seja, se e , então
M =
⎛
⎜
⎝
1 2 3
4 5 6
7 8 9
⎞
⎟
⎠
,
c1 =
⎛
⎜
⎝
1
4
7
⎞
⎟
⎠
, c2 =
⎛
⎜
⎝
2
5
8
⎞
⎟
⎠
 e c3 =
⎛
⎜
⎝
3
6
9
⎞
⎟
⎠
ℓ1 = ( 1 2 3 ) ,
ℓ2 = ( 4 5 6 )  e 
ℓ3 = ( 7 8 9 ) . )
% Faça a parte 5 aqui
V K v,w ∈ V V
v + w ∈ V λv ∈ V λ ∈ K v ∈ V w ∈ W V W W ∩ V = ∅
v + w w ⋅ v
v = (v1 v2  ⋯  vn)T w = (w1 w2  ⋯  wn)T λ ∈ C
v + w = (v1 + w1 v2 + w2  ⋯  vn + wn)T v + w
λv = (λv1 λv2  ⋯  λvn)T λ ∗ v
v ⊙ w = (v1w1 v2w2  ⋯  vnwn)T v. ∗w
vT = (v1 v2  ⋯  vn) v′
⟨v,w⟩ = v ⋅ w = ∑ni=1 viwi dot(v,w) v
′ ∗ w
v ∈ Cn w ∈ Cm ⟨v,w⟩ = vTw vwT Cn×w.
v = (1 2 3)T w = (4 3 2 1)T
vwT =
⎛
⎜
⎝
4 3 2 1
8 6 4 2
12 9 6 3
⎞
⎟
⎠
.
v = (v1 v2  ⋯  vn)T w = (w1 w2  ⋯  wm)T
Vejamos:
In [27]:
O produto v'*w = 
 10
O produto v*w' = 
 3 2 1
 6 4 2
 9 6 3
As operações válidas para matrizes são:
Se , então 
Se , então ;
Importante: no Octave/Matlab, utiliza-se para o produto entre matrizes e produto matriz-vetor. Percebam que esse produto só está definido se o número de colunas da matriz à esquerda no produto é o
mesmo número de linhas da matriz à direita no produto. A comutatividade não é sempre válida .
Se tais que seus elementossão e 
 (produto de Hadamard - no Octave/Matlab, utiliza-se , isto é, )
Exercícios
1) Considere as matrizes Faça:
 a) . b) . c) . d) . e) . f) . g) . h) . i) 
In [28]:
vwT =
⎛
⎜⎜⎜⎜
⎝
v1w
v2w
⋮
vnw
⎞
⎟⎟⎟⎟
⎠
.
v=[1;2;3]; w=[3;2;1];
disp("O produto v'*w = ")
disp(v'*w)
disp("O produto v*w' = ")
disp(v*w')
M ∈ Cm×p N ∈ Cp×n MN ∈ Cm×n
M ∈ Cm×p x ∈ Cp Mx ∈ Cp
∗
M,N ∈ Cp×q M = [mij]
p,q
i=1,j=1 N = [nij]
p,q
i=1,j=1
M + N = [mij + mij]
p,q
i=1,j=1
M ⊙ N = [mij ⋅ mij]
p,q
i=1,j=1 . ∗ M. ∗N
A ∈ C3×2,B ∈ C2×3,C ∈ C3×3,x ∈ C2, y ∈ C3 e z ∈ C5.
       AB     CA     ATC     BC     3AT + B1
2
    B ⊙ AT     Ax      By      [xT  yT ]z
A=[rand() 2*rand(); sqrt(rand()) sqrt(2*rand()); 1/sin(sqrt(2)) rand/cos(sqrt(2))];
B=inv(A'*A)*A';
C=rand(3);
x=A(:,randi(2));
y=A(randi(3),:)';
z=[B(randi(2),:)';B(:,randi(3))];
% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %%
% % % % % % % % % % % % % % % % % % Responda aqui aos exercícios
String
String são caracteres organizados na forma de um vetor. Para criá-la, digitamos os caracteres entre aspas simples (’) ou duplas ("):
Strings podem conter números, letras, símbolos etc.
Para usar aspas como uma string é necessário duas aspas dentro do corpo da string.
O fato de string ser um vetor nos permite o mesmo tratamento que temos feito até o momento. Assim podemos referenciar, adicionar e eliminar elementos da string e criar matrizes de strings.
Vejamos os exemplos a seguir:
In [29]:
nome = Carlos
sobrenome = Castro
idade = 33
In [30]:
dados =
Carlos
Castro
33 
ans =
 3 6
In [31]:
dados = CarlosCastro33
ans =
 1 14
Algumas funções nativas do Matlab/Octave
zeros(m,n): retorna uma matriz nula com linhas e colunas.
ones(m,n): retorna uma matriz com todos os elementos igual a 1, com linhas e colunas.
eye(m,n): retorna uma matriz com a diagonal principal com elementos iguais a 1 e os outros elementos iguais a zero, com linhas e colunas.
length(A): retorna o número de elementos no vetor .
% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %%
% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %%
nome = "Carlos"
sobrenome='Castro'
idade = '33'
dados = [nome;sobrenome;idade]
size(dados)
dados = [nome sobrenome idade]
size(dados)
m n
m n
m n
A
size(A): retorna um vetor linha onde e representam a dimensão da linha e coluna respectivamente.
reshape(A,m,n): rearranja uma matriz com linhas e colunas para linhas e colunas. vezes deve ser numericamente igual a vezes .
diag(v): quando é um vetor, cria uma matriz quadrada contendo os elementos de na diagonal principal. Quando é uma matriz, cria um vetor coluna a partir dos elementos na diagonal principal.
round(v): quando é uma matriz, os elementos são arredondados para o inteiro mais próximo, no caso de a parte fracion ária ser igual a 0,5 o elemento é arredondado para o inteiro maior.
rand ou rand(): retorna um número aleatório entre e .
rand(m,n): retorna uma matriz com elementos aleatórios entre e .
randperm(n): retorna um vetor linha com elementos que são a permutação aleatória dos inteiros de até .
randn(m,n): retorna uma matriz com média e desvio-padrão 1.
median(A): se é um vetor, retorna o valor mediano dos elementos do vetor.
mean(A): se é um vetor, retorna o valor médio dos elementos do vetor. Se é uma matriz retorna um vetor linha com a media de cada coluna.
sort(A): se é um vetor, ordena os elementos de na ordem crescente. Se é uma matriz, ordena os elementos de cada coluna.
C = max(A): se é um vetor, receberá o maior elemento de . Se é uma matriz, é um vetor linha contendo o maior elemento em cada coluna de .
[d n]=max(A): se é um vetor, recebe o maior elemento de e indica a posição desse elemento no vetor (a primeira posição, caso o elemento não seja único).
min(A): semelhante à função , porém retorna o minimo.
[d,n]=min(A): semelhante à função , porém retorna o minimo.
sum(A): se é um vetor, retorna a soma dos elementos do vetor. Se é uma matriz retorna um vetor linha com a soma de cada coluna.
std(A): se é um vetor, retorna o desvio-padrão dos elementos do vetor.
det(A): retorna o determinante da matriz quadrada .
dot(a,b): determina o produto escalar de dois vetores e .
cross(a,b): determina o produto vetorial de dois vetores e . Os dois vetores devem possuir três elementos.
In [32]:
Sistema linear
O sistema linear é uma coleção de equações com uma ou mais variáveis. Um sistema linear, geral, com equações e incógnitas é como dado a seguir:
Pela definição de produto matriz-vetor, é fácil perceber que o sistema linear acima pode ser representado pelo produto matriz-vetor , em que
[m,n] m n
A r s m n r s m n
v v v
v
0 1
m × n 0 1
n 1 n
m × n 0
A
A A
A A A
A C A A C A
A d A n
max(A)
[d,n] = max(A)
A A
A
A
a b
a b
% Teste aqui as funçoes, se quiser :)
m n
⎧⎪⎪⎪⎪⎪⎪⎪⎪⎪
⎨
⎪⎪⎪⎪⎪⎪⎪⎪⎪⎩
a11x1 + a12x2 + a13x3 + ⋯ + a1(n−1)xn−1 = b1
a21x1 + a22x2 + a23x3 + ⋯ + a2(n−1)xn−1 = b2
a31x1 + a32x2 + a33x3 + ⋯ + a3(n−1)xn−1 = b3
⋮ ⋮ ⋮
am1x1 + am2x2 + am3x3 + ⋯ + am(n−1)xn−1 = bm
Ax = b
A =
⎛
⎜⎜⎜⎜⎜⎜⎜⎜
⎝
a11 a12 ⋯ a1(n−1)
a21 a22 ⋯ a2(n−1)
a31 a32 ⋯ a3(n−1)
⋮ ⋮ ⋱ ⋮
am1 am2 ⋯ am(n−1)
⎞
⎟⎟⎟⎟⎟⎟⎟⎟
⎠
,x =
⎛
⎜⎜⎜⎜⎜⎜⎜
⎝
x1
x2
x3
⋮
xm
⎞
⎟⎟⎟⎟⎟⎟⎟
⎠
 e A =
⎛
⎜⎜⎜⎜⎜⎜⎜
⎝
b1
b2
b3
⋮
bm
⎞
⎟⎟⎟⎟⎟⎟⎟
⎠
Portanto, a solução do sistema linear, quando existe, pode ser obtida isolando o vetor de um lado da igualdade . Se é uma matriz quadrada e inversível, a solução do sistema é dada por
No Octave/Matlab, para resolver um sistema linar que tenha solução, basta representa-lo no formato matricial e, utilizar o operador , que vimos anteriormente. Esse operador escolhe a forma mais eficiente
de resolver esse sistema.
obs: podíamos, aqui, dizer que para resolver um sistema, bastava encontrar a matriz inversa de , e fazer . O Matlab até tem uma função que encontra essa inversa ( , ou simplesmente
). Mas como encontrar essa inversa é muito caro computacionalmente, e pode levar a erros numéricos de ponto flutuante, existem métodos mais eficientes de se obter a solução de sistemas lineares
(como fatoração , ...). Vejamos...
In [36]:
In [37]:
x Ax = b A
x = A−1b.
∖
A A−1 x = A−1b inv(A)
A−1
QR SVD
t=[];
for n=500:200:5000
 A=rand(n);
 b=rand(n,1);
 tic;
 x1=A\b;
 t1=toc;
 tic;
 x2=inv(A)*b;
 t2=toc;
 t=[t;t1 t2];
end
plot([500:200:5000],log(t(:,1)),
 [500:200:5000],log(t(:,2)));
 legend(['Operador \';'Inversa']);
 xlabel('Size'); ylabel('log Time (s)');
Exemplo
Considere o sistema
Observe que é possível representar o sistema de equações acima como uma igualdade entre dois vetore,
em que
Colocando em variáveis no Octave/Matlab, podemos encontrar a solução como segue:
In [38]:
⎧⎪
⎨
⎪⎩
x − y + 2z = 5
−x + y + −z = −3
3x + 5y + 7z = −1
Ax = b,
A =
⎛
⎜
⎝
1 −1 2
−1 1 −1
3 5 7
⎞
⎟
⎠
,x =
⎛
⎜
⎝
x
y
z
⎞
⎟
⎠
 e b =
⎛
⎜
⎝
5
−3
−1
⎞
⎟
⎠
.
x =
⎛
⎜⎜
⎝
−
−
2
⎞
⎟⎟
⎠
5
4
9
4
format rat
A = [1 -1 2;
 -1 1 -1;
x =
 -5/4
 -9/4
 2
Plotando gráficos
Suponha que queiramos imprimir o gráfico da função . Em nosso primeiro teste, vamos aplicar a função seno no conjunto . Ao aplicar a função seno em cada um dos pontos
desse domínio, obtemos o vetor .
Para imprimirmos esse resultado, utilizaremos a função plot em sua sintaxe mais simples:
plot(D,f(D))
em que é o domínio do gráfico e f(D) é a imagem da função, no domínio especificado. Na próxima célula definiremos os conjuntos , o conjunto e plotaremos esse resultado.
In [39]:
 3 5 7];
b=[5;-3;-1];
x = A\b
f(x) = sin (x) {0, ,π, , 2π}π2
3π
2
{sin(0), sin( ), sin(π), sin( ), sin(2π)} = {0, 1, −1, 0}π
2
3π
2
D D FD = sin(D)
D=[0;pi/2;pi;3*pi/2;2*pi];
FD=sin(D);
plot(D,FD)
Note que esse não é exatamente o gráfico do seno que conhecemos, mas sim uma aproximação. O comando plot liga cada ponto , e como nesse caso só temos 5 pontos, o gráfico terá apenas 5
pontos.
Vamos usar o comando linspace para criar um vetor com uma quantidadegrande o suficientede elementos. Por exemplo, se quisermos um vetor de 50 elementos:
In [40]:
Isso fará com que seja o vetor que tem como primeiro, elemento, como último elemento, e elementos entre eles. Por fim, criamos o vetor com o seno aplicado a cada elemento de x e o plotamos
In [41]:
O Octave/Matlab te dá algumas possibilidades de plot 2D. Com a função plot, você poderá plotar mais de um gráfico em uma única janela, ou plotar em subjanelas, adicionar título, legenda, alterar o formato
do domínio e imagem, etc. Aqui vamos explorar algumas possibilidades. Fique livre em explorar outras possibilidades.
Mult-line plots
Caso necessite plotar dois gráficos de um mesmo domínio em uma só janela, com a função plot é possível. Para isso, basta adicionar mais elementos na função, a ver
plot(D,I1,D,I2,...,D,In)
In [42]:
(x, f(x))
x = linspace(0, 2*pi, 50);
x 0 2π 48
y = sin(x);
plot(x, y);
x=linspace(0,6*pi,100);
plot(x,sin(x),x,cos(x),x,1./(1+x))
Você pode, ainda, utilizar a sintaxe
plot(D,F(D))
hold on
plot(D,G(D))
hold on
plot(D,H(D))
hold off
para plotar diversos gráficos em uma mesma janela.
Subplots
A sintaxe para criar subplots, ou seja, multiplos plots em diferentes janelas, é
subplot(m,n,p)
em que é o número de linhas, é o número de colunas e é a posição em que o gráfico irá ocupar. Para ilustrar melhor, vamos observar a seguinte imagem (Fonte:
http://matlab.izmiran.ru/help/techdoc/ref/subplot.html):
Observe que, o plot nomeado como subplot 221 é o gráfico na posição , de um conjunto de gráficos 4 gráficos, em uma "matriz de gráficos" , com . Confuso? SIM :( Vamos para a
prática.
In [43]:
m n p
p = 1 m × n m = n = 2
x = [0:0.1:2*pi];
subplot(221); plot(x,sin(x));
http://matlab.izmiran.ru/help/techdoc/ref/subplot.html
In [44]:
subplot(222); plot(x,cos(x));
subplot(223); plot(x,x);
subplot(224); plot(x,x.^2);
x = [0:0.1:2*pi]';
subplot(223); plot(x,sin(x));
subplot(224); plot(x,cos(x));
subplot(2,2,[1 2]); plot(x,sin(x) + cos(x) + cos(x).*sin(x));
Plot a partir de matrizes
Você pode armazenar todos os gráficos que queira imprimir em uma mesma janela em uma matriz e aplicar a função plot nela:
In [45]: x=[0:0.1:2*pi]';
A=[sin(x) sin(x+pi/2)];
plot(x,A)
Design dos plots
É possível mudar o design dos gráficos. Você poderá alterar as cores das linhas e até o formato da linha (pontilhado, tracejado, etc). A sintaxe pode ser:
plot(D,F(D),'opcao 1','opcao 2', ... , 'opcao n',D, G(D), 'opcao n+1','opcao n+2',...)
em que é o domínio do seu gráfico, são as imagens, e são as opções de design que você escolher.
Algumas das opções podem ser vistas nas tabelas a seguir:
Cores
Nome código cor
Vermelho 'r'
Verde 'g'
Azul 'b'
Ciano 'c'
Magenta 'm'
Amarelo 'y'
D F(D)/G(D) ′opcao k′
Nome código cor
Preto 'k'
Branco 'w'
É possível, ainda, utilizar a sintaxe
plot(D,FD,'Color',RGB_code)
para utilizar a cor que desejar. Por exemplo:
In [46]:
Linestile e Marker
Linestile
Descrição Código Resultado
Linha sólida (padrão) ' '
Tracejado ' '
Pontilhado ':'
plot(x,sin(x),'Color',[0.4940 0.1840 0.5560])
−
−−
Descrição Código Resultado
Traço e ponto ' '
Mark
Código Descrição
'o' Círculo
'+' Sinal de +
'*' Asterisco
'.' Ponto
'x' X
'_' Linha horizontal
'|' Linha Vertical
'square' or 's' Quadrado
'diamond' or 'd' Losango
'^' Acento circunflexo
'v' Letra V
'>' Símbolo de maior
'<' Símbolo de menor
'pentagram' or 'p' Pentagrama
'hexagram' or 'h' Hexagrama
Vamos ver alguns exemplos:
In [47]:
−.
plot(x,sin(x),'g');
hold on;
plot(x,sin(x+pi/8),'.');
hold on;
plot(x,sin(x+2*pi/8),'-');
hold on;
plot(x,sin(x+3*pi/8),'p');
hold on;
plot(x,sin(x+4*pi/8),'-.');
hold on;
plot(x,sin(x+5*pi/8),':','Color','r');
hold on;
plot(x,sin(x+6*pi/8),'<','Color',[214, 85, 135]./255);
hold off;
Outros parâmetros do plot
A função plot tem alguns outros parâmetros que podem ser adicionados à janela do gráfico, como legenda, título, rótulo dos eixos, tamanho, etc. Vejamos alguns desses parâmetros:
plot(D,F(D),D,G(D), ... , D, Z(D));
title('...'); % Título do gráfico
legend(['...',...,'...']); % Legenda dos gráficos que compõe a janela do plot.
xlabel('...'); % Define o rótulo do eixo x
ylabel('...'); % Define o rótulo do eixo y
xlim([a b]); % Define o subdomínio do eixo x a ser exibido no gráfico
ylim([a b]); % Define o subdomínio do eixo y a ser exibido no gráfico
In [48]: t=[0:1/44100:1]';
y=sin(2*pi*20*t);
z=sin(2*pi*200*t);
subplot(211);
plot(t,y); 
hold on;
plot(t,z);
hold off;
title('Osciladores com taxa de amostragem a 44100 Hz');
legend(['20Hz';'200Hz']);
xlim([0 0.05]);
xlabel('t');
% ----------------------------------------------------------------------
y=sin(2*pi*5*t);
Cálculo no Octave
Neste módulo, vamos precisar de um pacote para Octave chamado "Symbolic". Nele, poderemos fazer cálculos simbólicos, isto é, utilizar x como variável. É possível que no Matlab já venha instalado. Caso
esteja usando Octave, será necessário fazer algumas instalações antes.
Instalação
1. Verifique sua instalação de Python (https://www.python.org/) e SymPy (https://www.sympy.org/en/index.html). Caso não os tenha instalados no seu computador, por favor, verifique como instalar eles
corretamente. O SymPy necessário para que o Symbolic do Octave rode corretamente é a versão 1.5.1. Caso você instale uma versão posterior, será necessário fazer o downgrade.
UBUNTU/macOS
Verifique q versão do seu python instalado fazendo
python --version
z=sin(2*pi*20*t);
subplot(212);
plot(t,y); 
hold on;
plot(t,z,':');
hold off;
title('Oscilador com taxa de amostragem a 44100 Hz');
legend(['5 Hz';'20Hz']);
xlim([0 1.2]);
xlabel('t');
https://www.python.org/
https://www.sympy.org/en/index.html
Caso não tenha o Python3.9 instalado no seu computador faça
sudo apt update
sudo apt install python3.9
Instale o PIP:
curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
python3.9 get-pip.py
Instale o Sympy (v. 1.5.1)
pip3.9 install sympy==1.5.1
1. Abra o Octave e execute
pkg install -forge symbolic
pkg load symbolic
WINDOWS
Download symbolic-win-py-bundle-2.7.0.zip em https://github.com/cbm755/octsympy/releases
Abra o octave e execute
pkg install symbolic-win-py-bundle-2.7.0.zip
pkg load symbolic
In [49]:
For information about changes from previous versions of the symbolic package, run 'news symbolic'.
O objetivo da matemática simbólica, aqui, é para simularmos a continuidade de funções. Lembre-se que no computador, trabalhamos com matemática discreta. Assim, a definição de limite, derivada e integral,
como conhecemos, não se aplica aqui. Por isso é necessário utilizar da simulação de continuidade para efetuarmos os cálculos dessas funções.
Ao instalar com sucesso o pacote de matemática simbólica em seu computador, utilizaremos uma função deste pacote chamada syms , para declarar a variável que iremos referenciar.
No seu Octave, digite:
In [50]:
Symbolic pkg v2.9.0: Python communication link active, SymPy v1.5.1.
Após definirmos nossa função simbólica, podemos definir nossas funções. Para definir a função , fazemos
In [51]:
fx = (sym)
 ________
 ╱ 1 
 ╱ ────── 
 ╱ 2 
pkg install -forge symbolic
pkg load symbolic
syms x;
f(x) = √ 1
x2+1
fx = sqrt(1/(x^2+1))
https://github.com/cbm755/octsympy/releases
 ╲╱ x + 1 
Limite
Para calcularmos o Limite na função acima, utilizaremos a função limit , cuja sintaxe é
limit(fx,x,a)
em que fx é a função que queremos calcular o limite, x é a variável a se aplicar esse limite e a é o escalar tal que . Por exemplo:
In [52]:
ans = (sym)
 √2
 ──
 2 
Derivada
Para o cálculo da -ésima derivada da função utilizaremos a função diff cuja sintaxe é
diff(fx,n)
em que fx é a função que queremos calcular e n é o grau da derivada que queremos calcular. No octave, obtemos:
In [53]:
Primeira derivada de f(x)
 ________ 
 ╱ 1 
 -x⋅ ╱ ────── 
 ╱ 2 
 ╲╱ x + 1 
 ─────────────────
 2 
 x + 1Segunda derivada de f(x)
 ⎛ 2 ⎞ ________
 ⎜ 3⋅x ⎟ ╱ 1 
 ⎜────── - 1⎟⋅ ╱ ────── 
 ⎜ 2 ⎟ ╱ 2 
 ⎝x + 1 ⎠ ╲╱ x + 1 
 ──────────────────────────
 2 
 x + 1 
7-ésima derivada de f(x)
 ⎛ 6 4 2 ⎞ ________
 ⎜ 429⋅x 693⋅x 315⋅x ⎟ ╱ 1 
f(x)
x → a
limit(fx,x,1)
n f(x)
disp('Primeira derivada de f(x)')
disp(diff(fx))
disp('Segunda derivada de f(x)')
disp(diff(fx,2))
disp('7-ésima derivada de f(x)')
disp(diff(fx,7))
 315⋅x⋅⎜- ───────── + ───────── - ────── + 35⎟⋅ ╱ ────── 
 ⎜ 3 2 2 ⎟ ╱ 2 
 ⎜ ⎛ 2 ⎞ ⎛ 2 ⎞ x + 1 ⎟ ╲╱ x + 1 
 ⎝ ⎝x + 1⎠ ⎝x + 1⎠ ⎠ 
 ───────────────────────────────────────────────────────────
 4 
 ⎛ 2 ⎞ 
 ⎝x + 1⎠ 
É possível avaliar o valor das derivadas (e das funções) nos pontos desejados. Para isso, utilizaremos a função subs , cuja sintaxe é
x=k;
subs(fx)
em que x é a variável que queremos avaliar, k é o valor em que substituiremos o e fx é a função. Por exemplo:
In [54]:
------------
f(2)=
 √5
 ──
 5 
------------
f`(2)=
 -2⋅√5 
 ──────
 25 
------------
f```(2)=
 -6⋅√5 
 ──────
 125 
------------
Integrais
Para calcularmos integrais indefinidas , devemos usar a função int , cuja sintaxe é
int(fx)
em que fx é a função que queremos avaliar. No octave, a integral indefinida da função
fica
x
disp('------------'); disp(''); 
x=2;
disp('f(2)='); disp(subs(fx)); disp(''); disp('------------'); disp(''); 
disp('f`(2)='); disp(subs(diff(fx))); disp(''); disp('------------'); disp('');
disp('f```(2)='); disp(subs(diff(fx,3))); disp(''); disp('------------'); disp('');
g(x) = ∫ lnx − x3dx
In [55]:
ans = (sym)
 4 
 x 
 - ── + x⋅log(x) - x
 4 
Para calcularmos integrais definidas , utilizaremos a mesma função anterior, adicionando os limites de integração na sintaxe. Ou seja, para calcular
utiliza-se a sintaxe
int(fx,a,b)
onde fx é a função que queremos avaliar, a é o limite inferior e b é o limite superior. No octave:
In [56]:
ans = (sym) -19/4 + 2⋅log(2)
Gráficos das funções simbólicas
Muitas vezes, tem-se a necessidade de visualizarmos as funções que estamos trabalhando. Assim, para plotarmos os gráficos de funções simbólicas, utilizaremos a função ezplot , cuja sintaxe é
ezplot(fx,DOM)
em que fx é a função que queremos visualizar e DOM é um vetor linha de 2 variáveis , que definirá o domínio da função. No octave:
In [57]:
syms x;
g=log(x)-x^3;
int(g)
b
∫
a
f(x)dx,
int(g,1,2)
DOM = [xminxmax]
ezplot(fx,[-2*pi 2*pi])
Programação
Um algoritmo é uma sequência finita de ações executáveis, precisos e não ambíguos a fim de obter uma solução para um determinado problema. Já a linguagem de programação traduz um algoritmo
(sequência de instruções/ações) da linguagem humana para a linguagem de máquina.
Uma maneira eficiente de projetar um algorítmo é por meio de um pseudo código. Por exemplo, se eu quero escrever um algoritmo que devolve o módulo de um número, em qualquer linguagem de
programação, seu pseudo código pode ser escrito da seguinte forma:
Dado um número a
Se a >= 0, então
 modulo = a
Senão
 modulo=-a
retorna modulo
Em C++, por exemplo, o algorítmo acima poderia ser escrita como uma função, e ficaria assim:
double modulo(double x){
 double m;
 if (x >= 0){
 m = x;
 } else {
 m = -x;
 }
 return m;
}
Em Python, por exemplo, esse mesma função ficaria
def modulo(x):
 if x>=0:
 m = x
 else:
 m = -x
 return m
Cada linguagem de programação tem suas características. No Matlab/Octave, por exemplo, a mesma função acima ficaria:
In [58]:
m1 = 2
m2 = 2332
Algumas observações importantes na hora de criarmos nossos algoritmos aqui no Octave/Matlab:
Todo texto depois de % é considerado um comentário;
O caractere ... indica que o comando continua na próxima linha. Tal recurso permite deixar o texto mais organizado;
Usa-se o ponto e vírgula ; (lembra dele?) no final de uma linha de comando. Ele omite na janela de comandos as iterações que serão realizadas (mantém a janela de comando mais limpa e organizada);
Pode-se colocar mais de um comando em uma linha, separando-os por ponto e vírgula;
Os nomes das variáveis devem ser palavras únicas, sem inclusão de espaços e devem começar com uma letra, seguida de letras ou números, podendo conter até caracteres;
Para a entrada de dados via teclado usa-se a função input ;
Para mostrar mensagens de texto na tela utiliza-se o comando disp .
Você pode usar a função tic/toc para contar o tempo de execução do algoritmo. Por exemplo:
tic;
% algoritmo
toc;
Comando lógico-relacionais
Operações lógicas Descrição
Negação
... ou ...
& ... e ...
OBS: Operações curto-circuito
function m = modulo(x)
 if x >= 0
 m = x;
 else
 m = -x;
 end
end
m1 = modulo(-2)
m2 = modulo(-2332)
19
∼
|
expr1 && expr2 representa a operação lógica ... e ... e aplica um comportamento de curto circuito no código. Isto é, não é avaliada se é falso .
expr1 || expr2 representa a operação lógica ... ou ... e aplica um comportamento de curto circuito no código. Isto é, não é avaliada se for verdadeira.
Operações relacionais Descrição
Igual a
Diferente
menor do que
maior do que
menor ou igual a ( )
maior ou igual a ( )
O Octave/Matlab possui estruturas que permitem o controle do fluxo de execução de comandos e da ordem em que a computação é feita.
Laço FOR
A estrutura FOR possibilita que um bloco de código seja repetido por um número de vezes fixo e predefinido. Sua sintaxe é:
for variável = início:passo:fim
 % comandos
end
Exemplo
1) Faça um algoritmo usando laço FOR que retorne a soma dos números de a , em que é dado pelo usuário.
In [59]:
Digite um número natural:2343
 
Método 1 - Laço FOR
 
A soma de 1 até 2343 é 2745996
Elapsed time is 0.015285 seconds.
OBS: Laços for nem sempre são a melhor forma de construir um algoritmo, em Matlab/Octave. Vou escrever o mesmo algorimo acima usando vetores e funções nativas. Vamos comparar os tempos.
expr2 expr1
expr2 expr1
==
∼=
<
>
<= ≤
>= ≥
1 N N
N = input('Digite um número natural: ');
disp(' ')
disp('Método 1 - Laço FOR')
disp(' ')
soma = 0;
tic;
for n = 1:N
 soma = soma + n;
end
disp(['A soma de 1 até ' num2str(N) ' é ' num2str(soma)]);
toc;
In [60]:
 
Método 2 - vetores e funções nativas
 
A soma de 1 até 2343 é 2745996
Elapsed time is 0.0112772 seconds.
Laço WHILE
A estrutura while é utilizada quando é necessário repetir certo comando de código várias vezes, enquanto uma determinada condição é satisfeita. Geralmente, usa-se while quando não se sabe ao certo a
quantidade de passos a serem dados pelo algoritmo. Sintaxe:
while expressão
 comandos
end
Exemplo
1) Encontre o menor número tal que .
In [61]:
Quando n = 40, a sequência 1/(2^n) chegou a 9.0949e-13
2) Encontre o menor número natural tal que .
In [62]:
A sequência n^(1/n) vale 1 quando n = 1416368
3) Encontre o menor número, maior ou igual a um fornecido pelo usuário que é múltiplo de .
disp(' ')
disp('Método 2 - vetores e funções nativas')
disp(' ')
tic;
t = [1:N];
soma2 = sum(t);
disp(['A soma de 1 até ' num2str(N) ' é ' num2str(soma)]);
toc;
n ∈ N ∪ {0} < 10−121
2n
x=1;
n=0;
while x>1e-12
 n = n+1;
 x = x/2;
end
disp(['Quando n = ' num2str(n) ', a sequência 1/(2^n) chegou a ' num2str(x)]);
n√n < 1 + 10−5
format long
n=2;
while n^(1/n) > 1 + 1e-5
 n = n + 1;
end
disp(['A sequência n^(1/n) vale ' num2str(n^(1/n)) ' quando n = ' num2str(n)])
N 7
In [63]:
Digite um número natural:2343
2345 é múltiplo de 7.
In [ ]:
If, Elseif e Else
A estruturaif é usada para executar um bloco de comandos apenas se uma determinada condição for satisfeita. Sintaxe:
if expressão1
 % comandos 1
elseif expressão2
 % comandos 2
elseif expressão3
 % comandos 3
else
 % comandos 4
end
Exemplo
1) Faça um programa que diga se a pessoa é adulta, adolescente, criança ou idosa, com base na idade fornecida. Use o comando While para fazer o usuário digitar uma idade maior do que zero.
In [64]:
N = input('Digite um número natural: ');
while rem(N,7) ~= 0
 N = N+1;
end
disp([num2str(N) ' é múltiplo de 7.'])
idade_correta = false;
while ~idade_correta
 idade = input('Informe sua idade: ');
 if idade > 0
 idade_correta = true;
 end
end
if idade < 12
 disp('Você é uma criança.')
elseif idade >= 12 & idade < 18
 disp('Você é um adolescente.')
elseif idade >= 18 & idade < 65
 disp('Você é um adulto.')
else
 disp('Você é um idoso')
end
if idade > 150
 disp(' ')
 disp(' ')
Informe sua idade:231
Você é um idoso
 
 
 
... Chico Xavier, é você?
Switch, case, otherwise
O switch executa uma ação dentre várias opções, dependendo de um parâmetro passado inicialmente, onde cada escolha é um caso. Sintaxe:
switch variável_de_teste
case{caso1}
 % comandos1
case{caso2}
 % comandos2
case{caso3}
 % comandos3
otherwise
 % comandos
end
Exemplo
1) Construa um programa onde o usuário digita dois números e indica se irá somá-los, multiplicá-los ou subtraí-los.
In [65]:
 disp(' ')
 disp('... Chico Xavier, é você?')
end
n = input('Digite um número: '); m = input('Digite um número: ');
operacao = input('Digite: 1 para somá-los; 2 para subtraí-los; 3 para multiplicá-los. Opção: ');
switch operacao
case{1}
 oper='+';
 x=n+m;
case{2}
 oper='-';
 x=n-m;
case{3}
 oper='*';
 x=m*n;
otherwise
 x=NaN;
 disp('Essa não é uma operação válida')
end
if x ~= NaN
 disp([num2str(n) oper num2str(m) '=' num2str(x)])
end
Digite um número:12
Digite um número:12
Digite: 1 para somá-los; 2 para subtraí-los; 3 para multiplicá-los. Opção:1
12+12=24
Funções
Muitas vezes não será necessário criarmos uma nova função, pois o Octave/MATLAB já nos traz uma grande biblioteca de funções pré-definidas. Por exemplo: se quisermos calcular o fatorial de um número ,
não é necessário criar uma nova função para isso, basta usarmos a função
factorial(n).
Algumas funções pré-definidas no Octave/MATLAB:
Função Descrição
factorial( ) Retorna o fatorial de 
Retorna o seno de 
Retorna a raíz quadrada de um número 
gcd( , ) Retorna o maior divisor comum entre e 
rem( , ) Retorna o resto de divisao de por 
Muitas vezes queremos criar funções que ainda não estão na biblioteca virtual do Octave/MATLAB. Para isso temos o comando , que obedece a seguinte sintaxe:
function[saida] = nomedafuncao(entrada)
 % Comentário da função, que aparecerá quando fizer '>>> help nomedafuncao'
 <comandos>
end
Exemplo
Dados dois números, queremos uma função que nos retorne a soma e o produto dos dois. Vamos utilizar o function:
In [68]:
Agora basta salvar o arquivo como somaprod.m . Para executar a função, basta digitarmos no Octave/MatLab que o propgrama irá retornar os vaores de soma e produto. Vale lembrar que, quando uma
função retorna 2 ou mais valores, é possível solicitar apenas um deles, como veremos na célula abaixo.
In [77]:
n
n n
sin(n) n
sqrt(n) n
nm n m
nm n m
function
function [s,p] = somaprod(a,b)
 % Função que retorna a soma e o produto de dois números dados.
 s = a + b;
 p = a*b;
end
disp('Imprimindo os dois valores:')
[a,b]=somaprod(11,12)
disp(' ')
disp('Imprimindo o primeiro valor')
c = somaprod(11,12)
disp(' ')
disp('Imprimindo o segundo valor')
Imprimindo os dois valores:
a = 23
b = 132
 
Imprimindo o primeiro valor
c = 23
 
Imprimindo o segundo valor
d = 132
 
Pedindo help da função
'somaprod' is a command-line function
 Função que retorna a soma e o produto de dois números dados.
Additional help for built-in functions and operators is
available in the online version of the manual. Use the command
'doc <topic>' to search the manual index.
Help and information about Octave is also available on the WWW
at http://www.octave.org and via the help@octave.org
mailing list.
[~,d]=somaprod(11,12)
disp(' ')
disp('Pedindo help da função')
help somaprod