MatLab
Matrix Laboratory

Sumário

6. Arquivos de comandos
    6.1 Criando Arquivos de Comandos
    6.2 Código do tipo Script
    6.3 Código do tipo Função
7. Controle de Fluxo
    7.1 Comando de Repetição for
    7.2 Comando de Repetição Condicional while
    7.3 Comando Condicional if
    7.4 Comando de Parada break
8. Gráficos
    8.1 Gráficos Bidimensionais
    8.2 Divisão de uma Janela Gráfica
    8.3 Estilos de Linhas, Símbolos e Cores
    8.4 Legendas dos Gráficos
    8.5 Gráficos Tridimensionais

6. Arquivos de Comandos

Os comandos do MatLab são normalmente digitados na “janela de comando”, onde uma única linha de comando é introduzida e processada imediatamente.

Além da possibilidade da janela de comandos, o MatLab também permite definição de comandos através dos arquivos de comandos, que possuem a extensão ".m". Os próprios comandos que o MatLab disponibiliza bem como todas as suas funções constituem arquivos de comandos.

Para a geração e utização de um arquivo de comando, dois passos principais são necessários:

Os arquivos de comandos podem ser de dois tipos distintos: script ou função. Os arquivos do tipo script   correspondem a uma seqüência de comandos que não recebem parâmetros de entrada. Já os do tipo "função" recebem um ou mais parâmetros.
 

6.1 Criando um arquivo de comandos

Os arquivos de comandos são, geralmente, criados no editor de texto do MatLab, mas também podem ser criados fora do ambiente MatLab, com a utilização de qualquer outro editor de texto.

Para acessar o editor de texto do MatLab, basta clicar no botão que traz uma folha em branco no label

ou selecionar a opção “New  -  M-File” do submenu oferecido pela opção “File” do menu principal. Existe, ainda, a possibilidade de invocar o editor de texto pela linha de comando, através do comando “edit”.

>> edit

A janela a seguir será exibida:



Após aberto o editor de texto, digita-se o código do script ou da função.

Para a inserção de comentários no corpo do código de algum arquivo de comando, utiliza-se o símbolo "%" no início da linha onde será inserido o comentário.

Com o término da digitação do código, "salva-se" o novo arquivo.

Uma atenção especial deve ser dispensada no momento de salvar o arquivo, pois se este for salvo em um diretório particular diferente do diretório corrente, a localização do arquivo deverá ser acrescentada no "path browser" do MatLab.

O "path browser" contém a localização de todos os arquivos de comandos originais que acompanham o MatLab e que podem ser invocados através da janela de comando ou por outros arquivos ".m".

O acesso ao "path browser" pode ser feito através da janela de comando com um clique no botão  :



ou pela opção “Set Path” do submenu oferecido pela opção “File” do menu principal.

Outra forma de indicar a localização de um arquivo para o MatLab é através da janela do próprio editor de texto, escolhendo-se a opção "Path Browser" contida no submenu da opção "View" no menu principal.

A janela a seguir será exibida:



Antes de ser fechada, a janela do "path browser" pede a confirmação das mudanças realizadas ao adicionar ou remover alguma localização de arquivos.

Após a criação de um arquivo de comando e a devida inclusão de sua localização no "path browser", este poderá ser executado através de sua invocação pela linha de comando:

>> nome_do_arquivo



6.2 Código do tipo Script

Os códigos do tipo script não recebem argumentos de entrada e nem retornam argumentos de saída,
operam diretamente sobre os dados do workspace. Como exemplos de comandos em forma de script que o MatLab disponibiliza pode-se citar o "clear" e o "clc".

A principal vantagem da utilização de scripts está na utilidade destes para a automatização de séries de passos que precisam ser executados várias vezes.

Por exemplo, um script pode conter o seguinte código:
 


 

%-------------------------------
% Arquivo "exemplo1.m"
%-------------------------------

clear
clc
A = [1 2 3; 4 5 6; 7 8 9]
B = A'
 

Para executá-lo a partir da janela de comando, deve-se invocá-lo como em:

>> exemplo1

6.3 Código do tipo Função

Os códigos do tipo "função" recebem um ou mais parâmetros de entrada através da constante "function" e retornam um ou mais parâmetros para o ambiente. Como exemplos de arquivos de comandos do tipo função, pode-se citar as próprias funções internas do MatLab: sin(x), cos(x), mean(x), zeros(m,n) entre outras.

As variáveis internas ao código são locais à função, não podendo ser acessadas diretamente pela janela de comando.

Uma das principais vantagens no uso de arquivos do tipo "função" está no fato destes serem úteis para estender a linguagem MatLab.

O seguinte arquivo constitui um exemplo de função:
 
 
 


 

%-------------------------------
% Arquivo "hipotenusa.m"
%-------------------------------

function h = hipotenusa(a,b)
h = sqrt((a^2)+(b^2));
 

Para a utilização desta função a partir da janela de comando, devem ser previamente feitas as definições das variáveis que serão usadas como argumentos. Veja o exemplo abaixo:

>> a = 5.2;
>> b = 9.33;

>> c = hipotenusa(a,b)

c =
   10.6812



Exercício:

1. Construa uma função que recebe como argumento duas matrizes linhas, representando dois vetores, e retorna o valor do produto escalar desses dois vetores. 
2. Construa scripts inicializando diferentes vetores e use-os para testar a função "produto escalar".

 

 

7. Controle de Fluxo

Os comandos que controlam o fluxo especificam a ordem em que a computação é realizada. No MatLab, estes comandos são semelhantes aos comandos utilizados na linguagem C, mas com estrutura diferente.

Os comandos de controle de fluxo oferecidos pelo MatLab são o "for", o "while", o "if", o "else",  o "elseif" e o "break".
 

7.1 Comando de Repetição for

A repetição pode ser realizada no MatLab através do uso do comando for.

Partindo da expressão:

>> for i = 1:5,
x(i) = i^2;
end;

pode-se dizer que o laço for é dividido em três partes:

O comando end é utilizado para delimitar o corpo do laço.

Obs.: a vírgula "," no final da primeira linha do for bem como o ponto-e-vírgula ";" após o end são opcionais.

Para visualizar os resultados do laço, pode-se digitar os seguintes comandos:

>> x(1)
ans =
1

(...)

x(5)
ans =
25

Um laço for também pode ser utilizado em conjunto com outro laço for e esta construção é principalmente utilizada com matrizes:

>> for i = 1:4,
    for j = 1:4,
A(i,j) = i + j;
B(i,j) = i - j;
end;
end;

As matrizes A e B poderiam ser geradas através de um arquivo ".m" do tipo script da seguinte maneira:
 


 

%----------------------------------
% Arquivo "gera1.m"
%----------------------------------

for i = 1:4,
  for j = 1:4,
     A(i,j) = i + j;
     B(i,j) = i - j;
  end;
end;
disp('A=');
disp(A);
disp('B=');
disp(B);

O comando "disp(x)" mostra o contéudo da variável "x".

O código equivalente ao código acima, na linguagem C, poderia ser realizado da seguinte forma:
 
 


//-----------------------------------
// Arquivo "gera1.m"
//-----------------------------------

#include <conio.h>
#include <stdio.h>

void main(void) {
   int i, j, A[4][4], B[4][4];
   for(i = 0; i < 4; i++){
      for(j = 0; j < 4; j++){
         A[i][j] = i + j;
         B[i][j] = i - j;
      }
   }

   printf("A =\n");
   for(i = 0; i < 4; i++){
      for(j = 0; j < 4; j++){
          printf("%3d ", A[i][j]);
      }
      printf ("\n");
   }

   printf("B =\n");
   for(i = 0; i < 4; i++){
      for(j = 0; j < 4; j++){
          printf("%3d ", B[i][j]);
      }
      printf ("\n");
   }
   getch();

}

Ambos os códigos levariam ao resultado

A =
     2     3     4     5
     3     4     5     6
     4     5     6     7
     5     6     7     8

B =
     0    -1    -2    -3
     1     0    -1    -2
     2     1     0     -1
    3     2     1     0

As matrizes A e B também poderiam ser geradas, no MatLab, através de uma "função":
 


 

%-------------------------------
% Arquivo "gera2.m"
%-------------------------------

function [A,B] = gera(N,M); 
 for i = 1:N, 
   for j = 1:M, 
      A(i,j) = i + j; 
      B(i,j) = i - j; 
   end; 
 end; 
 

 
 

7.2 Comando de Repetição Condicional while

No laço while, apenas a condição é testada. Por exemplo, na expressão

a = 1; b = 5;
>> while a < b,
clc;
a = a + 1;
b = b - 1;
end;

a condição "a < b" é testada incicialmente. Enquanto esta condição for verdadeira, o laço será executado. A cada iteração, a condição é testada novamente. Quando o teste da condição resultar em falso, o laço terminará.

Por exemplo, o seguinte algoritmo de cálculo da média na linguagem C
 


 

// CalculaMedia1 em "C"- usando comando while

#include <conio.h>
#include <stdio.h>
void main()
{
int   numero, n, acumulador;
float media;

n=0;
acumulador=0;
numero=0;
while (n< 5)  // média de 5 números
  {
    printf("Digite o %do. valor: ", n+1);
    scanf("%d" , &numero);
    printf("O numero digitado foi: %d\n",numero);
    n=n+1;
    acumulador= acumulador+numero;
  }
media = ((float) acumulador) / n;
printf("A soma dos %d numeros e' %d\n", n, acumulador);
printf("A media dos %d numeros e' %6.2f\n",n,media);
// espera que o usuario pressione uma tecla para encerrar 
getch();
getch();
getch();
}
 

poderia ser gerado no MatLab a partir do seguinte código
 


 

%CalculaMedia1 em "MatLab"- usando o comando while

acumulador = 0;
n = 0;
while n<5,
   numero = input('Digite o valor: ');
   disp('O número digitado foi: ');
   disp(numero);
   n = n+1;
   acumulador = acumulador + numero;
end;
media = acumulador/n;
disp('A soma dos números é: ');
disp(acumulador);
disp('A média dos números é: ');
disp(media);
 

 

O comando input faz uma requisição ao usuário em tempo de execução e atribui a resposta do usuário a uma variável.
 

7.3 Comando Condicional if (else / elseif)

A exemplo da linguagem C, o MatLab também oferece o comando if como comando condicional. O comando if vem acompanhado por uma condição de teste. Se a condição for verdadeira, o comando ligado ao if  é realizado. Se, por outro lado, a condição for falsa, o laço não entra no if e o comando else pode ser utilizado. Além do if e do else , ainda existe a possibilidade do uso do comando elseif.
 

A seguir, uma aplicação dos comandos if, else e elseif no MatLab na coluna da esquerda e, na coluna da direita, outra forma equivalente de realização dos mesmos comandos sem a utilização do comando elseif :
 
for i = 1:5,
    for j = 1:5,       if i == j
           A(i,j) = 2;
       elseif abs(i-j) == 1
           A(i,j) = -1;
       else
           A(i,j) = 0;
       end;
    end;
end;		 for i = 1:5,
    for j = 1:5,
       if i == j
           A(i,j) = 2;
       else
          if abs(i-j) == 1              A(i,j) = -1;
          else
              A(i,j) = 0;
              end;
       end;
    end;
end;

 

No código à esquerda, se a condição do if for falsa, a próxima condição testada será a que acompanha o elseif. Se nenhuma das condições forem satisfeitas, o laço realizará o comando seguido ao else .
 

7.4 Comando de Parada break

Durante a execução de um laço de repetição, muitas vezes é conveniente utilizar outra forma de controle de saída deste laço além do uso do teste. Para tanto, tem-se a opção do comando break , o qual permite uma saída antecipada de um laço for ou while.

O comando break faz com que o laço mais interno seja terminado imediatamente.

Por exemplo:
 


 

%CalculaMedia

acumulador = 0;
n = 0;
while n<5,
   numero = input('Digite o valor: ');
   disp('O número digitado foi: ');
   disp(numero);
   x = input('Continua? S/N: ');
   if x == 'N'
      break
   else
       n = n+1;
       acumulador = acumulador + numero;
   end;
end;
media = acumulador/n;
disp('A soma dos números é: ');
disp(acumulador);
disp('A média dos números é: ');
disp(media);
 

No código acima, se a entrada do usuário for 'N' (condição de término do laço), o comando break será executado e o laço while terminará, passando para o comando seguinte. Se qualquer string diferente de 'N' for entrada (manutenção da condição positiva de continuação do laço), o laço seguirá executando normalmente.
 
 
 
Exercício:

1. Construa um script que gere duas matrizes A e B de dimensão 4x4 , sendo que os elementos da matriz A devem ser obtidos randomicamente, e os elementos de B devem ser gerados a partir do elemento correspondente em A acrescido de 0.5. Por fim, exiba ambas as matrizes geradas.

2. Construa um arquivo ".m" que solicite a um usuário a entrada de um valor, e calcule e informe o fatorial deste número. Obs: Não utilize a função factorial do MatLab. 

3. Modifique o arquivo gerado no item 2 de forma que o programa passe a solicitar ao usuário a quantidade de números para os quais será  calculado o fatorial. 
 

 

8. Gráficos

O MatLab oferece uma vasta biblioteca de funções voltadas à construção de gráficos. Através de comandos simples, pode-se obter gráficos bidimensionais ou tridimensionais.
 

8.1 Gráficos Bidimensionais

O comando plot é o principal comando para a geração de gráficos bidimensionais no MatLab uma vez que constrói gráficos lineares.

Os gráficos gerados no MatLab são exibidos através de uma janela gráfica denominada "figure".

Se "x" é um vetor, "plot(x)" produz um gráfico linear dos elementos de "x" versus o índice dos elementos de "x". Por exemplo, para plotar o vetor "x":

>> x = [0.0 0.48 0.84 1.0 0.91 0.6 0.14];
>> plot(x)

após o comando "plot(x)", a seguinte figure , contendo o gráfico de "x", será exibida:

Se "x" e "y" são vetores de dimensões iguais, o comando "plot(x,y)" produz um gráfico dos elementos de "x" versus os elementos de "y".

Por exemplo, dados os vetores "t" e "y":

>> t = 0:0.05:4*pi;
>> y = sin(t);

o comando "plot(t,y)" resultará em:










A plotagem de gráficos contendo múltiplas linhas também é possível no MatLab. Então:

>> x = [-1 0; 1 2];
>> y = [1 3; 3 1];
>> plot(x,y)

>> plot(t,sin(t),t,cos(t),t,sin(t+pi),t,cos(t+pi))



Além do comando plot, outros comandos voltados à geração de gráficos bidimensionais são oferecidos pelo MatLab: fill (desenha polígono 2D), polar (gráficos em coordenadas polares), bar (gráfico de barras), fplot (gráfico de uma função), entre outros.

Gráficos 2D: polar, fill e bar.

8.2 Divisão de uma Janela Gráfica

O MatLab oferece a opção de mostrar mais de um gráfico em uma única figure. Para tanto, é utilizado o comando subplot. A sintaxe deste comando é a seguinte: subplot(l,c,n), plot(x,y).

Supondo que se deseja mostrar os resultados de seis gráficos, tem-se a seguinte seqüência de comandos:

>> subplot(2,3,1),plot(t,sin(t))
>> subplot(2,3,2),plot(t,cos(t))
>> subplot(2,3,3),plot(t,tan(t))
>> subplot(2,3,4),plot(t,sin(t+pi))
>> subplot(2,3,5),plot(t,cos(t+pi))
>> subplot(2,3,6),plot(t,tan(t+pi))

que resultam na seguinte figure, com os gráficos sendo plotados da esquerda para a direita, de cima para baixo:

8.3 Estilos de Linhas, Símbolos e Cores

Na construção de gráficos no MatLab, estilos diferentes de linhas, símbolos e cores podem ser utilizados.

Sintaxe: plot(x,y,'estilo de linha, símbolo ou cor').

>> x = 0:0.05:1;
>> subplot(2,2,1),plot(x,x.^2,'-')
>> subplot(2,2,2),plot(x,x.^2,':')
>> subplot(2,2,3),plot(x,x.^2,'-.')
>> subplot(2,2,4),plot(x,x.^2,'--')

>> x = 0:0.1:1;
>> subplot(4,3,1),plot(x,x.^2,'.')
>> subplot(4,3,2),plot(x,x.^2,'o')
>> subplot(4,3,3),plot(x,x.^2,'x')
>> subplot(4,3,4),plot(x,x.^2,'+')
>> subplot(4,3,5),plot(x,x.^2,'*')
>> subplot(4,3,6),plot(x,x.^2,'s')
>> subplot(4,3,7),plot(x,x.^2,'d')
>> subplot(4,3,8),plot(x,x.^2,'v')
>> subplot(4,3,9),plot(x,x.^2,'^')
>> subplot(4,3,10),plot(x,x.^2,'<')
>> subplot(4,3,11),plot(x,x.^2,'p')
>> subplot(4,3,12),plot(x,x.^2,'h')


y amarelo
m lilás
c azul claro
r vermelho
g verde
b azul escuro
w branco
k preto

8.4 Legendas dos Gráficos

O MatLab possui comandos para adicionar legendas e outras informações nos gráficos plotados:
 
 


title título do gráfico
xlabel título do eixo-X
ylabel título do eixo-Y
text insere anotação no gráfico
gtext insere anotação com o "mouse"
grid ativa linhas de grade
grid off desativa as linhas de grade

Por exemplo:

>> fplot('sin',[-pi pi])
>> title('Gráfico da função f(x) = seno(x), -pi<x<pi')
>> xlabel('x')
>> ylabel('f(x)')
>> grid

 O comando fplot faz a plotagem de funções. Sua sintaxe de utilização é: fplot('função',[intervalo pretendido]).
 
 
Exercício:
1. Dado o seguinte intervalo: -2*pi < x < 2 * pi:

a) gere o gráfico correspondente à função f(x) = x*cos(x), neste intervalo;
b) digite o comando "figure" na janela de comandos do MatLab;
c) gere um novo gráfico correspondente à função f(x) = x*sin(x), com o estilo de linha "traço-ponto" e com a cor vermelha;
d) ative as linhas de grade deste último gráfico.

2. Plote novamente as duas funções em um único gráfico, colocando as legendas correspondentes nos eixos x e y e mantendo as configurações de cada um em relação aos estilos de linhas e cores.

3. Considere um vetor contendo dez elementos e a função f(x) = x.^2. Construa seis gráficos, em uma única "figure", correspondentes a plotagem de "x,f(x)" onde cada gráfico possua um estilo de símbolo diferente. Use "+", "<", "p" e "x" como símbolos.
 

 

8.5 Gráficos Tridimensionais

O comando fundamental para a plotagem de gráficos tridimensionais no MatLab a partir de malhas é mesh.

O comando "mesh(z)" cria um desenho tridimensional em perspectiva dos elementos da matriz z.  A superfície da grade é definida pelas coordenadas z dos pontos, acima de uma grade retangular no plano x-y.

Exemplo:

>> mesh(eye(10))



Para desenhar o gráfico de uma função z = f(x,y), utiliza-se o comando "meshgrid". Esta função funciona da seguinte maneira: dados dois vetores "k" e "w", contendo as coordenadas dos eixos x-y, a função "meshgrid" retorna duas matrizes "x" e "y" contendo uma "malha" de coordenadas necessária para a geração de superfícies.
 

Por exemplo:

>> [x,y] = meshgrid(-2:0.2:2,-2:0.2:2);
>> z = x.*exp(-x.^2-y.^2);
>> mesh(x,y,z)
>> xlabel('x')
>> ylabel('y')
>> zlabel('z')
>> title('Gráfico 3D')




Pode-se, ainda, utilizar o comando contour que mostra a projeção da superfície acima do plano xy com 10 iso-linhas:

>> contour(z,10)

Para preencher a superfície plotada, o MatLab oferece o comando surfc:

>> surfc(x,y,z)

que exibirá o gráfico da seguinte forma:



 
 
 
Exercícios: 

1. Gere um gráfico tridimensional a partir dos seguintes comandos:
a) k = -2:0.1:2;
b) w = k;
c) [x,y] = meshgrid(k,w);
d) z = exp(-x.^2 -y.^2);
e) mesh(x,y,z);
f) surf(x,y,z);

2. Ainda em relação ao gráfico anterior, experimente digitar "surfc(x,y,z)" e rotacionar o gráfico gerado com a utilização do botão 

3. Gere um novo gráfico tridimensional como segue:
a) k = -pi:0.5:pi;
b) w = k;
c) [x,y] = meshgrid(k,w);
d)  z = cos(x).*sin(y);
e) mesh(x,y,z);
f) surf(x,y,z);