Machine Translated by Google

MATLAB

Notas para Profissionais MATLAB®

Notas para Profissionais

Mais de 100 páginas

de dicas e truques profissionais

Isenção de
GoalKicker. com Livros responsabilidade Este é um livro gratuito não oficial criado para fins educacionais
de programação gratuitos e não é afiliado a grupos ou empresas oficiais do MATLAB®.
Todas as marcas comerciais e marcas registradas são
propriedade de seus respectivos proprietários
Machine Translated by Google

Conteúdo
Sobre .................................................. .................................................. .................................................. ............................. 1
Capítulo 1: Introdução à linguagem MATLAB .......................................... ........................................... 2

Seção 1.1: Indexação de matrizes e arrays ........................................... .................................................. ...................... 3

Seção 1.2: Funções anônimas e manipuladores de funções .................................................. ........................................ 8
Seção 1.3: Matrizes e Arrays .................................... .................................................. ........................................... 11
Seção 1.4: Matrizes de células ............................................. .................................................. .................................................. 13
Seção 1.5: Olá, mundo .................................................. .................................................. ........................................... 14
Seção 1.6: Scripts e Funções Seção .................................................. .................................................. .......................... 14
1.7: Ajudando a si mesmo ........................................ .................................................. .............................................. 16
Seção 1.8: Tipos de dados ............................................. .................................................. ................................................ 16
Seção 1.9: Entrada de leitura e saída de escrita ........................................... .................................................. ................ 19
Capítulo 2: Inicializando matrizes ou arrays ........................................... .................................................. .......... 21

Seção 2.1: Criando uma matriz de 0s .................................................. .................................................. ....................... 21

Seção 2.2: Criando uma matriz de 1s .................................................. .................................................. ....................... 21
Seção 2.3: Criando uma matriz de identidade .................................................. .................................................. ................ 21

Capítulo 3: Condições Seção .................................................. .................................................. ........................................... 22

3.1: Condição IF .................................................. .................................................. ........................................... 22
Seção 3.2: Condição IF-ELSE .................................................. .................................................. ................................ 22
Seção 3.3: Condição IF-ELSEIF .................................................. .................................................. ............................. 23
Seção 3.4: Condições aninhadas .................................................. .................................................. ................................ 24
Capítulo 4: Funções .................................................. .................................................. ........................................... 27

Seção 4.1: nargin, nargout .......................................... .................................................. .......................................... 27

Capítulo 5: Operações de configuração ............................................. .................................................. ........................................
29

Seção 5.1: Operações elementares com conjuntos .......................................... .................................................. ........................ 29

Capítulo 6: Documentando funções Seção 6.1: .................................................. .................................................. ................ 30

Obtendo uma assinatura de função ...................................... .................................................. ...................... 30

Seção 6.2: Documentação de Função Simples .................................................. .................................................. ....... 30
Seção 6.3: Documentação de Função Local .................................................. .................................................. ......... 30
Seção 6.4: Documentando uma função com um script de exemplo ................................... ........................................ 31
Capítulo 7: Usando funções com saída lógica .......................................... ................................................ 34

Seção 7.1: All e Any com matrizes vazias .................................... .................................................. .................... 34
Capítulo 8: Loops For ............................................. .................................................. .................................................. 35
Seção 8.1: Iterar sobre colunas da matriz .................................................. .................................................. .......... 35
Seção 8.2: Aviso: Estranhos loops aninhados de mesmo contador ........................................ .................................................. .35
Seção 8.3: Iterar sobre elementos do vetor .................................................. .................................................. ........ 36
Seção 8.4: Loops aninhados ............................................. .................................................. ........................................... 37
Seção 8.5: Loop 1 a n .................................................. .................................................. ........................................... 38
Seção 8.6: Loop sobre índices .................................................. .................................................. .............................. 39
Capítulo 9: Programação Orientada a Objetos ........................................... .................................................. ....... 40
Seção 9.1: Classes Value vs Handle .................................................. .................................................. ..................... 40
Seção 9.2: Construtores .................................................. .................................................. ........................................ 40
Seção 9.3: Definindo uma .................................................. .................................................. ................................... 42
classe Seção 9.4: Herdando de classes e classes abstratas .................................................. .................................... 43
Capítulo 10: Vetorização .................................................. .................................................. ................................... 47
Seção 10.1: Uso de bsxfun .................................................. .................................................. ........................................... 47
Seção 10.2: Expansão implícita de array (transmissão) [R2016b] ...................................... .................................... 48
Machine Translated by Google

Seção 10.3: Operações elementares ........................................... .................................................. ........................... 49

Seção 10.4: Mascaramento Lógico ............................................. .................................................. ...................................... 50
Seção 10.5: Soma, média, prod & co .................................................. .................................................. ...................... 51
Seção 10.6: Obtenha o valor de uma função de dois ou mais argumentos ........................... ........................................... 52
Capítulo 11: Decomposições de matrizes ............................................. .................................................. ..................... 53
Seção 11.1: Decomposição de Schur ............................................. .................................................. ................................ 53
Seção 11.2: Decomposição de Cholesky ............................................. .................................................. ........................ 53
Seção 11.3: Decomposição QR ............................................. .................................................. ................................... 54
Seção 11.4: Decomposição LU ............................................. .................................................. ................................... 54
Seção 11.5: Decomposição de valores singulares .......................................... .................................................. ................ 55
Capítulo 12: Gráficos: Gráficos de Linhas 2D
.................................................. .................................................. ............... 56
Seção 12.1: Linha dividida com .................................................. .................................................. ............................. 56
NaNs Seção 12.2: Múltiplas linhas em um único gráfico .................................. .................................................. ............................
56
Seção 12.3: Ordens personalizadas de cores e estilos .................................................. ................................................ 57

de linha Capítulo 13: Gráficos: transformações 2D e 3D .................................................. ................................. 61

Seção 13.1: Transformações 2D .................................................. .................................................. ........................... 61
Capítulo 14: Controlando a coloração da subtrama no MATLAB .................................................. ............................. 64
Seção 14.1: Como é feito .................................................. .................................................. ........................................... 64

Capítulo 15: Processamento de imagem ............................................. .................................................. ................................ 65

Seção 15.1: E/S de imagem básica .......................................... .................................................. ........................................... 65
Seção 15.2: Recuperar imagens da Internet Seção .................................................. .................................................. .. 65
15.3: Filtragem usando uma FFT 2D .................................................. .................................................. ................... 65
Seção 15.4: Filtragem de imagens ............................. .................................................. .................................................. ...... 66
Seção 15.5: Medindo Propriedades de Regiões Conectadas .......................................... ........................................... 67
Capítulo 16: Desenho ............................................. .................................................. .................................................. 70
Seção 16.1: Círculos .................................................. .................................................. .................................................. 70
Seção 16.2: Setas .................................................. .................................................. ................................................ 71
Seção 16.3: Elipse ............................................. .................................................. .................................................. .... 74
Seção 16.4: Gráfico Pseudo 4D .......................................... .................................................. ........................................ 75
Seção 16.5: Desenho rápido ............................................. .................................................. ........................................... 79
Seção 16.6: Polígono(s) .......................................... .................................................. .................................................. 80
Capítulo 17: Aplicações Financeiras ............................................. .................................................. ...................... 82
Seção 17.1: Passeio Aleatório .................................................. .................................................. ..................................... 82
Seção 17.2: Movimento Browniano Geométrico Univariado .................................................. ........................................... 82

Capítulo 18: Transformadas de Fourier e Transformadas Inversas de Fourier Seção .................................................. .. 84

18.1: Implementar uma Transformada de Fourier simples no MATLAB .................................................. ......................... 84
Seção 18.2: Imagens e FTs multidimensionais Seção .................................................. .................................................. .. 85
18.3: Transformadas Inversas de Fourier .................................................. .................................................. .............. 90
Capítulo 19: Solucionadores de equações diferenciais ordinárias .................................................. ............... 92
(EDO) Seção 19.1: Exemplo .................................................. .................................................. ............................ 92
para odeset Capítulo 20: Interpolação com MATLAB
.................................................. .................................................. ...... 94
Seção 20.1: Interpolação por partes bidimensional Seção .................................................. ............................................... 94
20.2: Interpolação por partes unidimensional Seção 20.3: .................................................. ............................................... 96
Interpolação polinomial .............................. .................................................. ................................... 101
Capítulo 21: Integração ............................................. .................................................. ........................................... 105
Seção 21.1: Integral, integral2, integral3 ........................................... .................................................. .................... 105
Capítulo 22: Lendo arquivos grandes .................................................. .................................................. .................... 107
Seção 22.1: textscan .................................................. .................................................. ........................................... 107
Machine Translated by Google

Seção 22.2: Strings de data e hora para array numérico rapidamente .................................................. ................................ 107

Capítulo 23: Uso da função `accumarray()` Seção 23.1: Aplicar filtro .................................................. ........................................ 109

a patches de imagem e definir cada pixel como a média do resultado de cada patch
.................................................. .................................................. .................................................. ....................... 109

Seção 23.2: Encontrando o valor máximo entre elementos agrupados por outro vetor ................................ 110

Capítulo 24: Introdução à API MEX .................................................. .................................................. ......... 111

Seção 24.1: Verifique o número de entradas/saídas em um arquivo C++ MEX .................................................. ...................... 111

Seção 24.2: Insira uma string, modifique-a em C e produza-a Seção .................................................. .................................... 112

24.3: Passando uma estrutura por nomes de campos .................................................. .................................................. .... 113
Seção 24.4: Passe uma matriz 3D do MATLAB para C .................................................. ............................................. 113

Capítulo 25: Depuração ............................................. .................................................. .......................................... 116

Seção 25.1: Trabalhando com pontos de interrupção .......................................... .................................................. .................... 116
Seção 25.2: Depurando código Java invocado pelo MATLAB .................................................. ................................. 118

Capítulo 26: Desempenho e Benchmarking .......................................... ................................................ 121

Seção 26.1: Identificando gargalos de desempenho usando o Profiler Seção 26.2: .................................................. ............... 121

Comparando o tempo de execução de múltiplas funções Seção 26.3: A .................................................. .......................... 124

importância da pré-alocação ......................... .................................................. ........................... 125

Seção 26.4: Não há problema em ser `solteiro`! .................................................. .................................................. ........................ 127

Capítulo 27: Multithreading ............................................. .................................................. ................................. 130

Seção 27.1: Usando parfor para paralelizar um loop .................................... .................................................. ........... 130
Seção 27.2: Executando comandos em paralelo usando uma instrução "Programa Único, Dados Múltiplos" (SPMD)
.................................................. .................................................. .................................................. ....................... 130

Seção 27.3: Usando o comando batch para fazer vários cálculos em paralelo .................................... ........ 131

Seção 27.4: Quando usar parfor ........................................... .................................................. ................................ 131

Capítulo 28: Usando portas seriais .......................................... .................................................. ............................ 133

Seção 28.1: Criando uma porta serial no Mac/Linux/Windows .................................... ........................................... 133
Seção 28.2: Escolhendo seu modo de comunicação Seção .................................................. ........................................... 133

28.3: Processamento automático de dados recebidos de uma porta serial .............................. ........................... 136
Seção 28.4: Leitura da porta serial ........................................... .................................................. ................. 137
Seção 28.5: Fechando uma porta serial mesmo se for perdida, excluída ou .................................................. ............. 137

sobrescrita Seção 28.6: Gravando na porta serial ............................ .................................................. .................................... 137

Capítulo 29: Recursos não documentados Seção .................................................. .................................................. ........ 138

29.1: Gráficos de linhas 2D codificados por cores com dados coloridos em terceira .................................................. ...... 138

dimensão Seção 29.2: Marcadores semitransparentes em gráficos de linhas e de dispersão ............ .................................................. 138
...
Seção 29.3: Funções auxiliares compatíveis com C++ .................................................. .................................................. .. 140

Seção 29.4: Tremulação do gráfico de dispersão ..................................... .................................................. ...........................................141

Seção 29.5: Gráficos de contorno - Personalize os rótulos de texto .................................................. .................................... 141

Seção 29.6: Anexando/adicionando entradas a uma legenda existente ........................................ .................................. 143

Capítulo 30: Melhores Práticas MATLAB

.................................................. .................................................. ........... 145

Seção 30.1: Recuar o código corretamente .......................................... .................................................. ............................ 145

Seção 30.2: Evitar loops ............................................. .................................................. .......................................... 146

Seção 30.3: Mantenha as linhas curtas .................................................. .................................................. .............................. 146

Seção 30.4: Usar afirmação .................................................. .................................................. ........................................ 147

Seção 30.5: Operador de bloco de comentários .......................................... .................................................. ................... 147

Seção 30.6: Criar nome exclusivo para arquivo temporário .................................................. ........................................... 148

Capítulo 31: Interfaces de usuário MATLAB .................................................. .................................................. .......... 150

Seção 31.1: Passando dados pela interface do usuário .................................................. ................................................ 150

Seção 31.2: Criando um botão em sua UI que pausa a execução do retorno de .................................................. ........ 152

chamada Seção 31.3: Passando dados usando a estrutura "handles" .................................................. ...................... 153
Machine Translated by Google

Seção 31.4: Problemas de desempenho ao transmitir dados pela interface do usuário .................................................. . 154

Capítulo 32: Truques úteis .................................................. .................................................. ................................... 157

Seção 32.1: Extrair dados de figuras .................................................. .................................................. .......................... 157

Seção 32.2: Preferências de dobramento de .................................................. .................................................. ............. 158
código Seção 32.3: Programação funcional usando funções anônimas Seção .................................................. ............... 160
32.4: Salvar múltiplas figuras no mesmo arquivo .fig Seção .................................................. ........................................... 160
32.5: Blocos de comentários .................................................. .................................................. ............................. 161
Seção 32.6: Funções úteis que operam em células e arrays ........................................ ................................... 162
Capítulo 33: Erros e erros comuns .................................................. ................................................ 165

Seção 33.1: Os operadores de transposição .......................................... .................................................. ...................... 165

Seção 33.2: Não nomeie uma variável com um nome de função existente .................................................. ............. 165
Seção 33.3: Esteja ciente da imprecisão do ponto flutuante ............................ .................................................. ............... 166
Seção 33.4: O que você vê NÃO é o que você obtém: char vs cellstring na janela de comando Seção 33.5: ........................ 167
Função indefinida ou método X para argumentos de entrada do tipo Y Seção 33.6: O uso de ................................................ 168
"i" ou "j" como unidade imaginária, índices de loop ou variável comum Seção 33.7: Argumentos de .................................... 169
entrada insuficientes .................................... .................................................. .................... 172
Seção 33.8: Usando `length` para matrizes multidimensionais ........................................ .............................................. 173
Seção 33.9: Cuidado com as alterações no tamanho do array .................................... .................................................. ......... 173
Créditos .................................................. .................................................. .................................................. ...................... 175
você pode gostar .................................................. .................................................. .................................................. 177
Machine Translated by Google

Sobre

Sinta-se à vontade para compartilhar este PDF com qualquer pessoa

gratuitamente. A versão mais recente deste livro pode ser baixada em:

https://goalkicker.com/MATLABBook

Este livro MATLAB® Notes for Professionals foi compilado da documentação do Stack Overflow ,
o conteúdo foi escrito pelas pessoas bonitas do Stack Overflow.
O conteúdo do texto é liberado sob Creative Commons BY-SA, veja os créditos no final deste livro

quem contribuiu para os vários capítulos. As imagens podem ser protegidas por direitos autorais de seus
respectivos proprietários, salvo especificação em contrário

Este é um livro gratuito não oficial criado para fins educacionais e não é afiliado a grupos ou
empresas oficiais do MATLAB® nem ao Stack Overflow. Todas as marcas comerciais e marcas
registradas são propriedade de seus respectivos
proprietários de empresas

Não há garantia de que as informações apresentadas neste livro sejam corretas ou precisas, use
por sua conta e risco

Por favor, envie comentários e correções para [email protected]

GoalKicker.com Notas MATLAB® para profissionais 1

Machine Translated by Google

Capítulo 1: Introdução ao MATLAB

Linguagem
Data de lançamento da versão
1,0 01/01/1984

2 01/01/1986

3 01/01/1987

3.5 01/01/1990

4 01/01/1992

4.2c 01/01/1994

5,0 Volume 8 1996-12-01

5.1 Volume 9 01/05/1997

5.1.1 R9.1 02/05/1997

5.2 R1 01/03/1998

5.2.1 R10.1 02/03/1998

5.3 R11 01/01/1999

5.3.1 R11.1 01/11/1999

6,0 R12 01-11-2000

6.1 R12.1 01-06-2001

6,5 R13 01/06/2002

6.5.1 R13SP2 01/01/2003

6.5.2 R13SP2 02/01/2003

7 R14 01/06/2006

7.0.4 R14SP1 01/10/2004

7.1 R14SP3 2005-08-01

7.2 R2006a 2006-03-01

7.3 R2006b 2006-09-01

7.4 R2007a 2007-03-01

7,5 R2007b 2007-09-01

7.6 R2008a 2008-03-01

7.7 R2008b 2008-09-01

7,8 R2009a 2009-03-01

7,9 R2009b 2009-09-01

7.10 R2010a 2010-03-01

7.11 R2010b 01/09/2010

7.12 R2011a 2011-03-01

7.13 R2011b 01-09-2011

7.14 R2012a 2012-03-01

8,0 R2012b 01/09/2012

8.1 R2013a 01/03/2013

8.2 R2013b 01/09/2013

8.3 R2014a 01/03/2014

8.4 R2014b 01/09/2014

8,5 R2015a 2015-03-01

8.6 R2015b 01/09/2015

GoalKicker.com Notas MATLAB® para profissionais 2

Machine Translated by Google

9,0 R2016a 2016-03-01

9.1 R2016b 14/09/2016

9.2 R2017a 2017-03-08

Veja também: histórico de lançamentos do MATLAB na Wikipedia.

Seção 1.1: Indexação de matrizes e arrays

MATLAB permite vários métodos para indexar (acessar) elementos de matrizes e arrays:

Indexação subscrita - onde você especifica a posição dos elementos que deseja em cada dimensão do
matriz separadamente.
Indexação linear - onde a matriz é tratada como um vetor, independentemente de suas dimensões. Isso significa que você especifica
cada posição na matriz com um único número.
Indexação lógica - onde você usa uma matriz lógica (e uma matriz de valores verdadeiros e falsos ) com valores idênticos
dimensões da matriz que você está tentando indexar como uma máscara para especificar qual valor retornar.

Esses três métodos são agora explicados com mais detalhes usando a seguinte matriz 3 por 3 M como exemplo:

>> M = magia (3)

anos =

8 6
3 15 7
4 9 2

Indexação de subscritos

O método mais direto para acessar um elemento é especificar seu índice linha-coluna. Por exemplo,
acessando o elemento na segunda linha e terceira coluna:

>> M(2, 3)

anos =

O número de subscritos fornecidos corresponde exatamente ao número de dimensões que M possui (duas neste exemplo).

Observe que a ordem dos subscritos é a mesma da convenção matemática: o índice da linha é o primeiro. Além disso,
Os índices MATLAB começam com 1 e não 0 como a maioria das linguagens de programação.

Você pode indexar vários elementos de uma vez, passando um vetor para cada coordenada em vez de um único número. Para
Por exemplo, para obter a segunda linha inteira, podemos especificar que queremos a primeira, segunda e terceira colunas:

>> M(2, [1,2,3])

anos =

3 5 7

No MATLAB, o vetor [1,2,3] é mais facilmente criado usando o operador dois pontos, ou seja, 1:3. Você pode usar isso na indexação
também. Para selecionar uma linha (ou coluna) inteira, o MATLAB fornece um atalho permitindo apenas especificar :. Por exemplo,
o código a seguir também retornará toda a segunda linha

GoalKicker.com Notas MATLAB® para profissionais 3

Machine Translated by Google

>> M(2, :)

anos =

3 5 7

O MATLAB também fornece um atalho para especificar o último elemento de uma dimensão na forma do final palavra-chave. A palavra-chave final
funcionará exatamente como se fosse o número do último elemento daquela dimensão. Então, se você quiser todas as colunas da coluna 2 até a
última coluna, você pode escrever o seguinte:

>> M(2, 2:fim)

anos =

5 7

A indexação de subscritos pode ser restritiva, pois não permite extrair valores únicos de colunas e linhas diferentes; ele extrairá a
combinação de todas as linhas e colunas.

>> M([2,3], [1,3])

anos =

3 7
4 2

Por exemplo, a indexação subscrita não pode extrair apenas os elementos M(2,1) ou M(3,3). Para fazer isso, devemos considerar
a indexação linear.

Indexação linear

O MATLAB permite tratar arrays ndimensionais como arrays unidimensionais quando você indexa usando apenas uma
dimensão. Você pode acessar diretamente o primeiro elemento:

>> M(1)

anos =

Observe que as matrizes são armazenadas na ordem da coluna principal no MATLAB, o que significa que você acessa os elementos
descendo primeiro nas colunas. Então M(2) é o segundo elemento da primeira coluna que é 3 e M(4) será o primeiro elemento
da segunda coluna, ou seja

>> M(4)

anos =

Existem funções integradas no MATLAB para converter índices subscritos em índices lineares e vice-versa: sub2ind e ind2sub respectivamente.
Você pode converter manualmente os subscritos (r,c) em um índice linear

idx = r + (c-1)*tamanho(M,1)

Para entender isso, se estivermos na primeira coluna, o índice linear será simplesmente o índice da linha. A fórmula acima é válida para isso
porque para c == 1, (c-1) == 0. Nas próximas colunas, o índice linear é o número da linha

GoalKicker.com Notas MATLAB® para profissionais 4

Machine Translated by Google

mais todas as linhas das colunas anteriores.

Observe que a palavra-chave end ainda se aplica e agora se refere ao último elemento da matriz, ou seja, M(end) == M(end,
fim) == 2.

Você também pode indexar vários elementos usando indexação linear. Observe que se você fizer isso, a matriz retornada terá
a mesma forma que a matriz de vetores de índice.

M(2:4) retorna um vetor linha porque 2:4 representa o vetor linha [2,3,4]:

>> M(2:4)

anos =

3 4 1

Como outro exemplo, M([1,2;3,4]) retorna uma matriz 2 por 2 porque [1,2;3,4] também é uma matriz 2 por 2. Veja o
código abaixo para se convencer:

>> M([1,2;3,4])

anos =

8 3
4 1

Observe que a indexação apenas com : sempre retornará um vetor de coluna:

>> M(:)

anos =

8
3
4
1
5
9
6
7
2

Este exemplo também ilustra a ordem em que o MATLAB retorna elementos ao usar indexação linear.

Indexação lógica

O terceiro método de indexação é usar uma matriz lógica, ou seja, uma matriz contendo apenas valores verdadeiros ou falsos , como máscara
para filtrar os elementos que você não deseja. Por exemplo, se quisermos encontrar todos os elementos de M que são maiores que
5 podemos usar a matriz lógica

>> M > 5

anos =

0 1
10 0 1
0 1 0

GoalKicker.com Notas MATLAB® para profissionais 5

Machine Translated by Google

para indexar M e retornar apenas os valores maiores que 5 da seguinte forma:

>> M(M > 5)

anos =

8
9

6
7

Se você quisesse que esses números permanecessem no lugar (isto é, mantivessem a forma da matriz), então você poderia atribuir ao
complemento lógico

>> M(~(M > 5)) = NaN

anos =

8 NaN 6
NaN NaN 7
NaN 9 Em

Podemos reduzir blocos de código complicados contendo instruções if e for usando indexação lógica.

Pegue o não vetorizado (já reduzido para um único loop usando indexação linear):

para elem = 1:numel(M) se

M(elem) > 5
M(elem) = M(elem) - 2; fim fim

Isso pode ser reduzido para o seguinte código usando indexação lógica:

idx = M > 5;
M(idx) = M(idx) - 2;

Ou ainda mais curto:

M(M > 5) = M(M > 5) - 2;

Mais sobre indexação

Matrizes de dimensão superior

Todos os métodos mencionados acima são generalizados em n dimensões. Se usarmos a matriz tridimensional M3 = rand(3,3,3) como
exemplo, então você pode acessar todas as linhas e colunas da segunda fatia da terceira dimensão escrevendo

>> M(:,:,2)

Você pode acessar o primeiro elemento da segunda fatia usando indexação linear. A indexação linear só passará para a segunda fatia depois
de todas as linhas e colunas da primeira fatia. Portanto, o índice linear para esse elemento é

>> M(tamanho(M,1)*tamanho(M,2)+1)

GoalKicker.com Notas MATLAB® para profissionais 6

Machine Translated by Google

Na verdade, no MATLAB, toda matriz é n-dimensional: acontece que o tamanho da maioria das outras n-dimensões é um. Então, se a = 2 então

a(1) == 2 (como seria de esperar), mas também a(1, 1) == 2, assim como a(1, 1, 1)

== 2, a(1, 1, 1, ..., 1) == 2 e assim por diante. Essas dimensões "extras" (de tamanho 1) são chamadas de singleton
dimensões. O comando squeeze irá removê-los, e pode-se usar permute para trocar a ordem das dimensões
ao redor (e introduza dimensões singleton, se necessário).

Uma matriz n-dimensional também pode ser indexada usando m subscritos (onde m<=n). A regra é que o primeiro m-1
os subscritos se comportam normalmente, enquanto o último (m'ésimo) subscrito faz referência às dimensões restantes (n-m+1), assim como um
o índice linear faria referência a uma matriz dimensional (n-m+1). Aqui está um exemplo:

>> M = remodelar(1:24,[2,3,4]);
>> M(1,1)
anos =
1
>> M(1,10)
anos =
19
>> M(:,:)
anos =
5 7 11 13 15 17 19 21 23
12 34 6 8 9 10 12 14 16 18 20 22 24

Retornando intervalos de elementos

Com a indexação subscrita, se você especificar mais de um elemento em mais de uma dimensão, o MATLAB retornará cada
possível par de coordenadas. Por exemplo, se você tentar M([1,2],[1,3]) MATLAB retornará M(1,1) e M(2,3) mas
também retorne M(1,3) e M(2,1). Isto pode parecer pouco intuitivo quando você procura os elementos de uma lista de
pares de coordenadas, mas considere o exemplo de uma matriz maior, A = rand(20) (observe que A agora é 20 por 20), onde você
deseja obter o quadrante superior direito. Neste caso, em vez de ter que especificar cada par de coordenadas naquele
quadrante (e neste caso seriam 100 pares), basta especificar as 10 linhas e as 10 colunas que deseja
A(1:10, 11:fim). Fatiar uma matriz como essa é muito mais comum do que exigir uma lista de pares de coordenadas.

Caso você queira obter uma lista de pares de coordenadas, a solução mais simples é converter para indexação linear.
Considere o problema em que você tem um vetor de índices de coluna que deseja retornar, onde cada linha do vetor
contém o número da coluna que você deseja retornar para a linha correspondente da matriz. Por exemplo

colIdx = [3;2;1]

Então, neste caso, você realmente deseja recuperar os elementos em (1,3), (2,2) e (3,1). Então, usando indexação linear:

>> colIdx = [3;2;1];

>> linhaIdx = 1:comprimento(colIdx);
>> idx = sub2ind(tamanho(M), rowIdx, colIdx);
>> M(idx)

anos =

6 5 4

Retornando um elemento várias vezes

Com subscrito e indexação linear você também pode retornar um elemento várias vezes repetindo seu índice para

>> M([1,1,1,2,2,2])

anos =

GoalKicker.com Notas MATLAB® para profissionais 7

Machine Translated by Google
8 8 8 3 3 3

Você pode usar isso para duplicar linhas e colunas inteiras, por exemplo, para repetir a primeira linha e a última coluna

>> M([1, 1:fim], [1:fim, fim])

anos =

8 1 6 6
8 1 6 6
3 5 7 7
4 9 2 2

Para mais informações, veja aqui.

Seção 1.2: Funções anônimas e identificadores de função

Fundamentos

Funções anônimas são uma ferramenta poderosa da linguagem MATLAB. São funções que existem localmente, ou seja: em
o espaço de trabalho atual. No entanto, eles não existem no caminho MATLAB como uma função regular existiria, por exemplo, em um arquivo m. É por
isso que são chamados de anônimos, embora possam ter um nome como uma variável na área de trabalho.

O operador _

Use o operador @ para criar funções anônimas e identificadores de função. Por exemplo, para criar um identificador para o pecado
função (seno) e use-a como f:

>> f = @sin
f=
@pecado

Agora f é um identificador para a função sin . Assim como (na vida real) uma maçaneta de porta é uma forma de usar uma porta, uma maçaneta de função é
uma maneira de usar uma função. Para usar f, os argumentos são passados para ele como se fosse a função sin :

>> f(pi/2)
anos =
1

f aceita quaisquer argumentos de entrada que a função sin aceita. Se sin fosse uma função que aceita entrada zero
argumentos (o que não acontece, mas outros fazem, por exemplo, a função peaks ), f() seria usado para chamá-lo sem entrada
argumentos.

Funções anônimas personalizadas

Funções anônimas de uma variável

Obviamente não é útil criar um identificador para uma função existente, como sin no exemplo acima. É uma espécie de
redundante nesse exemplo. No entanto, é útil criar funções anônimas que fazem coisas personalizadas que
caso contrário, precisaria ser repetido várias vezes ou criado uma função separada para. Como exemplo de costume
função anônima que aceita uma variável como entrada, soma o seno e o cosseno ao quadrado de um sinal:

>> f = @(x) sin(x)+cos(x).^2

f=
@(x)sin(x)+cos(x).^2

GoalKicker.com Notas MATLAB® para profissionais 8

Machine Translated by Google

Agora f aceita um argumento de entrada chamado x. Isso foi especificado usando parênteses (...) logo após o operador @ . f
agora é uma função anônima de x: f(x). É usado passando um valor de x para f:

>> f(pi)
anos =
1,0000

Um vetor de valores ou uma variável também pode ser passado para f, desde que sejam usados de forma válida dentro de f:

>> f(1:3) % passa um vetor para f

anos =
1.1334 1.0825 1.1212
>> n = 5:7; >> f
(n) % passa n para f
anos =
-0,8785 0,6425 1.2254

Funções anônimas de mais de uma variável

Da mesma forma, funções anônimas podem ser criadas para aceitar mais de uma variável. Um exemplo de função anônima que
aceita três variáveis:

>> f = @(x,y,z) x.^2 + y.^2 - z.^2 f =

@(x,y,z)x.^2+y.^2-z.^2 >> f(2,3,4)

anos =
-3

Parametrizando funções anônimas

Variáveis no espaço de trabalho podem ser usadas na definição de funções anônimas. Isso é chamado de parametrização.
Por exemplo, para usar uma constante c = 2 em uma função anônima:

>> c = 2; >>
f = @(x) c*xf =

@(x)c*x
>> f(3)
anos =
6

f(3) usou a variável c como parâmetro para multiplicar pelo x fornecido. Observe que se o valor de c for definido como algo
diferente neste ponto, então f(3) for chamado, o resultado não será diferente. O valor de c é o valor no momento da criação da função
anônima:

>> c = 2; >>
f = @(x) c*x; >> f(3)

anos =
6
>> c = 3; >>
f(3)
anos =
6

Os argumentos de entrada para uma função anônima não se referem a variáveis do espaço de trabalho

Observe que usar o nome das variáveis no espaço de trabalho como um dos argumentos de entrada de uma função anônima

GoalKicker.com Notas MATLAB® para profissionais 9

Machine Translated by Google

(ou seja, usar @(...)) não usará os valores dessas variáveis. Em vez disso, elas são tratadas como variáveis diferentes dentro do escopo da função
anônima, ou seja: a função anônima tem seu espaço de trabalho privado onde as variáveis de entrada nunca se referem às variáveis do espaço
de trabalho principal. O espaço de trabalho principal e o espaço de trabalho da função anônima não conhecem o conteúdo um do outro. Um exemplo para
ilustrar isso:

>> x = 3 % x na área de trabalho principal

x=
3
>> f = @(x) x+1; % aqui x refere-se a uma variável x privada >> f(5)

anos =
6
>>x
x=
3

O valor de x do espaço de trabalho principal não é usado em f. Além disso, na área de trabalho principal x foi deixado intacto.
Dentro do escopo de f, os nomes das variáveis entre parênteses após o operador @ são independentes das principais variáveis do espaço de
trabalho.

Funções anônimas são armazenadas em variáveis

Uma função anônima (ou, mais precisamente, o identificador de função apontando para uma função anônima) é armazenada como qualquer outro valor
no espaço de trabalho atual: Em uma variável (como fizemos acima), em uma matriz de células ({@(x )x .^2,@(x)x+1}), ou mesmo em uma propriedade
(como h.ButtonDownFcn para gráficos interativos). Isso significa que a função anônima pode ser tratada como qualquer outro valor. Ao armazená-
lo em uma variável, ele possui um nome no espaço de trabalho atual e pode ser alterado e limpo da mesma forma que as variáveis que contêm
números.

Dito de outra forma: um identificador de função (seja no formato @sin ou para uma função anônima) é simplesmente um valor que pode ser
armazenado em uma variável, assim como uma matriz numérica pode ser.

Uso avançado

Passando identificadores de função para outras funções

Como os identificadores de função são tratados como variáveis, eles podem ser passados para funções que aceitam identificadores de função como
argumentos de entrada.

Um exemplo: uma função é criada em um arquivo m que aceita um identificador de função e um número escalar. Em seguida, ele chama o identificador
da função passando 3 para ele e adiciona o número escalar ao resultado. O resultado é retornado.

Conteúdo de funHandleDemo.m:

função y = funHandleDemo(diversão,x) y =
diversão(3); y
= y + x;

Salve-o em algum lugar do caminho, por exemplo, na pasta atual do MATLAB. Agora funHandleDemo pode ser usado da seguinte forma, por
exemplo:

>> f = @(x) x^2; % uma função anônima >> y =

funHandleDemo(f,10) % passa f e um escalar para funHandleDemo y =

19

O identificador de outra função existente pode ser passado para funHandleDemo:

GoalKicker.com Notas MATLAB® para profissionais 10

Machine Translated by Google

>> y = funHandleDemo(@sin,-5)
y=
-4,8589

Observe como @sin foi uma maneira rápida de acessar a função sin sem primeiro armazená-la em uma variável usando f = @sin.

Usando bsxfun, cellfun e funções similares com funções anônimas

O MATLAB possui algumas funções integradas que aceitam funções anônimas como entrada. Esta é uma forma de realizar muitos
cálculos com um número mínimo de linhas de código. Por exemplo bsxfun, que realiza operações binárias elemento por elemento, ou
seja: aplica uma função em dois vetores ou matrizes elemento por elemento.
Normalmente, isso exigiria o uso de loops for, o que geralmente requer pré-alocação de velocidade. Usando bsxfun esse processo é
acelerado. O exemplo a seguir ilustra isso usando tic e toc, duas funções que podem ser usadas para cronometrar quanto tempo leva o
código. Ele calcula a diferença de cada elemento da matriz em relação à média da coluna da matriz.

A = rand(50); % Matriz 50 por 50 de valores aleatórios entre 0 e 1

% método 1: lento e com muitas linhas de código tic meanA =

mean(A); % média de cada coluna da matriz: um vetor de linha % resultado pré-alocado

para velocidade, remova isso para um desempenho ainda pior resultado = zeros(size(A)); para j =
1:tamanho(A,1) resultado(j,:) =
A(j,:) - médiaA;

fim
toc
resultado claro % certifique-se de que o método 2 crie seu próprio resultado

% método 2: rápido e com apenas uma linha de código

resultado = bsxfun(@menos,A,média(A));
toc

Executar o exemplo acima resulta em duas saídas:

O tempo decorrido é 0,015153 segundos.

O tempo decorrido é 0,007884 segundos.

Essas linhas vêm das funções toc , que imprimem o tempo decorrido desde a última chamada à função tic .

A chamada bsxfun aplica a função do primeiro argumento de entrada aos outros dois argumentos de entrada. @menos é um nome longo
para a mesma operação que o sinal de menos faria. Uma função ou identificador anônimo diferente (@) para qualquer outra função
poderia ter sido especificado, desde que aceitasse A e mean(A) como entradas para gerar um resultado significativo.

Especialmente para grandes quantidades de dados em grandes matrizes, o bsxfun pode acelerar bastante as coisas. Também faz o
código parecer mais limpo, embora possa ser mais difícil de interpretar para pessoas que não conhecem MATLAB ou bsxfun. (Observe que
no MATLAB R2016a e posterior, muitas operações que anteriormente usavam bsxfun não precisam mais delas; A-mean(A) funciona
diretamente e pode, em alguns casos, ser ainda mais rápida.)

Seção 1.3: Matrizes e Arrays

No MATLAB, o tipo de dados mais básico é o array numérico. Pode ser um escalar, um vetor 1-D, uma matriz 2-D ou uma matriz
multidimensional ND.

GoalKicker.com Notas MATLAB® para profissionais 11

Machine Translated by Google

% um valor escalar 1 por 1 x = 1;

Para criar um vetor linha, insira os elementos entre colchetes, separados por espaços ou vírgulas:

% um vetor linha 1 por 4 v = [1,

2, 3, 4]; v = [1 2 3 4];

Para criar um vetor coluna, separe os elementos com ponto e vírgula:

% um vetor coluna 4 por 1 v = [1; 2;

3; 4];

Para criar uma matriz, inserimos as linhas como antes, separadas por ponto e vírgula:

% uma matriz de 2 linhas por 4 colunas

M = [1 2 3 4; 5 6 7 8];

% uma matriz de 4 linhas por 2 colunas M

= [1 2; ... 4 5; ... 6
7; ... 8 9];

Observe que você não pode criar uma matriz com tamanho de linha/coluna desigual. Todas as linhas devem ter o mesmo comprimento e todas
as colunas devem ter o mesmo comprimento:

% uma matriz de linha/coluna desigual

M = [1 2 3 ; 4 5 6 7]; % Isto não é válido e retornará um erro

% outra matriz linha/coluna desigual M = [1 2 3; ... 4

5; ... 6 7 8; ... 9 10];

% Isto não é válido e retornará um erro

Para transpor um vetor ou matriz, usamos o operador .', ou o operador ' para obter seu conjugado hermitiano, que é o conjugado complexo de sua
transposta. Para matrizes reais, estes dois são iguais:

% cria um vetor linha e transpõe-o para um vetor coluna v = [1 2 3 4].'; % v é igual a [1;
2; 3; 4];

% crie uma matriz 2 por 4 e transponha-a para obter uma matriz 4 por 2 M = [1 2 3 4; 5 6 7 8].';
% M é igual a [1 5; 26; 37; 4 8]

% transpõe um vetor ou matriz armazenada como uma variável A = [1 2; 3

4]; B = A.';
% B é igual a [1 3; 2 4]

Para matrizes com mais de duas dimensões, não há sintaxe de linguagem direta para inseri-las literalmente. Em vez disso, devemos usar funções
para construí-los (como uns, zeros, rand) ou manipular outros arrays (usando funções como cat, reshape, permute). Alguns exemplos:

% uma matriz 5 por 2 por 4 por 3 (4 dimensões) arr = uns(5,

2, 4, 3);

GoalKicker.com Notas MATLAB® para profissionais 12

Machine Translated by Google

% uma matriz 2 por 3 por 2 (3 dimensões)

arr = gato(3, [1 2 3; 4 5 6], [7 8 9; 0 1 2]);

% a 5 por 4 por 3 por 2 (4 dimensões)

arr = remodelar(1:120, [5 4 3 2]);

Seção 1.4: Matrizes de células

Elementos da mesma classe muitas vezes podem ser concatenados em arrays (com algumas raras exceções, por exemplo, função
alças). Escalares numéricos, por padrão da classe double, podem ser armazenados em uma matriz.

>> UMA = [1, -2, 3,14, 4/5, 5 ^ 6; pi, inf, 7/0, pol, log(0)]
UMA =

1.0e+04 *
0,0001 -0,0002 0,0003 Inf. 0,0003 0,0001 1,5625
Inf. NaN -Inf

Caracteres, que são da classe char no MATLAB, também podem ser armazenados em array usando sintaxe semelhante. Tal matriz é
semelhante a uma string em muitas outras linguagens de programação.

>> s = ['MATLAB ','é ','divertido']

s=
MATLAB é divertido

Observe que apesar de ambos usarem colchetes [ e ], as classes de resultados são diferentes. Portanto as operações
que pode ser feito neles também são diferentes.

>> quem é
Nome Tamanho Classe de Bytes Atributos

A 2x5 80 duplo
é 1x13 26 caracteres

Na verdade, o array s não é um array das strings 'MATLAB ', 'is ' e 'fun', é apenas uma string - um array de 13
personagens. Você obteria os mesmos resultados se fosse definido por qualquer um dos seguintes:

>> s = ['MAT','LAB ','é f','u','n'];

>> s = ['M','A','T','L','A','B,' ',' i','s',' ' ,'f','u', 'n'];

Um vetor MATLAB regular não permite armazenar uma combinação de variáveis de classes diferentes ou algumas strings diferentes. Esse
é onde a matriz de células é útil. Este é um array de células em que cada uma pode conter algum objeto MATLAB, cujo
a classe pode ser diferente em cada célula, se necessário. Use chaves { e } ao redor dos elementos para armazenar em uma matriz de células.

>> C = {UMA; e}
C=
[2x5 duplo]
'MATLAB é divertido'
>> quem é C
Nome Tamanho Classe de Bytes Atributos

C 2x1 330 células

Objetos MATLAB padrão de qualquer classe podem ser armazenados juntos em uma matriz de células. Observe que as matrizes de células requerem mais
memória para armazenar seu conteúdo.

O acesso ao conteúdo de uma célula é feito usando chaves { e }.

GoalKicker.com Notas MATLAB® para profissionais 13

Machine Translated by Google

>> C{1}
anos =
1.0e+04*
0,0001 -0,0002 Inf. 0,0003 0,0001 1,5625
0,0003 Inf. NaN -Inf

Observe que C(1) é diferente de C{1}. Enquanto o último retorna o conteúdo da célula (e tem classe double in out
exemplo), o primeiro retorna uma matriz de células que é uma submatriz de C. Da mesma forma, se D fosse uma matriz de células de 10 por 5, então

D(4:8,1:3) retornaria uma submatriz de D cujo tamanho é 5 por 3 e cuja classe é célula. E a sintaxe C{1:2} faz
não tem um único objeto retornado, mas retorna 2 objetos diferentes (semelhante a uma função MATLAB com
vários valores de retorno):

>> [x,y] = C{1:2}

x=
1 -2 3.14
0,8 15625
3.14159265358979 Informações Informações

NaN -Inf
você =

MATLAB é divertido

Seção 1.5: Olá, mundo

Abra um novo documento em branco no Editor MATLAB (em versões recentes do MATLAB, faça isso selecionando a guia Home
da barra de ferramentas e clicando em Novo Script). O atalho de teclado padrão para criar um novo script é Ctrl-n .

Alternativamente, digitar edit myscriptname.m abrirá o arquivo myscriptname.m para edição ou oferecerá a criação do arquivo se
ele não existe no caminho MATLAB.

No editor, digite o seguinte:

disp('Olá, mundo!');

Selecione a guia Editor da barra de ferramentas e clique em Salvar como. Salve o documento em um arquivo no diretório atual chamado

Olá mundo.m. Salvar um arquivo sem título abrirá uma caixa de diálogo para nomear o arquivo.

Na janela de comando do MATLAB, digite o seguinte:

>> olá mundo

Você deverá ver a seguinte resposta na janela de comando do MATLAB:

Olá Mundo!

Vemos que na janela de comando podemos digitar os nomes das funções ou arquivos de script que temos
escritos, ou que são fornecidos com o MATLAB, para executá-los.

Aqui, executamos o script ‘helloworld’. Observe que digitar a extensão (.m) é desnecessário. As instruções mantidas
no arquivo de script são executados pelo MATLAB, imprimindo aqui 'Hello, World!' usando a função disp .

Arquivos de script podem ser escritos desta forma para salvar uma série de comandos para (re)utilização posterior.

Seção 1.6: Scripts e Funções

O código MATLAB pode ser salvo em arquivos m para serem reutilizados. Os arquivos m têm a extensão .m que é automaticamente associada

GoalKicker.com Notas MATLAB® para profissionais 14

Machine Translated by Google

com MATLAB. Um arquivo m pode conter um script ou funções.

Roteiros

Scripts são simplesmente arquivos de programas que executam uma série de comandos MATLAB em uma ordem predefinida.

Os scripts não aceitam entrada, nem retornam saída. Funcionalmente, os scripts são equivalentes a digitar comandos diretamente na janela de
comando do MATLAB e ser capaz de reproduzi-los.

Um exemplo de roteiro:

comprimento =
10; largura =
3; área = comprimento * largura;

Este script definirá comprimento, largura e área na área de trabalho atual com os valores 10, 3 e 30 respectivamente.

Conforme afirmado anteriormente, o script acima é funcionalmente equivalente a digitar os mesmos comandos diretamente na janela de
comando.

>> comprimento =
10; >> largura =
3; >> área = comprimento * largura;

Funções

As funções, quando comparadas aos scripts, são muito mais flexíveis e extensíveis. Ao contrário dos scripts, as funções podem aceitar entrada
e retornar saída ao chamador. Uma função possui seu próprio espaço de trabalho, isso significa que as operações internas das funções não
alterarão as variáveis do chamador.

Todas as funções são definidas com o mesmo formato de cabeçalho:

função [saída] = meuNomeFunção(entrada)

A palavra-chave function inicia cada cabeçalho de função. A lista de saídas segue. A lista de saídas também pode ser uma lista separada por
vírgulas de variáveis a serem retornadas.

função [a, b, c] = meuNomeFunção(entrada)

A seguir está o nome da função que será usada para chamar. Geralmente é o mesmo nome do arquivo. Por exemplo, salvaríamos esta função
como myFunctionName.m.

Após o nome da função está a lista de entradas. Assim como as saídas, também pode ser uma lista separada por vírgulas.

função [a, b, c] = meuNomeFunção(x, y, z)

Podemos reescrever o script de exemplo anterior como uma função reutilizável como a seguinte:

função [área] = calcRecArea(comprimento, largura)

área = comprimento * largura;
fim

Podemos chamar funções de outras funções, ou mesmo de arquivos de script. Aqui está um exemplo de nossa função acima sendo usada
em um arquivo de script.

GoalKicker.com Notas MATLAB® para profissionais 15

Machine Translated by Google

eu = 100;
w = 20; a
= calcRecArea(l, w);

Como antes, criamos l, w e a no espaço de trabalho com os valores de 100, 20 e 2.000, respectivamente.

Seção 1.7: Ajudando a si mesmo

MATLAB vem com muitos scripts e funções integradas que vão desde simples multiplicação até caixas de ferramentas de reconhecimento
de imagem. Para obter informações sobre uma função que você deseja usar, digite: help functionname na linha de comando. Tomemos a função de
ajuda como exemplo.

Informações sobre como usá-lo podem ser obtidas digitando:

>> ajuda ajuda

na janela de comando. Isso retornará informações sobre o uso da ajuda da função. Se a informação que você procura ainda não
estiver clara, você pode tentar a página de documentação da função. Basta digitar:

>> ajuda do documento

na janela de comando. Isso abrirá a documentação navegável na página de ajuda da função , fornecendo todas as informações necessárias
para entender como a 'ajuda' funciona.

Este procedimento funciona para todas as funções e símbolos integrados.

Ao desenvolver suas próprias funções você pode permitir que elas tenham sua própria seção de ajuda adicionando comentários no topo do
arquivo de função ou logo após a declaração da função.

Exemplo de uma função simples multiplicar por2 salva no arquivo multiplicar por2.m

função [prod]=multiplyby2(num) % função

MULTIPLYBY2 aceita uma matriz numérica NUM e retorna a saída PROD % de modo que todos os números
sejam multiplicados por 2

prod=número*2;
fim

ou

A função % MULTIPLYBY2 aceita uma matriz numérica NUM e retorna a saída PROD % de forma que todos os
números sejam multiplicados por 2

função [prod]=multiplicarpor2(num) prod=num*2;

fim

Isso é muito útil quando você escolhe seu código semanas/meses/anos depois de escrevê-lo.

A função de ajuda e documento fornece muitas informações. Aprender como usar esses recursos o ajudará a progredir rapidamente e a
usar o MATLAB com eficiência.

Seção 1.8: Tipos de dados

Existem 16 tipos de dados fundamentais, ou aulas, no MATLAB. Cada uma dessas classes está na forma de uma matriz ou array.
Com exceção dos identificadores de função, essa matriz ou array tem tamanho mínimo de 0 por 0 e pode crescer até um

GoalKicker.com Notas MATLAB® para profissionais 16

Machine Translated by Google

matriz n-dimensional de qualquer tamanho. Um identificador de função é sempre escalar (1 por 1).

Um ponto importante no MATLAB é que você não precisa usar nenhuma declaração de tipo ou instrução de dimensão para
padrão. Quando você define uma nova variável, o MATLAB a cria automaticamente e aloca o espaço de memória apropriado.

Exemplo:

uma = 123;
b = [1 2 3];
c = '123';

>> quem é
Nome Tamanho Classe de Bytes Atributos

a 1x1 8 duplos 24
b 1x3 duplos
c 1x3 6 caracteres

Se a variável já existir, o MATLAB substitui os dados originais por novos e aloca novo espaço de armazenamento se
necessário.

Tipos de dados fundamentais

Os tipos de dados fundamentais são: numérico, lógico, char, célula, struct, tabela e function_handle.

Tipos de dados numéricos:

Números de ponto flutuante (padrão)

MATLAB representa números de ponto flutuante no formato de precisão dupla ou de precisão simples. O padrão
é de precisão dupla, mas você pode tornar qualquer número de precisão simples com uma função de conversão simples:

a = 1,23;
b = único(a);

>> quem é
Nome Tamanho Classe de Bytes Atributos

a 1x1 8 duplos 4
b 1x1 individuais

Inteiros

MATLAB tem quatro classes inteiras com sinal e quatro sem sinal. Os tipos assinados permitem que você trabalhe com dados negativos
inteiros, bem como positivos, mas não podem representar uma gama tão ampla de números quanto os tipos sem sinal porque
um bit é usado para designar um sinal positivo ou negativo para o número. Os tipos não assinados oferecem uma visão mais ampla
intervalo de números, mas esses números só podem ser zero ou positivos.

MATLAB suporta armazenamento de 1, 2, 4 e 8 bytes para dados inteiros. Você pode economizar memória e tempo de execução para
seus programas se você usar o menor tipo inteiro que acomoda seus dados. Por exemplo, você não
precisa de um número inteiro de 32 bits para armazenar o valor 100.

uma = int32(100);
b = int8(100);

>> quem é

GoalKicker.com Notas MATLAB® para profissionais 17

Machine Translated by Google
Nome Tamanho Classe de Bytes Atributos

a 1x1 4int32 _
b 1x1 1 você8

Para armazenar dados como um número inteiro, você precisa converter de double para o tipo inteiro desejado. Se o número for
convertido para um número inteiro tem uma parte fracionária, o MATLAB arredonda para o número inteiro mais próximo. Se a parte fracionária for
exatamente 0,5, então dos dois inteiros igualmente próximos, o MATLAB escolhe aquele para o qual o valor absoluto
valor é maior em magnitude.

a = int16(456);

Caracteres

Matrizes de caracteres fornecem armazenamento para dados de texto no MATLAB. Seguindo a programação tradicional
terminologia, uma matriz (sequência) de caracteres é definida como uma string. Não existe um tipo de string explícito no varejo
lançamentos do MATLAB.

lógico: valores lógicos de 1 ou 0, representam verdadeiro e falso respectivamente. Use para condições relacionais e matriz
indexação. Por ser apenas TRUE ou FALSE, tem tamanho de 1 byte.

uma = lógico(1);

estrutura. Uma matriz de estrutura é um tipo de dados que agrupa variáveis de diferentes tipos de dados usando contêineres de dados
chamados campos. Cada campo pode conter qualquer tipo de dados. Acesse dados em uma estrutura usando a notação de ponto do formulário
structName.fieldName.

campo1 = 'primeiro';
campo2 = 'segundo';
valor1 = [1 2 3 4 5];
valor2 = 'algumtexto';
s = struct(campo1,valor1,campo2,valor2);

Para acessar valor1, cada uma das seguintes sintaxes é equivalente

s.primeiro ou s.(campo1) ou s.('primeiro')

Podemos acessar explicitamente um campo que sabemos que existirá com o primeiro método, ou passar uma string ou criar um
string para acessar o campo no segundo exemplo. O terceiro exemplo está demonstrando que o ponto
a notação de parênteses leva uma string, que é a mesma armazenada na variável field1.

variáveis de tabela podem ter tamanhos e tipos de dados diferentes, mas todas as variáveis devem ter o mesmo número de linhas.

Idade = [15 25 54]';

Altura = [176 190 165]';
Nome = {'Mike', 'Pete', 'Steeve'}';
T = tabela(Nome,Idade,Altura);

célula. É um tipo de dados MATLAB muito útil: array de células é um array, cada elemento dele pode ser de tipo de dados diferente
e tamanho. É um instrumento muito forte para manipular dados como desejar.

a = { [1 2 3], 56, 'arte'};

GoalKicker.com Notas MATLAB® para profissionais 18

Machine Translated by Google

ou

uma = célula(3);

alças de função armazena um ponteiro para uma função (por exemplo, para uma função anônima). Ele permite que você passe uma função
para outra função ou chame funções locais de fora da função principal.

Existem muitos instrumentos para trabalhar com cada tipo de dados e também funções integradas de conversão de tipo de dados
(str2duplo, tabela2célula).

Tipos de dados adicionais

Existem vários tipos de dados adicionais que são úteis em alguns casos específicos. Eles são:

Data e hora: matrizes para representar datas, hora e duração. datetime('agora') retorna 21 de julho de 2016
16:30:16.

Matrizes categóricas: é um tipo de dados para armazenar dados com valores de um conjunto de categorias discretas. Útil para armazenar
dados não numéricos (memória efetiva). Pode ser usado em uma tabela para selecionar grupos de linhas.

a = categórico({'a' 'b' 'c'});

Os contêineres de mapa são uma estrutura de dados que possui capacidade única de indexação não apenas por meio de quaisquer
valores numéricos escalares, mas também de vetores de caracteres. Os índices dos elementos de um mapa são chamados de chaves.
Essas chaves, juntamente com os valores de dados associados a elas, são armazenados no Mapa.

Série temporal são vetores de dados amostrados ao longo do tempo, em ordem, geralmente em intervalos regulares. É útil armazenar os
dados conectados aos intervalos de tempo e possui muitos métodos úteis para trabalhar.

Seção 1.9: Entrada de leitura e saída de escrita

Assim como todas as linguagens de programação, o MATLAB foi projetado para ler e escrever em uma grande variedade de formatos. A biblioteca
nativa suporta um grande número de formatos de texto, imagem, vídeo, áudio e dados com mais formatos incluídos em cada atualização de
versão - verifique aqui para ver a lista completa de formatos de arquivo suportados e qual função usar para importá-los.

Antes de tentar carregar seu arquivo, você deve se perguntar o que deseja que os dados se tornem e como espera que o computador os organize para
você. Digamos que você tenha um arquivo txt/csv no seguinte formato:

Frutas, Total de unidades, Unidades restantes após venda, Preço de venda por
unidade Maçãs, 200,67, $
0,14 Bananas, 300.172, $ 0,11
Abacaxi, 50,12, $ 1,74

Podemos ver que a primeira coluna está no formato de Strings, enquanto a segunda, a terceira são Numéricas, a última coluna está no formato de
Moeda. Digamos que queremos descobrir quanta receita obtivemos hoje usando MATLAB e primeiro queremos carregar este arquivo txt/csv. Depois
de verificar o link, podemos ver que os arquivos txt do tipo String e Numérico são manipulados pelo textscan. Então poderíamos tentar:

fileID = fopen('dir/teste.txt'); %Carregar arquivo do diretório C =

textscan(fileID,'%s %f %f %s','Delimiter',',','HeaderLines',1); %Analisar no txt/csv

onde %s sugere que o elemento é do tipo String, %f sugere que o elemento é do tipo Float e que o arquivo é delimitado por ",". A opção HeaderLines
pede ao MATLAB para pular as primeiras N linhas enquanto o 1 imediatamente após

GoalKicker.com Notas MATLAB® para profissionais 19

Machine Translated by Google

significa pular a primeira linha (a linha do cabeçalho).

Agora C são os dados que carregamos, que estão na forma de um Cell Array de 4 células, cada uma contendo a coluna de dados no arquivo txt/csv.

Então primeiro queremos calcular quantas frutas vendemos hoje subtraindo a terceira coluna da segunda coluna, isso pode ser feito por:

vendido = C{2} - C{3}; %C{2} fornece os elementos dentro da segunda célula (ou segunda coluna)

Agora queremos multiplicar este vetor pelo Preço por unidade, então primeiro precisamos converter aquela coluna de Strings em uma coluna de
Números, depois convertê-la em uma Matriz Numérica usando o cell2mat do MATLAB , a primeira coisa que precisamos fazer é remover- fora do sinal
"$", há muitas maneiras de fazer isso. A maneira mais direta é usar um regex simples:

D = cellfun(@(x)(str2num(regexprep(x, '\$',''))), C{4}, 'UniformOutput', false);%cellfun nos permite evitar o loop através de cada
elemento no célula.

Ou você pode usar um loop:

para t=1:tamanho(C{4},1)
D{t} = str2num(regexprep(C{4}{t}, '\$','')); fim

E = cell2mat(D)% converte a matriz de células em uma matriz

A função str2num transforma a string que tinha os sinais "$" removidos em tipos numéricos e cell2mat transforma a célula de elementos numéricos
em uma matriz de números

Agora podemos multiplicar as unidades vendidas pelo custo por unidade:

receita = vendida.* E; % produto por elemento é denotado por .* no MATLAB

receita total = soma(receita);

GoalKicker.com Notas MATLAB® para profissionais 20

Machine Translated by Google

Capítulo 2: Inicializando matrizes ou arrays

Parâmetro Detalhes
é n (para uma matriz nxn)
é n, m (para uma matriz nxm)
é m,n,...,k (para uma matriz m-por-n-por-...-por-k)
tipo de dados 'duplo' (padrão), 'single', 'int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64' ou 'uint64' arraytype 'distribuído' arraytype '

codistribuído' arraytype 'gpuArray'

O MATLAB possui três funções importantes para criar matrizes e definir seus elementos como zeros, uns ou a matriz identidade. (A matriz identidade tem

uns na diagonal principal e zeros em outros lugares.)

Seção 2.1: Criando uma matriz de 0s

z1 = zeros(5); % Crie uma matriz 5 por 5 de zeros z2 =
zeros(2,3); % Crie uma matriz 2 por 3

Seção 2.2: Criando uma matriz de 1s

o1 = uns(5); % Crie uma matriz 5 por 5 de uns o2 =
uns(1,3); % Crie uma matriz/vetor 1 por 3 de tamanho 3

Seção 2.3: Criando uma matriz de identidade

i1 = olho(3); % Crie uma matriz identidade 3 por 3 i2 =
eye(5,6); % Crie uma matriz identidade 5 por 6

GoalKicker.com Notas MATLAB® para profissionais 21

Machine Translated by Google

Capítulo 3: Condições
Parâmetro Expressão de
descrição uma expressão que tem significado lógico

Seção 3.1: Condição IF

As condições são uma parte fundamental de quase qualquer parte do código. Eles são usados para executar algumas partes do
código apenas em algumas situações, mas não em outras. Vejamos a sintaxe básica:

uma =
5; se a > 10 % esta condição não for atendida, então nada acontecerá disp('OK')

fim

se a < 10 % esta condição é atendida, então as instruções entre if...end são executadas
disp('Não OK')
fim

Saída:

Não está tudo bem

Neste exemplo vemos que o if consiste em 2 partes: a condição e o código a ser executado se a condição for verdadeira. O código
é tudo escrito depois da condição e antes do final desse if. A primeira condição não foi cumprida e, portanto, o código dentro dela não foi
executado.

Aqui está outro exemplo:

uma =
5; se a ~= a+1 % "~=" significa "diferente de" disp('É
verdade!') % usamos dois apóstrofos para dizer ao MATLAB que o ' faz parte da string
fim

A condição acima sempre será verdadeira e exibirá a saída É verdade!.

Também podemos escrever:

uma =
5; se a == a+1 % "==" significa "é igual a", NÃO é o operador de atribuição ("=")
disp('Igual')
fim

Desta vez a condição é sempre falsa, portanto nunca obteremos a saída Igual.

Porém, não há muita utilidade para condições que são sempre verdadeiras ou falsas, porque se elas forem sempre falsas, podemos
simplesmente excluir esta parte do código, e se elas forem sempre verdadeiras, a condição não será necessária.

Seção 3.2: Condição IF-ELSE

Em alguns casos queremos executar um código alternativo se a condição for falsa, para isso usamos a parte opcional else :

uma =
20; se a < 10
disp(' menor que 10')

GoalKicker.com Notas MATLAB® para profissionais 22

Machine Translated by Google
senão
disp(' maior que 10')
fim

Aqui vemos que porque a não é menor que 10 a segunda parte do código, depois que o else é executado e obtemos a saída maior que 10. Agora
vamos fazer outra tentativa:

uma = 10;
if a > 10
disp(' maior que 10') else disp('
menor
que 10')
fim

Neste exemplo mostra que não verificamos se a é realmente menor que 10, e recebemos uma mensagem errada porque a condição apenas verifica
a expressão como ela é, e QUALQUER caso que não seja igual a verdadeiro (a = 10) fará com que o segunda parte a ser executada.

Este tipo de erro é uma armadilha muito comum tanto para programadores iniciantes quanto para programadores experientes, especialmente
quando as condições se tornam complexas, e deve ser sempre mantido em mente

Seção 3.3: Condição IF-ELSEIF

Usando else podemos realizar alguma tarefa quando a condição não for satisfeita. Mas e se quisermos verificar uma segunda condição caso a
primeira seja falsa. Podemos fazer desta forma:

uma =
9; if mod(a,2)==0 % MOD - operação de módulo, retorne o restante após a divisão de 'a' por 2
disp('a é par') else if

mod(a,3)==0 disp('3 é um
divisor de a')
fim
fim

SAÍDA:
3 é um divisor de a

Isso também é chamado de "condição aninhada", mas aqui temos um caso especial que pode melhorar a legibilidade do código e reduzir a chance
de erro - podemos escrever:

uma =
9; if mod(a,2)==0
disp('a é par') elseif
mod(a,3)==0 disp('3 é um
divisor de a')
fim

SAÍDA: 3
é um divisor de a

usando elseif podemos verificar outra expressão dentro do mesmo bloco de condição, e isso não está limitado a uma tentativa:

uma = 25;

GoalKicker.com Notas MATLAB® para profissionais 23

Machine Translated by Google

if mod(a,2)==0 disp('a
é par') elseif mod(a,3)==0
disp('3 é um divisor de a')
elseif mod(a,5)==0 disp ('5 é um divisor de
a')

fim

SAÍDA: 5
é um divisor de a

Cuidado extra deve ser tomado ao escolher usar elseif em sequência, pois apenas um deles será executado de todos os blocos if to end .
Então, em nosso exemplo, se quisermos exibir todos os divisores de a (daqueles que verificamos explicitamente), o exemplo acima não será
bom:

uma = 15;
if mod(a,2)==0 disp('a
é par') elseif mod(a,3)==0
disp('3 é um divisor de a')
elseif mod(a,5)==0 disp ('5 é um divisor de
a')

fim

SAÍDA: 3
é um divisor de a

não só 3, mas também 5 é divisor de 15, mas a parte que verifica a divisão por 5 não é alcançada se alguma das expressões acima
for verdadeira.

Finalmente, podemos adicionar um else (e apenas um) depois de todas as condições elseif para executar um código quando nenhuma
das condições acima for atendida:

uma = 11;
if mod(a,2)==0 disp('a
é par') elseif mod(a,3)==0
disp('3 é um divisor de a')
elseif mod(a,5)==0 disp ('5 é um divisor de
a') else disp('2, 3 e 5 não são
divisores de a')

fim

SAÍDA: 2,
3 e 5 não são divisores de a

Seção 3.4: Condições aninhadas

Quando usamos uma condição dentro de outra condição dizemos que as condições estão “aninhadas”. Um caso especial de condições
aninhadas é fornecido pela opção elseif , mas existem inúmeras outras maneiras de usar condições aninhadas. Vamos examinar o
seguinte código:

uma = 2;
se mod(a,2)==0 % MOD - operação de módulo, retorna o resto após a divisão de 'a' por 2

GoalKicker.com Notas MATLAB® para profissionais 24

Machine Translated by Google

disp('a é par') if
mod(a,3)==0 disp('3
é um divisor de a') if mod(a,5)==0 disp('5
é um divisor de a')

fim
fim
senão
disp('a é ímpar')
fim

Para a=2, a saída será par , o que é correto. Para a=3, a saída será a é ímpar, o que também é correto, mas falha na verificação se 3 é um divisor
de a. Isso ocorre porque as condições estão aninhadas, portanto, somente se a primeira for verdadeira, passaremos para a interna e, se a for
ímpar, nenhuma das condições internas será verificada. Isso é um pouco oposto ao uso de elseif , onde somente se a primeira condição

for falsa é que verificamos a próxima. Que tal verificar a divisão por 5? apenas um número que tenha 6 como divisor (2 e 3) será verificado para
a divisão por 5, e podemos testar e ver que para a=30 a saída é:

a é par 3 é
divisor de a 5 é divisor de a

Devemos também observar duas coisas:

1. A posição da extremidade no lugar certo para cada if é crucial para que o conjunto de condições funcione conforme o esperado,
portanto, o recuo é mais do que uma boa recomendação aqui.
2. A posição da declaração else também é crucial, porque precisamos saber em que if (e poderia haver
vários deles) queremos fazer algo caso a expressão seja falsa.

Vejamos outro exemplo:

para a = 5:10 % o loop FOR executa todo o código dentro dele para cada a de 5 a 10 ch = num2str(a); if mod(a,2)==0 if
mod(a,3)==0 disp(['3 é % NUM2STR converte o inteiro a em um caractere
um divisor de ' ch])
elseif mod(a,4)==0
disp(['4 é um divisor de ' ch]) else disp([ch '

é par'])
end
elseif mod(a,3)==0 disp(['3
é um divisor de ' ch])

senão
disp([ch ' é estranho'])
fim
fim

E a saída será:

5 é ímpar 3
é divisor de 6 7 é ímpar 4 é
divisor de 8
3 é divisor de 9 10 é par

GoalKicker.com Notas MATLAB® para profissionais 25

Machine Translated by Google

vemos que obtivemos apenas 6 linhas para 6 números, porque as condições estão aninhadas de uma forma que garante apenas uma impressão
por número e também (embora não possa ser vista diretamente na saída) nenhuma verificação extra é realizada, então se um número não é par,
não faz sentido verificar se 4 é um de seus divisores.

GoalKicker.com Notas MATLAB® para profissionais 26

Machine Translated by Google

Capítulo 4: Funções
Seção 4.1: nargin, nargout
No corpo de uma função nargin e nargout indicam respectivamente o número real de entradas e saídas fornecidas
na chamada.

Podemos, por exemplo, controlar a execução de uma função com base no número de entradas fornecidas.

meuVetor.m:

função [res] = meuVetor(a, b, c)

% Emula aproximadamente o operador dois pontos

mudar nargin
caso 1
nada = [0:a];
caso 2
nada = [a:b];
caso 3
res = [a:b:c];
de outra forma
error('Número errado de parâmetros');
fim
fim

terminal:

>> meuVetor(10)

anos =

0 1 2 3 4 5 6 7 8 9 10

>> meuVetor(10, 20)

anos =

10 11 12 13 14 15 16 17 18 19 20

>> meuVetor(10, 2, 20)

anos =

10 12 14 16 18 20

De forma semelhante podemos controlar a execução de uma função com base no número de parâmetros de saída.

minhaIntegerDivision:

função [qt, rm] = minhaDivisãoInteira(a, b)

qt = piso(a / b);

se nargout == 2
rm = rem(a, b);
fim
fim

GoalKicker.com Notas MATLAB® para profissionais 27

Machine Translated by Google

terminal:

>> q = minhaDivisãoInteira(10, 7)

q=1

>> [q, r] = minhaDivisãoInteira(10, 7)

q=1
r=3

GoalKicker.com Notas MATLAB® para profissionais 28

Machine Translated by Google

Capítulo 5: Definir operações

Parâmetro Conjuntos

A, B de detalhes , possivelmente matrizes ou

x vetores, possível elemento de um conjunto

Seção 5.1: Operações elementares de conjuntos

É possível realizar operações elementares com conjuntos com MATLAB. Vamos supor que fornecemos dois vetores ou matrizes

A = randi([0 10],1,5);
B = randi([-1 9], 1,5);

e queremos encontrar todos os elementos que estão em A e em B. Para isso podemos usar

C = intersecção(A,B);

C incluirá todos os números que fazem parte de A e parte de B. Se também quisermos encontrar a posição desses elementos, chamamos

[C,pos] = interseção(A,B);

pos é a posição desses elementos tal que C == A(pos).

Outra operação básica é a união de dois conjuntos

D = união(A,B);

Herby contém D todos os elementos de A e B.

Observe que A e B são aqui tratados como conjuntos, o que significa que não importa quantas vezes um elemento faz parte de A ou B. Para
esclarecer isso pode-se verificar D == union(D,C).

Se quisermos obter os dados que estão em 'A' mas não em 'B' podemos usar a seguinte função

E = diferença definida(A,B);

Queremos observar novamente que estes são conjuntos tais que a seguinte instrução contém D == union(E,B).

Suponha que queiramos verificar se

x = randi([-10 10],1,1);

é um elemento de A ou B, podemos executar o comando

a = émembro(A,x); b =
émembro(B,x);

Se a==1 então x é elemento de A e x não é elemento é a==0. O mesmo vale para B. Se a==1 && b==1 x também é um elemento de
C. Se a == 1 || b == 1 x é elemento de D e se a == 1 || b == 0 também é elemento de E.

GoalKicker.com Notas MATLAB® para profissionais 29

Machine Translated by Google

Capítulo 6: Documentando funções

Seção 6.1: Obtendo uma assinatura de função
Muitas vezes é útil fazer com que o MATLAB imprima a primeira linha de uma função, pois ela geralmente contém a assinatura da função,
incluindo entradas e saídas:

tipo de banco de dados <nomedafunção> 1

Exemplo:

>> tipo de banco de dados ajustado 1

1 função [fitobj,goodness,output,warnstr,errstr,convmsg] = fit(xdatain,ydatain,fittypeobj,varargin)

Seção 6.2: Documentação de Função Simples

saída da função = mymult(a, b)

% MYMULT Multiplica dois números. % saída
= MYMULT(a, b) multiplica a e b. % % Veja também fft, foo, sin. % %

Para obter mais informações, consulte <a

href="matlab:web('https://google.com')">Google</a>.
saída = a * b;
fim

help mymult fornece:

mymult Multiplica dois números.

saída = mymult(a, b) multiplica a e b.

Veja também fft, foo, sin.

Para obter mais informações, consulte Google.

fft e sin vinculam automaticamente aos respectivos textos de ajuda, e Google é um link para google.com. foo não vinculará a nenhuma
documentação neste caso, desde que não haja uma função/classe documentada com o nome foo no caminho de pesquisa.

Seção 6.3: Documentação de Função Local

Neste exemplo, a documentação para a função local baz (definida em foo.m) pode ser acessada pelo link resultante em help foo ou diretamente através de
help foo>baz.

function bar = foo %Esta é a

documentação do FOO.
% Veja também foo>baz

% Isso não será impresso porque há uma linha sem % nela. fim

GoalKicker.com Notas MATLAB® para profissionais 30

Machine Translated by Google
função baz
% Esta é a documentação do BAZ. fim

Seção 6.4: Documentando uma função com um script de exemplo

Para documentar uma função, geralmente é útil ter um script de exemplo que use sua função. A função de publicação no MATLAB pode então ser usada para

gerar um arquivo de ajuda com imagens incorporadas, código, links, etc. A sintaxe para documentar seu código pode ser encontrada aqui.

A Função Esta função usa uma FFT "corrigida" no MATLAB.

função out_sig = myfft(in_sig)

out_sig = fftshift(fft(ifftshift(in_sig)));

fim

O script de exemplo Este é um script separado que explica as entradas, saídas e dá um exemplo explicando por que a correção é necessária.
Agradecimentos a Wu, Kan, o autor original desta função.

%% myfft %
Esta função usa o fft "adequado" no MATLAB. Observe que fft precisa% ser multiplicado por dt para ter significado físico.

% Para uma descrição completa de por que a FFT deve ser considerada assim, consulte % em:
Why_use_fftshift(fft(fftshift(x)))__in_Matlab.pdf incluído na % pasta de ajuda deste código. Informações adicionais
podem ser encontradas:% <https://www.mathworks.com/matlabcentral/fileexchange/25473-why-use-

fftshift-fft-fftshift-x----in-m atlab-instead-of-fft- x--> % %% Entradas % *in_sig* - sinal 1D % %% Saídas % *out_sig* - FFT corrigida de *in_sig* % %% Exemplos %
Gera um sinal com uma solução

analítica. A
solução analítica é% então

comparada com
o fft e depois com o myfft. Este exemplo é uma versão%

modificada
fornecida por Wu, Kan fornecida no link acima. %%

% Definir parâmetros fs =
500; dt = 1/fs; % frequência de amostragem
% passo de
T=1; tempo % janela de tempo total
t = -T/2:dt:T/2-dt; %tempo grades df = 1/T; %freq
passo %freq janela
Fmáx = 1/2/dt; f=-
Fmax:df:Fmax-df; Grades %freq, não usadas em nossos exemplos, poderiam ser usadas por plot(f, X) %%

% Gerar curva gaussiana

Bx = 10; A = sqrt(log(2))/(2*pi*Bx); x = exp(-t.^2/2/A^2); % %Características da curva gaussiana

% %Criar Curva Gaussiana

% Gerar solução analítica Xan =

A*sqrt(2*pi)*exp(-2*pi^2*f.^2*A^2); %X(f), parte real da transformada analítica de Fourier de x(t)

GoalKicker.com Notas MATLAB® para profissionais 31

Machine Translated by Google
%%

% Pegue a FFT e a FFT corrigida e compare

Xfft = dt *fftshift(fft(x)); %FFT
Xfinal = dt * myfft(x); espere plot % FFT corrigida
(f,Xan);
plot(f,real(Xfft));
plot(f,real(Xfinal),'ro');
title('Comparação de FFT corrigida e não
corrigida'); legend(' Solução Analítica',' FFT não corrigida','FFT corrigida');
xlabel('Frequência'); ylabel('Amplitude');

DT = máx(f) - mín(f); xlim([-DT/

4,DT/4]);

A opção Saída A publicação pode ser encontrada na guia "Publicar", destacada na documentação da função
imageSimple abaixo.

O MATLAB irá executar o script e salvar as imagens que serão exibidas, bem como o texto gerado pela linha de comando.
A saída pode ser salva em vários tipos diferentes de formatos, incluindo HTML, Latex e PDF.

A saída do script de exemplo fornecido acima pode ser vista na imagem abaixo.

GoalKicker.com Notas MATLAB® para profissionais 32

Machine Translated by Google

GoalKicker.com Notas MATLAB® para profissionais 33

Machine Translated by Google

Capítulo 7: Usando funções com saída

lógica
Seção 7.1: All e Any com matrizes vazias
Cuidado especial precisa ser tomado quando existe a possibilidade de um array se tornar um array vazio quando se trata de operadores lógicos.
Freqüentemente, espera-se que se all(A) for verdadeiro, então any(A) deve ser verdadeiro e se any(A) for falso, all(A) também deve ser falso.
Esse não é o caso do MATLAB com arrays vazios.

>> qualquer([])
anos =

0 >> todos([])
anos =
1

Portanto, se por exemplo você estiver comparando todos os elementos de um array com um determinado limite, você precisa estar ciente do caso
em que o array está vazio:

>> UM=1:10;
>> todos(A>5)
anos =
0
>> A=1:0;
>> todos(A>5)
anos =
1

Use a função integrada isempty para verificar arrays vazios:

uma = [];
está vazio(a)
anos =
1

GoalKicker.com Notas MATLAB® para profissionais 34

Machine Translated by Google

Capítulo 8: Loops For

Seção 8.1: Iterar sobre colunas da matriz

Se o lado direito da atribuição for uma matriz, então em cada iteração a variável recebe colunas subsequentes desta matriz.

alguma_matriz = [1, 2, 3; 4, 5, 6]; % Matriz 2 por 3 para some_column =

some_matrix display(some_column)

fim

(A versão do vetor linha é um caso normal disso, porque no MATLAB um vetor linha é apenas uma matriz cujas colunas têm tamanho
1.)

A saída seria exibida

1
4
2
5
3
6

ou seja, cada coluna da matriz iterada exibida, cada coluna impressa em cada chamada de exibição.

Seção 8.2: Aviso: Loops aninhados de contador iguais estranhos

Isso não é algo que você verá em outros ambientes de programação. Me deparei com isso há alguns anos e não conseguia
entender por que estava acontecendo, mas depois de trabalhar com o MATLAB por algum tempo, consegui descobrir.
Veja o trecho de código abaixo:

para x = 1:10
para x = 1:10
fprintf('%d,', x);
fim
fprintf('\n');
fim

você não esperaria que isso funcionasse corretamente, mas funciona, produzindo a seguinte saída:

1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10, 1,2,3,4,5,
6,7,8,9,10, 1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10, 1,2,3,4,5,
6,7,8,9,10, 1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,

A razão é que, como acontece com tudo no MATLAB, o contador x também é uma matriz – um vetor, para ser mais preciso.
Como tal, x é apenas uma referência a um 'array' (uma estrutura de memória coerente e consecutiva) que é apropriadamente

GoalKicker.com Notas MATLAB® para profissionais 35

Machine Translated by Google

referenciado com cada loop consequente (aninhado ou não). O fato de o loop aninhado usar o mesmo identificador
não faz diferença em como os valores dessa matriz são referenciados. O único problema é que dentro do loop aninhado o
x externo está oculto pelo x aninhado (local) e, portanto, não pode ser referenciado. No entanto, a funcionalidade da
estrutura de loop aninhado permanece intacta.

Seção 8.3: Iterar sobre elementos do vetor

O lado direito da atribuição em um loop for pode ser qualquer vetor linha. O lado esquerdo da atribuição pode ser
qualquer nome de variável válido. O loop for atribui um elemento diferente deste vetor à variável a cada execução.

outro_vetor_linha = [4, 3, 5, 1, 2]; para

any_name = other_row_vector
display(any_name)
fim

A saída seria exibida

(A versão 1:n é um caso normal disso, porque no MATLAB 1:n é apenas uma sintaxe para construir um vetor linha de [1,
2, ..., n].)

Portanto, os dois blocos de código a seguir são idênticos:

UMA = [1 2 3 4 5];
para x = A
disp(x);
fim

para x = 1:5
disp(x);
fim

E os seguintes também são idênticos:

UMA = [1 3 5 7 9];
para x = A
disp(x);
fim

para x = 1:2:9
disp(x);
fim

Qualquer vetor de linha serve. Eles não precisam ser números.

meus_caracteres = 'abcde';

GoalKicker.com Notas MATLAB® para profissionais 36

Machine Translated by Google

para meu_char = meus_caracteres

disp(meu_char)
fim

produzirá

ab
c
d
e

Seção 8.4: Loops aninhados

Os loops podem ser aninhados para pré-formar uma tarefa iterada dentro de outra tarefa iterada. Considere os seguintes loops:

ch = 'abc'; m = 3;
para c =
ch
para k = 1: m
disp([c num2str(k)]) % NUM2STR converte o número armazenado em k em um caractere,
% para que possa ser concatenado com a letra em c
fim
fim

usamos 2 iteradores para exibir todas as combinações de elementos de abc e 1:m, o que produz:

a1
a2
a3
b1
b2
b3
c1
c2
c3

Também podemos usar loops aninhados para combinar tarefas a serem realizadas a cada vez e tarefas a serem realizadas uma vez
em várias iterações:

N = 10; n=
3; a1 =
0; % o primeiro elemento da série de Fibonacci a2 = 1; % o segundo
elemento da série Fibonacci para j = 1:N

para k = 1:n
um = a1 + a2; % calcula o próximo elemento da série de Fibonacci a1 = a2; % salva o elemento
anterior para a próxima iteração a2 = an; % salva o novo elemento para a próxima iteração

fim
disp(an) % exibe cada enésimo elemento
fim

Aqui queremos calcular todas as séries de Fibonacci, mas para exibir apenas o enésimo elemento de cada vez, obtemos

GoalKicker.com Notas MATLAB® para profissionais 37

Machine Translated by Google

3
13
55
233
987
4181
17711
75025
317811 1346269

Outra coisa que podemos fazer é usar o primeiro iterador (externo) dentro do loop interno. Aqui está outro exemplo:

N = 12;
lacuna = [1 2 3 4 6]; for j =
gap for k = 1:j:N
fprintf('%d ',k) %
FPRINTF imprime o número k seguindo para a próxima linha
fim
fprintf('\n') % vai para a próxima linha
fim

Desta vez usamos o loop aninhado para formatar a saída e freamos a linha somente quando uma nova lacuna (j) entre os
elementos for introduzida. Fazemos um loop pela largura da lacuna no loop externo e a usamos dentro do loop interno para
iterar pelo vetor:

1 2 3 4 5 6 7 8 9 10 11 12 1 3 5 7 9 11
1 4 7 10 1 5 9 1 7

Seção 8.5: Loop 1 a n

O caso mais simples é apenas executar uma tarefa por um número fixo conhecido de vezes. Digamos que queremos exibir os
números entre 1 e n, podemos escrever:

n = 5;
para k = 1:n
exibição (k)
fim

O loop executará as instruções internas, tudo entre o for e o final, por n vezes (5 neste exemplo):

Aqui está outro exemplo:

n = 5;
para k = 1:n

GoalKicker.com Notas MATLAB® para profissionais 38

Machine Translated by Google

disp(n-k+1:-1:1) % DISP usa uma forma mais "limpa" de imprimir na tela

fim

desta vez usamos n e k no loop, para criar uma exibição "aninhada":

5 4 3 2 1

4 3 2 1

3 2 1

2 1

Seção 8.6: Loop sobre índices

meu_vetor = [0, 2, 1, 3, 9];
para i = 1:numel(meu_vetor)
meu_vetor(i) = meu_vetor(i) + 1;
fim

A maioria das coisas simples feitas com loops for podem ser feitas de maneira mais rápida e fácil por meio de operações vetorizadas. Por exemplo, o
o loop acima pode ser substituído por my_vector = my_vector + 1.

GoalKicker.com Notas MATLAB® para profissionais 39

Machine Translated by Google

Capítulo 9: Programação Orientada a Objetos

Seção 9.1: Classes Value vs Handle

As classes no MATLAB são divididas em duas categorias principais: classes de valor e classes de manipulação. A principal diferença
é que ao copiar uma instância de uma classe de valor, os dados subjacentes são copiados para a nova instância, enquanto para
classes de tratamento a nova instância aponta para os dados originais e a alteração dos valores na nova instância os altera no
original. Uma classe pode ser definida como um identificador herdando da classe identificador .

valor classdefClasse
dados de
propriedades
fim
fim

classdef handleClass < handle

dados de
propriedades
fim
fim

então

>> v1 = classevalor; >>

v1.dados = 5; >> v2
= v1; >>
v2.dados = 7; >>
v1.dados
anos =
5

>> h1 = handleClass; >>

h1.dados = 5; >> h2
= h1; >>
h2.dados = 7; >>
h1.dados
anos =
7

Seção 9.2: Construtores

Um construtor é um método especial em uma classe que é chamado quando uma instância de um objeto é criada. É uma função
regular do MATLAB que aceita parâmetros de entrada, mas também deve seguir certas regras.

Os construtores não são necessários porque o MATLAB cria um padrão. Na prática, entretanto, este é um local para definir o estado de
um objeto. Por exemplo, as propriedades podem ser restritas especificando atributos. Então, um construtor pode inicializar tais
propriedades por padrão ou valores definidos pelo usuário que de fato podem ser enviados por parâmetros de entrada de um construtor.

Chamando um construtor de uma classe simples

Esta é uma classe simples Person.

classedef Pessoa
propriedades

GoalKicker.com Notas MATLAB® para profissionais 40

Machine Translated by Google

nome
sobrenome
endereço
fim

métodos
função obj = Pessoa(nome,sobrenome,endereço)
obj.nome = nome;
obj.sobrenome = sobrenome;
obj.endereço = endereço;
fim
fim
fim

O nome de um construtor é igual ao nome de uma classe. Conseqüentemente, os construtores são chamados pelo nome de sua classe. Uma
classe Person pode ser criada da seguinte forma:

>> p = Pessoa('John','Smith','Londres')
p=
Pessoa com propriedades:

nome: 'John'
sobrenome: 'Smith'
endereço: 'Londres'

Chamando um construtor de uma classe filha

As classes podem ser herdadas de classes pai se compartilharem propriedades ou métodos comuns. Quando uma classe é herdada de
outra, é provável que um construtor de uma classe pai precise ser chamado.

Uma classe Member herda de uma classe Person porque Member usa as mesmas propriedades da classe Person, mas também adiciona
pagamento à sua definição.

classdef Membro <Person propriedades

pagamento

fim

métodos
função obj = Membro(nome,sobrenome,endereço,pagamento) obj =
obj@Pessoa(nome,sobrenome,endereço); obj.pagamento =
pagamento;
fim
fim
fim

Da mesma forma que a classe Person, Member é criado chamando seu construtor:

>> m = Membro('Adam','Woodcock','Manchester',20)
m=
Membro com propriedades:

pagamento: 20
nome: 'Adam'
sobrenome: 'Woodcock'
endereço: 'Manchester'

Um construtor de Person requer três parâmetros de entrada. O membro deve respeitar este fato e portanto chamar um construtor
da classe Person com três parâmetros. É cumprido pela linha:

GoalKicker.com Notas MATLAB® para profissionais 41

Machine Translated by Google

obj = obj@Pessoa(nome,sobrenome,endereço);

O exemplo acima mostra o caso em que uma classe filha precisa de informações para sua classe pai. É por isso que um construtor de
Member requer quatro parâmetros: três para sua classe pai e um para si mesmo.

Seção 9.3: Definindo uma classe

Uma classe pode ser definida usando classdef em um arquivo .m com o mesmo nome da classe. O arquivo pode conter o bloco
classdef...end e funções locais para uso em métodos de classe.

A definição mais geral da classe MATLAB tem a seguinte estrutura:

classdef (ClassAttribute = expressão, ...) ClassName < ParentClass1 & ParentClass2 & ...

propriedades (PropertyAttributes)
Fim do nome da
propriedade

métodos (MethodAttributes) função

obj = methodName(obj,arg2,...)
...
fim
fim

eventos (EventAttributes)
Fim do
EventName

enumeração
EnumName
fim

fim

Documentação MATLAB: atributos de classe, Atributos de propriedade, Atributos do método, Atributos do evento, Restrições de
classe de enumeração .

Classe de exemplo:

Uma classe chamada Car pode ser definida no arquivo Car.m como

classdef Car < handle % manipula a classe para que as propriedades persistam
propriedades
make
model
quilometragem = 0;
fim

função
de métodos obj = Carro (marca, modelo)
obj.make = marca;
obj.model = modelo;

função final dirigir (obj, milhas conduzidas)

obj.mileage = obj.mileage + milhas conduzidas;
fim
fim
fim

GoalKicker.com Notas MATLAB® para profissionais 42

Machine Translated by Google

Observe que o construtor é um método com o mesmo nome da classe. <Um construtor é um método especial de uma classe ou estrutura na
programação orientada a objetos que inicializa um objeto desse tipo. Um construtor é um método de instância que geralmente tem o mesmo nome
da classe e pode ser usado para definir os valores dos membros de um objeto, seja para valores padrão ou definidos pelo usuário.>

Uma instância desta classe pode ser criada chamando o construtor;

>> meuCarro = Carro('Ford', 'Mustang'); //criando uma instância da classe carro

Chamar o método drive aumentará a quilometragem

>> meuCarro.mileage

anos =
0

>> meuCarro.drive(450);

>> meuCarro.mileage

anos =
450

Seção 9.4: Herdando de classes e classes abstratas

Isenção de responsabilidade: os exemplos apresentados aqui têm apenas o propósito de mostrar o uso de classes abstratas e herança e
podem não ser necessariamente de uso prático. Além disso, não existe polimórfico no MATLAB e, portanto, o uso de classes abstratas é
limitado. Este exemplo é para mostrar quem deve criar uma classe, herdar de outra classe e aplicar uma classe abstrata para definir uma
interface comum.

O uso de classes abstratas é bastante limitado no MATLAB, mas ainda pode ser útil em algumas ocasiões.

Digamos que queremos um registrador de mensagens. Poderíamos criar uma classe semelhante à abaixo:

classdef Propriedades do
ScreenLogger (Acesso = protegido)
scrh;
fim

métodos
função obj = ScreenLogger (screenhandler) obj.scrh =
screenhandler;
fim

function LogMessage(obj, varargin) if

~isempty(varargin) varargin{1}
= num2str(varargin{1}); fprintf(obj.scrh, '%s\n',
sprintf(varargin{:}));
fim
fim
fim
fim

Propriedades e métodos

Resumindo, as propriedades mantêm o estado de um objeto, enquanto os métodos são como uma interface e definem ações nos objetos.

GoalKicker.com Notas MATLAB® para profissionais 43

Machine Translated by Google

A propriedade scrh está protegida. É por isso que deve ser inicializado em um construtor. Existem outros métodos (getters) para acessar esta
propriedade, mas isso está fora do alcance deste exemplo. Propriedades e métodos podem ser acessados por meio de uma variável que
contém uma referência a um objeto usando a notação de ponto seguida pelo nome de um método ou propriedade:

meulogger = ScreenLogger(1); % OK
mylogger.LogMessage('Minha %s %d mensagem', 'muito', 1); % OK meulogger.scrh
= 2; % ERRO!!! Acesso negado

Propriedades e métodos podem ser públicos, privados ou protegidos. Neste caso, protegido significa que poderei acessar o scrh de uma
classe herdada, mas não de fora. Por padrão, todas as propriedades e métodos são públicos.
Portanto LogMessage() pode ser usado livremente fora da definição de classe. Além disso, LogMessage define uma interface, o que
significa que é isso que devemos chamar quando queremos que um objeto registre nossas mensagens personalizadas.

Aplicativo

Digamos que eu tenha um script onde utilizo meu logger:

clc;
% ... um
registrador de código =
ScreenLogger(1);
% ... um código logger.LogMessage('alguma
coisa'); % ... um
código logger.LogMessage('alguma coisa');
% ... um código
logger.LogMessage('alguma coisa'); % ... um
código
logger.LogMessage('alguma coisa');

Se eu tiver vários locais onde uso o mesmo logger e depois quiser alterá-lo para algo mais sofisticado, como escrever uma mensagem em um
arquivo, teria que criar outro objeto:

propriedades classdef do
DeepLogger (SetAccess = protegido)
Nome do arquivo

métodos finais
função obj = DeepLogger (nome do arquivo)
obj.NomeArquivo = nome do arquivo;
fim

function LogMessage(obj, varargin) if

~isempty(varargin) varargin{1}
= num2str(varargin{1}); fid = fopen(obj.nome
completo, 'a+t'); fprintf(fid, '%s\n', sprintf(varargin{:}));
fclose(fid);

fim
fim
fim
fim

e apenas mude uma linha de um código para isto:

clc;
% ... um
registrador de código = DeepLogger('mymessages.log');

GoalKicker.com Notas MATLAB® para profissionais 44

Machine Translated by Google

O método acima irá simplesmente abrir um arquivo, anexar uma mensagem no final do arquivo e fechá-lo. No momento, para ser consistente com
minha interface, preciso lembrar que o nome de um método é LogMessage() mas poderia ser qualquer outra coisa. O MATLAB pode forçar
o desenvolvedor a manter o mesmo nome usando classes abstratas. Digamos que definimos uma interface comum para qualquer logger:

classdef MessageLogger
métodos (Resumo = verdadeiro)
LogMessage(obj, varargin);
fim
fim

Agora, se tanto o ScreenLogger quanto o DeepLogger herdarem desta classe, o MATLAB irá gerar um erro se LogMessage() não estiver definido.
Classes abstratas ajudam a construir classes semelhantes que podem usar a mesma interface.

Para fins deste exemplo, farei alterações ligeiramente diferentes. Vou assumir que o DeepLogger registrará mensagens em uma tela e em um
arquivo ao mesmo tempo. Como o ScreenLogger já registra mensagens na tela, herdarei o DeepLogger do ScreenLoggger para evitar repetições.
O ScreenLogger não muda nada além da primeira linha:

classdef ScreenLogger < MessageLogger // o

restante do código anterior

No entanto, o DeepLogger precisa de mais alterações no método LogMessage :

classdef DeepLogger <propriedades MessageLogger e ScreenLogger

(SetAccess = protegido)
Nome do arquivo

Caminho

fim
métodos
função obj = DeepLogger(screenhandler, nome do arquivo)
[caminho,arquivo,ext] = partes do arquivo(nome do
arquivo); obj.FileName = [extensão
do arquivo]; pbj.Path =
caminhon; obj = obj@ScreenLogger(screenhandler);

função final LogMessage(obj, varargin) if

~isempty(varargin)
varargin{1} = num2str(varargin{1});
LogMessage@ScreenLogger(obj, varargin{:}); fid =
fopen(obj.nome completo, 'a+t'); fprintf(fid,
'%s\n', sprintf(varargin{:})); fclose(fid);

fim
fim
fim
fim

Primeiramente, simplesmente inicializo as propriedades no construtor. Em segundo lugar, como esta classe herda do ScreenLogger , também
preciso inicializar esse objeto pai. Esta linha é ainda mais importante porque o construtor ScreenLogger requer um parâmetro para inicializar
seu próprio objeto. Está linha:

obj = obj@ScreenLogger(screenhandler);

simplesmente diz "chame o construtor do ScreenLogger e inicialize-o com um manipulador de tela". É importante notar aqui que defini scrh como
protegido. Portanto, eu poderia igualmente acessar essa propriedade no DeepLogger. Se a propriedade foi definida como privada. A única
maneira de inicializá-lo seria usando o construtor.

GoalKicker.com Notas MATLAB® para profissionais 45

Machine Translated by Google

Outra mudança está nos métodos de seção. Novamente, para evitar repetições, chamo LogMessage() de uma classe pai para registrar
uma mensagem em uma tela. Se eu tivesse que mudar alguma coisa para fazer melhorias no registro da tela, agora tenho que fazer
isso em um só lugar. O código restante é o mesmo que faz parte do DeepLogger.

Como essa classe também herda de uma classe abstrata MessageLogger , tive que ter certeza de que LogMessage() dentro do
DeepLogger também estava definido. Herdar do MessageLogger é um pouco complicado aqui. Acho que a redefinição do LogMessage
é obrigatória - meu palpite.

Em termos do código onde o logger é aplicado, graças a uma interface comum nas classes, posso ter certeza de que alterar esta linha em
todo o código não causaria problemas. As mesmas mensagens serão registradas na tela como antes, mas adicionalmente o código
gravará essas mensagens em um arquivo.

clc;
% ... um
registrador de código = DeepLogger(1, 'mylogfile.log');
% ... um código
logger.LogMessage('alguma coisa'); % ...
um código
logger.LogMessage('alguma coisa'); % ...
um código
logger.LogMessage('alguma coisa'); % ...
um código
logger.LogMessage('alguma coisa');

Espero que estes exemplos expliquem o uso de classes, o uso de herança e o uso de classes abstratas.

PS. A solução para o problema acima é uma entre muitas. Outra solução, menos complexa, seria fazer com que o ScreenLoger
fosse um componente de outro logger como o FileLogger etc. O ScreenLogger seria mantido em uma das propriedades. Seu LogMessage
simplesmente chamaria LogMessage do ScreenLogger e mostraria o texto em uma tela. Escolhi uma abordagem mais complexa para
mostrar como as classes funcionam no MATLAB. O código de exemplo abaixo:

classdef DeepLogger < Propriedades do

MessageLogger (SetAccess = protegido)
Nome do arquivo

Caminho

ScrLogger
fim
métodos
função obj = DeepLogger(screenhandler, nome do arquivo)
[caminho,arquivo,ext] = partes do arquivo(nome do
[extensão do arquivo); =
arquivo]; obj.FileName obj.Path =
caminhon; obj.ScrLogger = ScreenLogger(manipulador de tela);
fim
function LogMessage(obj, varargin) if
~isempty(varargin) varargin{1}
= num2str(varargin{1});
obj.LogMessage(obj.ScrLogger, varargin{:}); % <-------- a mudança aqui fid = fopen(obj.fullfname,
'a+t'); fprintf(fid, '%s\n', sprintf(varargin{:}));
fclose(fid);

fim
fim
fim
fim

GoalKicker.com Notas MATLAB® para profissionais 46

Machine Translated by Google

Capítulo 10: Vetorização

Seção 10.1: Uso de bsxfun

Muitas vezes, a razão pela qual o código foi escrito em um loop for é para calcular valores de valores 'próximos'. O
A função bsxfun muitas vezes pode ser usada para fazer isso de uma forma mais sucinta.

Por exemplo, suponha que você deseja realizar uma operação colunar na matriz B, subtraindo a média de
cada coluna dele:

B = rodada(randn(5)*10); % Gerar dados aleatórios

A = zeros(tamanho(B)); para % Matriz pré-alocada
col = 1:tamanho(B,2); % Loop sobre colunas
A(:,col) = B(:,col) - média(B(:,col)); % Subtrair significa
fim

Este método é ineficiente se B for grande, muitas vezes devido ao MATLAB ter que mover o conteúdo das variáveis
memória. Ao usar bsxfun, pode-se fazer o mesmo trabalho de maneira organizada e fácil em apenas uma linha:

A = bsxfun(@menos, B, média(B));

Aqui, @minus é um identificador de função para o menos operador (-) e será aplicado entre elementos dos dois
matrizes B e média(B). Outros identificadores de função, mesmo os definidos pelo usuário, também são possíveis.

A seguir, suponha que você queira adicionar o vetor linha v a cada linha da matriz A:

v = [1, 2, 3];

UMA = [8, 1, 6
3, 5, 7
4, 9, 2];

A abordagem ingênua é usar um loop ( não faça isso):

B = zeros(3);
para linha = 1:3
B(linha,:) = A(linha,:) + v;
fim

Outra opção seria replicar v com repmat ( também não faça isso):

>> v = repmat(v,3,1)
em =
1 2 3
1 2 3
1 2 3

>> B = A + v;

Em vez disso, use bsxfun para esta tarefa:

>> B = bsxfun(@plus, A, v);

B=
3 9
94 7 10

GoalKicker.com Notas MATLAB® para profissionais 47

Machine Translated by Google
5 11 5

Sintaxe

bsxfun(@fun, A, B)

onde @fun é uma das funções suportadas e as duas matrizes A e B respeitam as duas condições abaixo.

O nome bsxfun ajuda a entender como a função funciona e significa Binary FUNction with Singleton eXpansion. Em outras palavras, se:

1. duas matrizes compartilham as mesmas dimensões, exceto uma 2. e

a dimensão discordante é um singleton (ou seja, tem tamanho 1) em qualquer uma das duas matrizes

então a matriz com a dimensão singleton será expandida para corresponder à dimensão da outra matriz. Após a expansão, uma função binária é
aplicada elemento a elemento nas duas matrizes.

Por exemplo, seja A uma matriz M por N por K e B uma matriz M por N. Em primeiro lugar, as suas duas primeiras dimensões têm
tamanhos correspondentes. Em segundo lugar, A tem K camadas enquanto B tem implicitamente apenas 1, portanto é um singleton. Todas as
condições são atendidas e B será replicado para corresponder à 3ª dimensão de A.

Em outras linguagens, isso é comumente chamado de transmissão e acontece automaticamente em Python (numpy) e Octave.

A função @fun deve ser uma função binária, o que significa que deve receber exatamente duas entradas.

Observações

Internamente, bsxfun não replica o array e executa um loop eficiente.

Seção 10.2: Expansão implícita de array (transmissão) [R2016b]

MATLAB R2016b apresentou uma generalização de seu mecanismo de expansão escalar1,2, para também suportar certas operações elemento
a elemento entre arrays de tamanhos diferentes, desde que suas dimensões sejam compatíveis. Os operadores que suportam expansão
implícita são1:

Operadores aritméticos elementares: +, -, .*, .^, ./, .\.

Operadores relacionais: <, <=, >, >=, ==, ~=.

Operadores lógicos: &, |, xor.

Funções bit a bit: bitand, bitor, bitxor.

Funções matemáticas elementares: max, min, mod, rem, hypot, atan2, atan2d.

As operações binárias mencionadas acima são permitidas entre arrays, desde que tenham "tamanhos compatíveis". Os tamanhos são
considerados "compatíveis" quando cada dimensão em uma matriz é exatamente igual à mesma dimensão na outra matriz ou é igual a 1. Observe
que as dimensões singleton finais (ou seja, de tamanho 1) são omitidas pelo MATLAB, mesmo embora haja teoricamente uma quantidade infinita
deles. Em outras palavras - dimensões que aparecem em uma matriz e não aparecem na outra, são implicitamente adequadas para expansão
automática.

Por exemplo, nas versões do MATLAB anteriores ao R2016b isso aconteceria:

>> magia(3) + (1:3)

Erro ao usar + As
dimensões da matriz devem estar de acordo.

GoalKicker.com Notas MATLAB® para profissionais 48

Machine Translated by Google

Considerando que a partir do R2016b a operação anterior terá sucesso:

>> magia(3) + (1:3)

anos =

3 9
94 7 10
5 11 5

Exemplos de tamanhos compatíveis:

Descrição Tamanho do 1º array Tamanho do resultado do 2º tamanho do array
Vetorial e escalar [3x1] [1x1] [3x1]
Vetores de linha e coluna [1x3] [2x1] [2x3]
Matriz vetorial e 2D [1x3] [5x3] [5x3]

Matrizes ND e KD [1x3x3] [5x3x1x4x2] [5x3x3x4x2]

Exemplos de tamanhos incompatíveis:

2ª Matriz Possível solução alternativa
Descrição 1º tamanho da matriz
Tamanho

Vetores onde uma dimensão é um múltiplo da mesma

[1x2] [1x8] transpor
dimensão na outra matriz.

Matrizes com dimensões múltiplas umas das outras. [2x2] [8x8] repmat, remodelar

Matrizes ND que possuem a quantidade certa de singleton

[2x3x4] [2x4x3] trocas
dimensões, mas elas estão na ordem errada (#1).

Matrizes ND que possuem a quantidade certa de singleton

[2x3x4x5] [5x2] trocas
dimensões, mas elas estão na ordem errada (#2).

IMPORTANTE:

O código que depende desta convenção NÃO é compatível com versões anteriores do MATLAB. Portanto, o
a invocação explícita de bsxfun1,2 (que atinge o mesmo efeito) deve ser usada se o código precisar ser executado em versões mais antigas
Versões MATLAB. Se tal preocupação não existir, notas de lançamento do MATLAB R2016 incentivar os usuários a mudar de
bsxdivertido:

Comparado ao uso de bsxfun, a expansão implícita oferece velocidade de execução mais rápida, melhor uso de memória e
melhor legibilidade do código.

Leitura relacionada:

Documentação MATLAB sobre "Tamanhos de array compatíveis para operações básicas".

Transmissão do NumPy1,2.

Uma comparação entre a velocidade da computação usando bsxfun vs. expansão implícita da matriz.

Seção 10.3: Operações elementares

O MATLAB apoia (e incentiva) operações vetorizadas em vetores e matrizes.
Por exemplo, suponha que temos A e B, duas matrizes n por m e queremos que C seja o produto elemento a elemento do

elementos correspondentes (ou seja, C(i,j) = A(i,j)*B(i,j)).

A forma não vetorizada, usando loops aninhados, é a seguinte:

C = zeros(n,m);
para ii=1:n

GoalKicker.com Notas MATLAB® para profissionais 49

Machine Translated by Google

para jj=1:m
C(ii,jj) = A(ii,jj)*B(ii,jj);
fim
fim

No entanto, a maneira vetorizada de fazer isso é usando o operador elemento a elemento .*:

C = A.*B;

Para obter mais informações sobre a multiplicação elemento a elemento no MATLAB, consulte a documentação de tempos.
Para obter mais informações sobre a diferença entre operações de matriz e matriz, consulte Operações de matriz vs. na
documentação do MATLAB.

Seção 10.4: Mascaramento Lógico

MATLAB suporta o uso de mascaramento lógico para realizar a seleção em uma matriz sem o uso de loops for
ou instruções if.

Uma máscara lógica é definida como uma matriz composta apenas por 1 e 0.

Por exemplo:

máscara = [1 0 0; 0 1 0; 0 0 1];

é uma matriz lógica que representa a matriz identidade.

Podemos gerar uma máscara lógica usando um predicado para consultar uma matriz.

UMA = [1 2 3; 4 5 6; 7 8 9];
B = A > 4;

Primeiro criamos uma matriz 3x3, A, contendo os números de 1 a 9. Em seguida, consultamos A para valores maiores que 4 e armazenamos
o resultado em uma nova matriz chamada B.

B é uma matriz lógica da forma:

B = [0 0 0
011
1 1 1]

Ou 1 quando o predicado A > 4 era verdadeiro. E 0 quando era falso.

Podemos usar matrizes lógicas para acessar elementos de uma matriz. Se uma matriz lógica for usada para selecionar elementos, os índices
onde um 1 aparecer na matriz lógica serão selecionados na matriz que você está selecionando.

Usando o mesmo B acima, poderíamos fazer o seguinte:

C = [0 0 0; 0 0 0; 0 0 0];
C(B) = 5;

Isso selecionaria todos os elementos de C onde B tem 1 nesse índice. Esses índices em C são então definidos como 5.

Nosso C agora se parece com:

GoalKicker.com Notas MATLAB® para profissionais 50

Machine Translated by Google

C = [0 0 0
055
5 5 5]

Podemos reduzir blocos de código complicados contendo if e for usando máscaras lógicas.

Pegue o código não vetorizado:

UMA = [1 3 5; 7 9 11; 11 9 7]; para j = 1:

comprimento (A) se A (j) > 5

UMA(j) = UMA(j) - 2; fim

fim

Isso pode ser reduzido usando mascaramento lógico para o seguinte código:

UMA = [1 3 5; 7 9 11; 11 9 7];

B = A > 5;
UMA(B) = UMA(B) - 2;

Ou ainda mais curto:

UMA = [1 3 5; 7 9 11; 11 9 7];

UMA(A > 5) = A(A > 5) - 2;

Seção 10.5: Soma, média, prod & co

Dado um vetor aleatório

v = rand(10,1);

se você quiser a soma de seus elementos, NÃO use um loop

s = 0;
para ii = 1:10
s = s + v(ii);
fim

mas use a capacidade vetorizada de sum() função

s = soma(v);

Funções como soma(), significar(), produção() e outros, têm a capacidade de operar diretamente ao longo de linhas, colunas ou outras
dimensões.

Por exemplo, dada uma matriz aleatória

A = rand(10,10);

a média de cada coluna é

m = média(A,1);

a média de cada linha é

GoalKicker.com Notas MATLAB® para profissionais 51

Machine Translated by Google

m = média(A,2)

Todas as funções acima funcionam apenas em uma dimensão, mas e se você quiser somar a matriz inteira? Você poderia usar:

s = soma(soma(A))

Mas e se você tiver um array ND? aplicar soma sobre soma sobre soma... não parece ser a melhor opção, em vez disso use o operador :
para vetorizar seu array:

s = soma(A(:))

e isso resultará em um número que é a soma de todo o seu array, não importa quantas dimensões ele tenha.

Seção 10.6: Obtenha o valor de uma função de dois ou mais

argumentos
Em muitas aplicações é necessário calcular a função de dois ou mais argumentos.

Tradicionalmente, usamos loops for. Por exemplo, se precisarmos calcular f = exp(-x^2-y^2) (não use isso se precisar de simulações rápidas):

% código1
x = -1,2:0,2:1,4; y =
-2:0,25:3; para nx =
1: comprimento (x)
para ny=1:comprimento(y)
f(nx,ny) = exp(-x(nx)^2-y(ny)^2); fim fim

Mas a versão vetorizada é mais elegante e rápida:

% código2
[x,y] = ndgrid(-1.2:0.2:1.4, -2:0.25:3); f = exp(-x.^2-y.^2);

do que podemos visualizá-lo:

surfar (x, y, f)

Nota1 - Grades: Normalmente, o armazenamento da matriz é organizado linha por linha. Mas no MATLAB é o armazenamento coluna por
coluna como no FORTRAN. Assim, existem duas funções semelhantes ndgrid e meshgrid no MATLAB para implementar os dois modelos
mencionados. Para visualizar a função no caso do meshgrid, podemos usar:

navegar (y,x,f)

Nota2 - Consumo de memória: Deixe o tamanho de x ou y ser 1000. Assim, precisamos armazenar 1000*1000+2*1000 ~ 1e6 elementos para
código não vetorizado1 . Mas precisamos de 3*(1000*1000) = 3e6 elementos no caso de código vetorizado2. No caso 3D (deixe z ter o
mesmo tamanho de x ou y), o consumo de memória aumenta drasticamente: 4*(1000*1000*1000) (~32GB para duplos) no caso do código
vetorizado2 vs ~1000*1000*1000 (apenas ~ 8 GB) no caso do code1. Assim, temos que escolher a memória ou a velocidade.

GoalKicker.com Notas MATLAB® para profissionais 52

Machine Translated by Google

Capítulo 11: Decomposições matriciais

Seção 11.1: Decomposição de Schur
Se A é uma matriz complexa e quadrática, existe um Q unitário tal que Q*AQ = T = D + N com D sendo a matriz diagonal que consiste nos
autovalores e N sendo estritamente tridiagonal superior.

UMA = [3 6 1
23 13 1
0 3 4];
T = Schur(A);

Também exibimos o tempo de execução de Schur dependente da raiz quadrada dos elementos da matriz:

Seção 11.2: Decomposição de Cholesky

A decomposição de Cholesky é um método para decompor uma matriz Hermiteana definida positiva em uma matriz triangular
superior e sua transposta. Pode ser usado para resolver sistemas de equações lineares e é cerca de duas vezes mais rápido que a
decomposição LU.

A = [4 12 -16 12
37 -43 -16
-43 98];
R = col(A);

Isso retorna a matriz triangular superior. O inferior é obtido por transposição.

eu = R';

Finalmente podemos verificar se a decomposição estava correta.

GoalKicker.com Notas MATLAB® para profissionais 53

Machine Translated by Google

b = (A == L*R);

Seção 11.3: decomposição QR

Este método irá decompor uma matriz em uma matriz triangular superior e uma matriz ortogonal.

A = [4 12 -16 12 37
-43 -16 -43
98];
R = qr(A);

Isso retornará a matriz triangular superior, enquanto o seguinte retornará ambas as matrizes.

[Q,R] = qr(A);

O gráfico a seguir exibirá o tempo de execução de qr dependente da raiz quadrada dos elementos da matriz.

Seção 11.4: decomposição LU

Assim, uma matriz será decomposta em uma matriz triangular superior e uma matriz triangular inferior. Freqüentemente será usado
para aumentar o desempenho e a estabilidade (se for feito com permutação) da eliminação de Gauß.

No entanto, muitas vezes este método não funciona ou funciona mal, pois não é estável. Por exemplo

UMA = [8 1 6
3574
9 2];
[L,U] = lu(A);

É suficiente adicionar uma matriz de permutação tal que PA=LU:

[L,U,P]=lu(A);

GoalKicker.com Notas MATLAB® para profissionais 54

Machine Translated by Google

A seguir representaremos agora o tempo de execução de `lu' dependente da raiz quadrada dos elementos da matriz.

Seção 11.5: Decomposição de valores singulares

Dada uma m vezes n matriz A com n maior que m. A decomposição de valor singular

[U,S,V] = svd(A);

calcula as matrizes U,S,V.

A matriz U consiste nos autovetores singulares à esquerda que são os autovetores de A*A.' enquanto V consiste nos autovalores
singulares à direita que são os autovetores de A.'*A. A matriz S tem as raízes quadradas dos autovalores de A*A.' e A.'*A em sua diagonal.

Se m for maior que n pode-se usar

[U,S,V] = svd(A,'econ');

para realizar decomposição de valor singular em tamanho econômico.

GoalKicker.com Notas MATLAB® para profissionais 55

Machine Translated by Google

Capítulo 12: Gráficos: Gráficos de Linhas 2D

Parâmetro Detalhes
X valores x
E valores y
LineSpec Estilo de linha, símbolo de marcador e cor, especificados como uma string
Nome,Valor Pares opcionais de argumentos nome-valor para personalizar as propriedades da linha
h identificador para linha de objeto gráfico

Seção 12.1: Linha dividida com NaNs

Intercale seus valores y ou x com NaNs

x = [1:5; 6:10]';

x(3,2) = NaN
x=
1 6
27
3NaN _
4 9
5 10

enredo (x)

Seção 12.2: Múltiplas linhas em um único gráfico

Neste exemplo, vamos plotar várias linhas em um único eixo. Além disso, escolhemos uma aparência diferente
para as linhas e crie uma legenda.

% cria dados de amostra

x = linspace(-2,2,100); y1 = x.^2; % 100 pontos espaçados linearmente de -2 a 2

y2 = 2*x.^2;
y3 = 4*x.^2;

% criar gráfico
figura; % abrir nova figura
gráfico(x,y1, x,y2,'--', x,y3,'-.'); % linhas de plotagem
grade menor; % adicionar grade secundária
title('Funções quadráticas com diferentes curvaturas');
xlabel('x');

GoalKicker.com Notas MATLAB® para profissionais 56

Machine Translated by Google

rótulo('f(x)');
legenda('f(x) = x^2', 'f(x) = 2x^2', 'f(x) = 4x^2', 'Localização','Norte');

No exemplo acima, plotamos as linhas com um único comando plot. Uma alternativa é usar comandos separados para cada linha.
Precisamos manter o conteúdo de uma figura segurando o último antes de adicionar a segunda linha. Caso contrário, as linhas traçadas
anteriormente desaparecerão da figura. Para criar o mesmo gráfico acima, podemos usar os seguintes comandos:

figura; aguentar ;
plotar(x,y1);
gráfico(x,y2,'--');
gráfico(x,y3,'-.');

A figura resultante é semelhante a esta em ambos os casos:

Seção 12.3: Pedidos personalizados de cores e estilos de linha

No MATLAB, podemos definir novas ordens personalizadas padrão , como ordem de cores e ordem de estilo de linha. Isso significa que
novos pedidos serão aplicados a qualquer figura criada após a aplicação dessas configurações. As novas configurações permanecem até que a
sessão do MATLAB seja encerrada ou novas configurações sejam feitas.

Ordem padrão de cores e estilos de linha

Por padrão, o MATLAB usa algumas cores diferentes e apenas um estilo de linha sólida. Portanto, se plot for chamado para desenhar múltiplas
linhas, o MATLAB alterna uma ordem de cores para desenhar linhas em cores diferentes.

GoalKicker.com Notas MATLAB® para profissionais 57

Machine Translated by Google

Podemos obter a ordem de cores padrão chamando get com um identificador global 0 seguido por este atributo
OrdemDefaultAxesColor:

>> get(0, 'DefaultAxesColorOrder')

anos =
0 0,4470 0,7410
0,8500 0,3250 0,0980
0,9290 0,6940 0,1250
0,4940 0,1840 0,5560
0,4660 0,6740 0,1880
0,3010 0,7450 0,9330
0,6350 0,0780 0,1840

Ordem personalizada de cores e estilos de linha

Depois de decidirmos definir uma ordem de cores personalizada E uma ordem de estilo de linha, o MATLAB deve alternar entre ambos. O
a primeira alteração que o MATLAB aplica é uma cor. Quando todas as cores se esgotarem, o MATLAB aplica o próximo estilo de linha de um
definiu a ordem do estilo de linha e definiu um índice de cores como 1. Isso significa que o MATLAB começará a alternar entre todas as cores
novamente, mas usando o próximo estilo de linha em sua ordem. Quando todos os estilos e cores de linha estiverem esgotados, obviamente o MATLAB
começa a circular desde o início usando a primeira cor e o primeiro estilo de linha.

Para este exemplo, defini um vetor de entrada e uma função anônima para tornar a plotagem de figuras um pouco mais complicada.
mais fácil:

F = @(a,x) bsxfun(@mais, -0,2*x(:).^2, a);

x = (-5:5/100:5-5/100)';

Para definir uma nova cor ou um novo estilo de linha, chamamos a função set com um identificador global 0 seguido por um atributo

Eixos padrãoXXXXXXX; XXXXXXX pode ser ColorOrder ou LineStyleOrder. O comando a seguir define um novo
ordem de cores para preto, vermelho e azul, respectivamente:

set(0, 'DefaultAxesColorOrder', [0 0 0; 1 0 0; 0 0 1]);

GoalKicker.com Notas MATLAB® para profissionais 58

Machine Translated by Google

plotar(x, F([1 2 3 4 5 6],x));

Como você pode ver, o MATLAB alterna apenas por meio de cores porque a ordem do estilo de linha é definida como uma linha sólida por padrão.
Quando um conjunto de cores se esgota, o MATLAB inicia a partir da primeira cor na ordem de cores.

Os comandos a seguir definem as ordens de cores e estilos de linha:

set(0, 'DefaultAxesColorOrder', [0 0 0; 1 0 0; 0 0 1]); set(0, 'DefaultAxesLineStyleOrder',

{'-' '--'}); plotar(x, F([1 2 3 4 5 6],x));

GoalKicker.com Notas MATLAB® para profissionais 59

Machine Translated by Google

Agora, o MATLAB alterna diferentes cores e diferentes estilos de linha usando a cor como atributo mais frequente.

GoalKicker.com Notas MATLAB® para profissionais 60

Machine Translated by Google

Capítulo 13: Gráficos: 2D e 3D

Transformações
Seção 13.1: Transformações 2D

Neste exemplo, pegaremos uma linha quadrada traçada usando linha e realizaremos transformações nela.
Depois vamos usar as mesmas transformações mas em ordem diferente e ver como isso influencia os resultados.

Primeiro abrimos uma figura e definimos alguns parâmetros iniciais (coordenadas de pontos quadrados e parâmetros de transformação)

%Abra a figura e crie o eixo

Figureh=figure('NumberTitle','off','Name','Transformation Example',...
'Posição',[200 200 700 700]); %bg está definido como vermelho, então sabemos que só podemos ver os eixos
Axesh=eixos('XLim',[-8 8],'YLim',[-8,8]);

% Inicializando Variáveis
quadrado=[-0,5 -0,5;-0,5 0,5;0,5 0,5;0,5 -0,5]; %representado pelos seus vértices Sx=0,5; Si=2;
Tx=2;
Ty=2;
teta=pi/
4;

A seguir construímos as matrizes de transformação (escala, rotação e translação):

%Gerar Matriz de Transformação

S=makehgtform('escala',[Sx Sy 1]);
R=makehgtform('zrotate',teta);
T=makehgtform('traduzir',[Tx Ty 0]);

A seguir plotamos o quadrado azul:

%% Traçando o Quadrado Azul original

OriginalSQ=linha([quadrado(:,1);quadrado(1,1)],[quadrado(:,2);quadrado(1,2)],'Cor','b','LarguraLinha',3) ; grade ativada; segure
tudo; % % Aplicando grade na figura
Mantendo todos os gráficos seguintes nos eixos atuais

A seguir vamos plotá-lo novamente em uma cor diferente (vermelho) e aplicar as transformações:

%% Traçando o Quadrado Vermelho

%Calcular vértices do retângulo
HrectTRS=T*R*S;
RedSQ=linha([quadrado(:,1);quadrado(1,1)],[quadrado(:,2);quadrado(1,2)],'Cor','r','LinhaLargura',3) ; % transformação
dos eixos
AxesTransformation=hgtransform('Parent',gca,'matriz',HrectTRS); %definindo a linha
como filha dos eixos transformados
set(RedSQ,'Parent',AxesTransformation);

O resultado deve ficar assim:

GoalKicker.com Notas MATLAB® para profissionais 61

Machine Translated by Google

Agora vamos ver o que acontece quando alteramos a ordem de transformação:

%% Traçando o Quadrado Verde

HrectRST=R*S*T;
VerdeSQ=linha([quadrado(:,1);quadrado(1,1)],[quadrado(:,2);quadrado(1,2)],'Cor','g','LinhaLargura',3) ;
AxesTransformation=hgtransform('Parent',gca,'matriz',HrectRST);
set(GreenSQ,'Parent',AxesTransformation);

%% Traçando o Quadrado Amarelo

HrectSRT=S*R*T;
AmareloSQ=linha([quadrado(:,1);quadrado(1,1)],[quadrado(:,2);quadrado(1,2)],'Cor','y','LinhaLargura',3) ;
AxesTransformation=hgtransform('Parent',gca,'matriz',HrectSRT);
set(YellowSQ,'Parent',AxesTransformation);

GoalKicker.com Notas MATLAB® para profissionais 62

Machine Translated by Google

GoalKicker.com Notas MATLAB® para profissionais 63

Machine Translated by Google

Capítulo 14: Controlando a coloração da subtrama em

MATLAB
Como eu estava lutando com isso mais de uma vez, e a web não é muito clara sobre o que fazer, decidi pegar o que está lá fora, adicionando alguns
dos meus próprios para explicar como criar subtramas que possuem uma barra de cores e eles são dimensionados de acordo com ele.

Eu testei isso usando o MATLAB mais recente, mas tenho certeza de que funcionará em versões mais antigas.

Seção 14.1: Como é feito

Este é um código simples criando 6 subparcelas 3D e no final sincronizando a cor exibida em cada uma delas.

c_fin = [0,0]; [X,Y] =

grade de malha(1:0,1:10,1:0,1:10);

figura; aguentar ; para

eu = 1 : 6
Z(:,:,i) = i * (sin(X) + cos(Y));

machado(i) = subtrama(3,2,i); aguentar ; grade ativada;

navegar(X, Y, Z(:,:,i));
visualizar(-26,30);
mapa de cores('jato');
ca = caxis; c_fin
= [min(c_fin(1),ca(1)), max(c_fin(2),ca(2))];
fim

%% você pode parar aqui para ver como fica antes de manipularmos as cores

c = colorbar('lestefora'); c.Label.String =
'Unidades'; set(c, 'Posição', [0,9,
0,11, 0,03, 0,815]); %% você pode querer brincar com esses valores pause(2); %% precisa disso para permitir que a última
imagem seja redimensionada antes de alterar seus eixos para i = 1 : 6 pos=get(ax(i), 'Position'); eixos(ax(i)); set(ax(i), 'Posição',
[pos(1) pos(2)
0,85*pos(3) pos(4)]); set(ax(i),'Clim',
c_fin); %%É aqui
que a mágica acontece

fim

GoalKicker.com Notas MATLAB® para profissionais 64

Machine Translated by Google

Capítulo 15: Processamento de imagem Seção 15.1: E/S

básica de imagem

>> img = imread('futebol.jpg');

Usar imread para ler arquivos de imagem em uma matriz no MATLAB.

Depois de ler uma imagem, ela é armazenada como um array ND na memória:

>> tamanho (img)

anos =
256 320 3

A imagem 'football.jpg' possui 256 linhas e 320 colunas e possui 3 canais de cores: Vermelho, Verde e Azul.

Agora você pode espelhá-lo:

>> espelhado = img(:, end:-1:1, :); % // como espelhar qualquer array ND no MATLAB

E finalmente, escreva de volta como uma imagem usando imwrite:

>> imwrite(espelhado, 'mirrored_football.jpg');

Seção 15.2: Recuperar imagens da Internet

Contanto que você tenha uma conexão com a Internet, você poderá ler imagens de um hiperlink

I=imread('https://cdn.sstatic.net/Sites/stackoverflow/company/img/logos/so/so-logo.png');

Seção 15.3: Filtragem usando uma FFT 2D

Assim como nos sinais 1D, é possível filtrar imagens aplicando uma transformação de Fourier, multiplicando por um filtro no domínio da
frequência e transformando novamente no domínio espacial. Veja como você pode aplicar filtros passa-alta ou passa-baixa a uma
imagem com MATLAB:

Deixe a imagem ser a imagem original e não filtrada. Veja como calcular sua FFT 2D:

ft = fftshift(fft2(imagem));

Agora, para excluir uma parte do espectro, é necessário definir seus valores de pixel como 0. A frequência espacial contida na imagem
original é mapeada do centro para as bordas (após usar fftshift). Para excluir as frequências baixas, definiremos a área circular central
como 0.

Veja como gerar uma máscara binária em forma de disco com raio D usando a função integrada:

[xy ~] = tamanho (pés);

D = 20;
máscara = fspecial('disco', D) == 0; máscara =
imresize(padarray(mask, [floor((x/2)-D) floor((y/2)-D)], 1, 'ambos'), [x y]);

O mascaramento da imagem no domínio da frequência pode ser feito multiplicando a FFT ponto a ponto pela máscara binária obtida
acima:

GoalKicker.com Notas MATLAB® para profissionais 65

Machine Translated by Google

mascarado_ft = pés.* máscara;

Agora, vamos calcular a FFT inversa:

imagem_filtrada = ifft2(ifftshift(masked_ft), 'simétrico');

As altas frequências em uma imagem são as bordas nítidas, portanto, esse filtro passa-alta pode ser usado para tornar as imagens mais nítidas.

Seção 15.4: Filtragem de imagens

Digamos que você tenha uma imagem rgbImg, por exemplo, lida usando imread.

>> rgbImg = imread('pears.png'); >> figura,

imshow(rgbImg), título('Imagem Original')

Use fspecial para criar um filtro 2D:

>> h = fspecial('disco', 7); >> figura,

imshow(h, []), título('Filtro')

GoalKicker.com Notas MATLAB® para profissionais 66

Machine Translated by Google

Usar imfiltro para aplicar o filtro na imagem:

>> filtradoRgbImg = imfilter(rgbImg, h); >> figura,

imshow(filteredRgbImg), title('Imagem Filtrada')

Seção 15.5: Medindo Propriedades de Regiões Conectadas

Começando com uma imagem binária, bwImg, que contém vários objetos conectados.

>> bwImg = imread('blobs.png'); >> figura,

imshow(bwImg), título('Imagem binária')

GoalKicker.com Notas MATLAB® para profissionais 67

Machine Translated by Google

Para medir propriedades (por exemplo, área, centróide, etc.) de cada objeto na imagem, use regionprops:

>> estatísticas = regionalprops(bwImg, 'Área', 'Centroid');

stats é uma matriz de estrutura que contém uma estrutura para cada objeto na imagem. Acessar uma propriedade medida de
um objeto é simples. Por exemplo, para exibir a área do primeiro objeto, simplesmente,

>> estatísticas(1).Área

anos =

35

Visualize os centróides do objeto sobrepondo-os à imagem original.

>> figura, imshow(bwImg), title('Imagem binária com centróides sobrepostos') >> espere >> para i =
1:size(stats)
scatter(stats(i).Centroid(1),
stats(i) .Centroid(2), 'preenchido'); fim

GoalKicker.com Notas MATLAB® para profissionais 68

Machine Translated by Google

GoalKicker.com Notas MATLAB® para profissionais 69

Machine Translated by Google

Capítulo 16: Desenho

Seção 16.1: Círculos
A opção mais fácil para desenhar um círculo é - obviamente - o retângulo função.

% // raio r =
2;

% // centro c
= [3 3];

posição = [cr 2*r 2*r];

retângulo('Posição',pos,'Curvatura',[1 1]) eixo igual

mas a curvatura do retângulo deve ser definida como 1!

O vetor posição define o retângulo, os dois primeiros valores x e y são o canto inferior esquerdo do retângulo.
Os dois últimos valores definem a largura e a altura do retângulo.

pos = [ [x y] largura altura ]

O canto inferior esquerdo do círculo - sim, este círculo tem cantos, embora imaginários - é o centro c = [3 3] menos o
raio r = 2 que é [x y] = [1 1]. A largura e a altura são iguais ao diâmetro do círculo, então largura = 2*r; altura = largura;

Caso a suavidade da solução acima não seja suficiente, não há como evitar o uso da maneira óbvia de desenhar um
círculo real usando funções trigonométricas.

%// número de pontos n =

1000;

GoalKicker.com Notas MATLAB® para profissionais 70

Machine Translated by Google

%// variável em execução t =

linspace(0,2*pi,n);

x = c(1) + r*sin(t); y = c(2) +

r*cos(t);

%//desenha linha
linha(x,y)

% // ou desenhe um polígono se quiser preenchê-lo com a cor % // fill(x,y,[1,1,1])

axis equal

Seção 16.2: Setas

Em primeiro lugar, pode-se usar aljava, onde não é necessário lidar com unidades de figuras normalizadas incómodas através do uso de
anotação

desenharArrow = @(x,y) quiver( x(1),y(1),x(2)-x(1),y(2)-y(1),0 )

x1 = [10 30]; y1 =
[10 30];

desenharArrow(x1,y1); aguentar _

x2 = [25 15]; y2 =
[15 25];

desenharArrow(x2,y2)

GoalKicker.com Notas MATLAB® para profissionais 71

Machine Translated by Google

Importante é o 5º argumento de quiver: 0 que desativa uma escala padrão, já que esta função é geralmente usada para plotar campos vetoriais. (ou
use o par de valores de propriedade 'AutoScale','off')

Também é possível adicionar recursos adicionais:

drawArrow = @(x,y,varargin) quiver( x(1),y(1),x(2)-x(1),y(2)-y(1),0, varargin{:} ) drawArrow (x1,y1);

segure drawArrow
(x2,y2,'linewidth',3,'color','r')

Se forem desejadas pontas de seta diferentes, é necessário usar anotações (esta resposta pode ser útil. Como altero o estilo da ponta da seta no gráfico
de aljava?).

GoalKicker.com Notas MATLAB® para profissionais 72

Machine Translated by Google

O tamanho da ponta da seta pode ser ajustado com a propriedade 'MaxHeadSize' . Não é consistente, infelizmente. Os limites dos eixos
precisam ser definidos posteriormente.

x1 = [10 30]; y1 =
[10 30];
drawArrow(x1,y1,{'MaxHeadSize',0.8,'Color','b','LineWidth',3}); aguentar _

x2 = [25 15]; y2 =
[15 25];
drawArrow(x2,y2,{'MaxHeadSize',10,'Color','r','LineWidth',3}); aguentar _

xlim([1, 100]) ylim([1,

100])

Há outro ajuste para pontas de seta ajustáveis:

função [ h ] = desenharArrow( x,y,xlimites,ylimites,props )

xlim(xlimites)
ylim(ylimites)

h = anotação('seta'); set(h,'pai',
gca, ...
'posição', [x(1),y(1),x(2)-x(1),y(2)-y(1)], ...
'HeadLength', 10, 'HeadWidth', 10, 'HeadStyle', 'cback1', ... adereços{:} );

fim

que você pode chamar do seu script da seguinte maneira:

drawArrow(x1,y1,[1, 100],[1, 100],{'Cor','b','LinhaLargura',3}); segure drawArrow (x2,y2,[1, 100],[1, 100],

{'Color','r','LineWidth',3}); aguentar _

GoalKicker.com Notas MATLAB® para profissionais 73

Machine Translated by Google

Seção 16.3: Elipse

Para traçar uma elipse você pode usar sua equação. Uma elipse tem um eixo maior e um eixo menor. Também queremos poder traçar a elipse em
diferentes pontos centrais. Portanto escrevemos uma função cujas entradas e saídas são:

Entradas:
r1,r2: eixo maior e menor respectivamente
C: centro da elipse (cx,cy)
Saída:
[x,y]: pontos na circunferência da elipse

Você pode usar a função a seguir para obter os pontos em uma elipse e depois plotá-los.

função [x,y] = getEllipse(r1,r2,C) beta =

linspace(0,2*pi,100); x = r1*cos(beta)
- r2*sin(beta); y = r1*cos(beta) +
r2*sin(beta); x = x + C(1,1); y = y +
C(1,2); fim

Exemplo:

[x,y] = getEllipse(1,0.3,[2 3]); plotar(x,y);

GoalKicker.com Notas MATLAB® para profissionais 74

Machine Translated by Google

Seção 16.4: Gráfico pseudo 4D

Uma matriz (mx n) pode ser representada por uma superfície usando surf;

A cor da superfície é definida automaticamente em função dos valores da matriz (mx n) . Se o mapa de cores não for especificado, o
padrão será aplicado.

Uma barra de cores pode ser adicionado para exibir o mapa de cores atual e indicar o mapeamento de valores de dados no
mapa de cores.

No exemplo a seguir, a matriz z (mx n) é gerada pela função:

z=x.*y.*sin(x).*cos(y);

no intervalo [-pi,pi]. Os valores x e y podem ser gerados usando o meshgrid função e a superfície é renderizada da seguinte forma:

% Crie uma figura %

Gere
os valores `x` e `y` no intervalo `[-pi,pi]` [x,y] = meshgrid([-pi:.2:pi],[-pi:.
2:pi]); % Avalie a função no intervalo selecionado
z=x.*y.*sin(x).*cos(y); % Use surf para traçar a superfície
S=surf(x,y,z); xlabel(' Eixo
X');

GoalKicker.com Notas MATLAB® para profissionais 75

Machine Translated by Google

ylabel(' Eixo Y'); zlabel('

Eixo Z'); grid menor
colormap('hot')
colorbar

figura 1

Agora pode ser que informações adicionais sejam vinculadas aos valores da matriz z e armazenadas em outra matriz (mx n).

É possível adicionar essas informações adicionais ao gráfico modificando a forma como a superfície é colorida.

Isso permitirá ter uma espécie de gráfico 4D: para a representação 3D da superfície gerada pela primeira matriz (mx n) , a quarta dimensão
será representada pelos dados contidos na segunda matriz (mx n) .

É possível criar tal gráfico chamando surf com 4 entradas:

surfar (x, y, z, C)

onde o parâmetro C é a segunda matriz (que deve ter o mesmo tamanho de z) e é usado para definir a cor da superfície.

No exemplo a seguir, a matriz C é gerada pela função:

C=10*sen(0,5*(x.^2.+y.^2))*33;

no intervalo [-pi,pi]

A superfície gerada por C é

GoalKicker.com Notas MATLAB® para profissionais 76

Machine Translated by Google

Figura 2

Agora podemos chamar surf com quatro entradas:

figura
surf(x,y,z,C) %
sombreamento
interp xlabel(' Eixo
X'); ylabel(' Eixo Y');
zlabel(' Eixo Z'); grid
menor
colormap('hot')
colorbar

GoalKicker.com Notas MATLAB® para profissionais 77

Machine Translated by Google

Figura 3

Comparando a Figura 1 e a Figura 3, podemos notar que:

a forma da superfície corresponde aos valores z (a primeira matriz (mx n) ) a

cor da superfície (e seu intervalo, dado pela barra de cores) corresponde aos valores C (a primeira matriz
(mx n) )

GoalKicker.com Notas MATLAB® para profissionais 78

Machine Translated by Google

Figura 4

Claro, é possível trocar z e C no gráfico para ter a forma da superfície dada pela matriz C e a cor dada pela matriz z :

figura
surf(x,y,C,z) %
sombreamento interp
xlabel(' Eixo X'); ylabel('
Eixo Y'); zlabel(' Eixo
Z'); grid menor
colormap('hot')
colorbar

e comparar a Figura 2 com a Figura 4

Seção 16.5: Desenho rápido

'XDados'
Existem três maneiras principais de fazer plotagens ou animações sequenciais: plot(x,y), set(h , , y) e linha , y, Se
animada. 'YDados'
quiser que sua
animação seja suave, você precisa de um desenho eficiente e os três métodos não são equivalentes.

% Trace um sen com mudança de fase crescente em 500 passos x =

linspace(0 , 2*pi , 100);

figura
tic
para thetha = linspace(0 , 10*pi , 500) y = sin(x +
thetha); plotar (x, y)
desenhado
agora
fim

GoalKicker.com Notas MATLAB® para profissionais 79

Machine Translated by Google

toc

Eu recebo 5,278172 segundos. A função plot basicamente exclui e recria o objeto de linha a cada vez. Uma maneira mais eficiente de atualizar um
gráfico é usar as propriedades XData e YData do objeto Line .

tique h = []; % Identificador do objeto de linha

para thetha = linspace(0 , 10*pi , 500) y = sin(x + thetha);

se estiver vazio(h)
% Se a Linha ainda não existir, crie-a h = plot(x,y); outro

% Se a linha existir, atualize-a set(h , , y)

'YDados'
fim

desenhado agora

fim
toc

Agora consigo 2,741996 segundos, muito melhor!

animadoline é uma função relativamente nova, introduzida em 2014b. Vamos ver como fica:

tique
h = linha animada; para
thetha = linspace(0 , 10*pi , 500) y = sin(x + thetha);
pontos claros (h) pontos
adicionais (h ,
desenhado x , e)

fim
toc

3,360569 segundos, não tão bom quanto atualizar um gráfico existente, mas ainda melhor que plot(x,y).

Claro, se você tiver que traçar uma única linha, como neste exemplo, os três métodos são quase equivalentes e fornecem animações
suaves. Mas se você tiver gráficos mais complexos, atualizar os objetos Line existentes fará a diferença.

Seção 16.6: Polígono(s)

Crie vetores para manter as localizações x e y dos vértices e alimente-os no patch.

Polígono Único

X=rand(1,4); Y=rand(1,4);
h=patch(X,Y,'vermelho');

GoalKicker.com Notas MATLAB® para profissionais 80

Machine Translated by Google

Vários polígonos

Os vértices de cada polígono ocupam uma coluna de cada um de X, Y.

X=rand(4,3); Y=rand(4,3); para

eu=2:3
X(:,i)=X(:,i)+(i-1); % cria deslocamentos horizontais para fim de visibilidade

h=patch(X,Y,'vermelho');

GoalKicker.com Notas MATLAB® para profissionais 81

Machine Translated by Google

Capítulo 17: Aplicações Financeiras

Seção 17.1: Passeio Aleatório

A seguir está um exemplo que exibe 5 passeios aleatórios unidimensionais de 200 passos:

y = cumsum(rand(200,5) - 0,5);

enredo
(y) legenda ('1', '2', '3', '4', '5') título
('caminhadas aleatórias')

No código acima, y é uma matriz de 5 colunas, cada uma com comprimento 200. Como x é omitido, o padrão é os números das linhas de y
(equivalente a usar x=1:200 como o eixo x). Dessa forma, a função plot plota vários vetores y em relação ao mesmo vetor x, cada um usando uma
cor diferente automaticamente.

Seção 17.2: Movimento Browniano Geométrico Univariado

A dinâmica do Movimento Geométrico Browniano (GBM) é descrita pela seguinte equação diferencial estocástica (SDE):

Posso usar a solução exata para o SDE

para gerar caminhos que seguem um GBM.

GoalKicker.com Notas MATLAB® para profissionais 82

Machine Translated by Google

Dados os parâmetros diários para uma simulação de um ano

em = 0,08/250;
sigma = 0,25/m²(250);
dt = 1/250;
ncaminhos = 100;
npassos = 250;
S0 = 23,2;

podemos obter o Movimento Browniano (BM) W começando em 0 e usá-lo para obter o GBM começando em S0

% BM
épsilon = randn(nsteps, npaths);
EM
= [zeros(1,ncaminhos); sqrt(dt)*cumsum(épsilon)];

% GBM
t = (0:npassos)'*dt;
Y = bsxfun(@plus, (in-0,5*sigma.^2)*t, sigma*W);
Y = S0*exp(Y);

O que produz os caminhos

enredo (Y)

GoalKicker.com Notas MATLAB® para profissionais 83

Machine Translated by Google

Capítulo 18: Transformadas de Fourier e

Transformadas Inversas de Fourier
Parâmetro Descrição
X este é o seu sinal de entrada no domínio do tempo, deve ser um vetor de números.

n este é o parâmetro NFFT conhecido como Transform Length, pense nele como a resolução do seu resultado FFT, é
DEVE ser um número que seja uma potência de 2 (ou seja, 64.128.256...2^N)

esta é a dimensão na qual você deseja calcular a FFT, use 1 se quiser calcular sua FFT no
escurecer
direção horizontal e 2 se você deseja calcular sua FFT na direção vertical - Observe isto
O parâmetro geralmente é deixado em branco, pois a função é capaz de detectar a direção do seu vetor.

Seção 18.1: Implementar uma transformada de Fourier simples no MATLAB

A Transformada de Fourier é provavelmente a primeira lição em Processamento Digital de Sinais, sua aplicação está em toda parte e é uma
ferramenta poderosa quando se trata de analisar dados (em todos os setores) ou sinais. O MATLAB possui um conjunto de caixas de ferramentas poderosas para

Transformada de Fourier. Neste exemplo, usaremos a Transformada de Fourier para analisar um sinal de onda senoidal básico e gerar
o que às vezes é conhecido como Periodograma usando FFT:

%Geração de sinal
A1=10; % Amplitude 1
A2=10; % Amplitude 2
w1=2*pol*0,2; % Frequência angular 1
w2=2*pi*0,225; Ts=1; % Frequência angular 2
N=64; % Tempo de amostragem
K=5; % Número de amostras de processo a serem geradas
smg % Número de realizações de processos independentes
= 1; % Desvio padrão do ruído
n=repmat([0:N-1].',1,K); % Gerar resolução
phi1=repmat(rand(1,K)*2*pi,N,1); % Matriz de fase aleatória 1
phi2=repmat(rand(1,K)*2*pi,N,1); % Matriz de fase aleatória 2
x=A1*sin(w1*n*Ts+phi1)+A2*sin(w2*n*Ts+phi2)+sgm*randn(N,K); % de sinal resultante

NFFT=256; % de comprimento da FFT

F=fft(x,NFFT); Z=1/ % Resultado da Transformada Rápida de Fourier

N*abs(F).^2; % Converte o resultado da FFT em um periodograma

GoalKicker.com Notas MATLAB® para profissionais 84

Machine Translated by Google

Observe que a Transformada Discreta de Fourier é implementada pela Transformada Rápida de Fourier (fft) no MATLAB, ambas produzirão o mesmo resultado, mas

a FFT é uma implementação rápida da DFT.

figura
w=linspace(0,2,NFFT);
plot(w,10*log10(Z)),grade;
xlabel('w [\pi rad/s]')
ylabel('Z(f) [dB]')
title('Faixa de frequência: [ 0 , \omega_s ]')

Seção 18.2: Imagens e FTs multidimensionais

Em imagens médicas, espectroscopia, processamento de imagens, criptografia e outras áreas da ciência e da engenharia, muitas vezes deseja-se calcular

transformadas multidimensionais de Fourier de imagens. Isso é bastante simples no MATLAB: afinal, imagens (multidimensionais) são apenas matrizes

n-dimensionais, e as transformadas de Fourier são operadores lineares: apenas uma transformada de Fourier iterativamente ao longo de outras dimensões.

O MATLAB fornece fft2 e ifft2 para fazer isso em 2-d ou fftn em n dimensões.

Uma armadilha potencial é que a transformada de Fourier das imagens geralmente é mostrada em "ordenação centrada", ou seja, com a origem do espaço k no meio

da imagem. MATLAB fornece o comando fftshift para trocar a localização dos componentes DC da transformada de Fourier de forma adequada. Esta notação de

ordenação torna substancialmente mais fácil a execução de técnicas comuns de processamento de imagens, uma das quais é ilustrada abaixo.

Enchimento zero

Uma maneira "rápida e suja" de interpolar uma imagem pequena para um tamanho maior é transformá-la em Fourier, preencher a transformada de Fourier com

zeros e, em seguida, fazer a transformação inversa. Isso interpola efetivamente entre cada pixel com uma função de base em formato sincronizado e é comumente

usado para aumentar a escala de dados de imagens médicas de baixa resolução. Vamos começar carregando um exemplo de imagem integrada

%Carregar imagem de exemplo

GoalKicker.com Notas MATLAB® para profissionais 85

Machine Translated by Google

I=imread('moedas.png'); %Carregar dados de exemplo - coins.png está embutido no MATLAB I=double(I);

%Converter para precisão dupla - imread retorna inteiros imageSize = size(I); % I é uma imagem 2D
de 246 x 300

%Exibir
imagensc(I); mapa de cores cinza; eixo igual; %imagesc
exibe imagens dimensionadas para intensidade máxima

Agora podemos obter a transformada de Fourier de I. Para ilustrar o que o fftshift faz, vamos comparar os dois métodos:

% Transformada de Fourier
% Obtenha a transformada de Fourier ordenada centrada e não centrada de I k=fftshift(fft2(fftshift(I)));
errado=fft2(I);

%Apenas para efeito de comparação, mostre a magnitude de ambas as transformadas: figure;

subtrama(2,1,1); imagensc(abs(k),
[0 1e4]); mapa de cores cinza; eixo igual; subtrama(2,1,2);
imagensc(abs(kwrong),
[0 1e4]); mapa de cores cinza; eixo igual; %(O segundo argumento para imagesc
define o eixo da cor para deixar a diferença clara).

GoalKicker.com Notas MATLAB® para profissionais 86

Machine Translated by Google

Agora obtivemos o FT 2D de uma imagem de exemplo. Para preenchê-lo com zero, queremos pegar cada espaço k, preencher as arestas com
zeros e, em seguida, fazer a transformação reversa:

%Preenchimento zero kzf = zeros(imageSize .* 2); %Gere um array vazio de 492x600 para colocar o
resultado em kzf(end/4:3*end/4-1,end/4:3*end/4-1) = k; %Coloque k no meio
kzfwrong = zeros(imageSize .* 2); %Gere um array vazio de 492x600 para colocar o resultado em
kzfwrong(end/4:3*end/4-1,end/4:3*end/4-1) = kwrong; %Coloque k no meio

%Mostre as diferenças novamente

%Apenas para fins de comparação, mostre a magnitude de ambas as transformações:
figure; subtrama(2,1,1);
imagensc(abs(kzf),[0 1e4]); mapa de cores cinza; eixo igual;
subtrama(2,1,2);
imagensc(abs(kzfwrong),[0 1e4]); mapa de cores cinza; eixo igual; %(O
segundo argumento para imagesc define o eixo da cor para deixar a diferença clara).

Neste ponto, o resultado é bastante normal:

GoalKicker.com Notas MATLAB® para profissionais 87

Machine Translated by Google

Depois de fazermos as transformações reversas, podemos ver que (corretamente!) Os dados de preenchimento zero fornecem um método sensato
para interpolação:

% Pegue a transformação traseira e veja

Izf = fftshift(ifft2(ifftshift(kzf)));
Izferrado = ifft2(kzferrado);

figura; subtrama(1,3,1);
imagensc(abs(Izf)); mapa de cores cinza; eixo igual; title('Imagem
preenchida com zero'); subtrama(1,3,2);
imagensc(abs(Izfwrong));
mapa de cores cinza; eixo igual; title('Imagem preenchida com zero
incorretamente'); subtrama(1,3,3); imagensc(I); mapa de cores
cinza; eixo igual;
título('Imagem original'); set(gcf,'cor','w');

GoalKicker.com Notas MATLAB® para profissionais 88

Machine Translated by Google

Observe que o tamanho da imagem preenchida com zero é o dobro do original. Pode-se preencher o zero por mais de um fator de dois em
cada dimensão, embora obviamente isso não aumente arbitrariamente o tamanho de uma imagem.

Dicas, sugestões, 3D e muito mais

O exemplo acima vale para imagens 3D (como são frequentemente geradas por técnicas de imagem médica ou microscopia confocal,
por exemplo), mas exige que fft2 seja substituído por fftn(I, 3), por exemplo. Devido à natureza um tanto complicada de escrever
fftshift(fft(fftshift(... várias vezes, é bastante comum definir funções como fft2c localmente para fornecer uma sintaxe mais fácil localmente -
como:

função y = fft2c(x)

y = fftshift(fft2(fftshift(x)));

Observe que a FFT é rápida, mas grandes transformadas de Fourier multidimensionais ainda levarão tempo em um computador moderno.
Além disso, é inerentemente complexo: a magnitude do espaço k foi mostrada acima, mas a fase é absolutamente vital; as traduções no
domínio da imagem são equivalentes a uma rampa de fase no domínio de Fourier. Existem várias operações muito mais complexas que se
pode desejar fazer no domínio de Fourier, como filtrar frequências espaciais altas ou baixas (multiplicando-as por um filtro) ou mascarar pontos
discretos correspondentes ao ruído. Há correspondentemente uma grande quantidade de código gerado pela comunidade para lidar com
operações comuns de Fourier, disponível no principal site de repositório da comunidade do MATLAB, o File Exchange.

GoalKicker.com Notas MATLAB® para profissionais 89

Machine Translated by Google

Seção 18.3: Transformadas Inversas de Fourier

Um dos principais benefícios da Transformada de Fourier é sua capacidade de reverter para o Domínio do Tempo sem perder
Informação. Vamos considerar o mesmo sinal que usamos no exemplo anterior:

A1=10; % Amplitude 1
A2=10; % Amplitude 2
w1=2*pol*0,2; % Frequência angular 1
w2=2*pi*0,225; % Frequência angular 2
Ts=1; % Tempo de amostragem
N=64; % Número de amostras de processo a serem geradas
K=1; % Número de realizações de processos independentes
smg = % Desvio padrão do ruído
1; n=repmat([0:N-1].',1,K); % Gerar resolução
phi1=repmat(rand(1,K)*2*pi,N,1); % Matriz de fase aleatória 1
phi2=repmat(rand(1,K)*2*pi,N,1); % Matriz de fase aleatória 2
x=A1*sin(w1*n*Ts+phi1)+A2*sin(w2*n*Ts+phi2)+sgm*randn(N,K); % de sinal resultante

NFFT=256; % de comprimento da FFT

F=fft(x,NFFT); % FFT resultado do sinal no domínio do tempo

Se abrirmos F no MATLAB, descobriremos que é uma matriz de números complexos, uma parte real e uma parte imaginária. Por
definição, para recuperar o sinal original no Domínio do Tempo, precisamos tanto do Real (que representa a Magnitude
variação) e o Imaginário (que representa a variação de Fase), então para retornar ao Domínio do Tempo, pode-se simplesmente
quer:

TD = ifft(F,NFFT); %Retorna o inverso de F no domínio do tempo

Observe aqui que o TD retornado teria comprimento 256 porque definimos NFFT como 256, no entanto, o comprimento de x é apenas 64, então
O MATLAB preencherá zeros até o final da transformação TD. Por exemplo, se NFFT fosse 1024 e o comprimento fosse 64,
então o TD retornado será 64 + 960 zeros. Observe também que devido ao arredondamento de ponto flutuante, você pode obter algo como
3.1 * 10e-20 mas para uso geral: Para qualquer X, ifft(fft(X)) é igual a X dentro do erro de arredondamento.

Digamos por um momento que após a transformação fizemos alguma coisa e só nos resta a parte REAL do
FFT:

R = real(F); % Dê a parte real da FFT

TDR = ifft(R,NFFT); % Forneça o domínio do tempo da parte real da FFT

Isso significa que estamos perdendo a parte imaginária da nossa FFT e, portanto, estamos perdendo informações nesse sentido reverso
processo. Para preservar o original sem perder informações, você deve sempre manter a parte imaginária da FFT
usando imag e aplique suas funções a ambos ou à parte real.

figura
subtrama (3,1,1)
plot(x);xlabel(' amostras de tempo');ylabel('magnitude');title(' Sinal Original no Domínio do Tempo')
subtrama (3,1,2)
plot(TD(1:64));xlabel(' amostras de tempo');ylabel('magnitude');title('Inverse Fourier Transformed - Time
Sinal de Domínio')
subtrama (3,1,3)
plot(TDR(1:64));xlabel(' amostras de tempo');ylabel('magnitude');title(' Parte real do IFFT transformada
Sinal no domínio do tempo')

GoalKicker.com Notas MATLAB® para profissionais 90

Machine Translated by Google

GoalKicker.com Notas MATLAB® para profissionais 91

Machine Translated by Google

Capítulo 19: Diferencial Comum

Solucionadores de Equações (ODE)
Seção 19.1: Exemplo para odeset
Primeiro inicializamos nosso problema de valor inicial que queremos resolver.

odefun = @(t,y) cos(y).^2*sin(t); tspan =

[0 16*pi]; y0=1;

Em seguida, usamos a função ode45 sem nenhuma opção especificada para resolver este problema. Para compará-lo mais tarde, traçamos a trajetória.

[t,y] = ode45(odefun, tspan, y0);

plotar(t,y,'-o');

Estabelecemos agora um limite de tolerância relativo estreito e um limite absoluto estreito de tolerância para o nosso problema.

opções = odeset('RelTol',1e-2,'AbsTol',1e-2); [t,y] =

ode45(odefun, tspan, y0, opções); plotar(t,y,'-o');

Estabelecemos limites de tolerância relativos e absolutos estreitos.

opções = odeset('RelTol',1e-7,'AbsTol',1e-2); [t,y] =

ode45(odefun, tspan, y0, opções); plotar(t,y,'-o');

Estabelecemos limites de tolerância relativos estreitos e absolutos restritos. Como nos exemplos anteriores com limites de tolerância estreitos,
vê-se a trajetória sendo completamente diferente da primeira parcela, sem quaisquer opções específicas.

opções = odeset('RelTol',1e-2,'AbsTol',1e-7); [t,y] =

ode45(odefun, tspan, y0, opções); plotar(t,y,'-o');

Estabelecemos limites de tolerância relativos e absolutos rígidos. A comparação do resultado com o outro gráfico irá sublinhar os erros cometidos no
cálculo com limites de tolerância estreitos.

opções = odeset('RelTol',1e-7,'AbsTol',1e-7); [t,y] =

ode45(odefun, tspan, y0, opções); plotar(t,y,'-o');

O seguinte deve demonstrar a compensação entre precisão e tempo de execução.

tique; opções = odeset('RelTol',1e-7,'AbsTol',1e-7); [t,y]

= ode45(odefun, tspan, y0, opções); tempo1 = toc;
plotar(t,y,'-o');

Para efeito de comparação, restringimos o limite de tolerância para erros absolutos e relativos. Podemos agora ver que, sem um grande ganho de
precisão, demorará consideravelmente mais tempo para resolver o nosso problema de valor inicial.

GoalKicker.com Notas MATLAB® para profissionais 92

Machine Translated by Google

tique;
opções = odeset('RelTol',1e-13,'AbsTol',1e-13); [t,y] = ode45(odefun,
tspan, y0, opções); tempo2 = toc; plotar(t,y,'-o');

GoalKicker.com Notas MATLAB® para profissionais 93

Machine Translated by Google

Capítulo 20: Interpolação com MATLAB

Seção 20.1: Interpolação por partes bidimensional
Inicializamos os dados:

[X,Y] = grade de malha(1:2:10);

Z = X.*cos(Y) - Y.*sin(X);

A superfície se parece com a seguinte.

Agora definimos os pontos onde queremos interpolar:

[Vx,Vy] = grade de malha(1:0,25:10);

Agora podemos realizar a interpolação mais próxima,

Vz = interp2(X,Y,Z,Vx,Vy,'mais próximo');

GoalKicker.com Notas MATLAB® para profissionais 94

Machine Translated by Google

interpolação linear,

Vz = interp2(X,Y,Z,Vx,Vy,'linear');

interpolação cúbica

Vz = interp2(X,Y,Z,Vx,Vy,'cúbico');

GoalKicker.com Notas MATLAB® para profissionais 95

Machine Translated by Google

ou interpolação spline:

Vz = interp2(X,Y,Z,Vx,Vy,'spline');

Seção 20.2: Interpolação por partes unidimensional

Usaremos os seguintes dados:

x = 1:5:50; y
= randi([-10 10],1,10);

GoalKicker.com Notas MATLAB® para profissionais 96

Machine Translated by Google

Assim, xey são as coordenadas dos pontos de dados e z são os pontos sobre os quais precisamos de informações .

z = 0:0,25:50;

Uma maneira de encontrar os valores y de z é a interpolação linear por partes.

z_y = interp1(x,y,z,'linear');

GoalKicker.com Notas MATLAB® para profissionais 97

Machine Translated by Google

Assim, calcula-se a linha entre dois pontos adjacentes e obtém-se z_y assumindo que o ponto seria um elemento dessas linhas.

interp1 também oferece outras opções, como interpolação mais próxima,

z_y = interp1(x,y,z, 'mais próximo');

próxima interpolação,

z_y = interp1(x,y,z, 'próximo');

GoalKicker.com Notas MATLAB® para profissionais 98

Machine Translated by Google

interpolação anterior,

z_y = interp1(x,y,z, 'anterior');

Interpolação cúbica por partes que preserva a forma,

z_y = interp1(x,y,z, 'pcchip');

GoalKicker.com Notas MATLAB® para profissionais 99

Machine Translated by Google

convolução cúbica, z_y = interp1(x,y,z, 'v5cubic');

e interpolação spline

z_y = interp1(x,y,z, 'spline');

GoalKicker.com Notas MATLAB® para profissionais 100

Machine Translated by Google

Aqui estão as interpolações constantes por partes da interpolação mais próxima, seguinte e anterior.

Seção 20.3: Interpolação polinomial

Inicializamos os dados que queremos interpolar:

x = 0:0,5:10; y
= pecado(x/2);

Isso significa que a função subjacente para os dados no intervalo [0,10] é senoidal. Agora os coeficientes dos polinômios aproximados
estão sendo calculados:

p1 = polifit(x,y,1); p2 =
polifit(x,y,2); p3 =
polifit(x,y,3); p5 =
polifit(x,y,5); p10 =
polifit(x,y,10);

Assim, x é o valor x e y é o valor y de nossos pontos de dados e o terceiro número é a ordem/grau do polinômio. Agora definimos a
grade na qual queremos calcular nossa função de interpolação:

zx = 0:0,1:10;

e calcule os valores de y:

zy1 = polival(p1,zx); zy2 =

polival(p2,zx); zy3 =
polival(p3,zx); zy5 =
polival(p5,zx); zy10 =
polival(p10,zx);

Pode-se ver que o erro de aproximação da amostra diminui à medida que o grau do polinômio aumenta.

GoalKicker.com Notas MATLAB® para profissionais 101

Machine Translated by Google

Embora a aproximação da linha reta neste exemplo tenha erros maiores, o polinômio de ordem 3 aproxima a função sinusal neste intervalo
relativamente bem.

A interpolação com polinômios de ordem 5 e ordem 10 quase não apresenta erro de aproximação.

No entanto, se considerarmos o desempenho fora da amostra, vemos que pedidos muito altos tendem a se ajustar demais e, portanto, têm um
desempenho ruim fora da amostra. Montamos

GoalKicker.com Notas MATLAB® para profissionais 102

Machine Translated by Google

zx = -10:0,1:40; p10 =
polifit(X,Y,10); p20 = polifit(X,Y,20);

zy10 = polival(p10,zx); zy20 =

polival(p20,zx);

Se dermos uma olhada no gráfico, veremos que o desempenho fora da amostra é melhor para a ordem 1

e continua piorando com o aumento do grau.

GoalKicker.com Notas MATLAB® para profissionais 103

Machine Translated by Google

GoalKicker.com Notas MATLAB® para profissionais 104

Machine Translated by Google

Capítulo 21: Integração

Seção 21.1: Integral, integral2, integral3
Unidimensional

Para integrar uma função unidimensional

f = @(x) sin(x).^3 + 1;

dentro do alcance

xmín = 2;
xmáx = 8;

pode-se chamar a função

q = integral(f,xmin,xmax);

também é possível definir limites para erros relativos e absolutos

q = integral(f,xmin,xmax, 'RelTol',10e-6, 'AbsTol',10-4);

Bidimensional

Se alguém quiser integrar uma função bidimensional

f = @(x,y) sin(x).^y ;

dentro do alcance

xmín = 2;
xmáx = 8;
ymin = 1;
ymáx = 4;

alguém chama a função

q = integral2(f,xmin,xmax,ymin,ymax);

Como no outro caso é possível limitar as tolerâncias

q = integral2(f,xmin,xmax,ymin,ymax, 'RelTol',10e-6, 'AbsTol',10-4);

Tridimensional

Integrando uma função tridimensional

f = @(x,y,z) sin(x).^y - cos(z) ;

dentro do alcance

xmín = 2;
xmáx = 8;

GoalKicker.com Notas MATLAB® para profissionais 105

Machine Translated by Google

ymin = 1;
ymáx = 4;
zmin = 6;
zmáx = 13;

é realizado ligando

q = integral3(f,xmin,xmax,ymin,ymax, zmin, zmax);

Novamente é possível limitar as tolerâncias

q = integral3(f,xmin,xmax,ymin,ymax, zmin, zmax, 'RelTol',10e-6, 'AbsTol',10-4);

GoalKicker.com Notas MATLAB® para profissionais 106

Machine Translated by Google

Capítulo 22: Lendo arquivos grandes

Seção 22.1: verificação de texto

Suponha que você formatou dados em um grande arquivo de texto ou string, por exemplo

Dados, 16/09/2015,15:41:52;781.780,000000,0,0034,2,2345
Dados, 16/09/2015,15:41:52;791.790,000000,0,1255,96,5948
Dados, 16/09/2015,15:41:52;801.800,000000,1,5123,0,0043

pode-se usar o textscan para ler isso bem rápido. Para fazer isso, obtenha um identificador de arquivo do arquivo de texto com fopen:

fid = fopen('caminho/para/meuarquivo');

Suponha que para os dados deste exemplo, queremos ignorar a primeira coluna "Dados", ler a data e a hora como strings,
e leia o resto das colunas como duplas, ou seja

Dados , 16/09/2015 , 15:41:52;801 , sequência 800.000000 , 1,5123 , 0,0043

ignorar corda duplo duplo dobro

Para fazer isso, ligue:

dados = textscan(fid,'%*s %s %s %f %f %f','Delimitador',',');

O asterisco em %*s significa "ignorar esta coluna". %s significa "interpretar como uma string". %f significa "interpretar como duplo
(flutua)". Finalmente, 'Delimitador',',' afirma que todas as vírgulas devem ser interpretadas como o delimitador entre cada
coluna.

Resumindo:

fid = fopen('caminho/para/meuarquivo');
dados = textscan(fid,'%*s %s %s %f %f %f','Delimitador',',');

data agora contém uma matriz de células com cada coluna em uma célula.

Seção 22.2: Strings de data e hora para array numérico rapidamente

A conversão de strings de data e hora em matrizes numéricas pode ser feita com datenum, embora possa levar até metade
o momento de ler um grande arquivo de dados.

Considere os dados no exemplo Textscan. Usando, novamente, textscan e interpretando data e hora como números inteiros, eles podem

ser rapidamente convertido em uma matriz numérica.

Ou seja, uma linha nos dados de exemplo seria interpretada como:

Dados , 2015 - 09 - 16 , 15:41:52 ; _ _ _ _ 801 ignorar duplo , 800.000000 , 1,5123 0,0043

,
duplo duplo duplo duplo duplo duplo duplo dobro dobro

que será lido como:

fid = fopen('caminho/para/meuarquivo');
dados = textscan(fid,'%*s %f %f %f %f %f %f %f %f %f % f','Delimitador',',-:;');
fclose(fid);

GoalKicker.com Notas MATLAB® para profissionais 107

Machine Translated by Google

Agora:

y = dados{1}; m = % ano
dados{2}; d = % mês
dados{3}; % dia
H = dados{4}; % horas
M = dados{5}; % minutos
S = dados{6}; % segundos
F = dados{7}; % milissegundos

% Tradução de mês para dias

ms = [0,31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];

n = comprimento(y); % Número de elementos

Tempo = zeros(n,1); % Declara matriz numérica de tempo

% Algoritmo para calcular matriz numérica de tempo

para k = 1:n
Tempo(k) = y(k)*365 + ms(m(k)) + d(k) + piso(y(k)/4)...
- piso(y(k)/100) + piso(y(k)/400) + (mod(y(k),4)~=0)...
- (mod(y(k),100)~=0) + (mod(y(k),400)~=0)...
+ (H(k)*3600 + M(k)*60 + S(k) + F(k)/1000)/86400 + 1;
fim

Usar datenum em 566.678 elementos exigiu 6,626570 segundos, enquanto o método acima exigiu 0,048334
segundos, ou seja, 0,73% do tempo para datenum ou ~137 vezes mais rápido.

GoalKicker.com Notas MATLAB® para profissionais 108

Machine Translated by Google

Capítulo 23: Uso de `accumarray()`

Função
Parâmetro Detalhes
subscriptArray Matriz subscrita, especificada como um vetor de índices, matriz de índices ou matriz de células de vetores de índice. valoresArray

Dados, especificados como um vetor ou escalar. sizeOfOutput

Tamanho do array de saída, especificado como um vetor de números inteiros positivos.

funcHandle Função a ser aplicada a cada conjunto de itens durante a agregação, especificada como um identificador de função ou [].

preencherVal Valor de preenchimento, para quando subs não faz referência a cada elemento na saída.
é esparso A saída deve ser uma matriz esparsa?

accumarray permite agregar itens de um array de várias maneiras, potencialmente aplicando alguma função aos itens no processo. accumarray
pode ser considerado um redutor leve (veja também: Introdução ao MapReduce).

Este tópico conterá cenários comuns onde o accumarray é especialmente útil.

Seção 23.1: Aplicar filtro a patches de imagem e definir cada

pixel como a média do resultado de cada patch
Muitos algoritmos modernos de processamento de imagens usam patches como seu elemento básico para trabalhar.
Por exemplo, pode-se eliminar o ruído dos patches (consulte Algoritmo BM3D).

Porém, ao construir a imagem a partir dos patches processados, temos muitos resultados para o mesmo pixel.
Uma maneira de lidar com isso é calcular a média (média empírica) de todos os valores do mesmo pixel.

O código a seguir mostra como dividir uma imagem em patches e reconstruí-la a partir de patches usando a média usando [accumarray()][1]:

numLinhas = 5;
numCols = 5;

numRowsPatch = 3;
numColsPatch = 3;

% A imagem
mI = rand([numRows, numCols]);

% Decompondo em Patches - Cada pixel faz parte de muitos patches (negligenciando% dos limites,
cada pixel faz parte de patches (numRowsPatch * numColsPatch)). mY = ImageToColumnsSliding(mI,
[numRowsPatch, numColsPatch]);

% Aqui seria aplicada alguma operação que funciona em patches

% Criando imagem do índice de cada pixel mPxIdx =

reshape(1:(numRows * numCols), [numRows, numCols]);

% Criando patches dos mesmos índices mSubsAccu

= ImageToColumnsSliding(mPxIdx, [numRowsPatch, numColsPatch]);

% Reconstrua a imagem - Opção A mO =

accumarray(mSubsAccu(:), mY(:)) ./ accumarray(mSubsAccu(:), 1);

% Reconstrua a imagem - Opção B mO =

accumarray(mSubsAccu, mY(:), [(numRows * numCols), 1], @(x) mean(x));

GoalKicker.com Notas MATLAB® para profissionais 109

Machine Translated by Google

% Remodelar o vetor na imagem mO = reshape(mO,

[numRows, numCols]);

Seção 23.2: Encontrando o valor máximo entre elementos

agrupados por outro vetor
Este é um exemplo oficial do MATLAB

Considere o seguinte código:

mês = [1;1;2;3;8;1;3;4;9;11;9;12;3;4;11]; temperatura =

[57;61;60;62;45;59;64;66;40;56;38;65;61;64;55]; maxTemp = accumarray(mês,temperatura,
[],@max);

A imagem abaixo demonstra o processo de cálculo feito pelo accumarray neste caso:

Neste exemplo, todos os valores que possuem o mesmo mês são coletados primeiro e, em seguida, a função especificada pela 4ª entrada para
accumarray (neste caso, @max) é aplicada a cada conjunto.

GoalKicker.com Notas MATLAB® para profissionais 110

Machine Translated by Google

Capítulo 24: Introdução à API MEX Seção 24.1:

Verifique o número de entradas/saídas em um arquivo
C++ MEX
Neste exemplo escreveremos um programa básico que verifica o número de entradas e saídas passadas para uma função MEX.

Como ponto de partida, precisamos criar um arquivo C++ implementando o "gateway MEX". Esta é a função executada quando o
arquivo é chamado do MATLAB.

testinputs.cpp
// MathWorks forneceu arquivo de cabeçalho
#include "mex.h"

// função de gateway void

mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {

//Esta função irá erro se o número de entradas não for 3 ou 4

//Esta função irá erro se o número de saídas for maior que 1

// Verifica as entradas:
if (nrhs < 3 || nrhs > 4)
{ mexErrMsgIdAndTxt("Testinputs:ErrorIdIn",
"Número inválido de entradas para arquivo MEX.");
}

// Verifica as saídas: if
(nlhs > 1)
{ mexErrMsgIdAndTxt("Testinputs:ErrorIdOut",
"Número inválido de saídas para arquivo MEX.");
}
}

Primeiro, incluímos o cabeçalho mex.h que contém definições de todas as funções e tipos de dados necessários para trabalhar com a
API MEX. Em seguida, implementamos a função mexFunction conforme mostrado, onde sua assinatura não deve mudar, independente
das entradas/saídas realmente utilizadas. Os parâmetros da função são os seguintes:

nlhs: Número de saídas solicitadas. *plhs[]:

Array contendo todas as saídas no formato MEX API. nrhs: Número de
entradas passadas. *prhs[]: Array
contendo todas as entradas no formato MEX API.

A seguir, verificamos o número de argumentos de entradas/saídas e, se a validação falhar, um erro é gerado usando a função
mexErrMsgIdAndTxt (ela espera algum nome: identificador de formato iD , um simples "ID" não funcionará).

Depois que o arquivo for compilado como mex testinputs.cpp, a função pode ser chamada no MATLAB como:

>> entradas de teste (2,3)

Erro ao usar entradas de teste. Número inválido de entradas para arquivo MEX.

>> entradas de teste (2,3,5)

>> [~,~] = entradas de teste(2,3,3)

Erro ao usar entradas de teste. Número inválido de saídas para arquivo MEX.

GoalKicker.com Notas MATLAB® para profissionais 111

Machine Translated by Google

Seção 24.2: Insira uma string, modifique-a em C e produza-a

Neste exemplo, ilustramos a manipulação de strings no MATLAB MEX. Criaremos uma função MEX que aceita uma string como entrada do MATLAB,
copiaremos os dados para a string C, modificaremos e converteremos de volta para mxArray retornado ao lado do MATLAB.

O objetivo principal deste exemplo é mostrar como strings podem ser convertidas para C/C++ a partir do MATLAB e vice-versa.

stringIO.cpp

#include "mex.h"
#include <cstring>

void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {

// verifica o número de argumentos if

(nrhs != 1 || nlhs > 1) {
mexErrMsgIdAndTxt("StringIO:WrongNumArgs", "Número errado de argumentos.");
}

// verifica se a entrada é uma string if

(mxIsChar(prhs[0])) {
mexErrMsgIdAndTxt("StringIO:TypeError", "A entrada não é uma string");
}

// copia dados de caracteres de mxArray para uma string estilo C (terminada em nulo) char *str =
mxArrayToString(prhs[0]);

//manipule a string de alguma forma if

(strcmp("theOneString", str) == 0) {
str[0] = 'T'; // coloca a primeira letra em maiúscula } else
{ str[0] =
' '; // fazer outra coisa?
}

// retorna a nova string modificada plhs[0] =

mxCreateString(str);

// libera memória alocada

mxFree(str);
}

As funções relevantes neste exemplo são:

mxIsChar para testar se um mxArray é do tipo mxCHAR .

mxArrayToString para copiar os dados de uma string mxArray para um buffer char * .
mxCreateString para criar uma string mxArray a partir de um char*.

Como observação lateral, se você deseja apenas ler a string, e não modificá-la, lembre-se de declará-la como const char* para velocidade e robustez.

Finalmente, uma vez compilado, podemos chamá-lo no MATLAB como:

>> mex stringIO.cpp

>> strOut = stringIO('theOneString') strOut =

TheOneString

>> strOut = stringIO('alguma coisa')

GoalKicker.com Notas MATLAB® para profissionais 112

Machine Translated by Google

strOut=
alguma coisa

Seção 24.3: Passando uma estrutura por nomes de campo

Este exemplo ilustra como ler entradas de estrutura de vários tipos do MATLAB e passá-las para variáveis de tipo equivalente em C.

Embora seja possível e fácil descobrir a partir do exemplo como carregar campos por números, aqui isso é conseguido comparando os nomes dos campos com

strings. Assim, os campos struct podem ser endereçados por seus nomes de campo e as variáveis nele contidas podem ser lidas por C.

structIn.c

#include "mex.h"
#include <string.h> // strcmp

void mexFunction (int nlhs, mxArray *plhs[],

int nrhs, const mxArray *prhs[])
{
// ajudantes
double* double_ptr; não
assinado int i; // variável de loop

// variáveis a serem lidas bool

ideal; int
randomseed; não
assinado int desejadoNodes;

if (!mxIsStruct(prhs[0])) {
mexErrMsgTxt("O primeiro argumento deve ser uma estrutura de parâmetro!");

} for (i=0; i<mxGetNumberOfFields(prhs[0]); i++) {

if (0==strcmp(mxGetFieldNameByNumber(prhs[0],i),"randomseed")) {
mxArray *p = mxGetFieldByNumber(prhs[0],0,i); randomseed
= *mxGetPr(p);

} if (0==strcmp(mxGetFieldNameByNumber(prhs[0],i),"ótimo")) { mxArray *p =
mxGetFieldByNumber(prhs[0],0,i); ótimo = (bool)*mxGetPr(p);

} if (0==strcmp(mxGetFieldNameByNumber(prhs[0],i),"numNodes")) { mxArray *p =
mxGetFieldByNumber(prhs[0],0,i); desejadoNodes =
*mxGetPr(p);
}
}
}

O loop sobre i percorre todos os campos da estrutura fornecida, enquanto as partes if(0==strcmp) comparam o nome do campo MATLAB com a string fornecida. Se

for uma correspondência, o valor correspondente é extraído para uma variável C.

Seção 24.4: Passe uma matriz 3D do MATLAB para C

Neste exemplo, ilustramos como pegar uma matriz 3D dupla de tipo real do MATLAB e passá-la para um C duplo*
variedade.

Os principais objetivos deste exemplo são mostrar como obter dados de arrays MATLAB MEX e destacar alguns pequenos detalhes no armazenamento e

manuseio de matrizes.

GoalKicker.com Notas MATLAB® para profissionais 113

Machine Translated by Google

matrizIn.cpp
#include "mex.h"

void mexFunction(int nlhs , mxArray *plhs[], int

nrhs, mxArray const *prhs[]){ // verifica a
quantidade de entradas if (nrhs!
=1) {
mexErrMsgIdAndTxt("matrixIn:InvalidInput", "Número inválido de entradas para arquivo MEX.");
}

// verifica o tipo de entrada

if( !mxIsDouble(prhs[0]) || mxIsComplex(prhs[0])){
mexErrMsgIdAndTxt("matrixIn:InvalidType", "A matriz de entrada deve ser uma matriz dupla e não complexa."); }

// extrai os dados double

const * const arrayAux= static_cast<double const *>(mxGetData(prhs[0]));

// Obtém o tamanho da
matriz const mwSize *sizeInputMatrix= mxGetDimensions(prhs[0]);

// aloca array em C. Nota: seu array 1D, não 3D mesmo se nossa entrada for 3D double*
matrixInC= (double*)malloc(sizeInputMatrix[0] *sizeInputMatrix[1] *sizeInputMatrix[2]* sizeof(double) );

// MATLAB é coluna principal, não linha principal (como C). Precisamos reordenar os números //
Basicamente permuta as dimensões

// NOTA: a ordem dos loops é otimizada para acesso mais rápido à memória!
// Isso melhora a velocidade em cerca de 300%

const int tamanho0 = tamanhoInputMatrix[0]; // Const faz com que a otimização do compilador seja ativada
const int size1 = sizeInputMatrix[1]; const int
tamanho2 = tamanhoInputMatrix[2];

for (int j = 0; j < tamanho2; j++) {

int jOffset = j*tamanho0*tamanho1; // isso economiza tempo de recálculo para

(int k = 0; k < size0; k++) {

int kOffset = k*tamanho1; // isso economiza tempo de recálculo para (int

i = 0; i < size1; i++) {

int iOffset = i*tamanho0;

matrizInC[i + jOffset + kOffset] = matrizAux[iOffset + jOffset + k];
}
}
}

// acabamos!

// Use sua matriz C aqui

// libera memória
free(matrixInC);
retornar;
}

Os conceitos relevantes a ter em conta:

GoalKicker.com Notas MATLAB® para profissionais 114

Machine Translated by Google

As matrizes MATLAB são todas 1D na memória, não importa quantas dimensões elas tenham quando usadas no MATLAB.

Isso também é verdadeiro para a maioria (se não todas) das representações de matrizes principais em bibliotecas C/C++, pois permite otimização e
execução mais rápida.

Você precisa copiar explicitamente as matrizes do MATLAB para C em um loop.

As matrizes MATLAB são armazenadas na ordem principal das colunas, como no Fortran, mas C/C++ e a maioria das linguagens modernas são as

principais linhas. É importante permutar a matriz de entrada , caso contrário, os dados parecerão completamente diferentes.

As funções relevantes neste exemplo são:

mxIsDouble verifica se a entrada é do tipo duplo .

mxIsComplex verifica se a entrada é real ou imaginária. mxGetData

retorna um ponteiro para os dados reais na matriz de entrada. NULL se não houver dados reais. mxGetDimensions retorna um

ponteiro para uma matriz mwSize , com o tamanho da dimensão em cada índice.

GoalKicker.com Notas MATLAB® para profissionais 115

Machine Translated by Google

Capítulo 25: Depuração

Parâmetro Detalhes

Nome do arquivo .m (sem extensão), por exemplo, fit. Este parâmetro é (obrigatório) , a menos que você defina tipos de pontos de interrupção
arquivo
condicionais especiais, como dbstop se for erro ou dbstop se naninf.

Número da linha onde o ponto de interrupção deve ser colocado. Se a linha especificada não contiver código executável, o ponto de interrupção será
localização
colocado na primeira linha válida após a especificada.

Qualquer expressão ou combinação delas avaliada como um valor booleano. Exemplos: ind == 1,
expressão
nargin < 4 && isdir('Q:\').

Seção 25.1: Trabalhando com pontos de interrupção

Definição

No desenvolvimento de software, um ponto de interrupção é um local de parada ou pausa intencional em um programa, implementado para fins de

depuração.

De forma mais geral, um ponto de interrupção é um meio de adquirir conhecimento sobre um programa durante sua execução. Durante a interrupção, o

programador inspeciona o ambiente de teste (registros de uso geral, memória, logs, arquivos, etc.) para descobrir se o programa está funcionando conforme

o esperado. Na prática, um ponto de interrupção consiste em uma ou mais condições que determinam quando a execução de um programa deve ser

interrompida.

-Wikipédia

Pontos de interrupção no MATLAB

Motivação

No MATLAB, quando a execução é pausada em um ponto de interrupção, as variáveis existentes no espaço de trabalho atual (também conhecido como escopo) ou em

qualquer um dos espaços de trabalho de chamada podem ser inspecionadas (e geralmente também modificadas).

Tipos de pontos de interrupção

O MATLAB permite aos usuários colocar dois tipos de pontos de interrupção em arquivos .m :

Pontos de interrupção padrão (ou "irrestritos") (mostrados em vermelho) - pausam a execução sempre que a linha marcada é alcançada.

Pontos de interrupção "condicionais" (mostrados em amarelo) - pausa a execução sempre que a linha marcada é alcançada E a condição definida no ponto de

interrupção é avaliada como verdadeira.

Colocando pontos de interrupção

Ambos os tipos de pontos de interrupção podem ser criados de diversas maneiras:

GoalKicker.com Notas MATLAB® para profissionais 116

Machine Translated by Google

Usando a GUI do Editor MATLAB, clicando com o botão direito na linha horizontal ao lado do número da linha.

Usando o comando dbstop :

% Crie um ponto de interrupção irrestrito: dbstop no

arquivo no local
% Crie um ponto de interrupção condicional: dbstop
no arquivo no local if expression

% Exemplos e casos especiais: dbstop

ajustado em 99 % Ponto de interrupção irrestrito padrão.

dbstop em ajuste em 99 if nargin==3 % Ponto de interrupção condicional padrão.

dbstop if error % Este tipo especial de ponto de interrupção não está limitado a um arquivo específico e
% será acionado *sempre* que um erro for encontrado no código "depurável".

dbstop no arquivo % Isto criará um ponto de interrupção irrestrito na primeira linha executável
% de "arquivo".

dbstop if naninf % Este ponto de interrupção especial será acionado sempre que um resultado de cálculo % contiver um NaN (indica uma
divisão por 0) ou um Inf

Usando atalhos de teclado: a tecla padrão para criar um ponto de interrupção padrão no Windows é F12; a chave padrão para pontos de interrupção

condicionais não está definida.

Desativando e reativando pontos de interrupção

Desabilite um ponto de interrupção para ignorá-lo temporariamente: pontos de interrupção desabilitados não pausam a execução. A desativação de um ponto de

interrupção pode ser feita de várias maneiras:

Clique com o botão direito no círculo vermelho/amarelo do ponto de interrupção> Desativar ponto de interrupção.

Clique com o botão esquerdo em um ponto de interrupção condicional (amarelo).

Na guia Editor > Pontos de interrupção > Ativar\Desativar.

Removendo pontos de interrupção

Todos os pontos de interrupção permanecem em um arquivo até serem removidos, manual ou automaticamente. Os pontos de interrupção são

apagados automaticamente ao encerrar a sessão MATLAB (ou seja, encerrar o programa). A limpeza manual dos pontos de interrupção é feita de uma das

seguintes maneiras:

Usando o dbclear comando:

dbclear tudo
dbclear no arquivo
dbclear no arquivo no local dbclear if
condição

Clicar com o botão esquerdo em um ícone de ponto de interrupção padrão ou em um ícone de ponto de interrupção condicional desabilitado.

Clique com o botão direito em qualquer ponto de interrupção> Limpar ponto de interrupção.

Na guia Editor > Pontos de interrupção > Limpar tudo.

Nas versões anteriores ao R2015b do MATLAB, usando o comando clear.

Retomando a Execução

GoalKicker.com Notas MATLAB® para profissionais 117

Machine Translated by Google

Quando a execução é pausada em um ponto de interrupção, existem duas maneiras de continuar a execução do programa:

Execute a linha atual e faça uma pausa novamente antes da próxima linha.

F10 1 no Editor, dbstep na janela de comando, "Step" em Ribbon > Editor > DEBUG.

Executar até o próximo breakpoint (se não houver mais breakpoints, a execução prossegue até o final do programa).

F12 1 no Editor, dbcont na Janela de Comando, "Continuar" na Faixa de Opções > Editor > DEBUG.

1 – padrão no Windows.

Seção 25.2: Depurando código Java invocado pelo MATLAB

Visão geral

Para depurar classes Java que são chamadas durante a execução do MATLAB, é necessário realizar duas etapas:

1. Execute o MATLAB no modo de depuração JVM.

2. Anexe um depurador Java ao processo MATLAB.

Quando o MATLAB é iniciado no modo de depuração JVM, a seguinte mensagem aparece na janela de comando:

A JVM está sendo iniciada com a depuração habilitada.

Use "jdb -connect com.sun.jdi.SocketAttach:port=4444" para anexar o depurador.

Fim do MATLAB
Janelas:

Crie um atalho para o executável MATLAB (matlab.exe) e adicione o sinalizador -jdb no final, conforme mostrado abaixo:

GoalKicker.com Notas MATLAB® para profissionais 118

Machine Translated by Google

Ao executar o MATLAB usando este atalho, a depuração da JVM será habilitada.

Alternativamente, o arquivo java.opts pode ser criado/atualizado. Este arquivo é armazenado em "matlab-root\bin\arch", onde "matlab-root" é o diretório de
instalação do MATLAB e "arch" é a arquitetura (por exemplo, "win32").

O seguinte deve ser adicionado ao arquivo:

-Xdebug
-Xrunjdwp:transport=dt_socket,endereço=1044,servidor=y,suspender=n

Fim do depurador
eu entendo a ideia

Anexar este depurador requer a criação de uma configuração de "depuração remota" com a porta exposta por
MATLAB:

GoalKicker.com Notas MATLAB® para profissionais 119

Machine Translated by Google

Então o depurador é iniciado:

Se tudo estiver funcionando conforme o esperado, a seguinte mensagem aparecerá no console:

GoalKicker.com Notas MATLAB® para profissionais 120

Machine Translated by Google

Capítulo 26: Desempenho e

avaliação comparativa
Seção 26.1: Identificando gargalos de desempenho usando
o Profiler
O perfilador MATLAB é uma ferramenta para criação de perfil de software do código MATLAB. Utilizando o Profiler é possível obter uma
representação visual tanto do tempo de execução quanto do consumo de memória.

A execução do Profiler pode ser feita de duas maneiras:

Clicar no botão "Run and Time" na GUI do MATLAB enquanto tem algum arquivo .m aberto no editor (adicionado em R2012b).

Programaticamente, usando:

perfil ativado
<algum código que queremos testar> perfil
desativado

Abaixo está um exemplo de código e o resultado de seu perfil:

função docTest

para ind1 = 1:100 [~] =

var(... sum(...
randn(1000)));

fim

espião

GoalKicker.com Notas MATLAB® para profissionais 121

Machine Translated by Google

Com o exposto, aprendemos que a função espiã leva cerca de 25% do tempo total de execução. No caso do "código real", uma função que
ocupa uma porcentagem tão grande de tempo de execução seria uma boa candidata para otimização, ao contrário de funções análogas a var e cla
cuja otimização deve ser evitada.

Além disso, é possível clicar nas entradas da coluna Nome da Função para ver um detalhamento do tempo de execução dessa entrada. Aqui
está o exemplo de clicar em espião:

GoalKicker.com Notas MATLAB® para profissionais 122

Machine Translated by Google

Também é possível traçar o perfil do consumo de memória executando profile('-memory') antes de executar o Profiler.

GoalKicker.com Notas MATLAB® para profissionais 123

Machine Translated by Google

Seção 26.2: Comparando o tempo de execução de múltiplas funções

A combinação amplamente utilizada de tique e toc pode fornecer uma ideia aproximada do tempo de execução de uma função ou trechos de
código.

Para comparar várias funções não deve ser usado. Por que? É quase impossível fornecer condições iguais para todos os trechos de código
serem comparados em um script usando a solução acima. Talvez as funções compartilhem o mesmo espaço funcional e variáveis comuns, então
funções chamadas posteriormente e trechos de código já aproveitam variáveis e funções previamente inicializadas. Além disso, não há como saber
se o compilador JIT lidaria igualmente com esses trechos chamados posteriormente.

A função dedicada para benchmarks é timeit. O exemplo a seguir ilustra seu uso.

Existem o array A e a matriz B. Deve-se determinar qual linha de B é mais semelhante a A contando o número de elementos diferentes.

função t = bancada()
UMA = [0 1 1 0 0]; 1
B = permissões(A);

% funções para comparar

fcns =
{ @() compare1(A,B);
@() comparar2(A,B);
@() comparar3(A,B);

GoalKicker.com Notas MATLAB® para profissionais 124

Machine Translated by Google

@() comparar4(A,B);
};

% do meu tempo

t = cellfun(@timeit, fcns);
fim

função Z = comparar1(A,B)
Z = soma( bsxfun(@eq, A,B) , 2);
fim
função Z = comparar2(A,B)
Z = soma(bsxfun(@xor, A, B),2);
fim
função Z = comparar3(A,B)
UMA = lógico(A);
Z = soma(B(:,~A),2) + soma(~B(:,A),2);
fim
função Z = comparar4(A,B)
Z = pdist2( A, B, 'hamming', 'Menor', 1 );
fim

Essa forma de benchmark foi vista pela primeira vez nesta resposta.

Seção 26.3: A importância da pré-alocação

Arrays no MATLAB são mantidos como blocos contínuos na memória, alocados e liberados automaticamente pelo MATLAB.
MATLAB esconde operações de gerenciamento de memória, como redimensionamento de um array, por trás de uma sintaxe fácil de usar:

uma = 1:4

uma =

1 2 3 4

a(5) = 10 % ou alternativamente a = [a, 10]

uma =

1 2 3 4 10

É importante entender que o acima não é uma operação trivial, a(5) = 10 fará com que o MATLAB aloque um
novo bloco de memória de tamanho 5, copie os primeiros 4 números e defina o 5º como 10. Isso é um O(numel(a))
operação, e não O(1).

Considere o seguinte:

limpar tudo
n=12345678;
uma=0;
tique
para eu = 2:n
uma(i) = quadrado(a(i-1)) + eu;
fim
toc

O tempo decorrido é 3,004213 segundos.

a é realocado n vezes neste loop (excluindo algumas otimizações realizadas pelo MATLAB)! Observe que o MATLAB fornece

nos um aviso:

GoalKicker.com Notas MATLAB® para profissionais 125

Machine Translated by Google

"A variável 'a' parece mudar de tamanho a cada iteração do loop. Considere pré-alocar para velocidade."

O que acontece quando pré-alocamos?

a=zeros(1,n);
tique
para eu = 2:n
uma(i) = quadrado(a(i-1)) + eu;
fim
toc

O tempo decorrido é 0,410531 segundos.

Podemos ver que o tempo de execução é reduzido em uma ordem de magnitude.

Métodos de pré-alocação:

MATLAB fornece diversas funções para alocação de vetores e matrizes, dependendo dos requisitos específicos

do usuário. Estes incluem: zeros, uns, nan, olho, verdadeiro etc.

uma = zeros(3) % Aloca uma matriz 3 por 3 inicializada em 0

uma =

0 0 0
0 0 0
0 0 0

uma = zeros(3, 2) % Aloca uma matriz 3 por 2 inicializada em 0

uma =

0 0
0 0
0 0

uma = uns(2, 3, 2) % Aloca uma matriz tridimensional (2 por 3 por 2) inicializada como 1
uma(:,:,1) =

1 1 1
1 1 1

uma(:,:,2) =

1 1 1
1 1 1

a = uns(1, 3) * 7 % Aloca um vetor linha de comprimento 3 inicializado em 7

uma =

7 7 7

Um tipo de dados também pode ser especificado:

a = zeros(2, 1, 'uint8'); % aloca um array do tipo uint8

Também é fácil clonar o tamanho de um array existente:

a = uns(3, 4); % a é uma matriz 3 por 4 de 1's

GoalKicker.com Notas MATLAB® para profissionais 126

Machine Translated by Google

b = zeros(tamanho(a)); % b é uma matriz 3 por 4 de 0's

E clone o tipo:

a = uns(3, 4, 'único'); b = zeros(2, % a é uma matriz 3 por 4 do tipo single

'gosto', a); % b é uma matriz 2 por 2 do tipo single

observe que 'curtir' também clona complexidade e dispersão.

A pré-alocação é alcançada implicitamente usando qualquer função que retorne um array com o tamanho final requerido, como rand,
galeria, coroa, bsxdivertido, cólon e muitos outros. Por exemplo, uma maneira comum de alocar vetores com variação linear
elementos é usar o operador dois pontos (com a variante1 de 2 ou 3 operandos):

uma = 1:3
uma =

1 2 3

uma = 2:-3:-4
uma =

2 -1 -4

Matrizes de células podem ser alocadas usando a função cell() da mesma maneira que zeros().

uma = célula (2,3)

uma =

[] [] []
[] [] []

Observe que as matrizes de células funcionam mantendo ponteiros para os locais na memória do conteúdo da célula. Então, todas as dicas de pré-alocação
aplicam-se também aos elementos individuais da matriz de células.

Leitura adicional:

Documentação oficial do MATLAB em "Pré-alocação de memória".

Documentação oficial do MATLAB em "Como o MATLAB aloca memória".

Desempenho de pré-alocação no matlab não documentado.

Compreendendo a pré-alocação de array sobre Loren sobre a arte do MATLAB

Seção 26.4: Não há problema em ser `solteiro`!

Visão geral:

O tipo de dados padrão para matrizes numéricas no MATLAB é duplo. double é uma representação de números em ponto flutuante,
e esse formato ocupa 8 bytes (ou 64 bits) por valor. Em alguns casos, onde, por exemplo, lidar apenas com números inteiros ou quando

a instabilidade numérica não é um problema iminente, tal profundidade de bits elevada pode não ser necessária. Por este motivo, aconselha-se
considerar os benefícios da precisão única (ou outros tipos apropriados ):

Tempo de execução mais rápido (especialmente perceptível em GPUs).

Metade do consumo de memória: pode ter sucesso onde o dobro falha devido a um erro de falta de memória; mais
compacto ao armazenar como arquivos.

A conversão de uma variável de qualquer tipo de dados suportado para único é feita usando:

GoalKicker.com Notas MATLAB® para profissionais 127

Machine Translated by Google

sing_var = único(var);

Algumas funções comumente usadas (como: zeros, olho, uns, etc.) que geram valores duplos por padrão, permitem
especificando o tipo/classe da saída.

Convertendo variáveis em um script para uma precisão/tipo/classe não padrão:

Em julho de 2016, não existia nenhuma maneira documentada de alterar o tipo de dados padrão do MATLAB de duplo.

No MATLAB, novas variáveis geralmente imitam os tipos de dados das variáveis usadas ao criá-las. Para ilustrar isso,
considere o seguinte exemplo:

A = magia(3);
B = diag(A);
C = 20*B;
>> quem é C
Nome Tamanho Bytes Classe 24 Atributos
C 3x1 duplo

A = único(mágica(3)); % A é convertido para "único"

B = diag(A);
C = B*duplo(20); % Prevalece o tipo mais rigoroso, que neste caso é “único”
D = único(tamanho(C)); % Geralmente é aconselhável converter explicitamente para o tipo desejado.
>> quem é C
Nome Bytes Classe 12 Atributos
C Tamanho 3x1 único

Assim, pode parecer suficiente lançar/converter diversas variáveis iniciais para que a mudança permeie todo o processo.
código - no entanto, isso é desencorajado (veja Advertências e Armadilhas abaixo).

Advertências e armadilhas:

1. Conversões repetidas são desencorajadas devido à introdução de ruído numérico (ao transmitir de um único
para duplo) ou perda de informações (ao converter de duplo para único ou entre certos tipos inteiros), por exemplo
:

duplo(único(1,2)) == duplo(1,2)
anos =
0

Isso pode ser mitigado um pouco usando typecast. Consulte também Esteja ciente da imprecisão do ponto flutuante.

2. Baseando-se apenas na digitação implícita de dados (ou seja, o que o MATLAB adivinha o tipo de saída de uma computação
deveria ser) é desencorajado devido a vários efeitos indesejados que podem surgir:

Perda de informação: quando se espera um resultado duplo , mas uma combinação descuidada de simples e duplo
operandos produzem precisão única .

Consumo de memória inesperadamente alto: quando um único resultado é esperado, mas um cálculo descuidado
resulta em uma saída dupla .

Sobrecarga desnecessária ao trabalhar com GPUs: ao misturar tipos gpuArray (ou seja, variáveis armazenadas em
VRAM) com variáveis não gpuArray (ou seja, aquelas normalmente armazenadas em RAM), os dados terão que ser
transferido de uma forma ou de outra antes que o cálculo possa ser executado. Esta operação demora
tempo e pode ser muito perceptível em cálculos repetitivos.

GoalKicker.com Notas MATLAB® para profissionais 128

Machine Translated by Google

Erros ao misturar tipos de ponto flutuante com tipos inteiros: funções como mtimes (*) não são definidos para entradas mistas de tipos inteiros e

de ponto flutuante - e causarão erros. Funciona como tempos (.*) não são definidos para entradas do tipo inteiro - e ocorrerão novamente

erros.

>> uns(3,3,'int32')*uns(3,3,'int32')
Erro ao usar *
MTIMES não é totalmente suportado para classes inteiras. Pelo menos uma entrada deve ser escalar.

>> uns(3,3,'int32').*ones(3,3,'duplo')
Erro ao usar .*
Números inteiros só podem ser combinados com números inteiros da mesma classe ou duplos escalares.

Para melhor legibilidade do código e redução do risco de tipos indesejados, é aconselhável uma abordagem defensiva, onde as variáveis são

explicitamente convertidas para o tipo desejado.

Veja também:

Documentação MATLAB: Números de ponto flutuante.

Artigo Técnico da MathWorks: Melhores Práticas para Converter Código MATLAB em Ponto Fixo.

GoalKicker.com Notas MATLAB® para profissionais 129

Machine Translated by Google

Capítulo 27: Multithreading

Seção 27.1: Usando parfor para paralelizar um loop
Você pode usar parfor para executar as iterações de um loop em paralelo:

Exemplo:

poolobj = parpool(2); % Abra um pool paralelo com 2 trabalhadores

s = 0; % Executando alguns cálculos paralelos

parfor i=0:9
s = s + 1;
fim
dispensa(s) % Saídas '10'

excluir(poolobj); % Fechar o pool paralelo

Nota: parfor não pode ser aninhado diretamente. Para aninhamento de parfor , use uma função no primeiro parfor e adicione o segundo parfor em
essa função.

Exemplo:

parfor i = 1:n
[op] = fun_name(ip);
fim

função [op] = fun_name(ip)

parfor j = 1: comprimento (ip)
% Alguma computação
fim

Seção 27.2: Execução de comandos em paralelo usando um "Single

Instrução Programa, Dados Múltiplos" (SPMD)
Ao contrário de um loop for paralelo (parfor), que pega as iterações de um loop e as distribui entre vários
threads, um único programa, instrução de múltiplos dados (spmd) pega uma série de comandos e os distribui para todos
os threads, para que cada thread execute o comando e armazene os resultados. Considere isto:

poolobj = parpool(2); % abre um pool paralelo com dois trabalhadores

spmd
q = rand(3); % cada thread gera um array 3x3 exclusivo de números aleatórios
fim

q{1} % q é chamado como um vetor de célula

q{2} % os valores armazenados em cada thread podem ser acessados pelo seu índice

delete(poolobj) % se o pool estiver fechado, os dados em q não estarão mais acessíveis

É importante notar que cada thread pode ser acessada durante o bloco spmd pelo seu índice de thread (também chamado de lab
índice ou labindex):

poolobj = parpool(2); % abre um pool paralelo com dois trabalhadores

spmd

GoalKicker.com Notas MATLAB® para profissionais 130

Machine Translated by Google

q = rand(labíndice + 1); % cada thread gera um array exclusivo de números aleatórios

fim

tamanho(q{1}) % o tamanho de q{1} é 2x2 % o

tamanho(q{2}) tamanho de q{2} é 3x3

excluir(poolobj) % q não está mais acessível

Em ambos os exemplos, q é um objeto composto, que pode ser inicializado com o comando q = Composite(). É importante observar que os
objetos compostos só são acessíveis enquanto o pool está em execução.

Seção 27.3: Usando o comando batch para fazer

vários cálculos em paralelo
Para usar multi-threading no MATLAB pode-se usar o comando batch . Observe que você deve ter a caixa de ferramentas Parallel
Computing instalada.

Para um script demorado, por exemplo,

para ii=1:1e8
A(ii)=sen(ii*2*pi/1e8); fim

para executá-lo em modo batch, usaria o seguinte:

trabalho=lote("da")

que permite que o MATLAB seja executado em modo lote e, entretanto, torna possível usar o MATLAB para fazer outras coisas, como adicionar mais
processos em lote.

Para recuperar os resultados após terminar o trabalho e carregar o array A no espaço de trabalho:

carregar(trabalho, 'A')

Por fim, abra o "monitor job gui" em Home ÿ Environment ÿ Parallel ÿ Monitor jobs e exclua o trabalho por meio de:

excluir (trabalho)

Para carregar uma função para processamento em lote, basta usar esta instrução onde fcn é o nome da função, N é o número de arrays de saída
e x1, ..., xn são arrays de entrada:

j = lote (fcn, N, {x1, x2, ..., xn})

Seção 27.4: Quando usar parfor

Basicamente, parfor é recomendado em dois casos: muitas iterações em seu loop (ou seja, como 1e10), ou se cada iteração levar muito tempo
(por exemplo, eig(magic(1e4))). No segundo caso, você pode querer considerar o uso do spmd . A

razão pela qual parfor é mais lento que um for loop para intervalos curtos ou iterações rápidas é a sobrecarga necessária para gerenciar todos
os trabalhadores corretamente, em vez de apenas fazer o cálculo.

Além disso, muitas funções possuem multi-threading implícito integrado, tornando um loop parfor não mais eficiente, ao usar essas funções, do que
um loop for serial , uma vez que todos os núcleos já estão sendo usados. parfor será realmente um prejuízo neste caso, pois possui sobrecarga de
alocação, embora seja tão paralelo quanto a função que você está tentando usar.

GoalKicker.com Notas MATLAB® para profissionais 131

Machine Translated by Google

Considere o exemplo a seguir para ver o comportamento de for em oposição ao de parfor. Primeiro abra o pool paralelo, caso
ainda não tenha feito isso:

PGC; % Abre um pool paralelo usando suas configurações atuais

Em seguida, execute alguns loops grandes:

n = 1000; % Número de iteração

Valores próprios = célula(n,1); % Prepare-se para armazenar os dados
Tempo = zeros(n,1);
para ii = 1:n tic

EigenValues{ii,1} = eig(magic(1e3)); % Pode querer diminuir a magia se demorar muito

Tempo(ii,1) = toc; % Tempo de coleta após o término de cada iteração

figura; % Crie um gráfico de resultados

plot(1:n,t) title
'Tempo por iteração' ylabel 'Tempo
[s]' xlabel 'Número da
iteração[-]';

Então faça o mesmo com parfor em vez de for. Você notará que o tempo médio por iteração aumenta. No entanto, perceba que o
parfor usou todos os trabalhadores disponíveis, portanto o tempo total (soma(Tempo)) deve ser dividido pelo número de
núcleos no seu computador.

Portanto, embora o tempo para fazer cada iteração separada aumente usando parfor em relação ao uso de for, o tempo total diminui
consideravelmente.

GoalKicker.com Notas MATLAB® para profissionais 132

Machine Translated by Google

Capítulo 28: Usando portas seriais

Parâmetro de porta serial o que faz

Taxa de transmissão
Define a taxa de transmissão. O mais comum hoje é 57.600, mas 4.800, 9.600 e 115.200 também são vistos
com frequência. O número

de bytes mantidos na memória. O MATLAB possui um FIFO, o que significa que novos bytes serão descartados.
TamanhoBuffer de entrada O padrão é 512 bytes, mas pode ser facilmente definido para 20 MB sem problemas.
Existem apenas alguns casos extremos em que o usuário gostaria que isso fosse pequeno O
Bytes disponíveis número de bytes aguardando para serem lidos O
ValoresEnviados número de bytes enviados desde que a porta foi aberta O número
ValoresRecebidos de bytes lidos desde que a porta foi aberta Especifique a função de

retorno de chamada a ser executada quando um número especificado de bytes está disponível no buffer de
BytesDisponíveisFcn
entrada ou um terminador é lido Especifique o

número de bytes que devem estar disponíveis no buffer de entrada para gerar um evento
BytesAvailableFcnCount bytes-
available Especifique se o evento

bytes-available será gerado após um número especificado de bytes está disponível no buffer de entrada ou
BytesDisponíveisFcnMode
após a leitura de um terminador

As portas seriais são uma interface comum para comunicação com sensores externos ou sistemas embarcados, como Arduinos. As
comunicações seriais modernas são frequentemente implementadas por meio de conexões USB usando adaptadores seriais USB.
MATLAB fornece funções integradas para comunicações seriais, incluindo protocolos RS-232 e RS-485. Essas funções podem ser usadas
para portas seriais de hardware ou conexões seriais USB "virtuais". Os exemplos aqui ilustram comunicações seriais no MATLAB.

Seção 28.1: Criando uma porta serial no Mac/Linux/Windows

% Definir porta serial com taxa de transmissão de 115200
taxa = 115200; if
ispc s =
serial('COM1', 'BaudRate',taxa);
elseif ismac
% Observe que no OSX o dispositivo serial é enumerado exclusivamente. Você % terá
que olhar /dev/tty.* para descobrir a assinatura exata do seu % dispositivo serial s =
serial('/dev/
tty.usbserial-A104VFT7', 'BaudRate',rate); elseif isunix

s = serial('/dev/ttyusb0', 'BaudRate',taxa);
fim

% Defina o tamanho do buffer de entrada para 1.000.000 bytes (padrão: 512 bytes).
s.InputBufferSize = 1000000;

% Porta serial aberta

fopen(s);

Seção 28.2: Escolhendo seu modo de comunicação

MATLAB suporta comunicação síncrona e assíncrona com uma porta serial. É importante escolher o modo de comunicação correto. A escolha
dependerá de:

como o instrumento com o qual você está se comunicando se comporta.

quais outras funções seu programa principal (ou GUI) terá que executar além de gerenciar a porta serial.

Vou definir 3 casos diferentes para ilustrar, dos mais simples aos mais exigentes. Para os 3 exemplos, o

GoalKicker.com Notas MATLAB® para profissionais 133

Machine Translated by Google

O instrumento ao qual estou me conectando é uma placa de circuito com um inclinômetro, que pode funcionar nos 3 modos que
descreverei a seguir.

Modo 1: Síncrono (Mestre/Escravo)

Este modo é o mais simples. Corresponde ao caso em que o PC é o Mestre e o instrumento é o escravo.
O instrumento sozinho não envia nada para a porta serial, apenas responde após receber uma pergunta/comando do Mestre (o PC, seu
programa). Por exemplo:

O PC envia um comando: "Dê-me uma medição agora"

O instrumento recebe o comando, faz a medição e envia de volta o valor da medição para o
linha serial: "O valor do inclinômetro é XXX".

OU

O PC envia um comando: "Mudar do modo X para o modo Y"

O instrumento recebe o comando, executa-o e envia uma mensagem de confirmação de volta para a linha serial: "Comando executado"
(ou "Comando NÃO executado"). Isso é comumente chamado de resposta ACK/NACK (para "Acknowledge(d)" / "NOT
Acknowledged").

Resumo: neste modo o instrumento (o Slave) só envia dados para a linha serial imediatamente após ter sido solicitado pelo PC (o Master)

Modo 2: Assíncrono

Agora, suponha que eu liguei meu instrumento, mas ele é mais do que apenas um sensor idiota. Ele monitora constantemente sua própria
inclinação e enquanto estiver na vertical (dentro de uma tolerância, digamos +/- 15 graus), permanece silencioso. Caso o aparelho seja inclinado
mais de 15 graus e fique próximo da horizontal, ele envia uma mensagem de alarme para a linha serial, seguida imediatamente da leitura
da inclinação. Enquanto a inclinação estiver acima do limite, continua a enviar uma leitura de inclinação a cada 5s.

Se o seu programa principal (ou GUI) estiver constantemente "esperando" pela chegada de uma mensagem na linha serial, ele poderá ... mas

fazer isso bem, mas não poderá fazer mais nada nesse meio tempo. Se o programa principal for uma GUI, é altamente frustrante ter uma
GUI aparentemente "congelada" porque não aceita nenhuma entrada do usuário. Essencialmente, tornou-se o Escravo e o instrumento
é o Mestre. A menos que você tenha uma maneira sofisticada de controlar sua GUI a partir do instrumento, isso é algo a ser evitado.
Felizmente, o modo de comunicação assíncrona permitirá:

defina uma função separada que diga ao seu programa o que fazer quando uma mensagem for recebida

GoalKicker.com Notas MATLAB® para profissionais 134

Machine Translated by Google

deixe essa função em um canto, ela só será chamada e executada quando chegar uma mensagem na linha serial.
No resto do tempo, a GUI pode executar qualquer outro código necessário.

Resumo: Neste modo, o instrumento pode enviar mensagens para a linha serial a qualquer momento (mas não necessariamente o
tempo todo ). O PC não espera permanentemente pelo processamento de uma mensagem. É permitido executar qualquer outro código.
Somente quando chega uma mensagem ele ativa uma função que irá ler e processar essa mensagem.

Modo 3: Streaming (tempo real)

Agora vamos liberar todo o poder do meu instrumento. Coloquei-o em um modo onde ele enviará medições constantemente para a linha
serial. Meu programa deseja receber esses pacotes e exibi-los em uma curva ou display digital. Se enviar apenas um valor a cada 5s
conforme acima, não há problema, mantenha o modo acima. Mas meu instrumento, em plena potência, envia um ponto de dados para
a linha serial a 1000 Hz, ou seja, envia um novo valor a cada milissegundo. Se eu permanecer no modo assíncrono descrito acima, há um
alto risco (na verdade, uma certeza garantida) de que a função especial que definimos para processar cada novo pacote leve
mais de 1ms para ser executada (se você quiser plotar ou exibir o valor, as funções gráficas são bastante lentas, nem mesmo
considerando a filtragem ou FFT do sinal). Isso significa que a função começará a ser executada, mas antes de terminar, um novo
pacote chegará e acionará a função novamente. A segunda função é colocada em uma fila para execução, e só será iniciada quando a
primeira terminar e cada uma colocar uma função para executar na fila. Você pode ... mas a essa altura alguns novos pacotes
prever rapidamente o resultado: no momento em que estou traçando os 5 pontos, já tenho centenas esperando para serem plotados
também ... o gui fica mais lento, eventualmente congela,
a pilha cresce, os buffers ficam cheios, até que algo cede. Eventualmente, você fica com um programa completamente congelado ou
simplesmente travado.

Para superar isso, desconectaremos ainda mais o link de sincronização entre o PC e o instrumento. Deixaremos o instrumento enviar
dados em seu próprio ritmo, sem acionar imediatamente uma função a cada chegada de pacote.
O buffer da porta serial apenas acumulará os pacotes recebidos. O PC apenas coletará dados no buffer em um ritmo que puder gerenciar
(um intervalo regular, configurado no lado do PC), fará algo com eles (enquanto o buffer está sendo recarregado pelo instrumento) e,
em seguida, coletará um novo lote de dados. dados do buffer ... e assim por diante.

Resumo: Neste modo, o instrumento envia dados continuamente, que são coletados pelo buffer da porta serial. Em intervalos regulares,
o PC coleta dados do buffer e faz algo com eles. Não há link de sincronização física entre o PC e o instrumento. Ambos executam suas
tarefas em seu próprio tempo.

GoalKicker.com Notas MATLAB® para profissionais 135

Machine Translated by Google

Seção 28.3: Processamento automático de dados recebidos de

uma porta serial
Alguns dispositivos conectados através de uma porta serial enviam dados para o seu programa a uma taxa constante (streaming de dados) ou
enviam dados em intervalos imprevisíveis. Você pode configurar a porta serial para executar uma função automaticamente para manipular os dados
sempre que eles chegarem. Isso é chamado de "função de retorno de chamada" para o objeto de porta serial.

Existem duas propriedades da porta serial que devem ser configuradas para utilizar este recurso: o nome da função que você deseja para o
callback (BytesAvailableFcn), e a condição que deve acionar a execução da função de callback (BytesAvailableFcnMode).

Existem duas maneiras de acionar uma função de retorno de chamada:

1. Quando um certo número de bytes foi recebido na porta serial (normalmente usada para dados binários)
2. Quando um determinado caractere é recebido na porta serial (normalmente usado para texto ou dados ASCII)

As funções de retorno de chamada têm dois argumentos de entrada obrigatórios, chamados obj e evento. obj é a porta serial. Por
exemplo, se você deseja imprimir os dados recebidos da porta serial, defina uma função para imprimir os dados chamada newdata:

função novosdados(obj,evento)
[d,c] = pão(obj); % obtém os dados da porta serial
% Nota: para dados ASCII, use fscanf(obj) para retornar caracteres em vez de valores binários
fprintf(1,'Received %d bytes\n',c); disp(d)

fim

Por exemplo, para executar a função newdata sempre que 64 bytes de dados forem recebidos, configure a porta serial assim:

s = serial(nome_porta);
s.BytesAvailableFcnMode = 'byte';
s.BytesAvailableFcnCount = 64;
s.BytesAvailableFcn = @newdata;

Com dados de texto ou ASCII, os dados normalmente são divididos em linhas com um "caractere terminador", assim como o texto em uma página.
Para executar a função newdata sempre que o caractere de retorno de carro for recebido, configure a porta serial como
esse:

s = serial(nome_porta);

GoalKicker.com Notas MATLAB® para profissionais 136

Machine Translated by Google

s.BytesAvailableFcnMode = 'terminador'; s.Terminator =

'CR'; % o retorno de carro, código ASCII 13 s.BytesAvailableFcn = @newdata;

Seção 28.4: Leitura da porta serial

Supondo que você criou os objetos de porta serial como neste exemplo, então

% Leitura de dados
de um byte = fread(s, 1);

% Ler todos os bytes, versão 1 data = fread(s);

% Ler todos os bytes, versão 2 data = fread(s,

s.BytesAvailable);

% Feche a(s) porta (s) serial(is);

Seção 28.5: Fechando uma porta serial mesmo se for perdida,

excluída ou substituída
Supondo que você criou os objetos de porta serial como neste exemplo, para fechá-lo

fechar(s)

No entanto, às vezes você pode perder acidentalmente a porta (por exemplo, limpar, sobrescrever, alterar o escopo, etc...), e fclose(s)
não funcionarão mais. A solução é fácil

fclose(instrfindall)

Mais informações em instrfindall().

Seção 28.6: Escrevendo na porta serial

Supondo que você criou os objetos de porta serial como neste exemplo, então

% Grava um byte
fwrite(s, 255);

% Escreva um inteiro assinado de 16 bits fwrite(s,

32767, 'int16');

% Escreva um array de inteiros sem sinal de 8 bits fwrite(s,[48

49 50],'uchar');

% Feche a(s) porta (s) serial(is);

GoalKicker.com Notas MATLAB® para profissionais 137

Machine Translated by Google

Capítulo 29: Recursos não documentados

Seção 29.1: Gráficos de linhas 2D codificados por cores com dados de cores
em terceira dimensão

Nas versões do MATLAB anteriores ao R2014b, usando o antigo mecanismo gráfico HG1, não era óbvio como criar gráficos de linhas 2D codificados
por cores . Com o lançamento do novo motor gráfico HG2 surgiu um novo recurso não documentado introduzido por Yair Altman:

n = 100;
x = linspace(-10,10,n); y = x.^2; p =
plot(x,y,'r', 'LinhaLargura',5);

% modificado jet-colormap
cd = [uint8(jet(n)*255) uint8(ones(n,1))].';

conjunto
desenhado (p.Edge, 'ColorBinding','interpolado', 'ColorData',cd)

Seção 29.2: Marcadores semitransparentes em linhas e gráficos de dispersão

Desde o MATLAB R2014b é facilmente possível obter marcadores semitransparentes para gráficos de linha e dispersão usando recursos não
documentados introduzidos por Yair Altman.

A ideia básica é obter o identificador oculto dos marcadores e aplicar um valor <1 ao último valor do EdgeColorData para obter a
transparência desejada.

Aqui vamos nós para dispersão:

% // dados de
exemplo x = linspace(0,3*pi,200);

GoalKicker.com Notas MATLAB® para profissionais 138

Machine Translated by Google

y = cos(x) + rand(1.200);

%// plotar dispersão, obter identificador h

= dispersão(x,y);
desenhado; %// importante

% // obtém o identificador do
marcador hMarkers = h.MarkerHandle;

% // obtém a borda atual e a cor da face edgeColor

= hMarkers.EdgeColorData faceColor =
hMarkers.FaceColorData

% // define a cor da face como a cor da borda faceColor =

edgeColor;

%// opacidade
opa = 0,3;

% // define a borda do marcador e a cor da face

hMarkers.EdgeColorData = uint8( [edgeColor(1:3); 255*opa] ); hMarkers.FaceColorData
= uint8( [faceColor(1:3); 255*opa] );

e para um gráfico de linha

% // dados de exemplo
x = linspace(0,3*pi,200); y1 = cos(x);
y2 = pecado(x);

% // plotar dispersão, obter identificador

h1 = plot(x,y1,'o-','MarkerSize',15); espere h2 =
plot(x,y2,'o-','MarkerSize',15);

GoalKicker.com Notas MATLAB® para profissionais 139

Machine Translated by Google

desenhado; %// importante

% // obtém o identificador do
marcador h1Markers = h1.MarkerHandle;
h2Markers = h2.MarkerHandle;

% // obtém a borda atual e a cor da face edgeColor1

= h1Markers.EdgeColorData; edgeColor2 =
h2Markers.EdgeColorData;

% // define a cor da face como a cor da borda faceColor1 =

edgeColor1; faceColor2 =
bordaColor2;

%// opacidade
opa = 0,3;

% // define a borda do marcador e a cor da face

h1Markers.EdgeColorData = uint8( [edgeColor1(1:3); 255*opa] ); h1Markers.FaceColorData
= uint8( [faceColor1(1:3); 255*opa] ); h2Markers.EdgeColorData = uint8( [edgeColor2(1:3);
255*opa] ); h2Markers.FaceColorData = uint8( [faceColor2(1:3); 255*opa] );

As alças do marcador, utilizadas para a manipulação, são criadas com a figura. O comando drawow garante a criação da
figura antes da chamada dos comandos subsequentes e evita erros em caso de atrasos.

Seção 29.3: Funções auxiliares compatíveis com C++

O uso do MATLAB Coder às vezes nega o uso de algumas funções muito comuns, caso não sejam compatíveis com C++.
Com relativa frequência existem funções auxiliares não documentadas, que podem ser usadas como substitutas.

Aqui está uma lista abrangente de funções suportadas.

E seguindo uma coleção de alternativas, para funções não suportadas:

GoalKicker.com Notas MATLAB® para profissionais 140

Machine Translated by Google

As funções sprintf e sprintfc são bastante semelhantes, a primeira retorna um array de caracteres, a última uma string de célula:

str = sprintf('%i',x) % retorna '5' para x = 5 str = sprintfc('%i',x) % retorna

{'5'} para x = 5

No entanto, sprintfc é compatível com C++ suportado pelo MATLAB Coder, e sprintf não.

Seção 29.4: Tremulação do gráfico de dispersão

A função de dispersão possui duas propriedades não documentadas 'jitter' e 'jitterAmount' que permitem oscilar os dados apenas no eixo x. Isso
remonta ao MATLAB 7.1 (2005) e possivelmente antes.

Para habilitar este recurso defina a propriedade 'jitter' como 'on' e defina a propriedade 'jitterAmount' como o valor absoluto desejado (o
padrão é 0,2).

Isto é muito útil quando queremos visualizar dados sobrepostos, por exemplo:

dispersão(uns(1,10), uns(1,10), 'jitter', 'on', 'jitterAmount', 0,5);

Leia mais sobre Matlab não documentado

Seção 29.5: Gráficos de contorno - Personalize os rótulos de texto

Ao exibir rótulos em contornos, o MATLAB não permite controlar o formato dos números, por exemplo, para mudar para notação científica.

Os objetos de texto individuais são objetos de texto normais, mas a forma como você os obtém não está documentada. Você os acessa de

GoalKicker.com Notas MATLAB® para profissionais 141

Machine Translated by Google

a propriedade TextPrims do identificador de contorno.

figura
[X,Y]=malhagrid(0:100,0:100);
Z=(X+Y.^2)*1e10;
[C,h]=contorno(X,Y,Z);
h.ShowText='ligado';
desenhado();
txt = get(h,'TextPrims'); v =
str2double(get(txt,'String')); para
ii=1:comprimento(v)
set(txt(ii),'String',sprintf('%0.3e',v(ii))) fim

Nota: você deve adicionar um comando drawow para forçar o MATLAB a desenhar os contornos, o número e a localização dos objetos
txt só são determinados quando os contornos são realmente desenhados, então os objetos de texto só são criados então.

O fato de os objetos txt serem criados quando os contornos são desenhados significa que eles são recalculados toda vez que o gráfico é
redesenhado (por exemplo, redimensionamento da figura). Para gerenciar isso, você precisa ouvir o evento não documentado
Marcado como Limpo:

função personalizarFigura do
contorno
[X,Y]=meshgrid(0:100,0:100);
Z=(X+Y.^2)*1e10;
[C,h]=contorno(X,Y,Z);
h.ShowText='ligado';
% adicione um ouvinte e chame seu novo formato function
addlistener(h,'MarkedClean',@(a,b)ReFormatText(a)) end function

ReFormatText(h) % obtenha
todos os itens de texto do contorno t = get(h,
'TextPrims'); para
ii=1:comprimento(t)
% obtém o valor atual (o MATLAB altera isso de volta quando % redesenha
o gráfico) v =
str2double(get(t(ii),'String')); % Atualize com o
formato desejado - científico por exemplo set(t(ii),'String',sprintf('%0.3e',v));
fim fim

GoalKicker.com Notas MATLAB® para profissionais 142

Machine Translated by Google

Exemplo testado usando MATLAB r2015b no Windows

Seção 29.6: Anexando/adicionando entradas a uma legenda existente

As lendas existentes podem ser difíceis de gerenciar. Por exemplo, se o seu gráfico tem duas linhas, mas apenas uma delas tem uma entrada de legenda e

deve permanecer assim, pode ser difícil adicionar uma terceira linha com uma entrada de legenda. Exemplo:

figure
hold on
fplot(@sin)
fplot(@cos)
legend sin % Adicione apenas uma entrada de legenda
para sin hTan = fplot(@tan); % Certifique-se de obter o identificador, hTan, para o objeto gráfico que deseja adicionar à
legenda

Agora, para adicionar uma entrada de legenda para tan, mas não para cos, qualquer uma das linhas a seguir não resolverá o problema; todos eles falham em alguns

caminho:

legenda tangente % Substitui a legenda atual -> legenda de

falha -DynamicLegend % Recurso não documentado, adiciona 'cos', que não deve ser adicionado -> legenda de
falha tangente seno % Define cos DisplayName como 'tangente' -> legenda de
''
falha seno tangente % Define cos DisplayName, embora vazio -> falhar legenda(f)

Felizmente, uma propriedade de legenda não documentada chamada PlotChildren rastreia os filhos da figura pai1.

Portanto, o caminho a seguir é definir explicitamente os filhos da legenda por meio de sua propriedade PlotChildren da seguinte forma:

hTan.DisplayName = 'tangente'; % Defina o nome de exibição do objeto gráfico l = legenda;

l.PlotChildren(fim
+ 1) = hTan; % Anexa o identificador gráfico aos filhos do enredo da legenda

A legenda é atualizada automaticamente se um objeto for adicionado ou removido de sua propriedade PlotChildren .

GoalKicker.com Notas MATLAB® para profissionais 143

Machine Translated by Google

1 Na verdade: figura. Você pode adicionar o filho de qualquer figura com a propriedade DisplayName a qualquer legenda da figura, por exemplo, de
uma subtrama diferente. Isso ocorre porque uma legenda em si é basicamente um objeto de eixos.

Testado em MATLAB R2016b

GoalKicker.com Notas MATLAB® para profissionais 144

Machine Translated by Google

Capítulo 30: Melhores Práticas MATLAB

Seção 30.1: Recuar o código corretamente
O recuo adequado não apenas proporciona uma aparência estética, mas também aumenta a legibilidade do código.

Por exemplo, considere o seguinte código:

%não há necessidade de entender o código, apenas dê uma olhada n = 2; bf =

falso;
enquanto n>1
para ii = 1:n

para jj = 1:n se
ii+jj>30 bf =
verdadeiro; fim
da

pausa
fim se
bf quebrar fim
fim
se bf
quebrar
fim
n=n+ 1; fim

Como você pode ver, você precisa dar uma olhada cuidadosa para ver qual loop e se as instruções terminam onde.
Com o recuo inteligente, você terá esta aparência:

n = 2; bf
= falso; enquanto
n>1 para ii =
1:n
para jj = 1:n se
ii+jj>30 bf =
verdadeiro;
quebrar
fim

acabar se bf
quebrar
fim
fim
se bf
quebrar
fim
n=n+ 1;
fim

Isso indica claramente o início e o fim dos loops/ instrução if.

Você pode fazer uma indentação

inteligente: • selecionando todo o seu código ( Ctrl + A )

• e então pressionando Ctrl + I ou clicando na barra de edição.

GoalKicker.com Notas MATLAB® para profissionais 145

Machine Translated by Google

Seção 30.2: Evite loops

Na maioria das vezes, os loops são computacionalmente caros com o MATLAB. Seu código será muito mais rápido se você usar a vetorização.
Freqüentemente, também torna seu código mais modular, facilmente modificável e mais fácil de depurar. A principal desvantagem é que você
precisa de tempo para planejar as estruturas de dados e é mais fácil encontrar erros de dimensão.

Exemplos

Não escreva

para t=0:0,1:2*pi
R(end+1)=cos(t);
fim

mas

t=0:0,1:2*pi;
R=cos(t)

Não escreva

para i=1:n
para j=1:m
c(i,j)=a(i)+2*b(j);
fim
fim

Mas algo semelhante a

c=repmat(a.',1,m)+2*repmat(b,n,1)

Para mais detalhes, veja vetorização

Seção 30.3: Mantenha as linhas curtas

Use o caractere de continuação (reticências) ... para continuar uma instrução longa.

Exemplo:

MyFunc( parâmetro1,parâmetro2,parâmetro3,parâmetro4, parâmetro5, parâmetro6,parâmetro7, parâmetro8, parâmetro9)

pode ser substituído por:

MinhaFunc( parâmetro1, ...

parâmetro2, ...
parâmetro3, ...

GoalKicker.com Notas MATLAB® para profissionais 146

Machine Translated by Google

parâmetro4, ...
parâmetro5, ...
parâmetro6, ...
parâmetro7, ...
parâmetro8, ...
parâmetro9)

Seção 30.4: Usar afirmação

O MATLAB permite que alguns erros muito triviais ocorram silenciosamente, o que pode fazer com que um erro seja gerado muito
mais tarde na execução - dificultando a depuração. Se você presumir algo sobre suas variáveis, valide-o .

function out1 = get_cell_value_at_index(scalar1,cell2) assert(isscalar(scalar1),'1ª

entrada deve ser um escalar') assert(iscell(cell2),'2ª entrada deve ser uma matriz
de células')

assert(numel(cell2) >= escalar1),'2ª entrada deve ter mais elementos que o valor da 1ª entrada') assert(~isempty(cell2{scalar1}),'2ª entrada
no local
está vazia')

saída1 = célula2{escalar1};

Seção 30.5: Operador de bloco de comentários

É uma boa prática adicionar comentários que descrevam o código. É útil para outras pessoas e até mesmo para o codificador quando retornado
posteriormente. Uma única linha pode ser comentada usando o símbolo % ou usando a tecla de atalho Ctrl + R descomente uma . Para

linha comentada anteriormente, remova o símbolo % ou use a tecla de atalho Crtl+T.

Embora comentar um bloco de código possa ser feito adicionando um símbolo % no início de cada linha, as versões mais recentes
do MATLAB (após 2015a) permitem usar o Operador de comentário de bloco %{código %}. Este operador aumenta a
legibilidade do código. Ele pode ser usado tanto para comentários de código quanto para documentação de ajuda de funções. O
Bloco pode ser dobrado e desdobrado para aumentar a legibilidade do código.

Como pode ser visto os operadores %{ e %} devem aparecer sozinhos nas linhas. Não inclua nenhum outro texto nestas linhas.

GoalKicker.com Notas MATLAB® para profissionais 147

Machine Translated by Google

function y = myFunction(x) %

{ myFunction Binary Singleton Expansion Function y = myFunction(x)

aplica a operação binária elemento por elemento especificada pelo identificador de função FUNC
às matrizes A e B, com expansão implícita habilitada. %}

%% Calcule z(x, y) = x.*sin(y) em uma grade: % x = 1:10; y =

x.';

%
{ z = zeros(numel(x),numel(y)); para
ii=1:numel(x) para
jj=1:numel(y) z(ii,jj) =
x(ii)*sin(y(jj));
fim
fim
%}

z = bsxfun(@(x, y) x.*sin(y), x, y); y = y + z;

fim

Seção 30.6: Criar nome exclusivo para arquivo temporário

Ao codificar um script ou uma função, pode ser necessário um ou mais arquivos temporários para, por exemplo, armazenar alguns
dados.

Para evitar a substituição de um arquivo existente ou ocultar uma função MATLAB, o tempname A função pode ser usada para
gerar um nome exclusivo para um arquivo temporário na pasta temporária do sistema.

meu_arquivo_temp = nome temporário

O nome do arquivo é gerado sem a extensão; pode ser adicionado concatenando a extensão desejada ao nome gerado por tempname

meu_temp_file_with_ext=[tempname '.txt']

A localização da pasta temporária do sistema pode ser recuperada chamando tempdir função.

Se durante a execução da função/script o arquivo temporário não for mais necessário, ele poderá ser excluído utilizando a função delete

Como a exclusão não pede confirmação, pode ser útil ativar a opção de mover o arquivo a ser excluído para a pasta de reciclagem .

Isso pode ser feito usando a função reciclar Por aqui:

reciclar('ligado')

No exemplo a seguir, é proposta uma possível utilização das funções tempname, delete e recycle .

% Crie alguns dados de exemplo

GoalKicker.com Notas MATLAB® para profissionais 148

Machine Translated by Google

teta=0:.1:2*pi;
x=cos(teta); y =
pecado (teta); %

% Gere o nome do arquivo temporário %

meu_temp_file=[tempname '.mat']; % % Divida

o nome do arquivo (caminho, nome, extensão) e exiba-os em uma caixa de mensagem [tmp_file_path,tmp_file_name,
tmp_file_ext]=fileparts(my_temp_file) uiwait(msgbox(sprintf('Path= %s\nName= %s\nExt= %s', ...
tmp_file_path,tmp_file_name,tmp_file_ext),'ARQUIVO TEMPORÁRIO '))

% Salva as variáveis em um arquivo temporário %

save(my_temp_file,'x','y','theta') %

% Carrega as variáveis do arquivo temporário %

carregar(meu_arquivo_temp)
%
% Defina a opção de reciclagem em %

recycle('on') %

% Exclua o arquivo temporário %

delete(my_temp_file)

Embargo

O nome do arquivo temporário é gerado usando o método java.util.UUID.randomUUID (randomUUID).

Se o MATLAB for executado sem JVM, o nome do arquivo temporário será gerado usando
matlab.internal.timing.timing com base no contador e no tempo da CPU. Neste caso, não é garantido que o nome do arquivo temporário seja
exclusivo.

GoalKicker.com Notas MATLAB® para profissionais 149

Machine Translated by Google

Capítulo 31: Interfaces de usuário MATLAB

Seção 31.1: Transmissão de dados pela interface do usuário
As interfaces de usuário mais avançadas exigem que o usuário seja capaz de passar informações entre as diversas funções que compõem uma interface de

usuário. O MATLAB possui vários métodos diferentes para fazer isso.

guiado

Ambiente de desenvolvimento GUI próprio do MATLAB (GUIDE) prefere usar uma estrutura chamada handles para passar dados entre retornos de

chamada. Esta estrutura contém todos os identificadores gráficos para os vários componentes da UI, bem como dados especificados pelo usuário. Se você

não estiver usando um retorno de chamada criado pelo GUIDE que passa identificadores automaticamente, você pode recuperar o valor atual usando guidata

% hObject é um identificador gráfico para qualquer componente de UI em seus

identificadores GUI = guidata(hObject);

Se desejar modificar um valor armazenado nesta estrutura de dados, você poderá modificá-lo, mas deverá armazená-lo novamente no hObject
para que as alterações sejam visíveis por outros retornos de chamada. Você pode armazená-lo especificando um segundo argumento de entrada
para guidata.

% Atualize o valor
handles.myValue = 2;

% Salvar alterações
guidata(hObject, identificadores)

O valor de hObject não importa, desde que seja um componente de UI dentro da mesma figura porque, em última análise, os dados são armazenados na figura

que contém hObject.

Melhor para:

Armazenando a estrutura de identificadores , na qual você pode armazenar todos os identificadores de seus componentes GUI.

Armazenar outras variáveis "pequenas" que precisam ser acessadas pela maioria dos retornos de chamada.

Não recomendado para:

Armazenar variáveis grandes que não precisam ser acessadas por todos os retornos de chamada e subfunções (use setappdata/
getappdata para elas).

setappdata/getappdata

Semelhante à abordagem guidata , você pode usar setappdata e obter dados do aplicativo para armazenar e recuperar valores de dentro de um identificador gráfico.

A vantagem de usar esses métodos é que você pode recuperar apenas o valor desejado , em vez de uma estrutura inteira contendo todos os dados armazenados.

É semelhante a um armazenamento de chave/valor.

Para armazenar dados em um objeto gráfico

% Crie alguns dados que você gostaria de armazenar myvalue

=2

% Armazene-o usando a chave 'mykey'

GoalKicker.com Notas MATLAB® para profissionais 150

Machine Translated by Google

setappdata(hObject, 'minhachave', meuvalor)

E para recuperar o mesmo valor de um retorno de chamada diferente

valor = getappdata(hObject, 'minhachave');

Nota: Se nenhum valor foi armazenado antes de chamar getappdata, ele retornará um array vazio ([]).

Semelhante ao guidata, os dados são armazenados na figura que contém o hObject.

Melhor para:

Armazenar variáveis grandes que não precisam ser acessadas por todos os retornos de chamada e subfunções.

Dados do usuário

Cada identificador gráfico possui uma propriedade especial, UserData , que pode conter quaisquer dados que você desejar. Pode conter uma matriz de células,

uma estrutura ou até mesmo um escalar. Você pode aproveitar esta propriedade e armazenar quaisquer dados que deseja associar a um determinado

identificador gráfico neste campo. Você pode salvar e recuperar o valor usando os métodos get/set padrão para objetos gráficos ou notação de ponto se estiver

usando R2014b ou mais recente.

% Crie alguns dados para armazenar

meus dados = {1, 2, 3};

% Armazene-o dentro do conjunto de propriedades

UserData (hObject, 'UserData', mydata)

% De se você estiver usando R2014b ou mais recente:

% hObject.UserData = mydata;

Então, de outro retorno de chamada, você pode recuperar estes dados:

seus_dados = get(hObject, 'UserData');

% Ou se você estiver usando R2014b ou mais recente:

% their_data = hObject.UserData;

Melhor para:

Armazenar variáveis com escopo limitado (variáveis que provavelmente serão usadas apenas pelo objeto no qual estão armazenadas ou objetos que

tenham um relacionamento direto com elas).

Funções aninhadas

No MATLAB, uma função aninhada pode ler e modificar qualquer variável definida na função pai. Dessa forma, se você especificar um retorno de chamada

como uma função aninhada, ele poderá recuperar e modificar quaisquer dados armazenados na função principal.

function mygui() hButton

= uicontrol('String', 'Click Me', 'Callback', @callback);

% Crie um contador para controlar o número de vezes que o botão é clicado nClicks = 0;

% A função de retorno de chamada está aninhada e pode, portanto, ler e modificar o retorno de chamada
da função nClicks (fonte, evento)

GoalKicker.com Notas MATLAB® para profissionais 151

Machine Translated by Google
% Aumenta o número de cliques
nCliques = nCliques + 1;

% Imprime o número de cliques até o momento

fprintf('Número de cliques: %d\n', nClicks);
fim
fim

Melhor para:

GUIs pequenas e simples. (para prototipagem rápida, para não precisar implementar os métodos guidata e/ou set/getappdata ).

Não recomendado para:

GUIs médias, grandes ou complexas.

GUI criada com GUIDE.

Argumentos de entrada explícitos

Se você precisar enviar dados para uma função de retorno de chamada e não precisar modificar os dados dentro do retorno de chamada, poderá sempre

considerar passar os dados para o retorno de chamada usando uma definição de retorno de chamada cuidadosamente elaborada.

Você poderia usar uma função anônima que adiciona entradas

% Crie alguns dados para enviar para mycallback data = [1, 2,

3];

% Passa dados como uma terceira entrada para mycallback

set(hObject, 'Callback', @(source, event)mycallback(source, event, data))

Ou você pode usar a sintaxe da matriz de células para especificar um retorno de chamada, especificando novamente entradas adicionais.

set(hObject, 'Callback', {@mycallback, dados})

Melhor para:

Quando o retorno de chamada precisa de dados para realizar algumas operações, mas a variável de dados não precisa ser modificada e salva em
um novo estado.

Seção 31.2: Criando um botão em sua IU que pausa a execução do

retorno de chamada

Às vezes gostaríamos de pausar a execução do código para inspecionar o estado do aplicativo (consulte Depuração). Ao executar o código através do editor MATLAB,

isso pode ser feito usando o botão "Pause" na UI ou pressionando Ctrl + c (no Windows). Porém, quando um cálculo foi iniciado a partir de uma GUI (através do

retorno de chamada de algum uicontrol), este método não funciona mais e o retorno de chamada deve ser interrompido por outro retorno de chamada. Abaixo está

uma demonstração deste princípio:

função interruptibleUI dbclear em

interruptibleUI % redefine pontos de interrupção neste arquivo figure('Position',[400,500,329,160]);

GoalKicker.com Notas MATLAB® para profissionais 152

Machine Translated by Google

uicontrol('Estilo', 'botão',...
'String', 'Computar',...
'Posição', [24 55 131 63],...
'Retorno de chamada', @longComputation,...
'Interruptível','ligado'); % 'ativado' por padrão de qualquer maneira

uicontrol('Estilo', 'botão',...
'Sequência', 'Pausa #1',...
'Posição', [180 87 131 63],...
'Retorno de chamada', @interrupção1);

uicontrol('Estilo', 'botão',...
'Sequência', 'Pausa #2',...
'Posição', [180 12 131 63],...
'Retorno de chamada', @interrupt2);

fim

função longComputation(src,event) superSecretVar

= rand(1); pausa(15); imprimir('pronto!');
% usaremos
isso para determinar se o código continuou sendo executado "em segundo plano". fim

function interrupt1(src,event) % dependendo de onde você deseja parar dbstop em interruptibleUI em

27 % irá parar após print('done!'); dbstop em interruptibleUI em 32 % irá parar após **esta** linha.
fim

função interrupção2(src,evento) % método 2 teclado; dbup;

% isso
precisará ser executado manualmente quando o código parar na linha anterior. fim

Para ter certeza de que você entendeu este exemplo, faça o seguinte:

1. Cole o código acima em um novo arquivo chamado e salve-o como interruptibleUI.m, de forma que o código comece em
a primeira linha do arquivo (isso é importante para que o primeiro método funcione).
2. Execute o script.
3. Clique em Compute e logo depois clique em Pause #1 ou em Pause #2 4. Certifique-se de encontrar o valor .
de superSecretVar.

Seção 31.3: Transmitindo dados usando a estrutura

"handles"
Este é um exemplo de GUI básica com dois botões que alteram um valor armazenado na estrutura de identificadores da GUI .

função gui_passing_data()
% Uma GUI básica com dois botões para mostrar um uso simples da estrutura 'handles' % na
construção de GUI

% Crie uma nova figura. f = figura();

% Recupera a estrutura dos identificadores

handles = guidata(f);

% Armazene o identificador da figura

handles.figure = f;

GoalKicker.com Notas MATLAB® para profissionais 153

Machine Translated by Google

% Crie uma caixa de edição e dois botões (mais e menos), % e armazene seus
identificadores para uso futuro handles.hedit =
uicontrol('Style','edit','Position',[10,200,60,20] , 'Enable ', 'Inativo');

handles.hbutton_plus = uicontrol('Estilo','pushbutton','String','+',...
'Posição',[80,200,60,20] , , @ButtonPress);'Ligar de volta'

handles.hbutton_minus = uicontrol('Estilo','pushbutton','String','-',...
'Posição',[150,200,60,20] , 'Ligar de volta' , @ButtonPress);

% Defina um valor inicial, armazene-o na estrutura de handles e mostre-o na caixa de edição

handles.value = 1;
set(handles.hedit, 'String' ,
num2str(handles.value))

% Armazena
manipuladores guidata(f, identificadores);

função ButtonPress (hObject, dados do evento)

% Um botão foi pressionado
% Recuperar os identificadores
handles = guidata(hObject);

% Determina qual botão foi pressionado; hObject é o objeto de chamada switch(get(hObject , 'String'))
case '+'

% Adicione 1 ao valor
handles.value = handles.value + 1; set(handles.hedit,
'String', num2str(handles.value))
caso '-'
% Subtraia 1 do valor
alças.valor = alças.valor - 1;
fim

% Exibe o novo conjunto de

valores (handles.hedit, 'String', num2str(handles.value))

% Armazena
manipuladores guidata(hObject, identificadores);

Para testar o exemplo, salve-o em um arquivo chamado gui_passing_data.m e execute-o com F5. Observe que, em um caso
tão simples, você nem precisaria armazenar o valor na estrutura de identificadores, pois poderia acessá-lo diretamente a partir da
propriedade String da caixa de edição .

Seção 31.4: Problemas de desempenho ao transmitir dados pela

interface do usuário
Duas técnicas principais permitem passar dados entre funções GUI e retornos de chamada: setappdata/getappdata e guidata (leia
mais sobre isto). O primeiro deve ser usado para variáveis maiores, pois é mais eficiente em termos de tempo. O exemplo a
seguir testa a eficiência dos dois métodos.

Uma GUI com um botão simples é criada e uma variável grande (10000x10000 duplo) é armazenada tanto com guidata quanto
com setappdata. O botão recarrega e armazena a variável usando os dois métodos enquanto cronometra sua execução. O
tempo de execução e a melhoria percentual usando setappdata são exibidos na janela de comando.

função gui_passing_data_performance()

GoalKicker.com Notas MATLAB® para profissionais 154

Machine Translated by Google

% Uma GUI básica com um botão para mostrar a diferença de desempenho entre
% assistente e setappdata

% Crie uma nova figura.

f = figure('Unidades' , 'normalizado');

% Recupera a estrutura dos identificadores

alças = assistente(f);

% Armazene o identificador da figura

alças.figura = f;

handles.hbutton = uicontrol('Estilo','pushbutton','String','Calcular','unidades','normalizado',...
'Posição',[0,4 , 0,1] 0,45 , 0,2 , , 'Ligar de volta' , @ButtonPress);

% Crie um array grande e desinteressante

dados = zeros(10000);

% Armazene-o em appdata
setappdata(handles.figura , 'dados' , dados);

% Armazene-o em alças
identificadores.dados = dados;

% Salvar identificadores

conduzido(f, alças);

função ButtonPress (hObject, dados do evento)

% Calcule a diferença horária ao usar guidata e appdata

t_handles = timeit(@use_handles);
t_appdata = timeit(@use_appdata);

% Diferença absoluta e percentual

t_diff = t_handles - t_appdata;
t_perc = round(t_diff / t_handles * 100);

disp(['Diferença: ' num2str(t_diff) ' EM / ' num2str(t_perc) ' %'])

função use_appdata()

% Recuperar os dados do appdata

dados = getappdata(gcf , 'dados');

% Faça algo com dados %

% Armazene o valor novamente

setappdata(gcf , 'dados' , dados);

função use_handles()

% Recuperar os dados dos identificadores

identificadores = guidata(gcf);
dados = identificadores.dados;

% Faça algo com dados %

GoalKicker.com Notas MATLAB® para profissionais 155

Machine Translated by Google
% Guarde-o novamente nas alças
identificadores.dados = dados;
guidata(gcf, identificadores);

No meu Xeon W3530 @ 2,80 GHz obtenho diferença: 0,00018957 ms / 73 %, portanto, usando getappdata/setappdata obtenho uma melhoria de desempenho de 73%!

Observe que o resultado não muda se uma variável dupla 10x10 for usada; no entanto, o resultado mudará se os identificadores contiverem muitos campos

com dados grandes.

GoalKicker.com Notas MATLAB® para profissionais 156

Machine Translated by Google

Capítulo 32: Truques úteis

Seção 32.1: Extrair dados de figuras
Em algumas ocasiões, salvei uma figura interessante, mas perdi o acesso aos seus dados. Este exemplo mostra um truque para conseguir extrair
informações de uma figura.

As principais funções são findobj e pegue. encontrarobj retorna um manipulador para um objeto, dados atributos ou propriedades do objeto, como
Tipo ou Cor, etc. Depois que um objeto de linha for encontrado, obtenha pode retornar qualquer valor mantido pelas propriedades. Acontece que os
objetos Line contêm todos os dados nas seguintes propriedades: XData, YData e ZData; o último geralmente é 0, a menos que uma figura contenha
um gráfico 3D.

O código a seguir cria uma figura de exemplo que mostra duas linhas, uma função sin e um limite e uma legenda

t = (0:1/10:1-1/10)'; y =
pecado(2*pi*t);
plotar(t,y);
aguentar ;
plotar([0 0,9],[0 0], 'k-'); espere ;
legenda({'sin'
'limiar'});

O primeiro uso de findobj retorna dois manipuladores para ambas as linhas:

findobj(gcf, 'Tipo', 'Linha')

anos =
Matriz de linha 2x1 :

Linha (limiar) (pecado)

Linha

Para restringir o resultado, findobj também pode usar a combinação de operadores lógicos -and, -or e nomes de propriedades. Por exemplo,
posso encontrar um objeto de linha cujo DiplayName seja sin e ler seus XData e YData.

lineh = findobj(gcf, 'Tipo', 'Linha', '-e', 'NomeDisplay', 'sin'); xdados = get(linhah, 'XDados');
ydata = get(lineh, 'YData');

e verifique se os dados são iguais.

éigual(t(:),xdados(:))
anos =

1 isequal(y(:),ydata(:))
anos =
1

Da mesma forma, posso restringir meus resultados excluindo a linha preta (limiar):

lineh = findobj(gcf, 'Tipo', 'Linha', '-not', 'Cor', 'k'); xdados = get(linhah, 'XDados');
ydata = get(lineh, 'YData');

e a última verificação confirma que os dados extraídos desta figura são os mesmos:

GoalKicker.com Notas MATLAB® para profissionais 157

Machine Translated by Google

éigual(t(:),xdados(:))
anos =

1 isequal(y(:),ydata(:))
anos =
1

Seção 32.2: Preferências de dobramento de código

É possível alterar a preferência de Code Folding para atender às suas necessidades. Assim, a dobragem de código pode ser ativada/desativada
para construções específicas (ex: bloco if , loop for , seções ...).

Para alterar as preferências de dobramento, vá para Preferências -> Dobragem de Código:

Então você pode escolher qual parte do código pode ser dobrada.

Alguma informação:

Observe que você também pode expandir ou recolher todo o código em um arquivo colocando o cursor em qualquer lugar do arquivo, clicando com
o botão direito e selecionando Dobragem de código > Expandir tudo ou Dobragem de código > Dobrar tudo no menu de contexto.
Observe que a dobragem é persistente, no sentido de que parte do código que foi expandido/recolhido manterá seu status após o MATLAB ou o
arquivo m ter sido fechado e reaberto.

Exemplo: Para ativar a dobragem de seções:

Uma opção interessante é habilitar a dobra de Seções. As seções são delimitadas por sinais de dois por cento (%%).

GoalKicker.com Notas MATLAB® para profissionais 158

Machine Translated by Google

Exemplo: Para habilitá-lo marque a caixa "Seções":

Então, em vez de ver um código-fonte longo semelhante a:

Você poderá dobrar seções para ter uma visão geral do seu código:

GoalKicker.com Notas MATLAB® para profissionais 159

Machine Translated by Google

Seção 32.3: Programação Funcional usando Funções

Anônimas
Funções anônimas podem ser usadas para programação funcional. O principal problema a ser resolvido é que não existe uma forma
nativa de ancorar uma recursão, mas isso ainda pode ser implementado em uma única linha:

if_ = @(bool, tf) tf{2-bool}();

Esta função aceita um valor booleano e uma matriz de células de duas funções. A primeira dessas funções é avaliada se o valor
booleano for avaliado como verdadeiro, e a segunda se o valor booleano for avaliado como falso. Podemos escrever facilmente a
função fatorial agora:

fac = @(n,f) if_(n>1, {@()n*f(n-1,f), @()1});

O problema aqui é que não podemos invocar diretamente uma chamada recursiva, pois a função ainda não está atribuída a uma
variável quando o lado direito é avaliado. No entanto, podemos completar esta etapa escrevendo

fatorial_ = @(n)fac(n,fac);

Agora @(n)fac(n,fac) avalia a função fatorial recursivamente. Outra maneira de fazer isso na programação funcional usando um
combinador y, que também pode ser facilmente implementado:

y_ = @(f)@(n)f(n,f);

Com esta ferramenta, a função fatorial é ainda mais curta:

fatorial_ = y_(fac);

Ou diretamente:

fatorial_ = y_(@(n,f) if_(n>1, {@()n*f(n-1,f), @()1}));

Seção 32.4: Salvar múltiplas figuras no mesmo arquivo .fig

Ao colocar vários identificadores de figuras em uma matriz gráfica, várias figuras podem ser salvas no mesmo arquivo .fig

GoalKicker.com Notas MATLAB® para profissionais 160

Machine Translated by Google

h(1) = figura;
dispersão(rand(1.100),rand(1.100));

h(2) = figura;
dispersão(rand(1.100),rand(1.100));

h(3) = figura;
dispersão(rand(1.100),rand(1.100));

savefig(h,'TrêsRandomScatterplots.fig'); fechar(h);

Isso cria 3 gráficos de dispersão de dados aleatórios, cada parte da matriz gráfica h. Em seguida, a matriz gráfica pode ser salva usando savefig
como uma figura normal, mas com o identificador da matriz gráfica como um argumento adicional.

Uma observação interessante é que as figuras tenderão a permanecer organizadas da mesma forma que foram salvas quando você as abriu.

Seção 32.5: Blocos de comentários

Se você quiser comentar parte do seu código, os blocos de comentários podem ser úteis. O bloco de comentários começa com %{ em uma nova
linha e termina com %} em outra nova linha:

uma = 10;
b = 3; %
{c
= a*b; d
=ab; %}

Isso permite dobrar as seções comentadas para tornar o código mais limpo e compacto.

Esses blocos também são úteis para ativar/desativar partes do seu código. Tudo que você precisa fazer para descomentar o bloco é adicionar
outro % antes de começar:

uma = 10;
b = 3; %
%{ <- outro % aqui c = a*b; d =ab; %}

Às vezes você quer comentar uma seção do código, mas sem afetar seu recuo:

para k = 1:ab =
b*k; c = cb;
d = d*c;
disp(b)

fim

Normalmente, quando você marca um bloco de código e pressiona Ctrl + r para comentá-lo (adicionando% automaticamente a todas as
linhas, quando você pressiona mais tarde Ctrl + i para recuo automático, o bloco de código se move de sua posição hierárquica correta lugar, e
moveu-se muito para a direita:

para k = 1:ab =
b*k;

GoalKicker.com Notas MATLAB® para profissionais 161

Machine Translated by Google
% c = cb; % d
= d*c; disp(b)

fim

Uma maneira de resolver isso é usar blocos de comentários, para que a parte interna do bloco fique recuada corretamente:

para k = 1:ab =
b*k; %{ c =

cb; d = d*c;
%} disp(b)

fim

Seção 32.6: Funções úteis que operam em células e

arrays
Este exemplo simples fornece uma explicação sobre algumas funções que achei extremamente úteis desde que comecei a usar o MATLAB: cellfun,
arrayfun. A ideia é pegar uma variável de array ou classe de célula, percorrer todos os seus elementos e aplicar uma função dedicada em cada
elemento. Uma função aplicada pode ser anônima, o que geralmente é um caso, ou qualquer função regular definida em um arquivo *.m.

Vamos começar com um problema simples e dizer que precisamos encontrar uma lista de arquivos *.mat de acordo com a pasta. Para este exemplo,
primeiro vamos criar alguns arquivos *.mat em uma pasta atual:

para n=1:10; salvar(sprintf('meuarquivomat%d.mat',n)); fim

Após a execução do código, deverão existir 10 novos arquivos com extensão *.mat. Se executarmos um comando para listar todos os arquivos *.mat,
como:

meudir = dir('*.mat');

devemos obter um array de elementos de uma estrutura dir; O MATLAB deve fornecer uma saída semelhante a esta:

Matriz de estrutura 10x1 com campos:

nome
bytes
de data
isdir
dados

Como você pode ver, cada elemento deste array é uma estrutura com alguns campos. Todas as informações são realmente importantes em relação a
cada arquivo, mas em 99% estou bastante interessado em nomes de arquivos e nada mais. Para extrair informações de um array de estrutura, eu
costumava criar uma função local que envolveria a criação de variáveis temporais de tamanho correto, loops for, extrair um nome de cada elemento e
salvá-lo na variável criada. Uma maneira muito mais fácil de obter exatamente o mesmo resultado é usar uma das funções mencionadas:

mydirlist = arrayfun(@(x) x.name, dir('*.mat'), 'UniformOutput', false) mydirlist = 'mymatfile1.mat'

'mymatfile10.mat'
'mymatfile2.mat'
'mymatfile3.mat' '
meuarquivomat4.mat'

GoalKicker.com Notas MATLAB® para profissionais 162

Machine Translated by Google

'meumatfile5.mat'
'meumatfile6.mat'
'meumatfile7.mat'
'meumatfile8.mat'
'meumatfile9.mat'

Como funciona esta função? Geralmente leva dois parâmetros: um identificador de função como o primeiro parâmetro e um array. Uma
função operará então em cada elemento de um determinado array. O terceiro e o quarto parâmetros são opcionais, mas importantes.
Se soubermos que uma saída não será regular, ela deverá ser salva na célula. Isso deve ser apontado como false para UniformOutput.
Por padrão, esta função tenta retornar uma saída regular, como um vetor de números.
Por exemplo, vamos extrair informações sobre quanto espaço em disco é ocupado por cada arquivo em bytes:

meusdirbytes = arrayfun(@(x) x.bytes, dir('*.mat')) meusdirbytes = 34560

34560

34560
34560
34560
34560
34560
34560
34560
34560

ou quilobytes:

meusdirbytes = arrayfun(@(x) x.bytes/1024, dir('*.mat')) meusdirbytes = 33,7500

33,7500
33,7500
33,7500
33,7500
33,7500
33,7500
33,7500
33,7500
33,7500

Desta vez, a saída é um vetor regular de double. UniformOutput foi definido como verdadeiro por padrão.

cellfun é uma função semelhante. A diferença entre esta função e arrayfun é que cellfun opera em variáveis de classe de célula. Se desejarmos
extrair apenas nomes de uma lista de nomes de arquivos em uma célula 'mydirlist', precisaríamos apenas executar esta função da seguinte forma:

meusdirnames = cellfun(@(x) x(1:end-4), mydirlist, 'UniformOutput', false) meusdirnames = 'mymatfile1'

'mymatfile10'
'mymatfile2'
'mymatfile3'
'mymatfile4'
'mymatfile5'
'mymatfile6'
'mymatfile7 '
'meumatfile8'
'meumatfile9'

GoalKicker.com Notas MATLAB® para profissionais 163

Machine Translated by Google

Novamente, como uma saída não é um vetor regular de números, uma saída deve ser salva em uma variável de célula.

No exemplo abaixo, combino duas funções em uma e retorno apenas uma lista de nomes de arquivos sem extensão:

cellfun(@(x) x(1:end-4), arrayfun(@(x) x.name, dir('*.mat'), 'UniformOutput', false), 'UniformOutput', false)

anos =
'meumatfile1'
'meumatfile10'
'meumatfile2'
'meumatfile3'
'meumatfile4'
'meumatfile5'
'meumatfile6'
'meumatfile7'
'meumatfile8'
'meumatfile9'

É uma loucura, mas muito possível porque arrayfun retorna uma célula que é a entrada esperada de cellfun; uma observação adicional sobre isso é
que podemos forçar qualquer uma dessas funções a retornar resultados em uma variável de célula definindo UniformOutput como false,
explicitamente. Sempre podemos obter resultados em uma célula. Talvez não consigamos obter resultados em um vetor regular.

Existe mais uma função semelhante que opera em campos de uma estrutura: structfun. Particularmente, não o achei tão útil quanto os outros dois,
mas brilharia em algumas situações. Se, por exemplo, alguém quiser saber quais campos são

numérico ou não numérico, o código a seguir pode dar a resposta:

structfun(@(x) ischar(x), meudir(1))

O primeiro e o segundo campo de uma estrutura dir são do tipo char. Portanto, a saída é:

1
1
0
0
0

Além disso, a saída é um vetor lógico de verdadeiro / falso. Conseqüentemente, é regular e pode ser salvo em um vetor; não há necessidade de
usar uma classe de célula.

GoalKicker.com Notas MATLAB® para profissionais 164

Machine Translated by Google

Capítulo 33: Erros e erros comuns

Seção 33.1: Os operadores de transposição
.' é a maneira correta de transpor um vetor ou matriz no MATLAB. ' é a maneira
correta de obter a transposta conjugada complexa (também conhecida como conjugado Hermitiano) de um vetor ou matriz no MATLAB.

Observe que para a transposição .', há um ponto final antes do apóstrofo. Isso está de acordo com a sintaxe para as outras operações elemento a
elemento no MATLAB: * multiplica matrizes, .* multiplica elementos de matrizes entre si. Os dois comandos são muito semelhantes, mas conceitualmente
muito distintos. Como outros comandos do MATLAB, esses operadores são “açúcar sintático” que se transformam em uma chamada de função
“adequada” em tempo de execução. Assim como == se torna uma avaliação da equação função, pense em .' como a abreviação de transpor. Se você
apenas escrevesse ' (sem ponto), na verdade você estaria usando o ctranspose comando em vez disso, que calcula a transposta conjugada complexa,
que também é conhecido como conjugado hermitiano, frequentemente usado em física. Contanto que o vetor ou matriz transposto tenha valor real, os
dois operadores produzem o mesmo resultado. Mas assim que lidarmos com números complexos, inevitavelmente teremos problemas se não
usarmos a abreviação "correta". O que é "correto" depende da sua aplicação.

Considere o seguinte exemplo de uma matriz C contendo números complexos:

>> C = [1i, 2; 3*1i, 4]

C=
0,0000 + 1,0000i 2,0000 + 0,0000i 0,0000 + 3,0000i
4,0000 + 0,0000i

Vamos fazer a transposição usando a abreviação .' (com o ponto final). A saída é a esperada, a forma transposta de
C.

>> C.'
anos =
0,0000 + 1,0000i 0,0000 + 3,0000i
2,0000 + 0,0000i 4,0000 + 0,0000i

Agora, vamos usar ' (sem ponto final). Vemos que além da transposição, os valores complexos também foram transformados em seus conjugados

complexos .

>>C'
anos =
0,0000 - 1,0000i 0,0000 - 3,0000i
2,0000 + 0,0000i 4,0000 + 0,0000i

'
Resumindo, se você pretende calcular o conjugado hermitiano, transponha o conjugado complexo, então use (sem o ponto). Se você deseja
apenas calcular a transposta sem conjugar os valores de maneira complexa, use .' (com o ponto final).

Seção 33.2: Não nomeie uma variável com uma função existente
nome
Já existe uma função sum(). Como resultado, se nomearmos uma variável com o mesmo nome

soma = 1+3;

e se tentarmos usar a função enquanto a variável ainda existe no espaço de trabalho

GoalKicker.com Notas MATLAB® para profissionais 165

Machine Translated by Google

A = rand(2);
soma(A,1)

obteremos o erro enigmático:

Os índices subscritos devem ser números inteiros positivos reais ou lógicos.

claro() a variável primeiro e depois use a função

limpar soma

soma(A,1)
anos =
1.0826 1.0279

Como podemos verificar se já existe uma função para evitar este conflito?

Use qual() com o sinalizador -all :

qual soma -tudo

soma é uma variável.
embutido (C:\Arquivos de Programas\MATLAB\R2016a\toolbox\matlab\datafun\@double\sum) % Método duplo sombreado

...

Esta saída está nos dizendo que sum é primeiro uma variável e que os seguintes métodos (funções) são obscurecidos por ela, ou seja
O MATLAB tentará primeiro aplicar nossa sintaxe à variável, em vez de usar o método.

Seção 33.3: Esteja ciente da imprecisão do ponto flutuante

Os números de ponto flutuante não podem representar todos os números reais. Isso é conhecido como imprecisão de ponto flutuante.

Existem infinitos números de pontos flutuantes e eles podem ser infinitamente longos (por exemplo, ÿ), portanto, ser capaz de representá-los
perfeitamente exigiria uma quantidade infinita de memória. Vendo que isso era um problema, foi projetada uma representação especial para
armazenamento de "números reais" em computadores, o padrão IEEE 754. Resumindo, descreve como os computadores armazenam este tipo de
números, com expoente e mantissa, como,

float = sinal * 2 ^ expoente * mantissa

Com uma quantidade limitada de bits para cada um deles, apenas uma precisão finita pode ser alcançada. Quanto menor o número, menor a diferença

entre os números possíveis (e vice-versa!). Você pode testar seus números reais nesta demonstração online.

Esteja ciente deste comportamento e tente evitar todas as comparações de pontos flutuantes e seu uso como condições de parada em loops. Veja
abaixo dois exemplos:

Exemplos: comparação de ponto flutuante feita ERRADA:

>> 0,1 + 0,1 + 0,1 == 0,3

anos =

lógico

É uma prática inadequada usar comparação de ponto flutuante, conforme mostrado no exemplo anterior. Você pode superá-lo pegando o valor
absoluto da diferença e comparando-o com um (pequeno) nível de tolerância.

GoalKicker.com Notas MATLAB® para profissionais 166

Machine Translated by Google

Abaixo está outro exemplo, onde um número de ponto flutuante é usado como condição de parada em um loop while:**

k = 0,1;
enquanto k <= 0,3
disp(num2str(k)); k = k +
0,1; fim

% --- Saída: --- 0,1 0,2

Ele perde o último loop esperado (0,3 <= 0,3).

Exemplo: comparação de ponto flutuante feita À DIREITA:

x = 0,1 + 0,1 + 0,1; y = 0,3;

tolerância
= 1e-10; % Uma tolerância "suficientemente boa" para este caso.

if ( abs( x - y ) <= tolerância ) disp('x == y'); outro

disp('x ~= y'); fim

% --- Saída: ---

x == y

Várias coisas a serem observadas:

Como esperado, agora x e y são tratados como equivalentes.

No exemplo acima, a escolha da tolerância foi feita de forma arbitrária. Assim, o valor escolhido pode não ser adequado para todos
os casos (especialmente quando se trabalha com números muito menores). A escolha do limite de forma inteligente pode ser feita usando
o eps função, ou seja, N*eps(max(x,y)), onde N é algum número específico do problema. Uma escolha razoável para N, que também
é suficientemente permissiva, é 1E2 (embora, no problema acima, N=1 também seja suficiente).

Leitura adicional:

Veja estas perguntas para obter mais informações sobre imprecisão de ponto flutuante:

Por que 24,0000 não é igual a 24,0000 no MATLAB?

A matemática do ponto flutuante está quebrada?

Seção 33.4: O que você vê NÃO é o que você obtém: char vs

cellstring na janela de comando
Este é um exemplo básico voltado para novos usuários. Ele não se concentra em explicar a diferença entre char e cellstring.

Pode acontecer que você queira se livrar dos ' em suas strings, embora nunca os tenha adicionado. Na verdade, esses são artefatos que a janela
de comando usa para distinguir entre alguns tipos.

Uma linha irá imprimir

s = 'dsadasd'
s=

GoalKicker.com Notas MATLAB® para profissionais 167

Machine Translated by Google
dsadasd

Uma cadeia de células irá imprimir

c = {'dsadasd'};
c=
'dsadasd'

Observe como as aspas simples e o recuo são artefatos para nos notificar que c é uma string de célula em vez de um caractere. A string está de fato

contida na célula, ou seja

c{1}
anos =
dsadasd

Seção 33.5: Função indefinida ou método X para

argumentos de entrada do tipo Y
Esta é a maneira prolixa do MATLAB de dizer que não consegue encontrar a função que você está tentando chamar. Existem vários motivos pelos quais

você pode receber esse erro:

Essa função foi introduzida após sua versão atual do MATLAB

A documentação online do MATLAB fornece um recurso muito interessante que permite determinar em qual versão uma determinada função foi introduzida.

Ele está localizado no canto inferior esquerdo de cada página da documentação:

Compare esta versão com sua própria versão atual (ver) para determinar se esta função está disponível em sua versão específica. Caso contrário, tente

pesquisar as versões arquivadas da documentação para encontrar uma alternativa adequada em sua versão.

Você não tem essa caixa de ferramentas!

A instalação básica do MATLAB possui um grande número de funções; no entanto, funcionalidades mais especializadas são empacotadas em caixas de

ferramentas e vendidas separadamente pela MathWorks. A documentação de todas as caixas de ferramentas está visível, quer você tenha a caixa de

ferramentas ou não, portanto, verifique se você possui a caixa de ferramentas apropriada.

Para verificar a qual caixa de ferramentas uma determinada função pertence, procure no canto superior esquerdo da documentação on-line se uma caixa

de ferramentas específica é mencionada.

GoalKicker.com Notas MATLAB® para profissionais 168

Machine Translated by Google

Você pode então determinar quais caixas de ferramentas sua versão do MATLAB instalou emitindo o ver comando que imprimirá uma lista de todas
as caixas de ferramentas instaladas.

Se você não tiver essa caixa de ferramentas instalada e quiser usar a função, precisará adquirir uma licença para essa caixa de ferramentas
específica no MathWorks.

MATLAB não consegue localizar a função

Se o MATLAB ainda não conseguir encontrar sua função, ela deverá ser uma função definida pelo usuário. É possível que ele resida em outro
diretório e esse diretório deva ser adicionado ao caminho de pesquisa para que seu código seja executado. Você pode verificar se o MATLAB
pode localizar sua função usando qual que deve retornar o caminho para o arquivo de origem.

Seção 33.6: O uso de "i" ou "j" como unidade imaginária,

índices de loop ou variável comum
Recomendação

Como os símbolos i e j podem representar coisas significativamente diferentes no MATLAB, seu uso como índices de loop dividiu a comunidade
de usuários do MATLAB há muito tempo. Embora algumas razões históricas de desempenho possam ajudar o equilíbrio a inclinar-se para um lado,
este não é mais o caso e agora a escolha depende inteiramente de você e das práticas de codificação que você escolhe seguir.

As recomendações oficiais atuais do MathWorks são:

Como i é uma função, ela pode ser substituída e usada como variável. Entretanto, é melhor evitar usar i e j para nomes de
variáveis se você pretende usá-los em aritmética complexa.
Para velocidade e maior robustez em aritmética complexa, use 1i e 1j em vez de i e j.

Padrão

No MATLAB, por padrão, as letras i e j são nomes de funções integradas , que se referem à unidade imaginária no domínio complexo.

GoalKicker.com Notas MATLAB® para profissionais 169

Machine Translated by Google

Então, por padrão, i = j = sqrt(-1).

>> eu
anos =
0,0000 + 1,0000i
>> j
anos =
0,0000 + 1,0000i

e como você deve esperar:

>> eu^2
anos =
-1

Usando-os como uma variável (para índices de loop ou outras variáveis)

MATLAB permite usar o nome da função integrada como uma variável padrão. Neste caso, o símbolo usado não apontará mais para
a função interna, mas para a sua própria variável definida pelo usuário. Esta prática, no entanto, geralmente não é recomendada,
pois pode levar a confusão, dificuldade de depuração e manutenção (veja outro exemplo, não nomeie uma variável com um nome de
função existente).

Se você for ultrapedante em respeitar convenções e práticas recomendadas, evitará usá-las como índices de loop nesta linguagem. No
entanto, é permitido pelo compilador e perfeitamente funcional, portanto você também pode optar por manter velhos hábitos e usá-los
como iteradores de loop.

>> A = nan(2,3); >> para

i=1:2 % de construção de loop perfeitamente legal
para j = 1:3
UMA(eu, j) = 10 * eu + j; fim

fim

Observe que os índices de loop não saem do escopo no final do loop, portanto, eles mantêm seu novo valor.

>> [ eu ; j ]
anos =
2
3

Caso você os utilize como variáveis, certifique-se de que sejam inicializados antes de serem utilizados. No loop acima, o
MATLAB os inicializa automaticamente ao preparar o loop, mas se não for inicializado corretamente, você poderá ver rapidamente
que pode introduzir inadvertidamente números complexos em seu resultado.

Se mais tarde você precisar desfazer o sombreamento da função interna (=por exemplo, você deseja que i e j representem a
unidade imaginária novamente), você pode limpar as variáveis:

>> limpar ij

Você entende agora a reserva do MathWorks sobre usá-los como índices de loop se pretende usá-los em aritmética complexa.
Seu código estaria repleto de inicializações de variáveis e comandos claros , a melhor maneira de confundir o programador mais
sério (sim, você aí!...) e acidentes de programa esperando para acontecer.

Se nenhuma aritmética complexa for esperada, o uso de i e j é perfeitamente funcional e não há penalidade no desempenho.

GoalKicker.com Notas MATLAB® para profissionais 170

Machine Translated by Google

Usando-os como unidade imaginária:

Se o seu código tiver que lidar com números complexos , i e j certamente serão úteis. Contudo, por uma questão de desambiguação e até mesmo
para performances, recomenda-se usar a forma completa em vez da sintaxe abreviada. A forma completa é 1i (ou 1j).

>> [ eu ; j ; 1 eu ; 1j]
anos =
0,0000 + 1,0000i 0,0000
+ 1,0000i
0,0000 + 1,0000i
0,0000 + 1,0000i

Eles representam o mesmo valor sqrt(-1), mas a forma posterior:

é mais explícito, de forma semântica. é mais

sustentável (alguém que olhar seu código mais tarde não precisará ler o código para descobrir se i ou j era uma variável ou a unidade
imaginária). é mais rápido (fonte: MathWorks).

Observe que a sintaxe completa 1i é válida com qualquer número precedendo o símbolo:

>> uma = 3 + 7,8j

uma =

3,0000 + 7,8000i

Esta é a única função que você pode usar com um número sem um operador entre eles.

Armadilhas

Embora seu uso como unidade OU variável imaginária seja perfeitamente legal, aqui está apenas um pequeno exemplo de como pode ficar confuso se
ambos os usos forem misturados:

Vamos substituir i e torná-lo uma variável:

>> eu=3
eu =
3

Agora i é uma variável (mantendo o valor 3), mas apenas substituímos a notação abreviada da unidade imaginária, a forma completa ainda é
interpretada corretamente:

>> 3i
anos =
0,0000 + 3,0000i

O que agora nos permite construir as formulações mais obscuras. Eu deixei você avaliar a legibilidade de todos os itens a seguir
construções:

>> [ eu ; 3i ; 3*eu ; eu+3i ; eu+3*eu ]

anos =
3,0000 + 0,0000i 0,0000
+ 3,0000i
9,0000 + 0,0000i
3,0000 + 3,0000i

GoalKicker.com Notas MATLAB® para profissionais 171

Machine Translated by Google
12,0000 + 0,0000i

Como você pode ver, cada valor no array acima retorna um resultado diferente. Embora cada resultado seja válido (desde que essa seja a intenção
inicial), a maioria de vocês admitirá que seria um verdadeiro pesadelo ler um código repleto de tais informações.
construções.

Seção 33.7: Argumentos de entrada insuficientes

Freqüentemente, os desenvolvedores iniciantes do MATLAB usarão o editor do MATLAB para escrever e editar código, em particular funções
personalizadas com entradas e saídas. Há um botão Executar na parte superior que está disponível nas versões recentes do MATLAB:

Depois que o desenvolvedor termina o código, ele geralmente fica tentado a apertar o botão Executar . Para algumas funções isso funcionará bem,
mas para outras elas receberão um erro Argumentos de entrada insuficientes e ficarão intrigadas sobre o motivo do
ocorreu um erro.

A razão pela qual esse erro pode não acontecer é porque você escreveu um script MATLAB ou uma função que não aceita argumentos de
entrada. Usar o botão Executar executará um script de teste ou uma função assumindo que não há argumentos de entrada. Se a sua função exigir
argumentos de entrada, o erro Argumentos de entrada insuficientes ocorrerá porque você escreveu uma função que espera que as entradas
entrem na função. Portanto, você não pode esperar que a função seja executada simplesmente pressionando o botão Executar .

Para demonstrar esse problema, suponha que temos uma função mult que simplesmente multiplica duas matrizes:

função C = mult(A, B)
C=A*B;
fim

Nas versões recentes do MATLAB, se você escreveu esta função e apertou o botão Executar , ocorrerá o erro que esperamos:

>> mult
Argumentos de entrada insuficientes .

Erro em mult (linha 2)

C=A*B;

Existem duas maneiras de resolver esse problema:

Método #1 – Através do prompt de comando

Basta criar as entradas necessárias no prompt de comando e executar a função usando as entradas que você criou:

A = rand(5,5);
B = rand(5,5);
C = mult(A,B);

Método #2 – Interativamente através do Editor

Abaixo do botão Executar , há uma seta preta escura. Se você clicar nessa seta, poderá especificar as variáveis que deseja

GoalKicker.com Notas MATLAB® para profissionais 172

Machine Translated by Google

gostaria de obter no espaço de trabalho do MATLAB digitando a maneira como deseja chamar a função exatamente como você viu no
método nº 1. Certifique-se de que as variáveis que você está especificando dentro da função existam no espaço de trabalho do
MATLAB:

Seção 33.8: Usando `length` para matrizes multidimensionais

Um erro comum que os codificadores MATLAB cometem é usar a função de comprimento para matrizes (em oposição aos vetores,
aos quais se destina). A função length , conforme mencionado em sua documentação, "retorna o comprimento da maior dimensão do array"
da entrada.

Para vetores, o valor de retorno do comprimento tem dois significados diferentes:

1. O número total de elementos do vetor.

2. A maior dimensão do vetor.

Ao contrário dos vetores, os valores acima não seriam iguais para matrizes de mais de uma dimensão não-singleton (ou seja, cujo tamanho
é maior que 1). É por isso que usar comprimento para matrizes é ambíguo. Em vez disso, é recomendável usar uma das seguintes
funções, mesmo ao trabalhar com vetores, para deixar a intenção do código perfeitamente clara:

1. tamanho(A) - retorna um vetor linha cujos elementos contêm a quantidade de elementos ao longo do correspondente
dimensão de A.

2. numeração(A) - retorna o número de elementos em A. Equivalente a prod(size(A)). 3. ndim(A) -

retorna o número de dimensões no array A. Equivalente a numel(size(A)).

Isso é especialmente importante ao escrever funções de biblioteca vetorizadas "preparadas para o futuro", cujas entradas não são conhecidas
antecipadamente e podem ter vários tamanhos e formas.

Seção 33.9: Cuidado com as mudanças no tamanho do array

Algumas operações comuns no MATLAB, como diferenciação ou integração, produzem resultados que possuem uma quantidade de
elementos diferente da dos dados de entrada. Este fato pode ser facilmente ignorado, o que normalmente causaria erros como as
dimensões da Matriz devem concordar. Considere o seguinte exemplo:

t = 0:0,1:10; y = % Declarando um vetor de tempo

pecado(t); % Declarando uma função

dy_dt = diferença(y); % calcula dy/dt para y = sin(t)

Digamos que queremos representar graficamente esses resultados. Damos uma olhada nos tamanhos dos arrays e vemos:

tamanho (y) é 1x101

tamanho (t) é 1x101

Mas:

GoalKicker.com Notas MATLAB® para profissionais 173

Machine Translated by Google

tamanho (dy_dt) é 1x100

A matriz é um elemento mais curta!

Agora imagine que você tem dados de medição de posições ao longo do tempo e deseja calcular jerk(t), você obterá um array 3

elementos menores que a matriz de tempo (porque o jerk é a posição diferenciada 3 vezes).

vel = diferença(y); % calcula a velocidade vel=dy/dt para y = sin(t) tamanho(vel)=1x100

acc = diferença(vel); % calcula a aceleração acc=d(vel)/dt size(acc)=1x99
idiota = diff(acc); % calcula jerk jerk=d(acc)/dt size(jerk)=1x98

E então operações como:

x = idiota.*t; % multiplica jerk e t elemento sábio

retorna erros, porque as dimensões da matriz não concordam.

Para calcular operações como acima, você deve ajustar o tamanho maior do array para caber no menor. Você também pode correr

uma regressão (polyfit) com seus dados para obter um polinômio para seus dados.

Erros de incompatibilidade de dimensão

Erros de incompatibilidade de dimensão normalmente aparecem quando:

Não prestar atenção ao formato das variáveis retornadas das chamadas de função/método. Em muitos MATLAB embutidos

funções, as matrizes são convertidas em vetores para acelerar os cálculos, e a variável retornada pode

ainda será um vetor em vez da matriz que esperávamos. Este também é um cenário comum quando o mascaramento lógico é
envolvido.

Usando tamanhos de array incompatíveis ao invocar a expansão implícita de array.

GoalKicker.com Notas MATLAB® para profissionais 174

Machine Translated by Google

Créditos
Muito obrigado a todas as pessoas da Stack Overflow Documentation que ajudaram a fornecer este conteúdo,
mais alterações podem ser enviadas para [email protected] para que novo conteúdo seja publicado ou atualizado

adjpayot Capítulo 1
Adriaan Capítulo 27
agente_C.Hdj Capítulo 8
Alexander Korovin Capítulo 10
alexforrence Capítulos 6 e 9
Amro Capítulos 1, 12 e 17
Ander Biguri Capítulos 6, 15, 24, 28 e 33
o sol Capítulo 3
Batsu Capítulo 4
Código do Capítulo 15
Cabo celtechflamdhm Capítulo 6
Celdor Capítulos 9, 12 e 32
Chrisb2244 Capítulo 1
Co-aviador Christopher Capítulo 1
Creutzig Capítulo 29
daleonpz Capítulo 26
E Capítulos 1 e 10
darenshan Capítulos 9 e 27
Desenvolvedor
Capítulos 6, 9, 10, 23, 25, 26, 29, 31 e 33
drhagen Capítulo 8
DVarga Capítulos 1 e 25
EBA Capítulos 1, 3, 8, 10 e 32
edwinksl Capítulo 33
Érico Capítulo 6
Erik Capítulos 1, 29 e 32
excaza Capítulo 1
flor Capítulo 1
Franck Dernoncourt Capítulos 17 e 27
pinguim-fogo Capítulos 1 e 32
GameOfThrows Capítulos 1 e 18
girish_m Capítulo 15
Hardik_Jain Capítulo 27
Volte Capítulos 28, 31 e 33
il_raffa Capítulos 16, 26 e 30
itzik Ben Shabat Capítulo 13
jensvs Capítulo 25
Jim Capítulo 27
Jkazan Capítulo 22
Justino Capítulo 25
Ken Sebesta Capítulo 28
Porco-espinho
Capítulos 1, 7, 18 e 33
Lior Capítulo 1
Malick Capítulos 30, 32 e 33
matlabgui Capítulo 29
Matt Capítulos 1, 10, 12 e 33
MayeulC Capítulo 30
McLemon Capítulo 30

GoalKicker.com Notas MATLAB® para profissionais 175

Machine Translated by Google

Mike Capítulo 28
Mhopeng Capítulo 24
Michael_Sam Capítulos 1 e 7
Mohsen Nosratinia Capítulos 7 e 9
nahomyaja Capítulo 33
nitsua60 Capítulo 16
NKN Capítulos 16, 30 e 33
Noa Regev Capítulo 14
Oleg Capítulos 10, 12, 17, 28 e 33
pseudoDust Capítulo 26
R. Joiny Capítulo 33
rajah9 Capítulo 2
rayryeng Capítulo 33
Royi Capítulo 23
S. Radev Capítulo 7
Sam Roberts Capítulo 1
Sardar Osama Capítulo 30
Shai Capítulos 1, 5, 10 e 15
StefanM Capítulos 5, 11, 19, 20 e 21
Super Capítulos 31 e 33
o caminho que andamos Capítulos 16, 26 e 29
Tim Capítulo 33
Trilarion Capítulo 15
Trogdor Capítulo 9
Tyler Capítulos 1, 8 e 10
Umar Capítulo 33
ZEP Capítulos 16 e 31

GoalKicker.com Notas MATLAB® para profissionais 176

Machine Translated by Google

você pode gostar