MATLAB - Guida rapida

MATLAB (Matrix Laboratory) è un linguaggio di programmazione di alto livello di quarta generazione e un ambiente interattivo per il calcolo numerico, la visualizzazione e la programmazione.

MATLAB è sviluppato da MathWorks.

Consente manipolazioni di matrici; rappresentazione grafica di funzioni e dati; implementazione di algoritmi; creazione di interfacce utente; interfacciamento con programmi scritti in altri linguaggi, inclusi C, C ++, Java e FORTRAN; analizzare i dati; sviluppare algoritmi; e creare modelli e applicazioni.

Ha numerosi comandi incorporati e funzioni matematiche che ti aiutano nei calcoli matematici, nella generazione di grafici e nell'esecuzione di metodi numerici.

Il potere della matematica computazionale di MATLAB

MATLAB è utilizzato in ogni aspetto della matematica computazionale. Di seguito sono riportati alcuni calcoli matematici di uso comune in cui viene utilizzato più comunemente:

  • Trattare con matrici e array
  • Stampa e grafica 2-D e 3-D
  • Algebra lineare
  • Equazioni algebriche
  • Funzioni non lineari
  • Statistics
  • Analisi dei dati
  • Calcolo ed equazioni differenziali
  • Calcoli numerici
  • Integration
  • Transforms
  • Raccordo a curva
  • Varie altre funzioni speciali

Caratteristiche di MATLAB

Di seguito sono riportate le caratteristiche di base di MATLAB:

  • È un linguaggio di alto livello per il calcolo numerico, la visualizzazione e lo sviluppo di applicazioni.

  • Fornisce inoltre un ambiente interattivo per l'esplorazione iterativa, la progettazione e la risoluzione dei problemi.

  • Fornisce una vasta libreria di funzioni matematiche per algebra lineare, statistica, analisi di Fourier, filtri, ottimizzazione, integrazione numerica e risoluzione di equazioni differenziali ordinarie.

  • Fornisce grafica incorporata per la visualizzazione dei dati e strumenti per la creazione di grafici personalizzati.

  • L'interfaccia di programmazione di MATLAB fornisce strumenti di sviluppo per migliorare la manutenibilità della qualità del codice e massimizzare le prestazioni.

  • Fornisce strumenti per la creazione di applicazioni con interfacce grafiche personalizzate.

  • Fornisce funzioni per l'integrazione di algoritmi basati su MATLAB con applicazioni e linguaggi esterni come C, Java, .NET e Microsoft Excel.

Usi di MATLAB

MATLAB è ampiamente utilizzato come strumento di calcolo nella scienza e nell'ingegneria che comprende i campi della fisica, della chimica, della matematica e di tutti i flussi di ingegneria. Viene utilizzato in una vasta gamma di applicazioni, tra cui:

  • Elaborazione del segnale e comunicazioni
  • Elaborazione di immagini e video
  • Sistemi di controllo
  • Test e misurazioni
  • Finanza computazionale
  • Biologia computazionale

Configurazione dell'ambiente locale

La configurazione dell'ambiente MATLAB è questione di pochi clic. Il programma di installazione può essere scaricato da qui .

MathWorks fornisce il prodotto con licenza, una versione di prova e anche una versione per studenti. Devi accedere al sito e attendere un po 'per la loro approvazione.

Dopo aver scaricato il programma di installazione, il software può essere installato con pochi clic.

Capire l'ambiente MATLAB

L'IDE di sviluppo MATLAB può essere avviato dall'icona creata sul desktop. La finestra di lavoro principale in MATLAB si chiama desktop. Quando MATLAB viene avviato, il desktop appare nel suo layout predefinito -

Il desktop ha i seguenti pannelli:

  • Current Folder - Questo pannello consente di accedere alle cartelle e ai file del progetto.

  • Command Window- Questa è l'area principale in cui è possibile immettere i comandi dalla riga di comando. È indicato dal prompt dei comandi (>>).

  • Workspace - L'area di lavoro mostra tutte le variabili create e / o importate dai file.

  • Command History - Questo pannello mostra o restituisce i comandi immessi nella riga di comando.

Imposta GNU Octave

Se desideri utilizzare Octave sulla tua macchina (Linux, BSD, OS X o Windows), scarica gentilmente l'ultima versione da Download GNU Octave . È possibile controllare le istruzioni di installazione fornite per la macchina.

L'ambiente MATLAB si comporta come un calcolatore super complesso. È possibile immettere comandi al prompt dei comandi >>.

MATLAB è un ambiente interpretato. In altre parole, dai un comando e MATLAB lo esegue immediatamente.

Pratica pratica

Digita un'espressione valida, ad esempio,

5 + 5

E premere INVIO

Quando fai clic sul pulsante Esegui o digiti Ctrl + E, MATLAB lo esegue immediatamente e il risultato restituito è -

ans = 10

Prendiamo alcuni altri esempi:

3 ^ 2	       % 3 raised to the power of 2

Quando fai clic sul pulsante Esegui o digiti Ctrl + E, MATLAB lo esegue immediatamente e il risultato restituito è -

ans = 9

Un altro esempio,

sin(pi /2)	  % sine of angle 90o

Quando fai clic sul pulsante Esegui o digiti Ctrl + E, MATLAB lo esegue immediatamente e il risultato restituito è -

ans = 1

Un altro esempio,

7/0		      % Divide by zero

Quando fai clic sul pulsante Esegui o digiti Ctrl + E, MATLAB lo esegue immediatamente e il risultato restituito è -

ans = Inf
warning: division by zero

Un altro esempio,

732 * 20.3

Quando fai clic sul pulsante Esegui o digiti Ctrl + E, MATLAB lo esegue immediatamente e il risultato restituito è -

ans =  1.4860e+04

MATLAB fornisce alcune espressioni speciali per alcuni simboli matematici, come pi per π, Inf per ∞, i (ej) per √-1 ecc. Nan sta per "not a number".

Uso del punto e virgola (;) in MATLAB

Il punto e virgola (;) indica la fine dell'istruzione. Tuttavia, se desideri sopprimere e nascondere l'output MATLAB per un'espressione, aggiungi un punto e virgola dopo l'espressione.

Per esempio,

x = 3;
y = x + 5

Quando fai clic sul pulsante Esegui o digiti Ctrl + E, MATLAB lo esegue immediatamente e il risultato restituito è -

y =  8

Aggiunta di commenti

Il simbolo della percentuale (%) viene utilizzato per indicare una riga di commento. Per esempio,

x = 9	     % assign the value 9 to x

Puoi anche scrivere un blocco di commenti utilizzando gli operatori di commenti di blocco% {e%}.

L'editor MATLAB include strumenti e voci del menu contestuale per aiutarti ad aggiungere, rimuovere o modificare il formato dei commenti.

Operatori e caratteri speciali comunemente usati

MATLAB supporta i seguenti operatori e caratteri speciali di uso comune:

Operatore Scopo
+ Più; operatore di addizione.
- Meno; operatore di sottrazione.
* Operatore di moltiplicazione scalare e matriciale.
.* Operatore di moltiplicazione di array.
^ Operatore di esponenziazione scalare e matrice.
.^ Operatore di esponenziazione di array.
\ Operatore di divisione a sinistra.
/ Operatore di divisione a destra.
.\ Operatore di divisione sinistra della matrice.
./ Operatore di divisione a destra dell'array.
: Colon; genera elementi regolarmente distanziati e rappresenta un'intera riga o colonna.
( ) Parentesi; racchiude argomenti di funzione e indici di array; sovrascrive la precedenza.
[ ] Parentesi; racchiude gli elementi dell'array.
. Punto decimale.
Ellissi; operatore di continuazione della riga
, Virgola; separa le istruzioni e gli elementi in una riga
; Punto e virgola; separa le colonne e sopprime la visualizzazione.
% Segno di percentuale; designa un commento e specifica la formattazione.
_ Segnale di citazione e operatore di trasposizione.
._ Operatore di trasposizione non coniugato.
= Operatore di assegnazione.

Variabili speciali e costanti

MATLAB supporta le seguenti variabili e costanti speciali:

Nome Senso
ans Risposta più recente.
eps Precisione della precisione in virgola mobile.
i,j L'unità immaginaria √-1.
Inf Infinito.
NaN Risultato numerico indefinito (non un numero).
pi Il numero π

Denominazione delle variabili

I nomi delle variabili sono costituiti da una lettera seguita da un numero qualsiasi di lettere, cifre o trattini bassi.

MATLAB è case-sensitive.

I nomi delle variabili possono essere di qualsiasi lunghezza, tuttavia, MATLAB utilizza solo i primi N caratteri, dove N è dato dalla funzione namelengthmax.

Salvare il tuo lavoro

Il save viene utilizzato per salvare tutte le variabili nell'area di lavoro, come file con estensione .mat, nella directory corrente.

Per esempio,

save myfile

Puoi ricaricare il file in qualsiasi momento utilizzando l'estensione load comando.

load myfile

Nell'ambiente MATLAB, ogni variabile è un array o una matrice.

Puoi assegnare variabili in modo semplice. Per esempio,

x = 3	       % defining x and initializing it with a value

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

x = 3

Crea una matrice 1 per 1 denominata x e memorizza il valore 3 nel suo elemento. Controlliamo un altro esempio,

x = sqrt(16) 	% defining x and initializing it with an expression

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

x = 4

Si prega di notare che -

  • Una volta inserita una variabile nel sistema, è possibile farvi riferimento in un secondo momento.

  • Le variabili devono avere valori prima di essere utilizzate.

  • Quando un'espressione restituisce un risultato che non è assegnato a nessuna variabile, il sistema lo assegna a una variabile denominata ans, che può essere utilizzata in seguito.

Per esempio,

sqrt(78)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =  8.8318

Puoi usare questa variabile ans -

sqrt(78);
9876/ans

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =  1118.2

Diamo un'occhiata a un altro esempio:

x = 7 * 8;
y = x * 7.89

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

y =  441.84

Assegnazioni multiple

Puoi avere più compiti sulla stessa riga. Per esempio,

a = 2; b = 7; c = a * b

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

c = 14

Ho dimenticato le variabili!

Il who Il comando mostra tutti i nomi delle variabili che hai usato.

who

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

Your variables are:
a    ans  b    c

Il whos Il comando mostra poco di più sulle variabili -

  • Variabili attualmente in memoria
  • Tipo di ciascuna variabile
  • Memoria assegnata a ciascuna variabile
  • Che si tratti di variabili complesse o meno
whos

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

Attr Name        Size        Bytes      Class
==== ====        ====        ====       ===== 
   a             1x1           8        double
   ans           1x70         757        cell
   b             1x1           8        double
   c             1x1           8        double

Total is 73 elements using 781 bytes

Il clear Il comando elimina tutte (o le variabili specificate) dalla memoria.

clear x     % it will delete x, won't display anything
clear       % it will delete all variables in the workspace
            %  peacefully and unobtrusively

Assegnazioni lunghe

Le assegnazioni lunghe possono essere estese a un'altra riga utilizzando i puntini di sospensione (...). Per esempio,

initial_velocity = 0;
acceleration = 9.8;
time = 20;
final_velocity = initial_velocity + acceleration * time

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

final_velocity = 196

Il formato Command

Per impostazione predefinita, MATLAB visualizza i numeri con quattro valori di posizione decimale. Questo è noto comeshort format.

Tuttavia, se si desidera una maggiore precisione, è necessario utilizzare l'estensione format comando.

Il format long Il comando visualizza 16 cifre dopo i decimali.

Ad esempio:

format long
x = 7 + 10/3 + 5 ^ 1.2

MATLAB eseguirà l'istruzione precedente e restituirà il seguente risultato -

x = 17.2319816406394

Un altro esempio,

format short
x = 7 + 10/3 + 5 ^ 1.2

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

x = 17.232

Il format bankIl comando arrotonda i numeri a due cifre decimali. Per esempio,

format bank
daily_wage = 177.45;
weekly_wage = daily_wage * 6

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

weekly_wage = 1064.70

MATLAB visualizza numeri grandi utilizzando la notazione esponenziale.

Il format short e il comando consente la visualizzazione in forma esponenziale con quattro cifre decimali più l'esponente.

Per esempio,

format short e
4.678 * 4.9

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans = 2.2922e+01

Il format long eil comando consente la visualizzazione in forma esponenziale con quattro cifre decimali più l'esponente. Per esempio,

format long e
x = pi

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

x = 3.141592653589793e+00

Il format ratfornisce l'espressione razionale più vicina risultante da un calcolo. Per esempio,

format rat
4.678 * 4.9

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans = 34177/1491

Creazione di vettori

Un vettore è una matrice unidimensionale di numeri. MATLAB consente di creare due tipi di vettori:

  • Vettori di riga
  • Vettori di colonna

Row vectors vengono creati racchiudendo l'insieme di elementi tra parentesi quadre, utilizzando lo spazio o la virgola per delimitare gli elementi.

Per esempio,

r = [7 8 9 10 11]

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

r =

   7    8    9   10   11

Un altro esempio,

r = [7 8 9 10 11];
t = [2, 3, 4, 5, 6];
res = r + t

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

res =

         9         11         13         15         17

Column vectors vengono creati racchiudendo l'insieme di elementi tra parentesi quadre, utilizzando il punto e virgola (;) per delimitare gli elementi.

c = [7;  8;  9;  10; 11]

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

c =
       7       
       8       
       9       
      10       
      11

Creazione di matrici

Una matrice è una matrice bidimensionale di numeri.

In MATLAB, una matrice viene creata inserendo ogni riga come una sequenza di elementi separati da spazi o virgole e la fine di una riga è delimitata da un punto e virgola. Ad esempio, creiamo una matrice 3 per 3 come -

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

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

m =
       1              2              3       
       4              5              6       
       7              8              9

MATLAB è un programma interattivo per il calcolo numerico e la visualizzazione dei dati. È possibile immettere un comando digitandolo al prompt di MATLAB ">>" nel fileCommand Window.

In questa sezione, forniremo elenchi di comandi MATLAB generali di uso comune.

Comandi per la gestione di una sessione

MATLAB fornisce vari comandi per la gestione di una sessione. La tabella seguente fornisce tutti questi comandi:

Comando Scopo
clc Cancella la finestra dei comandi.
chiaro Rimuove le variabili dalla memoria.
esistere Verifica l'esistenza di file o variabili.
globale Dichiara le variabili come globali.
Aiuto Cerca un argomento della guida.
cercare Cerca una parola chiave nelle voci della guida.
smettere Ferma MATLAB.
chi Elenca le variabili correnti.
chi Elenca le variabili correnti (visualizzazione lunga).

Comandi per lavorare con il sistema

MATLAB fornisce vari comandi utili per lavorare con il sistema, come salvare il lavoro corrente nell'area di lavoro come file e caricare il file in un secondo momento.

Fornisce anche vari comandi per altre attività relative al sistema come la visualizzazione della data, l'elenco dei file nella directory, la visualizzazione della directory corrente, ecc.

La tabella seguente mostra alcuni comandi relativi al sistema di uso comune:

Comando Scopo
CD Cambia la directory corrente.
Data Visualizza la data corrente.
Elimina Elimina un file.
diario Attiva / disattiva la registrazione del file del diario.
dir Elenca tutti i file nella directory corrente.
caricare Carica le variabili dell'area di lavoro da un file.
sentiero Visualizza il percorso di ricerca.
pwd Visualizza la directory corrente.
Salva Salva le variabili dell'area di lavoro in un file.
genere Visualizza il contenuto di un file.
che cosa Elenca tutti i file MATLAB nella directory corrente.
wklread Legge il file del foglio di calcolo .wk1.

Comandi di input e output

MATLAB fornisce i seguenti comandi relativi a input e output:

Comando Scopo
disp Visualizza il contenuto di un array o di una stringa.
fscanf Leggi i dati formattati da un file.
formato Controlla il formato di visualizzazione dello schermo.
fprintf Esegue scritture formattate su schermo o file.
ingresso Visualizza i prompt e attende l'input.
; Elimina la serigrafia.

Il fscanf e fprintfi comandi si comportano come le funzioni C scanf e printf. Supportano i seguenti codici di formato:

Codice di formato Scopo
%s Formato come stringa.
%d Formato come numero intero.
%f Formatta come valore in virgola mobile.
%e Formato come valore in virgola mobile in notazione scientifica.
%g Formato nella forma più compatta:% fo% e.
\n Inserisce una nuova riga nella stringa di output.
\t Inserisce una tabulazione nella stringa di output.

La funzione di formattazione ha le seguenti forme utilizzate per la visualizzazione numerica:

Funzione di formattazione Visualizza fino a
formato breve Quattro cifre decimali (impostazione predefinita).
formato lungo 16 cifre decimali.
formato breve e Cinque cifre più esponente.
formato lungo e 16 cifre più esponenti.
formato banca Due cifre decimali.
formato + Positivo, negativo o zero.
formato ratto Approssimazione razionale.
formato compatto Sopprime alcuni avanzamenti di riga.
formato sciolto Ripristina la modalità di visualizzazione meno compatta.

Comandi Vector, Matrix e Array

La tabella seguente mostra i vari comandi utilizzati per lavorare con array, matrici e vettori:

Comando Scopo
gatto Concatena gli array.
trova Trova indici di elementi diversi da zero.
lunghezza Calcola il numero di elementi.
linspace Crea un vettore spaziato regolarmente.
logspace Crea un vettore spaziato logaritmicamente.
max Restituisce l'elemento più grande.
min Restituisce l'elemento più piccolo.
prod Prodotto di ogni colonna.
rimodellare Modifica le dimensioni.
taglia Calcola la dimensione dell'array.
ordinare Ordina ogni colonna.
somma Somma ogni colonna.
occhio Crea una matrice di identità.
ones Creates an array of ones.
zeros Creates an array of zeros.
cross Computes matrix cross products.
dot Computes matrix dot products.
det Computes determinant of an array.
inv Computes inverse of a matrix.
pinv Computes pseudoinverse of a matrix.
rank Computes rank of a matrix.
rref Computes reduced row echelon form.
cell Creates cell array.
celldisp Displays cell array.
cellplot Displays graphical representation of cell array.
num2cell Converts numeric array to cell array.
deal Matches input and output lists.
iscell Identifies cell array.

Plotting Commands

MATLAB provides numerous commands for plotting graphs. The following table shows some of the commonly used commands for plotting −

Command Purpose
axis Sets axis limits.
fplot Intelligent plotting of functions.
grid Displays gridlines.
plot Generates xy plot.
print Prints plot or saves plot to a file.
title Puts text at top of plot.
xlabel Adds text label to x-axis.
ylabel Adds text label to y-axis.
axes Creates axes objects.
close Closes the current plot.
close all Closes all plots.
figure Opens a new figure window.
gtext Enables label placement by mouse.
hold Freezes current plot.
legend Legend placement by mouse.
refresh Redraws current figure window.
set Specifies properties of objects such as axes.
subplot Creates plots in subwindows.
text Places string in figure.
bar Creates bar chart.
loglog Creates log-log plot.
polar Creates polar plot.
semilogx Creates semilog plot. (logarithmic abscissa).
semilogy Creates semilog plot. (logarithmic ordinate).
stairs Creates stairs plot.
stem Creates stem plot.

So far, we have used MATLAB environment as a calculator. However, MATLAB is also a powerful programming language, as well as an interactive computational environment.

In previous chapters, you have learned how to enter commands from the MATLAB command prompt. MATLAB also allows you to write series of commands into a file and execute the file as complete unit, like writing a function and calling it.

The M Files

MATLAB allows writing two kinds of program files −

  • Scripts − script files are program files with .m extension. In these files, you write series of commands, which you want to execute together. Scripts do not accept inputs and do not return any outputs. They operate on data in the workspace.

  • Functions − functions files are also program files with .m extension. Functions can accept inputs and return outputs. Internal variables are local to the function.

You can use the MATLAB editor or any other text editor to create your .mfiles. In this section, we will discuss the script files. A script file contains multiple sequential lines of MATLAB commands and function calls. You can run a script by typing its name at the command line.

Creating and Running Script File

To create scripts files, you need to use a text editor. You can open the MATLAB editor in two ways −

  • Using the command prompt
  • Using the IDE

If you are using the command prompt, type edit in the command prompt. This will open the editor. You can directly type edit and then the filename (with .m extension)

edit 
Or
edit <filename>

The above command will create the file in default MATLAB directory. If you want to store all program files in a specific folder, then you will have to provide the entire path.

Let us create a folder named progs. Type the following commands at the command prompt (>>) −

mkdir progs    % create directory progs under default directory
chdir progs    % changing the current directory to progs
edit  prog1.m  % creating an m file named prog1.m

If you are creating the file for first time, MATLAB prompts you to confirm it. Click Yes.

Alternatively, if you are using the IDE, choose NEW -> Script. This also opens the editor and creates a file named Untitled. You can name and save the file after typing the code.

Type the following code in the editor −

NoOfStudents = 6000;
TeachingStaff = 150;
NonTeachingStaff = 20;
Total = NoOfStudents + TeachingStaff ...
   + NonTeachingStaff;
disp(Total);

After creating and saving the file, you can run it in two ways −

  • Clicking the Run button on the editor window or

  • Just typing the filename (without extension) in the command prompt: >> prog1

The command window prompt displays the result −

6170

Example

Create a script file, and type the following code −

a = 5; b = 7;
c = a + b
d = c + sin(b)
e = 5 * d
f = exp(-d)

When the above code is compiled and executed, it produces the following result −

c =  12
d =  12.657
e =  63.285
f =    3.1852e-06

MATLAB does not require any type declaration or dimension statements. Whenever MATLAB encounters a new variable name, it creates the variable and allocates appropriate memory space.

If the variable already exists, then MATLAB replaces the original content with new content and allocates new storage space, where necessary.

For example,

Total = 42

The above statement creates a 1-by-1 matrix named 'Total' and stores the value 42 in it.

Data Types Available in MATLAB

MATLAB provides 15 fundamental data types. Every data type stores data that is in the form of a matrix or array. The size of this matrix or array is a minimum of 0-by-0 and this can grow up to a matrix or array of any size.

The following table shows the most commonly used data types in MATLAB −

Sr.No. Data Type & Description
1

int8

8-bit signed integer

2

uint8

8-bit unsigned integer

3

int16

16-bit signed integer

4

uint16

16-bit unsigned integer

5

int32

32-bit signed integer

6

uint32

32-bit unsigned integer

7

int64

64-bit signed integer

8

uint64

64-bit unsigned integer

9

single

single precision numerical data

10

double

double precision numerical data

11

logical

logical values of 1 or 0, represent true and false respectively

12

char

character data (strings are stored as vector of characters)

13

cell array

array of indexed cells, each capable of storing an array of a different dimension and data type

14

structure

C-like structures, each structure having named fields capable of storing an array of a different dimension and data type

15

function handle

pointer to a function

16

user classes

objects constructed from a user-defined class

17

java classes

objects constructed from a Java class

Example

Create a script file with the following code −

str = 'Hello World!'
n = 2345
d = double(n)
un = uint32(789.50)
rn = 5678.92347
c = int32(rn)

When the above code is compiled and executed, it produces the following result −

str = Hello World!
n =  2345
d =  2345
un = 790
rn = 5678.9
c =  5679

Data Type Conversion

MATLAB provides various functions for converting, a value from one data type to another. The following table shows the data type conversion functions −

Function Purpose
char Convert to character array (string)
int2str Convert integer data to string
mat2str Convert matrix to string
num2str Convert number to string
str2double Convert string to double-precision value
str2num Convert string to number
native2unicode Convert numeric bytes to Unicode characters
unicode2native Convert Unicode characters to numeric bytes
base2dec Convert base N number string to decimal number
bin2dec Convert binary number string to decimal number
dec2base Convert decimal to base N number in string
dec2bin Convert decimal to binary number in string
dec2hex Convert decimal to hexadecimal number in string
hex2dec Convert hexadecimal number string to decimal number
hex2num Convert hexadecimal number string to double-precision number
num2hex Convert singles and doubles to IEEE hexadecimal strings
cell2mat Convert cell array to numeric array
cell2struct Convert cell array to structure array
cellstr Create cell array of strings from character array
mat2cell Convert array to cell array with potentially different sized cells
num2cell Convert array to cell array with consistently sized cells
struct2cell Convert structure to cell array

Determination of Data Types

MATLAB provides various functions for identifying data type of a variable.

Following table provides the functions for determining the data type of a variable −

Function Purpose
is Detect state
isa Determine if input is object of specified class
iscell Determine whether input is cell array
iscellstr Determine whether input is cell array of strings
ischar Determine whether item is character array
isfield Determine whether input is structure array field
isfloat Determine if input is floating-point array
ishghandle True for Handle Graphics object handles
isinteger Determine if input is integer array
isjava Determine if input is Java object
islogical Determine if input is logical array
isnumeric Determine if input is numeric array
isobject Determine if input is MATLAB object
isreal Check if input is real array
isscalar Determine whether input is scalar
isstr Determine whether input is character array
isstruct Determine whether input is structure array
isvector Determine whether input is vector
class Determine class of object
validateattributes Check validity of array
whos List variables in workspace, with sizes and types

Example

Create a script file with the following code −

x = 3
isinteger(x)
isfloat(x)
isvector(x)
isscalar(x)
isnumeric(x)
 
x = 23.54
isinteger(x)
isfloat(x)
isvector(x)
isscalar(x)
isnumeric(x)
 
x = [1 2 3]
isinteger(x)
isfloat(x)
isvector(x)
isscalar(x)
 
x = 'Hello'
isinteger(x)
isfloat(x)
isvector(x)
isscalar(x)
isnumeric(x)

When you run the file, it produces the following result −

x = 3
ans = 0
ans = 1
ans = 1
ans = 1
ans = 1
x = 23.540
ans = 0
ans = 1
ans = 1
ans = 1
ans = 1
x =

          1          2          3

ans = 0
ans = 1
ans = 1
ans = 0
x = Hello
ans = 0
ans = 0
ans = 1
ans = 0
ans = 0

An operator is a symbol that tells the compiler to perform specific mathematical or logical manipulations. MATLAB is designed to operate primarily on whole matrices and arrays. Therefore, operators in MATLAB work both on scalar and non-scalar data. MATLAB allows the following types of elementary operations −

  • Arithmetic Operators
  • Relational Operators
  • Logical Operators
  • Bitwise Operations
  • Set Operations

Arithmetic Operators

MATLAB allows two different types of arithmetic operations −

  • Matrix arithmetic operations
  • Array arithmetic operations

Matrix arithmetic operations are same as defined in linear algebra. Array operations are executed element by element, both on one-dimensional and multidimensional array.

The matrix operators and array operators are differentiated by the period (.) symbol. However, as the addition and subtraction operation is same for matrices and arrays, the operator is same for both cases. The following table gives brief description of the operators −

Show Examples

Sr.No. Operator & Description
1

+

Addition or unary plus. A+B adds the values stored in variables A and B. A and B must have the same size, unless one is a scalar. A scalar can be added to a matrix of any size.

2

-

Subtraction or unary minus. A-B subtracts the value of B from A. A and B must have the same size, unless one is a scalar. A scalar can be subtracted from a matrix of any size.

3

*

Matrix multiplication. C = A*B is the linear algebraic product of the matrices A and B. More precisely,

For non-scalar A and B, the number of columns of A must be equal to the number of rows of B. A scalar can multiply a matrix of any size.

4

.*

Array multiplication. A.*B is the element-by-element product of the arrays A and B. A and B must have the same size, unless one of them is a scalar.

5

/

Slash or matrix right division. B/A is roughly the same as B*inv(A). More precisely, B/A = (A'\B')'.

6

./

Array right division. A./B is the matrix with elements A(i,j)/B(i,j). A and B must have the same size, unless one of them is a scalar.

7

\

Backslash or matrix left division. If A is a square matrix, A\B is roughly the same as inv(A)*B, except it is computed in a different way. If A is an n-by-n matrix and B is a column vector with n components, or a matrix with several such columns, then X = A\B is the solution to the equation AX = B. A warning message is displayed if A is badly scaled or nearly singular.

8

.\

Array left division. A.\B is the matrix with elements B(i,j)/A(i,j). A and B must have the same size, unless one of them is a scalar.

9

^

Matrix power. X^p is X to the power p, if p is a scalar. If p is an integer, the power is computed by repeated squaring. If the integer is negative, X is inverted first. For other values of p, the calculation involves eigenvalues and eigenvectors, such that if [V,D] = eig(X), then X^p = V*D.^p/V.

10

.^

Array power. A.^B is the matrix with elements A(i,j) to the B(i,j) power. A and B must have the same size, unless one of them is a scalar.

11

'

Matrix transpose. A' is the linear algebraic transpose of A. For complex matrices, this is the complex conjugate transpose.

12

.'

Array transpose. A.' is the array transpose of A. For complex matrices, this does not involve conjugation.

Relational Operators

Relational operators can also work on both scalar and non-scalar data. Relational operators for arrays perform element-by-element comparisons between two arrays and return a logical array of the same size, with elements set to logical 1 (true) where the relation is true and elements set to logical 0 (false) where it is not.

The following table shows the relational operators available in MATLAB −

Show Examples

Sr.No. Operator & Description
1

<

Less than

2

<=

Less than or equal to

3

>

Greater than

4

>=

Greater than or equal to

5

==

Equal to

6

~=

Not equal to

Logical Operators

MATLAB offers two types of logical operators and functions −

  • Element-wise − These operators operate on corresponding elements of logical arrays.

  • Short-circuit − These operators operate on scalar and, logical expressions.

Element-wise logical operators operate element-by-element on logical arrays. The symbols &, |, and ~ are the logical array operators AND, OR, and NOT.

Short-circuit logical operators allow short-circuiting on logical operations. The symbols && and || are the logical short-circuit operators AND and OR.

Show Examples

Bitwise Operations

Bitwise operators work on bits and perform bit-by-bit operation. The truth tables for &, |, and ^ are as follows −

p q p & q p | q p ^ q
0 0 0 0 0
0 1 0 1 1
1 1 1 1 0
1 0 0 1 1

Assume if A = 60; and B = 13; Now in binary format they will be as follows −

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

MATLAB provides various functions for bit-wise operations like 'bitwise and', 'bitwise or' and 'bitwise not' operations, shift operation, etc.

The following table shows the commonly used bitwise operations −

Show Examples

Function Purpose
bitand(a, b) Bit-wise AND of integers a and b
bitcmp(a) Bit-wise complement of a
bitget(a,pos) Get bit at specified position pos, in the integer array a
bitor(a, b) Bit-wise OR of integers a and b
bitset(a, pos) Set bit at specific location pos of a
bitshift(a, k) Returns a shifted to the left by k bits, equivalent to multiplying by 2k. Negative values of k correspond to shifting bits right or dividing by 2|k| and rounding to the nearest integer towards negative infinite. Any overflow bits are truncated.
bitxor(a, b) Bit-wise XOR of integers a and b
swapbytes Swap byte ordering

Set Operations

MATLAB provides various functions for set operations, like union, intersection and testing for set membership, etc.

The following table shows some commonly used set operations −

Show Examples

Sr.No. Function & Description
1

intersect(A,B)

Set intersection of two arrays; returns the values common to both A and B. The values returned are in sorted order.

2

intersect(A,B,'rows')

Treats each row of A and each row of B as single entities and returns the rows common to both A and B. The rows of the returned matrix are in sorted order.

3

ismember(A,B)

Returns an array the same size as A, containing 1 (true) where the elements of A are found in B. Elsewhere, it returns 0 (false).

4

ismember(A,B,'rows')

Treats each row of A and each row of B as single entities and returns a vector containing 1 (true) where the rows of matrix A are also rows of B. Elsewhere, it returns 0 (false).

5

issorted(A)

Returns logical 1 (true) if the elements of A are in sorted order and logical 0 (false) otherwise. Input A can be a vector or an N-by-1 or 1-by-N cell array of strings. A is considered to be sorted if A and the output of sort(A) are equal.

6

issorted(A, 'rows')

Returns logical 1 (true) if the rows of two-dimensional matrix A is in sorted order, and logical 0 (false) otherwise. Matrix A is considered to be sorted if A and the output of sortrows(A) are equal.

7

setdiff(A,B)

Sets difference of two arrays; returns the values in A that are not in B. The values in the returned array are in sorted order.

8

setdiff(A,B,'rows')

Treats each row of A and each row of B as single entities and returns the rows from A that are not in B. The rows of the returned matrix are in sorted order.

The 'rows' option does not support cell arrays.

9

setxor

Sets exclusive OR of two arrays

10

union

Sets union of two arrays

11

unique

Unique values in array

Decision making structures require that the programmer should specify one or more conditions to be evaluated or tested by the program, along with a statement or statements to be executed if the condition is determined to be true, and optionally, other statements to be executed if the condition is determined to be false.

Following is the general form of a typical decision making structure found in most of the programming languages −

MATLAB provides following types of decision making statements. Click the following links to check their detail −

Sr.No. Statement & Description
1 if ... end statement

An if ... end statement consists of a boolean expression followed by one or more statements.

2 if...else...end statement

An if statement can be followed by an optional else statement, which executes when the boolean expression is false.

3 If... elseif...elseif...else...end statements

An if statement can be followed by one (or more) optional elseif... and an else statement, which is very useful to test various conditions.

4 nested if statements

You can use one if or elseif statement inside another if or elseif statement(s).

5 switch statement

A switch statement allows a variable to be tested for equality against a list of values.

6 nested switch statements

You can use one switch statement inside another switch statement(s).

There may be a situation when you need to execute a block of code several number of times. In general, statements are executed sequentially. The first statement in a function is executed first, followed by the second, and so on.

Programming languages provide various control structures that allow for more complicated execution paths.

A loop statement allows us to execute a statement or group of statements multiple times and following is the general form of a loop statement in most of the programming languages −

MATLAB provides following types of loops to handle looping requirements. Click the following links to check their detail −

Sr.No. Loop Type & Description
1 while loop

Repeats a statement or group of statements while a given condition is true. It tests the condition before executing the loop body.

2 for loop

Executes a sequence of statements multiple times and abbreviates the code that manages the loop variable.

3 nested loops

You can use one or more loops inside any another loop.

Loop Control Statements

Loop control statements change execution from its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed.

MATLAB supports the following control statements. Click the following links to check their detail.

Sr.No. Control Statement & Description
1 break statement

Terminates the loop statement and transfers execution to the statement immediately following the loop.

2 continue statement

Causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating.

A vector is a one-dimensional array of numbers. MATLAB allows creating two types of vectors −

  • Row vectors
  • Column vectors

Row Vectors

Row vectors are created by enclosing the set of elements in square brackets, using space or comma to delimit the elements.

r = [7 8 9 10 11]

MATLAB will execute the above statement and return the following result −

r =

   7    8    9   10   11

Column Vectors

Column vectors are created by enclosing the set of elements in square brackets, using semicolon to delimit the elements.

c = [7;  8;  9;  10; 11]

MATLAB will execute the above statement and return the following result −

c =
      7       
      8       
      9       
      10       
      11

Referencing the Elements of a Vector

You can reference one or more of the elements of a vector in several ways. The ith component of a vector v is referred as v(i). For example −

v = [ 1; 2; 3; 4; 5; 6];	% creating a column vector of 6 elements
v(3)

MATLAB will execute the above statement and return the following result −

ans =  3

When you reference a vector with a colon, such as v(:), all the components of the vector are listed.

v = [ 1; 2; 3; 4; 5; 6];	% creating a column vector of 6 elements
v(:)

MATLAB will execute the above statement and return the following result −

ans =
     1
     2
     3
     4
     5
     6

MATLAB allows you to select a range of elements from a vector.

For example, let us create a row vector rv of 9 elements, then we will reference the elements 3 to 7 by writing rv(3:7) and create a new vector named sub_rv.

rv = [1 2 3 4 5 6 7 8 9];
sub_rv = rv(3:7)

MATLAB will execute the above statement and return the following result −

sub_rv =

   3   4   5   6   7

Vector Operations

In this section, let us discuss the following vector operations −

  • Addition and Subtraction of Vectors

  • Scalar Multiplication of Vectors

  • Transpose of a Vector

  • Appending Vectors

  • Magnitude of a Vector

  • Vector Dot Product

  • Vectors with Uniformly Spaced Elements

A matrix is a two-dimensional array of numbers.

In MATLAB, you create a matrix by entering elements in each row as comma or space delimited numbers and using semicolons to mark the end of each row.

For example, let us create a 4-by-5 matrix a

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

MATLAB will execute the above statement and return the following result −

a =
      1     2     3     4     5
      2     3     4     5     6
      3     4     5     6     7
      4     5     6     7     8

Referencing the Elements of a Matrix

To reference an element in the mth row and nth column, of a matrix mx, we write −

mx(m, n);

Ad esempio, per riferirsi all'elemento nella 2 ° riga e 5 ° colonna della matrice una , come creato nella sezione precedente, digitiamo -

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
a(2,5)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =  6

Per fare riferimento a tutti gli elementi nella m esima colonna digitiamo A (:, m).

Creiamo un vettore colonna v, dagli elementi della quarta riga della matrice a -

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
v = a(:,4)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

v =
      4
      5
      6
      7

Puoi anche selezionare gli elementi dalla m esima alla ennesima colonna, per questo scriviamo:

a(:,m:n)

Creiamo una matrice più piccola prendendo gli elementi dalla seconda e dalla terza colonna -

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
a(:, 2:3)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =
      2     3
      3     4
      4     5
      5     6

Allo stesso modo, puoi creare una sotto-matrice prendendo una sotto-parte di una matrice.

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
a(:, 2:3)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =
      2     3
      3     4
      4     5
      5     6

Allo stesso modo, puoi creare una sotto-matrice prendendo una sotto-parte di una matrice.

Ad esempio, creiamo una sotto-matrice sa prendendo la sottoparte interna di a -

3     4     5     
4     5     6

Per fare questo, scrivi:

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
sa = a(2:3,2:4)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

sa =
      3     4     5
      4     5     6

Eliminazione di una riga o di una colonna in una matrice

È possibile eliminare un'intera riga o colonna di una matrice assegnando un insieme vuoto di parentesi quadre [] a quella riga o colonna. Fondamentalmente, [] denota un array vuoto.

Ad esempio, eliminiamo la quarta riga di un -

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
a( 4 , : ) = []

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

a =
      1     2     3     4     5
      2     3     4     5     6
      3     4     5     6     7

Quindi, eliminiamo la quinta colonna di a -

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
a(: , 5)=[]

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

a =
      1     2     3     4
      2     3     4     5
      3     4     5     6
      4     5     6     7

Esempio

In questo esempio, creiamo una matrice 3 per 3 m, quindi copieremo la seconda e la terza riga di questa matrice due volte per creare una matrice 4 per 3.

Crea un file di script con il codice seguente:

a = [ 1 2 3 ; 4 5 6; 7 8 9];
new_mat = a([2,3,2,3],:)

Quando si esegue il file, viene visualizzato il seguente risultato:

new_mat =
      4     5     6
      7     8     9
      4     5     6
      7     8     9

Operazioni con matrici

In questa sezione, discutiamo le seguenti operazioni con le matrici di base e comunemente usate:

  • Addizione e sottrazione di matrici

  • Divisione delle matrici

  • Operazioni scalari delle matrici

  • Trasposizione di una matrice

  • Matrici concatenate

  • Moltiplicazione di matrici

  • Determinante di una matrice

  • Inverso di una matrice

Tutte le variabili di tutti i tipi di dati in MATLAB sono array multidimensionali. Un vettore è un array unidimensionale e una matrice è un array bidimensionale.

Abbiamo già discusso di vettori e matrici. In questo capitolo, discuteremo di array multidimensionali. Tuttavia, prima di ciò, esaminiamo alcuni tipi speciali di array.

Array speciali in MATLAB

In questa sezione, discuteremo alcune funzioni che creano alcuni array speciali. Per tutte queste funzioni, un singolo argomento crea un array quadrato, i doppi argomenti creano un array rettangolare.

Il zeros() la funzione crea un array di tutti zeri -

Ad esempio:

zeros(5)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =
      0     0     0     0     0
      0     0     0     0     0
      0     0     0     0     0
      0     0     0     0     0
      0     0     0     0     0

Il ones() la funzione crea un array di tutti quelli -

Ad esempio:

ones(4,3)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =
      1     1     1
      1     1     1
      1     1     1
      1     1     1

Il eye() la funzione crea una matrice di identità.

Ad esempio:

eye(4)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =
      1     0     0     0
      0     1     0     0
      0     0     1     0
      0     0     0     1

Il rand() la funzione crea un array di numeri casuali distribuiti uniformemente su (0,1) -

Ad esempio:

rand(3, 5)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =
   0.8147    0.9134    0.2785    0.9649    0.9572
   0.9058    0.6324    0.5469    0.1576    0.4854
   0.1270    0.0975    0.9575    0.9706    0.8003

Un quadrato magico

UN magic square è un quadrato che produce la stessa somma, quando i suoi elementi vengono aggiunti per riga, per colonna o diagonalmente.

Il magic()la funzione crea una matrice quadrata magica. Ci vuole un argomento singolare che dia la dimensione del quadrato. L'argomento deve essere uno scalare maggiore o uguale a 3.

magic(4)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =
   16     2     3    13
   5    11    10     8
   9     7     6    12
   4    14    15     1

Array multidimensionali

Un array con più di due dimensioni è chiamato array multidimensionale in MATLAB. Gli array multidimensionali in MATLAB sono un'estensione della normale matrice bidimensionale.

Generalmente per generare un array multidimensionale, creiamo prima un array bidimensionale e lo estendiamo.

Ad esempio, creiamo un array bidimensionale a.

a = [7 9 5; 6 1 9; 4 3 2]

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

a =
   7     9     5
   6     1     9
   4     3     2

L'array a è un array 3 per 3; possiamo aggiungere una terza dimensione a a , fornendo valori come -

a(:, :, 2)= [ 1 2 3; 4 5 6; 7 8 9]

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

a =

ans(:,:,1) =

   0   0   0
   0   0   0
   0   0   0

ans(:,:,2) =

   1   2   3
   4   5   6
   7   8   9

Possiamo anche creare array multidimensionali usando le funzioni ones (), zeros () o rand ().

Per esempio,

b = rand(4,3,2)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

b(:,:,1) =
   0.0344    0.7952    0.6463
   0.4387    0.1869    0.7094
   0.3816    0.4898    0.7547
   0.7655    0.4456    0.2760

b(:,:,2) =
   0.6797    0.4984    0.2238
   0.6551    0.9597    0.7513
   0.1626    0.3404    0.2551
   0.1190    0.5853    0.5060

Possiamo anche usare il cat()funzione per costruire array multidimensionali. Concatena un elenco di array lungo una dimensione specificata -

La sintassi per la funzione cat () è -

B = cat(dim, A1, A2...)

Dove,

  • B è il nuovo array creato

  • A1 , A2 , ... sono gli array da concatenare

  • dim è la dimensione lungo la quale concatenare gli array

Esempio

Crea un file di script e digita il seguente codice al suo interno:

a = [9 8 7; 6 5 4; 3 2 1];
b = [1 2 3; 4 5 6; 7 8 9];
c = cat(3, a, b, [ 2 3 1; 4 7 8; 3 9 0])

Quando esegui il file, viene visualizzato:

c(:,:,1) =
      9     8     7
      6     5     4
      3     2     1
c(:,:,2) =
      1     2     3
      4     5     6
      7     8     9
c(:,:,3) =
      2     3     1
      4     7     8
      3     9     0

Funzioni array

MATLAB fornisce le seguenti funzioni per ordinare, ruotare, permutare, rimodellare o spostare i contenuti dell'array.

Funzione Scopo
lunghezza Lunghezza del vettore o dimensione massima della matrice
ndims Numero di dimensioni della matrice
numel Numero di elementi dell'array
taglia Dimensioni della matrice
iscolumn Determina se l'input è un vettore colonna
è vuoto Determina se l'array è vuoto
ismatrix Determina se l'input è una matrice
isrow Determina se l'input è un vettore riga
isscalar Determina se l'input è scalare
isvector Determina se l'input è vettoriale
blkdiag Costruisce la matrice diagonale a blocchi dagli argomenti di input
circshift Sposta l'array in modo circolare
ctranspose Trasposizione coniugata complessa
diag Matrici diagonali e diagonali di matrice
flipdim Capovolge la matrice lungo la dimensione specificata
fliplr Capovolge la matrice da sinistra a destra
flipud Capovolge la matrice dall'alto verso il basso
ipermuto Le inversioni permutano le dimensioni della matrice ND
permutare Riorganizza le dimensioni della matrice ND
repmat Repliche e array di piastrelle
rimodellare Rimodella l'array
rot90 Ruota la matrice di 90 gradi
shiftdim Cambia le dimensioni
smistato Determina se gli elementi dell'insieme sono in ordine ordinato
ordinare Ordina gli elementi dell'array in ordine crescente o decrescente
sortrows Ordina le righe in ordine crescente
spremere Rimuove le dimensioni singleton
trasporre Trasporre
vettorializzare Vettorizza l'espressione

Esempi

I seguenti esempi illustrano alcune delle funzioni sopra menzionate.

Length, Dimension and Number of elements −

Crea un file di script e digita il seguente codice al suo interno:

x = [7.1, 3.4, 7.2, 28/4, 3.6, 17, 9.4, 8.9];
length(x)      % length of x vector
y = rand(3, 4, 5, 2);
ndims(y)       % no of dimensions in array y
s = ['Zara', 'Nuha', 'Shamim', 'Riz', 'Shadab'];
numel(s)       % no of elements in s

Quando si esegue il file, viene visualizzato il seguente risultato:

ans =  8
ans =  4
ans =  23

Circular Shifting of the Array Elements −

Crea un file di script e digita il seguente codice al suo interno:

a = [1 2 3; 4 5 6; 7 8 9]  % the original array a
b = circshift(a,1)         %  circular shift first dimension values down by 1.
c = circshift(a,[1 -1])    % circular shift first dimension values % down by 1 
                           % and second dimension values to the left % by 1.

Quando si esegue il file, viene visualizzato il seguente risultato:

a =
   1     2     3
   4     5     6
   7     8     9

b =
   7     8     9
   1     2     3
   4     5     6

c =
   8     9     7
   2     3     1
   5     6     4

Ordinamento di array

Crea un file di script e digita il seguente codice al suo interno:

v = [ 23 45 12 9 5 0 19 17]  % horizontal vector
sort(v)                      % sorting v
m = [2 6 4; 5 3 9; 2 0 1]    % two dimensional array
sort(m, 1)                   % sorting m along the row
sort(m, 2)                   % sorting m along the column

Quando si esegue il file, viene visualizzato il seguente risultato:

v =
   23    45    12     9     5     0    19    17
ans =
   0     5     9    12    17    19    23    45
m =
   2     6     4
   5     3     9
   2     0     1
ans =
   2     0     1
   2     3     4
   5     6     9
ans =
   2     4     6
   3     5     9
   0     1     2

Cell Array

Gli array di celle sono array di celle indicizzate in cui ogni cella può memorizzare un array di dimensioni e tipi di dati diversi.

Il cellviene utilizzata per creare un array di celle. La sintassi per la funzione cella è -

C = cell(dim)
C = cell(dim1,...,dimN)
D = cell(obj)

Dove,

  • C è l'array di celle;

  • dim è un numero intero scalare o un vettore di numeri interi che specifica le dimensioni della matrice di celle C;

  • dim1, ..., dimN sono numeri interi scalari che specificano le dimensioni di C;

  • obj è uno dei seguenti:

    • Matrice o oggetto Java
    • Matrice .NET di tipo System.String o System.Object

Esempio

Crea un file di script e digita il seguente codice al suo interno:

c = cell(2, 5);
c = {'Red', 'Blue', 'Green', 'Yellow', 'White'; 1 2 3 4 5}

Quando si esegue il file, viene visualizzato il seguente risultato:

c = 
{
   [1,1] = Red
   [2,1] =  1
   [1,2] = Blue
   [2,2] =  2
   [1,3] = Green
   [2,3] =  3
   [1,4] = Yellow
   [2,4] =  4
   [1,5] = White
   [2,5] =  5
}

Accesso ai dati negli array di celle

Esistono due modi per fare riferimento agli elementi di un array di celle:

  • Racchiudere gli indici nella prima parentesi (), per fare riferimento a gruppi di celle
  • Racchiudere gli indici tra parentesi graffe {}, per fare riferimento ai dati all'interno delle singole celle

Quando racchiudi gli indici nella prima parentesi, si riferisce al gruppo di celle.

Gli indici degli array di celle tra parentesi morbide si riferiscono a gruppi di celle.

Ad esempio:

c = {'Red', 'Blue', 'Green', 'Yellow', 'White'; 1 2 3 4 5};
c(1:2,1:2)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans = 
{
   [1,1] = Red
   [2,1] =  1
   [1,2] = Blue
   [2,2] =  2
}

È inoltre possibile accedere ai contenuti delle celle indicizzandoli con parentesi graffe.

Ad esempio:

c = {'Red', 'Blue', 'Green', 'Yellow', 'White'; 1 2 3 4 5};
c{1, 2:4}

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans = Blue
ans = Green
ans = Yellow

Il colon(:)è uno degli operatori più utili in MATLAB. Viene utilizzato per creare vettori, array di pedici especify for iterations.

Se vuoi creare un vettore riga, contenente numeri interi da 1 a 10, scrivi -

1:10

MATLAB esegue l'istruzione e restituisce un vettore riga contenente gli interi da 1 a 10 -

ans =                                                                           
                                                                                
   1    2    3    4    5    6    7    8    9   10

Se si desidera specificare un valore di incremento diverso da uno, ad esempio:

100: -5: 50

MATLAB esegue l'istruzione e restituisce il seguente risultato:

ans =
   100    95    90    85    80    75    70    65    60    55    50

Facciamo un altro esempio:

0:pi/8:pi

MATLAB esegue l'istruzione e restituisce il seguente risultato:

ans =
   Columns 1 through 7
      0    0.3927    0.7854    1.1781    1.5708    1.9635    2.3562
   Columns 8 through 9
      2.7489    3.1416

È possibile utilizzare l'operatore dei due punti per creare un vettore di indici per selezionare righe, colonne o elementi di array.

La tabella seguente descrive il suo utilizzo per questo scopo (si dia una matrice A) -

Formato Scopo
A(:,j) è la jesima colonna di A.
A(i,:) è l'ennesima riga di A.
A(:,:) è la matrice bidimensionale equivalente. Per le matrici è lo stesso di A.
A(j:k) è A (j), A (j + 1), ..., A (k).
A(:,j:k) è A (:, j), A (:, j + 1), ..., A (:, k).
A(:,:,k) è la k- esima pagina dell'array tridimensionale A.
A(i,j,k,:) è un vettore nella matrice quadridimensionale A. Il vettore include A (i, j, k, 1), A (i, j, k, 2), A (i, j, k, 3) e così via.
A(:) sono tutti gli elementi di A, considerati come un'unica colonna. Sul lato sinistro di un'istruzione di assegnazione, A (:) riempie A, preservandone la forma di prima. In questo caso, il lato destro deve contenere lo stesso numero di elementi di A.

Esempio

Crea un file di script e digita il seguente codice al suo interno:

A = [1 2 3 4; 4 5 6 7; 7 8 9 10]
A(:,2)      % second column of A
A(:,2:3)    % second and third column of A
A(2:3,2:3)  % second and third rows and second and third columns

Quando si esegue il file, viene visualizzato il seguente risultato:

A =
      1     2     3     4
      4     5     6     7
      7     8     9    10

ans =
      2
      5
      8

ans =
      2     3
      5     6
      8     9

ans =
      5     6
      8     9

MATLAB supporta varie classi numeriche che includono interi con e senza segno e numeri in virgola mobile a precisione singola e doppia. Per impostazione predefinita, MATLAB memorizza tutti i valori numerici come numeri in virgola mobile a precisione doppia.

È possibile scegliere di memorizzare qualsiasi numero o matrice di numeri come numeri interi o come numeri a precisione singola.

Tutti i tipi numerici supportano le operazioni di base degli array e le operazioni matematiche.

Conversione in vari tipi di dati numerici

MATLAB fornisce le seguenti funzioni per convertire in vari tipi di dati numerici:

Funzione Scopo
Doppio Converte in un numero a doppia precisione
single Converte in un numero a precisione singola
int8 Converte in un intero con segno a 8 bit
int16 Converte in un intero con segno a 16 bit
int32 Converte in un intero con segno a 32 bit
int64 Converte in un intero con segno a 64 bit
uint8 Converte in un intero senza segno a 8 bit
uint16 Converte in un intero senza segno a 16 bit
uint32 Converte in un intero senza segno a 32 bit
uint64 Converte in un intero senza segno a 64 bit

Esempio

Crea un file di script e digita il codice seguente:

x = single([5.32 3.47 6.28]) .* 7.5
x = double([5.32 3.47 6.28]) .* 7.5
x = int8([5.32 3.47 6.28]) .* 7.5
x = int16([5.32 3.47 6.28]) .* 7.5
x = int32([5.32 3.47 6.28]) .* 7.5
x = int64([5.32 3.47 6.28]) .* 7.5

Quando esegui il file, mostra il seguente risultato:

x =

   39.900   26.025   47.100

x =

   39.900   26.025   47.100

x =

   38  23  45

x =

   38  23  45

x =

   38  23  45

x =

   38  23  45

Esempio

Estendiamo ancora un po 'l'esempio precedente. Crea un file di script e digita il codice seguente:

x = int32([5.32 3.47 6.28]) .* 7.5
x = int64([5.32 3.47 6.28]) .* 7.5
x = num2cell(x)

Quando esegui il file, mostra il seguente risultato:

x =

   38  23  45

x =

   38  23  45

x = 
{
   [1,1] = 38
   [1,2] = 23
   [1,3] = 45
}

Numeri interi più piccoli e più grandi

Le funzioni intmax() e intmin() restituisce i valori massimo e minimo che possono essere rappresentati con tutti i tipi di numeri interi.

Entrambe le funzioni accettano il tipo di dati intero come argomento, ad esempio, intmax (int8) o intmin (int64) e restituiscono i valori massimo e minimo che è possibile rappresentare con il tipo di dati intero.

Esempio

Il seguente esempio illustra come ottenere i valori più piccoli e più grandi di interi. Crea un file di script e scrivi il seguente codice al suo interno:

% displaying the smallest and largest signed integer data
str = 'The range for int8 is:\n\t%d to %d ';
sprintf(str, intmin('int8'), intmax('int8'))
str = 'The range for int16 is:\n\t%d to %d ';
sprintf(str, intmin('int16'), intmax('int16'))
str = 'The range for int32 is:\n\t%d to %d ';
sprintf(str, intmin('int32'), intmax('int32'))
str = 'The range for int64 is:\n\t%d to %d ';
sprintf(str, intmin('int64'), intmax('int64'))
 
% displaying the smallest and largest unsigned integer data
str = 'The range for uint8 is:\n\t%d to %d ';
sprintf(str, intmin('uint8'), intmax('uint8'))
str = 'The range for uint16 is:\n\t%d to %d ';
sprintf(str, intmin('uint16'), intmax('uint16'))
str = 'The range for uint32 is:\n\t%d to %d ';
sprintf(str, intmin('uint32'), intmax('uint32'))
str = 'The range for uint64 is:\n\t%d to %d ';
sprintf(str, intmin('uint64'), intmax('uint64'))

Quando esegui il file, mostra il seguente risultato:

ans = The range for int8 is:
	-128 to 127 
ans = The range for int16 is:
	-32768 to 32767 
ans = The range for int32 is:
	-2147483648 to 2147483647 
ans = The range for int64 is:
	0 to 0 
ans = The range for uint8 is:
	0 to 255 
ans = The range for uint16 is:
	0 to 65535 
ans = The range for uint32 is:
	0 to -1 
ans = The range for uint64 is:
	0 to 18446744073709551616

Numeri in virgola mobile più piccoli e più grandi

Le funzioni realmax() e realmin() restituisce i valori massimo e minimo che possono essere rappresentati con numeri in virgola mobile.

Entrambe le funzioni, quando chiamate con l'argomento 'single', restituiscono i valori massimo e minimo che puoi rappresentare con il tipo di dati a precisione singola e quando chiamate con l'argomento 'double', restituiscono i valori massimo e minimo che puoi rappresentare con il tipo di dati a doppia precisione.

Esempio

Il seguente esempio illustra come ottenere i numeri in virgola mobile più piccoli e più grandi. Crea un file di script e scrivi il seguente codice al suo interno:

% displaying the smallest and largest single-precision 
% floating point number
str = 'The range for single is:\n\t%g to %g and\n\t %g to  %g';
sprintf(str, -realmax('single'), -realmin('single'), ...
   realmin('single'), realmax('single'))

% displaying the smallest and largest double-precision 
% floating point number
str = 'The range for double is:\n\t%g to %g and\n\t %g to  %g';
sprintf(str, -realmax('double'), -realmin('double'), ...
   realmin('double'), realmax('double'))

Quando si esegue il file, viene visualizzato il seguente risultato:

ans = The range for single is:                                                  
        -3.40282e+38 to -1.17549e-38 and                                        
         1.17549e-38 to  3.40282e+38                                            
ans = The range for double is:                                                  
        -1.79769e+308 to -2.22507e-308 and                                      
         2.22507e-308 to  1.79769e+308

Creare una stringa di caratteri è abbastanza semplice in MATLAB. In effetti, l'abbiamo usato molte volte. Ad esempio, digiti quanto segue nel prompt dei comandi:

my_string = 'Tutorials Point'

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

my_string = Tutorials Point

MATLAB considera tutte le variabili come array e le stringhe sono considerate come array di caratteri. Usiamo il filewhos comando per controllare la variabile creata sopra -

whos

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

Name           Size            Bytes  Class    Attributes
my_string      1x16               32  char

È interessante notare che puoi utilizzare funzioni di conversione numerica come uint8 o uint16per convertire i caratteri nella stringa nei rispettivi codici numerici. Ilchar la funzione converte il vettore intero in caratteri -

Esempio

Crea un file di script e digita il seguente codice al suo interno:

my_string = 'Tutorial''s Point';
str_ascii = uint8(my_string)        % 8-bit ascii values
str_back_to_char= char(str_ascii)  
str_16bit = uint16(my_string)       % 16-bit ascii values
str_back_to_char = char(str_16bit)

Quando si esegue il file, viene visualizzato il seguente risultato:

str_ascii =

   84  117  116  111  114  105   97  108   39  115   32   80  111  105  110  116

str_back_to_char = Tutorial's Point
str_16bit =

   84  117  116  111  114  105   97  108   39  115   32   80  111  105  110  116

str_back_to_char = Tutorial's Point

Matrice di caratteri rettangolare

Le stringhe che abbiamo discusso finora sono array di caratteri unidimensionali; tuttavia, dobbiamo archiviare più di questo. Abbiamo bisogno di memorizzare più dati testuali dimensionali nel nostro programma. Ciò si ottiene creando matrici di caratteri rettangolari.

Il modo più semplice per creare un array di caratteri rettangolare è concatenare due o più array di caratteri unidimensionali, verticalmente o orizzontalmente secondo necessità.

Puoi combinare le stringhe verticalmente in uno dei seguenti modi:

  • Utilizzo dell'operatore di concatenazione MATLAB []e separando ogni riga con un punto e virgola (;). Tieni presente che in questo metodo ogni riga deve contenere lo stesso numero di caratteri. Per stringhe con lunghezze diverse, è necessario riempire con caratteri spazio secondo necessità.

  • Usando il charfunzione. Se le stringhe hanno lunghezze diverse, il carattere riempie le stringhe più corte con spazi finali in modo che ogni riga abbia lo stesso numero di caratteri.

Esempio

Crea un file di script e digita il seguente codice al suo interno:

doc_profile = ['Zara Ali                             '; ...
               'Sr. Surgeon                          '; ...
               'R N Tagore Cardiology Research Center']
doc_profile = char('Zara Ali', 'Sr. Surgeon', ...
                  'RN Tagore Cardiology Research Center')

Quando si esegue il file, viene visualizzato il seguente risultato:

doc_profile =
Zara Ali                             
Sr. Surgeon                          
R N Tagore Cardiology Research Center
doc_profile =
Zara Ali                            
Sr. Surgeon                         
RN Tagore Cardiology Research Center

Puoi combinare le stringhe orizzontalmente in uno dei seguenti modi:

  • Utilizzando l'operatore di concatenazione MATLAB, []e separando le stringhe di input con una virgola o uno spazio. Questo metodo preserva gli spazi finali negli array di input.

  • Utilizzando la funzione di concatenazione di stringhe, strcat. Questo metodo rimuove gli spazi finali negli input.

Esempio

Crea un file di script e digita il seguente codice al suo interno:

name =     'Zara Ali                             ';
position = 'Sr. Surgeon                          '; 
worksAt =  'R N Tagore Cardiology Research Center';
profile = [name ', ' position ', ' worksAt]
profile = strcat(name, ', ', position, ', ', worksAt)

Quando si esegue il file, viene visualizzato il seguente risultato:

profile = Zara Ali      , Sr. Surgeon      , R N Tagore Cardiology Research Center
profile = Zara Ali,Sr. Surgeon,R N Tagore Cardiology Research Center

Combinazione di stringhe in una matrice di celle

Dalla nostra discussione precedente, è chiaro che la combinazione di stringhe con lunghezze diverse potrebbe essere un problema poiché tutte le stringhe nell'array devono essere della stessa lunghezza. Abbiamo utilizzato spazi vuoti alla fine delle stringhe per equalizzarne la lunghezza.

Tuttavia, un modo più efficiente per combinare le stringhe consiste nel convertire la matrice risultante in una matrice di celle.

L'array di celle MATLAB può contenere diverse dimensioni e tipi di dati in un array. Gli array di celle forniscono un modo più flessibile per memorizzare stringhe di lunghezza variabile.

Il cellstr funzione converte una matrice di caratteri in una matrice di celle di stringhe.

Esempio

Crea un file di script e digita il seguente codice al suo interno:

name =     'Zara Ali                             ';
position = 'Sr. Surgeon                          '; 
worksAt =  'R N Tagore Cardiology Research Center';
profile = char(name, position, worksAt);
profile = cellstr(profile);
disp(profile)

Quando si esegue il file, viene visualizzato il seguente risultato:

{                                                                               
   [1,1] = Zara Ali                                                              
   [2,1] = Sr. Surgeon                                                           
   [3,1] = R N Tagore Cardiology Research Center                                 
}

Funzioni di stringa in MATLAB

MATLAB fornisce numerose funzioni per stringhe che creano, combinano, analizzano, confrontano e manipolano stringhe.

La tabella seguente fornisce una breve descrizione delle funzioni stringa in MATLAB -

Funzione Scopo
Funzioni per memorizzare testo in matrici di caratteri, combinare matrici di caratteri, ecc.
spazi vuoti Crea una stringa di caratteri vuoti
cellstr Crea una matrice di celle di stringhe dalla matrice di caratteri
char Converti in matrice di caratteri (stringa)
iscellstr Determina se l'input è un array di celle di stringhe
ischar Determina se l'elemento è un array di caratteri
sprintf Formatta i dati in una stringa
strcat Concatena le stringhe orizzontalmente
strjoin Unisci le stringhe nella matrice di celle in una singola stringa
Funzioni per identificare parti di stringhe, trovare e sostituire sottostringhe
ischar Determina se l'elemento è un array di caratteri
isletter Elementi della matrice che sono lettere alfabetiche
isspace Elementi di matrice che sono caratteri spaziali
isstrprop Determina se la stringa appartiene alla categoria specificata
sscanf Legge i dati formattati dalla stringa
strfind Trova una stringa all'interno di un'altra
strrep Trova e sostituisci la sottostringa
strsplit Stringa di divisione al delimitatore specificato
strtok Parti di corda selezionate
validatestring Verifica la validità della stringa di testo
symvar Determina le variabili simboliche nell'espressione
regexp Trova espressione regolare (distingue tra maiuscole e minuscole)
regexpi Trova espressione regolare (senza distinzione tra maiuscole e minuscole)
regexprep Sostituisci la stringa usando l'espressione regolare
regexptranslate Traduci la stringa in un'espressione regolare
Funzioni per il confronto delle stringhe
strcmp Confronta stringhe (distingue tra maiuscole e minuscole)
strcmpi Confronta stringhe (senza distinzione tra maiuscole e minuscole)
strncmp Confronta i primi n caratteri di stringhe (distingue tra maiuscole e minuscole)
strncmpi Confronta i primi n caratteri di stringhe (senza distinzione tra maiuscole e minuscole)
Funzioni per cambiare la stringa in maiuscolo o minuscolo, creando o rimuovendo spazi bianchi
deblank Rimuovi gli spazi finali dalla fine della stringa
strtrim Rimuovi lo spazio bianco iniziale e finale dalla stringa
inferiore Converti la stringa in minuscolo
superiore Converte la stringa in maiuscolo
strjust Giustifica la matrice di caratteri

Esempi

I seguenti esempi illustrano alcune delle funzioni di stringa sopra menzionate:

Formattazione delle stringhe

Crea un file di script e digita il seguente codice al suo interno:

A = pi*1000*ones(1,5);
sprintf(' %f \n %.2f \n %+.2f \n %12.2f \n %012.2f \n', A)

Quando si esegue il file, viene visualizzato il seguente risultato:

ans =  3141.592654 
   3141.59 
   +3141.59 
      3141.59 
   000003141.59

Unire le stringhe

Crea un file di script e digita il seguente codice al suo interno:

%cell array of strings
str_array = {'red','blue','green', 'yellow', 'orange'};

% Join strings in cell array into single string
str1 = strjoin(str_array, "-")
str2 = strjoin(str_array, ",")

Quando si esegue il file, viene visualizzato il seguente risultato:

str1 = red-blue-green-yellow-orange
str2 = red,blue,green,yellow,orange

Ricerca e sostituzione di stringhe

Crea un file di script e digita il seguente codice al suo interno:

students = {'Zara Ali', 'Neha Bhatnagar', ...
            'Monica Malik', 'Madhu Gautam', ...
            'Madhu Sharma', 'Bhawna Sharma',...
            'Nuha Ali', 'Reva Dutta', ...
            'Sunaina Ali', 'Sofia Kabir'};
 
% The strrep function searches and replaces sub-string.
new_student = strrep(students(8), 'Reva', 'Poulomi')
% Display first names
first_names = strtok(students)

Quando si esegue il file, viene visualizzato il seguente risultato:

new_student = 
{
   [1,1] = Poulomi Dutta
}
first_names = 
{
   [1,1] = Zara
   [1,2] = Neha
   [1,3] = Monica
   [1,4] = Madhu
   [1,5] = Madhu
   [1,6] = Bhawna
   [1,7] = Nuha
   [1,8] = Reva
   [1,9] = Sunaina
   [1,10] = Sofia
}

Confronto di stringhe

Crea un file di script e digita il seguente codice al suo interno:

str1 = 'This is test'
str2 = 'This is text'
if (strcmp(str1, str2))
   sprintf('%s and %s are equal', str1, str2)
else
   sprintf('%s and %s are not equal', str1, str2)
end

Quando si esegue il file, viene visualizzato il seguente risultato:

str1 = This is test
str2 = This is text
ans = This is test and This is text are not equal

Una funzione è un gruppo di istruzioni che insieme eseguono un'attività. In MATLAB, le funzioni sono definite in file separati. Il nome del file e della funzione dovrebbero essere gli stessi.

Le funzioni operano su variabili all'interno del proprio spazio di lavoro, chiamato anche local workspace, separato dallo spazio di lavoro a cui accedi dal prompt dei comandi di MATLAB, chiamato base workspace.

Le funzioni possono accettare più di un argomento di input e possono restituire più di un argomento di output.

La sintassi di un'istruzione di funzione è:

function [out1,out2, ..., outN] = myfun(in1,in2,in3, ..., inN)

Esempio

La seguente funzione denominata mymax dovrebbe essere scritta in un file denominato mymax.m . Richiede cinque numeri come argomento e restituisce il massimo dei numeri.

Crea un file funzione, chiamato mymax.m e digita il seguente codice in esso -

function max = mymax(n1, n2, n3, n4, n5)

%This function calculates the maximum of the
% five numbers given as input
max =  n1;
if(n2 > max)
   max = n2;
end
if(n3 > max)
   max = n3;
end
if(n4 > max)
   max = n4;
end
if(n5 > max)
   max = n5;
end

La prima riga di una funzione inizia con la parola chiave function. Fornisce il nome della funzione e l'ordine degli argomenti. Nel nostro esempio, la funzione mymax ha cinque argomenti di input e un argomento di output.

Le righe di commento che vengono subito dopo l'istruzione della funzione forniscono il testo della guida. Queste righe vengono stampate durante la digitazione:

help mymax

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

This function calculates the maximum of the
   five numbers given as input

Puoi chiamare la funzione come -

mymax(34, 78, 89, 23, 11)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans = 89

Funzioni anonime

Una funzione anonima è come una funzione inline nei linguaggi di programmazione tradizionali, definita all'interno di una singola istruzione MATLAB. Consiste in una singola espressione MATLAB e un numero qualsiasi di argomenti di input e output.

Puoi definire una funzione anonima direttamente dalla riga di comando di MATLAB o all'interno di una funzione o uno script.

In questo modo puoi creare semplici funzioni senza dover creare un file per esse.

La sintassi per creare una funzione anonima da un'espressione è

f = @(arglist)expression

Esempio

In questo esempio, scriveremo una funzione anonima chiamata power, che prenderà due numeri come input e restituirà il primo numero elevato alla potenza del secondo numero.

Crea un file di script e digita il seguente codice al suo interno:

power = @(x, n) x.^n;
result1 = power(7, 3)
result2 = power(49, 0.5)
result3 = power(10, -10)
result4 = power (4.5, 1.5)

Quando esegui il file, viene visualizzato:

result1 =  343
result2 =  7
result3 =  1.0000e-10
result4 =  9.5459

Funzioni primarie e secondarie

Qualsiasi funzione diversa da una funzione anonima deve essere definita all'interno di un file. Ogni file di funzione contiene una funzione primaria richiesta che appare per prima e un numero qualsiasi di sotto-funzioni opzionali che viene dopo la funzione primaria e da essa utilizzate.

Le funzioni primarie possono essere chiamate dall'esterno del file che le definisce, dalla riga di comando o da altre funzioni, ma le sotto-funzioni non possono essere chiamate dalla riga di comando o da altre funzioni, dall'esterno del file di funzione.

Le sotto-funzioni sono visibili solo alla funzione primaria e ad altre sotto-funzioni all'interno del file di funzione che le definisce.

Esempio

Scriviamo una funzione chiamata quadratica che calcoli le radici di un'equazione quadratica. La funzione richiederebbe tre input, il coefficiente quadratico, il coefficiente lineare e il termine costante. Restituirebbe le radici.

Il file di funzione quadratic.m conterrà la funzione principale quadratic e la sub-funzione disco , che calcola il discriminante.

Crea un file funzione quadratic.m e digita il seguente codice al suo interno -

function [x1,x2] = quadratic(a,b,c)

%this function returns the roots of 
% a quadratic equation.
% It takes 3 input arguments
% which are the co-efficients of x2, x and the 
%constant term
% It returns the roots
d = disc(a,b,c); 
x1 = (-b + d) / (2*a);
x2 = (-b - d) / (2*a);
end   % end of quadratic

function dis = disc(a,b,c) 
%function calculates the discriminant
dis = sqrt(b^2 - 4*a*c);
end   % end of sub-function

Puoi chiamare la funzione sopra dal prompt dei comandi come -

quadratic(2,4,-4)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans = 0.7321

Funzioni annidate

È possibile definire funzioni all'interno del corpo di un'altra funzione. Queste sono chiamate funzioni annidate. Una funzione annidata contiene uno o tutti i componenti di qualsiasi altra funzione.

Le funzioni annidate sono definite nell'ambito di un'altra funzione e condividono l'accesso allo spazio di lavoro della funzione contenitore.

Una funzione nidificata segue la seguente sintassi:

function x = A(p1, p2)
...
B(p2)
   function y = B(p3)
   ...
   end
...
end

Esempio

Riscriviamo la funzione quadratic , dall'esempio precedente, tuttavia, questa volta la funzione disco sarà una funzione annidata.

Crea un file funzione quadratic2.m e digita il seguente codice al suo interno -

function [x1,x2] = quadratic2(a,b,c)
function disc  % nested function
d = sqrt(b^2 - 4*a*c);
end   % end of function disc

disc;
x1 = (-b + d) / (2*a);
x2 = (-b - d) / (2*a);
end   % end of function quadratic2

Puoi chiamare la funzione sopra dal prompt dei comandi come -

quadratic2(2,4,-4)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =  0.73205

Funzioni private

Una funzione privata è una funzione primaria visibile solo a un gruppo limitato di altre funzioni. Se non si desidera esporre l'implementazione di una o più funzioni, è possibile crearle come funzioni private.

Le funzioni private risiedono in subfolders con il nome speciale private.

Sono visibili solo alle funzioni nella cartella principale.

Esempio

Riscriviamo la funzione quadratica . Questa volta, tuttavia, la funzione del disco che calcola il discriminante, sarà una funzione privata.

Crea una sottocartella denominata private nella directory di lavoro. Memorizza il seguente file funzione disc.m in esso -

function dis = disc(a,b,c) 
%function calculates the discriminant
dis = sqrt(b^2 - 4*a*c);
end      % end of sub-function

Crea una funzione quadratic3.m nella tua directory di lavoro e digita il seguente codice in essa -

function [x1,x2] = quadratic3(a,b,c)

%this function returns the roots of 
% a quadratic equation.
% It takes 3 input arguments
% which are the co-efficient of x2, x and the 
%constant term
% It returns the roots
d = disc(a,b,c); 

x1 = (-b + d) / (2*a);
x2 = (-b - d) / (2*a);
end      % end of quadratic3

Puoi chiamare la funzione sopra dal prompt dei comandi come -

quadratic3(2,4,-4)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =  0.73205

Variabili globali

Le variabili globali possono essere condivise da più di una funzione. Per questo, è necessario dichiarare la variabile come globale in tutte le funzioni.

Se desideri accedere a quella variabile dallo spazio di lavoro di base, dichiara la variabile nella riga di comando.

La dichiarazione globale deve avvenire prima che la variabile venga effettivamente utilizzata in una funzione. È buona norma utilizzare lettere maiuscole per i nomi delle variabili globali per distinguerle dalle altre variabili.

Esempio

Creiamo un file di funzione chiamato average.m e digitiamo il seguente codice al suo interno -

function avg = average(nums)
global TOTAL
avg = sum(nums)/TOTAL;
end

Crea un file di script e digita il seguente codice al suo interno:

global TOTAL;
TOTAL = 10;
n = [34, 45, 25, 45, 33, 19, 40, 34, 38, 42];
av = average(n)

Quando esegui il file, verrà visualizzato il seguente risultato:

av =  35.500

Importare dati in MATLAB significa caricare dati da un file esterno. Ilimportdatala funzione consente di caricare vari file di dati di diversi formati. Ha le seguenti cinque forme:

Sr.No. Descrizione della funzione
1

A = importdata(filename)

Carica i dati nell'array A dal file indicato con nome file .

2

A = importdata('-pastespecial')

Carica i dati dagli appunti di sistema piuttosto che da un file.

3

A = importdata(___, delimiterIn)

Interpreta delimiterIn come separatore di colonna nel file ASCII, nel nome del file o nei dati degli appunti. È possibile utilizzare delimiterIn con uno qualsiasi degli argomenti di input nelle sintassi precedenti.

4

A = importdata(___, delimiterIn, headerlinesIn)

Carica i dati dal file ASCII, dal nome del file o dagli appunti, leggendo i dati numerici a partire dalle intestazioni di riga In + 1 .

5

[A, delimiterOut, headerlinesOut] = importdata(___)

Restituisce il carattere delimitatore rilevato per il file ASCII di input in delimiterOut e il numero rilevato di righe di intestazione in headerlinesOut , utilizzando uno degli argomenti di input nelle sintassi precedenti.

Per impostazione predefinita, Octave non supporta la funzione importdata () , quindi dovrai cercare e installare questo pacchetto per far funzionare i seguenti esempi con la tua installazione di Octave.

Esempio 1

Carichiamo e visualizziamo un file immagine. Crea un file di script e digita il seguente codice al suo interno:

filename = 'smile.jpg';
A = importdata(filename);
image(A);

Quando esegui il file, MATLAB visualizza il file immagine. Tuttavia, è necessario memorizzarlo nella directory corrente.

Esempio 2

In questo esempio, importiamo un file di testo e specifichiamo Delimitatore e Intestazione colonna. Creiamo un file ASCII delimitato da spazi con intestazioni di colonna, denominato settimanaledata.txt .

Il nostro file di testo Weeklydata.txt ha questo aspetto:

SunDay  MonDay  TuesDay  WednesDay  ThursDay  FriDay  SaturDay
95.01   76.21   61.54    40.57       55.79    70.28   81.53
73.11   45.65   79.19    93.55       75.29    69.87   74.68
60.68   41.85   92.18    91.69       81.32    90.38   74.51
48.60   82.14   73.82    41.03       0.99     67.22   93.18
89.13   44.47   57.63    89.36       13.89    19.88   46.60

Crea un file di script e digita il seguente codice al suo interno:

filename = 'weeklydata.txt';
delimiterIn = ' ';
headerlinesIn = 1;
A = importdata(filename,delimiterIn,headerlinesIn);

% View data
for k = [1:7]
   disp(A.colheaders{1, k})
   disp(A.data(:, k))
   disp(' ')
end

Quando si esegue il file, viene visualizzato il seguente risultato:

SunDay
   95.0100
   73.1100
   60.6800
   48.6000
   89.1300
 
MonDay
   76.2100
   45.6500
   41.8500
   82.1400
   44.4700
 
TuesDay
   61.5400
   79.1900
   92.1800
   73.8200
   57.6300

WednesDay
   40.5700
   93.5500
   91.6900
   41.0300
   89.3600
 
ThursDay
   55.7900
   75.2900
   81.3200
   0.9900
   13.8900
 
FriDay
   70.2800
   69.8700
   90.3800
   67.2200
   19.8800

SaturDay
   81.5300
   74.6800
   74.5100
   93.1800
   46.6000

Esempio 3

In questo esempio, importiamo i dati dagli appunti.

Copia le seguenti righe negli appunti:

Mathematics is simple

Crea un file di script e digita il codice seguente:

A = importdata('-pastespecial')

Quando si esegue il file, viene visualizzato il seguente risultato:

A = 
   'Mathematics is simple'

I / O file di basso livello

La funzione importdata è una funzione di alto livello. Le funzioni di I / O su file di basso livello in MATLAB consentono il massimo controllo sulla lettura o la scrittura di dati in un file. Tuttavia, queste funzioni richiedono informazioni più dettagliate sul file per funzionare in modo efficiente.

MATLAB fornisce le seguenti funzioni per le operazioni di lettura e scrittura a livello di byte o carattere:

Funzione Descrizione
fclose Chiudi uno o tutti i file aperti
feof Test per la fine del file
ferror Informazioni sugli errori di I / O dei file
fgetl Legge la riga dal file, rimuovendo i caratteri di nuova riga
fgets Legge la riga dal file, mantenendo i caratteri di nuova riga
fopen Apri file o ottieni informazioni sui file aperti
fprintf Scrivi i dati in un file di testo
fread Legge i dati dal file binario
frewind Sposta l'indicatore di posizione del file all'inizio del file aperto
fscanf Leggi i dati dal file di testo
fseek Sposta nella posizione specificata nel file
ftell Posizione nel file aperto
fwrite Scrive i dati in un file binario

Importa file di dati di testo con I / O di basso livello

MATLAB fornisce le seguenti funzioni per l'importazione di basso livello di file di dati di testo:

  • Il fscanf la funzione legge i dati formattati in un file di testo o ASCII.

  • Il fgetl e fgets le funzioni leggono una riga di un file alla volta, dove un carattere di nuova riga separa ogni riga.

  • Il fread la funzione legge un flusso di dati a livello di byte o bit.

Esempio

Abbiamo un file di dati di testo "myfile.txt" salvato nella nostra directory di lavoro. Il file memorizza i dati sulle precipitazioni per tre mesi; Giugno, luglio e agosto per l'anno 2012.

I dati in miofile.txt contengono serie ripetute di misurazioni di ora, mese e precipitazioni in cinque punti. I dati dell'intestazione memorizzano il numero di mesi M; quindi abbiamo M set di misurazioni.

Il file ha questo aspetto:

Rainfall Data
Months: June, July, August
 
M = 3
12:00:00
June-2012
17.21  28.52  39.78  16.55 23.67
19.15  0.35   17.57  NaN   12.01
17.92  28.49  17.40  17.06 11.09
9.59   9.33   NaN    0.31  0.23 
10.46  13.17  NaN    14.89 19.33
20.97  19.50  17.65  14.45 14.00
18.23  10.34  17.95  16.46 19.34
09:10:02
July-2012
12.76  16.94  14.38  11.86 16.89
20.46  23.17  NaN    24.89 19.33
30.97  49.50  47.65  24.45 34.00
18.23  30.34  27.95  16.46 19.34
30.46  33.17  NaN    34.89  29.33
30.97  49.50  47.65  24.45 34.00
28.67  30.34  27.95  36.46 29.34
15:03:40
August-2012
17.09  16.55  19.59  17.25 19.22
17.54  11.45  13.48  22.55 24.01
NaN    21.19  25.85  25.05 27.21
26.79  24.98  12.23  16.99 18.67
17.54  11.45  13.48  22.55 24.01
NaN    21.19  25.85  25.05 27.21
26.79  24.98  12.23  16.99 18.67

Importeremo i dati da questo file e visualizzeremo questi dati. Procedi nel seguente modo:

  • Apri il file con fopen funzione e ottenere l'identificatore del file.

  • Descrivi i dati nel file con format specifiers, ad esempio '%s"per una stringa,"%d"per un numero intero o"%f'per un numero in virgola mobile.

  • Per saltare i caratteri letterali nel file, includerli nella descrizione del formato. Per saltare un campo dati, utilizza un asterisco ("*") nello specificatore.

    Ad esempio, per leggere le intestazioni e restituire il singolo valore per M, scriviamo -

    M = fscanf(fid, '%*s %*s\n%*s %*s %*s %*s\nM=%d\n\n', 1);
  • Per impostazione predefinita, fscanflegge i dati in base alla nostra descrizione del formato fino a quando non trova alcuna corrispondenza per i dati o raggiunge la fine del file. Qui useremo il ciclo for per leggere 3 set di dati e ogni volta leggerà 7 righe e 5 colonne.

  • Creeremo una struttura denominata mydata nell'area di lavoro per memorizzare i dati letti dal file. Questa struttura ha tre campi: ora , mese e array raindata .

Crea un file di script e digita il seguente codice al suo interno:

filename = '/data/myfile.txt';
rows = 7;
cols = 5;
 
% open the file
fid = fopen(filename);
 
% read the file headers, find M (number of months)
M = fscanf(fid, '%*s %*s\n%*s %*s %*s %*s\nM=%d\n\n', 1);
 
% read each set of measurements
for n = 1:M
   mydata(n).time = fscanf(fid, '%s', 1);
   mydata(n).month = fscanf(fid, '%s', 1);
 
   % fscanf fills the array in column order,
   % so transpose the results
   mydata(n).raindata  = ...
      fscanf(fid, '%f', [rows, cols]);
end
for n = 1:M
   disp(mydata(n).time), disp(mydata(n).month)
   disp(mydata(n).raindata)
end
 
% close the file
fclose(fid);

Quando si esegue il file, viene visualizzato il seguente risultato:

12:00:00
June-2012
   17.2100   17.5700   11.0900   13.1700   14.4500
   28.5200       NaN    9.5900       NaN   14.0000
   39.7800   12.0100    9.3300   14.8900   18.2300
   16.5500   17.9200       NaN   19.3300   10.3400
   23.6700   28.4900    0.3100   20.9700   17.9500
   19.1500   17.4000    0.2300   19.5000   16.4600
   0.3500   17.0600   10.4600   17.6500   19.3400

09:10:02
July-2012
   12.7600       NaN   34.0000   33.1700   24.4500
   16.9400   24.8900   18.2300       NaN   34.0000
   14.3800   19.3300   30.3400   34.8900   28.6700
   11.8600   30.9700   27.9500   29.3300   30.3400
   16.8900   49.5000   16.4600   30.9700   27.9500
   20.4600   47.6500   19.3400   49.5000   36.4600
   23.1700   24.4500   30.4600   47.6500   29.3400

15:03:40
August-2012
   17.0900   13.4800   27.2100   11.4500   25.0500
   16.5500   22.5500   26.7900   13.4800   27.2100
   19.5900   24.0100   24.9800   22.5500   26.7900
   17.2500       NaN   12.2300   24.0100   24.9800
   19.2200   21.1900   16.9900       NaN   12.2300
   17.5400   25.8500   18.6700   21.1900   16.9900
   11.4500   25.0500   17.5400   25.8500   18.6700

L'esportazione (o l'output) dei dati in MATLAB significa scrivere in file. MATLAB ti consente di utilizzare i tuoi dati in un'altra applicazione che legge i file ASCII. Per questo, MATLAB fornisce diverse opzioni di esportazione dei dati.

È possibile creare il seguente tipo di file:

  • File di dati ASCII rettangolare e delimitato da un array.

  • File di diario (o registro) delle sequenze di tasti e output di testo risultante.

  • File ASCII specializzato che utilizza funzioni di basso livello come fprintf.

  • File MEX per accedere alla routine C / C ++ o Fortran che scrive in un particolare formato di file di testo.

Oltre a questo, puoi anche esportare i dati su fogli di calcolo.

Esistono due modi per esportare un array numerico come file di dati ASCII delimitato:

  • Usando il save e specificando la -ascii qualificatore

  • Usando il dlmwrite funzione

La sintassi per l'utilizzo della funzione di salvataggio è:

save my_data.out num_array -ascii

dove, my_data.out è il file di dati ASCII delimitato creato, num_array è un array numerico e−ascii è lo specificatore.

Sintassi per l'utilizzo di dlmwrite la funzione è -

dlmwrite('my_data.out', num_array, 'dlm_char')

dove, my_data.out è il file di dati ASCII delimitato creato, num_array è un array numerico e dlm_char è il carattere delimitatore.

Esempio

Il seguente esempio dimostra il concetto. Crea un file di script e digita il codice seguente:

num_array = [ 1 2 3 4 ; 4 5 6 7; 7 8 9 0];
save array_data1.out num_array -ascii;
type array_data1.out
dlmwrite('array_data2.out', num_array, ' ');
type array_data2.out

Quando si esegue il file, viene visualizzato il seguente risultato:

1.0000000e+00   2.0000000e+00   3.0000000e+00   4.0000000e+00
   4.0000000e+00   5.0000000e+00   6.0000000e+00   7.0000000e+00
   7.0000000e+00   8.0000000e+00   9.0000000e+00   0.0000000e+00

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

Si noti che il comando save -ascii e la funzione dlmwrite non funzionano con gli array di celle come input. Per creare un file ASCII delimitato dal contenuto di un array di celle, puoi farlo

  • In alternativa, converti l'array di celle in una matrice utilizzando l'estensione cell2mat funzione

  • Oppure esportare la matrice di celle utilizzando le funzioni di I / O di file di basso livello.

Se usi l'estensione save funzione per scrivere un array di caratteri in un file ASCII, scrive l'equivalente ASCII dei caratteri nel file.

Ad esempio, scriviamo la parola "ciao" in un file:

h = 'hello';
save textdata.out h -ascii
type textdata.out

MATLAB esegue le istruzioni precedenti e visualizza il seguente risultato. che sono i caratteri della stringa "ciao" in formato ASCII a 8 cifre.

1.0400000e+02   1.0100000e+02   1.0800000e+02   1.0800000e+02   1.1100000e+02

Scrivere su file di diario

I file di diario sono registri delle attività della tua sessione MATLAB. La funzione diario crea una copia esatta della sessione in un file su disco, escluse le immagini.

Per attivare la funzione diario, digita -

diary

Facoltativamente, puoi dare il nome del file di registro, ad esempio -

diary logdata.out

Per disattivare la funzione diario:

diary off

Puoi aprire il file del diario in un editor di testo.

Esportazione di dati in file di dati di testo con I / O di basso livello

Finora abbiamo esportato array numerici. Tuttavia, potrebbe essere necessario creare altri file di testo, comprese combinazioni di dati numerici e di caratteri, file di output non rettangolari o file con schemi di codifica non ASCII. Per questi scopi, MATLAB fornisce il livello bassofprintf funzione.

Come nelle attività di file di I / O di basso livello, prima di esportare, è necessario aprire o creare un file con l'estensione fopenfunzione e ottenere l'identificatore del file. Per impostazione predefinita, fopen apre un file per l'accesso in sola lettura. È necessario specificare l'autorizzazione per scrivere o aggiungere, ad esempio "w" o "a".

Dopo aver elaborato il file, è necessario chiuderlo con fclose(fid) funzione.

Il seguente esempio dimostra il concetto:

Esempio

Crea un file di script e digita il seguente codice al suo interno:

% create a matrix y, with two rows
x = 0:10:100;
y = [x; log(x)];
 
% open a file for writing
fid = fopen('logtable.txt', 'w');
 
% Table Header
fprintf(fid, 'Log     Function\n\n');
 
% print values in column order
% two values appear on each row of the file
fprintf(fid, '%f    %f\n', y);
fclose(fid);

% display the file created
type logtable.txt

Quando si esegue il file, viene visualizzato il seguente risultato:

Log         Function

0.000000    -Inf
10.000000    2.302585
20.000000    2.995732
30.000000    3.401197
40.000000    3.688879
50.000000    3.912023
60.000000    4.094345
70.000000    4.248495
80.000000    4.382027
90.000000    4.499810
100.000000    4.605170

Per tracciare il grafico di una funzione, è necessario eseguire i seguenti passaggi:

  • Definire x, specificando il range of values per la variabile x, per cui deve essere tracciata la funzione

  • Definisci la funzione, y = f(x)

  • Chiama il plot comando, come plot(x, y)

L'esempio seguente dimostrerebbe il concetto. Tracciamo la funzione semplicey = x per l'intervallo di valori per x da 0 a 100, con un incremento di 5.

Crea un file di script e digita il codice seguente:

x = [0:5:100];
y = x;
plot(x, y)

Quando esegui il file, MATLAB mostra il seguente grafico:

Prendiamo un altro esempio per tracciare la funzione y = x 2 . In questo esempio, disegneremo due grafici con la stessa funzione, ma nella seconda volta, ridurremo il valore di incremento. Si noti che diminuendo l'incremento, il grafico diventa più fluido.

Crea un file di script e digita il codice seguente:

x = [1 2 3 4 5 6 7 8 9 10];
x = [-100:20:100];
y = x.^2;
plot(x, y)

Quando esegui il file, MATLAB mostra il seguente grafico:

Cambia leggermente il file di codice, riduci l'incremento a 5 -

x = [-100:5:100];
y = x.^2;
plot(x, y)

MATLAB traccia un grafico più fluido -

Aggiunta di titolo, etichette, linee della griglia e scala sul grafico

MATLAB ti consente di aggiungere titolo, etichette lungo l'asse xe l'asse y, linee della griglia e anche di regolare gli assi per abbellire il grafico.

  • Il xlabel e ylabel i comandi generano etichette lungo l'asse xe l'asse y.

  • Il title Il comando ti permette di inserire un titolo nel grafico.

  • Il grid on Il comando consente di inserire le linee della griglia sul grafico.

  • Il axis equal il comando permette di generare il grafico con gli stessi fattori di scala e gli spazi su entrambi gli assi.

  • Il axis square il comando genera un grafico quadrato.

Esempio

Crea un file di script e digita il codice seguente:

x = [0:0.01:10];
y = sin(x);
plot(x, y), xlabel('x'), ylabel('Sin(x)'), title('Sin(x) Graph'),
grid on, axis equal

MATLAB genera il seguente grafico:

Disegnare più funzioni sullo stesso grafico

Puoi disegnare più grafici sullo stesso grafico. Il seguente esempio dimostra il concetto:

Esempio

Crea un file di script e digita il codice seguente:

x = [0 : 0.01: 10];
y = sin(x);
g = cos(x);
plot(x, y, x, g, '.-'), legend('Sin(x)', 'Cos(x)')

MATLAB genera il seguente grafico:

Impostazione dei colori sul grafico

MATLAB fornisce otto opzioni di colore di base per disegnare grafici. La tabella seguente mostra i colori e i relativi codici:

Codice Colore
w bianca
K Nero
b Blu
r Rosso
c Ciano
g verde
m Magenta
y Giallo

Esempio

Disegniamo il grafico di due polinomi

  • f (x) = 3x 4 + 2x 3 + 7x 2 + 2x + 9 e

  • g (x) = 5x 3 + 9x + 2

Crea un file di script e digita il codice seguente:

x = [-10 : 0.01: 10];
y = 3*x.^4 + 2 * x.^3 + 7 * x.^2 + 2 * x + 9;
g = 5 * x.^3 + 9 * x + 2;
plot(x, y, 'r', x, g, 'g')

Quando esegui il file, MATLAB genera il seguente grafico:

Impostazione delle scale degli assi

Il axisil comando consente di impostare le scale degli assi. È possibile fornire i valori minimi e massimi per gli assi xey utilizzando il comando assi nel modo seguente:

axis ( [xmin xmax ymin ymax] )

L'esempio seguente mostra questo:

Esempio

Crea un file di script e digita il codice seguente:

x = [0 : 0.01: 10];
y = exp(-x).* sin(2*x + 3);
plot(x, y), axis([0 10 -1 1])

Quando esegui il file, MATLAB genera il seguente grafico:

Generazione di sotto-grafici

Quando crei una serie di grafici nella stessa figura, ognuno di questi grafici viene chiamato sottotrama. Ilsubplot comando viene utilizzato per creare sottotrame.

La sintassi del comando è:

subplot(m, n, p)

dove, m e n sono il numero di righe e colonne della matrice del grafico e p specifica dove mettere un particolare grafico.

Ogni grafico creato con il comando sottotrama può avere le proprie caratteristiche. L'esempio seguente dimostra il concetto:

Esempio

Generiamo due grafici:

y = e −1,5x sin (10x)

y = e −2x sin (10x)

Crea un file di script e digita il codice seguente:

x = [0:0.01:5];
y = exp(-1.5*x).*sin(10*x);
subplot(1,2,1)
plot(x,y), xlabel('x'),ylabel('exp(–1.5x)*sin(10x)'),axis([0 5 -1 1])
y = exp(-2*x).*sin(10*x);
subplot(1,2,2)
plot(x,y),xlabel('x'),ylabel('exp(–2x)*sin(10x)'),axis([0 5 -1 1])

Quando esegui il file, MATLAB genera il seguente grafico:

Questo capitolo continuerà ad esplorare le capacità di stampa e grafica di MATLAB. Discuteremo -

  • Disegno di grafici a barre
  • Disegnare contorni
  • Trame tridimensionali

Disegno di grafici a barre

Il barIl comando disegna un grafico a barre bidimensionale. Facciamo un esempio per dimostrare l'idea.

Esempio

Facciamo una classe immaginaria con 10 studenti. Sappiamo che la percentuale di voti ottenuti da questi studenti è 75, 58, 90, 87, 50, 85, 92, 75, 60 e 95. Tracciamo il grafico a barre per questi dati.

Crea un file di script e digita il codice seguente:

x = [1:10];
y = [75, 58, 90, 87, 50, 85, 92, 75, 60, 95];
bar(x,y), xlabel('Student'),ylabel('Score'),
title('First Sem:')
print -deps graph.eps

Quando esegui il file, MATLAB mostra il seguente grafico a barre:

Disegnare contorni

Una linea di contorno di una funzione di due variabili è una curva lungo la quale la funzione ha un valore costante. Le curve di livello vengono utilizzate per creare mappe di contorno unendo punti di uguale elevazione sopra un dato livello, come il livello medio del mare.

MATLAB fornisce un file contour funzione per disegnare mappe di contorno.

Esempio

Generiamo una mappa di contorno che mostra le curve di livello per una data funzione g = f (x, y). Questa funzione ha due variabili. Quindi, dovremo generare due variabili indipendenti, cioè due set di dati x e y. Questo viene fatto chiamando ilmeshgrid comando.

Il meshgrid comando viene utilizzato per generare una matrice di elementi che forniscono l'intervallo su xey insieme alla specifica di incremento in ogni caso.

Tracciamo la nostra funzione g = f (x, y), dove −5 ≤ x ≤ 5, −3 ≤ y ≤ 3. Prendiamo un incremento di 0,1 per entrambi i valori. Le variabili sono impostate come -

[x,y] = meshgrid(–5:0.1:5, –3:0.1:3);

Infine, dobbiamo assegnare la funzione. Sia la nostra funzione: x 2 + y 2

Crea un file di script e digita il codice seguente:

[x,y] = meshgrid(-5:0.1:5,-3:0.1:3);   %independent variables
g = x.^2 + y.^2;                       % our function
contour(x,y,g)                         % call the contour function
print -deps graph.eps

Quando esegui il file, MATLAB visualizza la seguente mappa di contorno:

Modifichiamo un po 'il codice per abbellire la mappa

[x,y] = meshgrid(-5:0.1:5,-3:0.1:3);   %independent variables
g = x.^2 + y.^2;                       % our function
[C, h] = contour(x,y,g);               % call the contour function
set(h,'ShowText','on','TextStep',get(h,'LevelStep')*2)
print -deps graph.eps

Quando esegui il file, MATLAB visualizza la seguente mappa di contorno:

Grafici tridimensionali

I grafici tridimensionali mostrano fondamentalmente una superficie definita da una funzione in due variabili, g = f (x, y).

Come prima, per definire g, creiamo prima un insieme di punti (x, y) sul dominio della funzione usando il meshgridcomando. Successivamente, assegniamo la funzione stessa. Infine, usiamo ilsurf comando per creare un grafico di superficie.

Il seguente esempio dimostra il concetto:

Esempio

Creiamo una mappa della superficie 3D per la funzione g = xe - (x 2 + y 2 )

Crea un file di script e digita il codice seguente:

[x,y] = meshgrid(-2:.2:2);
g = x .* exp(-x.^2 - y.^2);
surf(x, y, g)
print -deps graph.eps

Quando esegui il file, MATLAB mostra la seguente mappa 3-D:

Puoi anche usare il file meshcomando per generare una superficie tridimensionale. in ogni caso, ilsurf Il comando visualizza sia le linee di collegamento che le facce della superficie a colori, mentre il mesh Il comando crea una superficie wireframe con linee colorate che collegano i punti di definizione.

Finora, abbiamo visto che tutti gli esempi funzionano in MATLAB così come il suo GNU, chiamato in alternativa Octave. Ma per risolvere le equazioni algebriche di base, sia MATLAB che Octave sono leggermente diversi, quindi proveremo a trattare MATLAB e Octave in sezioni separate.

Discuteremo anche la fattorizzazione e la semplificazione delle espressioni algebriche.

Risoluzione di equazioni algebriche di base in MATLAB

Il solveè usata per risolvere equazioni algebriche. Nella sua forma più semplice, la funzione di risoluzione accetta l'equazione racchiusa tra virgolette come argomento.

Ad esempio, risolviamo x nell'equazione x-5 = 0

solve('x-5=0')

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =
   5

Puoi anche chiamare la funzione di risoluzione come -

y = solve('x-5 = 0')

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

y =
   5

Potresti anche non includere il lato destro dell'equazione -

solve('x-5')

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =
   5

Se l'equazione coinvolge più simboli, MATLAB per impostazione predefinita presume che tu stia risolvendo per x, tuttavia, la funzione di risoluzione ha un'altra forma:

solve(equation, variable)

dove puoi anche menzionare la variabile.

Ad esempio, risolviamo l'equazione v - u - 3t 2 = 0, per v. In questo caso, dovremmo scrivere -

solve('v-u-3*t^2=0', 'v')

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =
   3*t^2 + u

Risoluzione di equazioni algebriche di base in ottava

Il roots è usata per risolvere equazioni algebriche in Octave e puoi scrivere sopra gli esempi come segue:

Ad esempio, risolviamo x nell'equazione x-5 = 0

roots([1, -5])

Octave eseguirà l'istruzione precedente e restituirà il seguente risultato:

ans = 5

Puoi anche chiamare la funzione di risoluzione come -

y = roots([1, -5])

Octave eseguirà l'istruzione precedente e restituirà il seguente risultato:

y = 5

Risoluzione di equazioni quadratiche in MATLAB

Il solvepuò anche risolvere equazioni di ordine superiore. Viene spesso utilizzato per risolvere equazioni quadratiche. La funzione restituisce le radici dell'equazione in un array.

L'esempio seguente risolve l'equazione quadratica x 2 -7x +12 = 0. Crea un file di script e digita il codice seguente:

eq = 'x^2 -7*x + 12 = 0';
s = solve(eq);
disp('The first root is: '), disp(s(1));
disp('The second root is: '), disp(s(2));

Quando si esegue il file, viene visualizzato il seguente risultato:

The first root is: 
   3
The second root is: 
   4

Risoluzione di equazioni quadratiche in ottava

L'esempio seguente risolve l'equazione quadratica x 2 -7x +12 = 0 in Ottava. Crea un file di script e digita il codice seguente:

s = roots([1, -7, 12]);

disp('The first root is: '), disp(s(1));
disp('The second root is: '), disp(s(2));

Quando si esegue il file, viene visualizzato il seguente risultato:

The first root is: 
   4
The second root is: 
   3

Risoluzione di equazioni di ordine superiore in MATLAB

Il solvepuò anche risolvere equazioni di ordine superiore. Ad esempio, risolviamo un'equazione cubica come (x-3) 2 (x-7) = 0

solve('(x-3)^2*(x-7)=0')

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =
   3
   3
   7

In caso di equazioni di ordine superiore, le radici sono lunghe e contengono molti termini. È possibile ottenere il valore numerico di tali radici convertendole in doppie. L'esempio seguente risolve l'equazione del quarto ordine x 4 - 7x 3 + 3x 2 - 5x + 9 = 0.

Crea un file di script e digita il codice seguente:

eq = 'x^4 - 7*x^3 + 3*x^2 - 5*x + 9 = 0';
s = solve(eq);
disp('The first root is: '), disp(s(1));
disp('The second root is: '), disp(s(2));
disp('The third root is: '), disp(s(3));
disp('The fourth root is: '), disp(s(4));

% converting the roots to double type
disp('Numeric value of first root'), disp(double(s(1)));
disp('Numeric value of second root'), disp(double(s(2)));
disp('Numeric value of third root'), disp(double(s(3)));
disp('Numeric value of fourth root'), disp(double(s(4)));

Quando esegui il file, restituisce il seguente risultato:

The first root is: 
6.630396332390718431485053218985
 The second root is: 
1.0597804633025896291682772499885
 The third root is: 
- 0.34508839784665403032666523448675 - 1.0778362954630176596831109269793*i
 The fourth root is: 
- 0.34508839784665403032666523448675 + 1.0778362954630176596831109269793*i
Numeric value of first root
   6.6304
Numeric value of second root
   1.0598
Numeric value of third root
   -0.3451 - 1.0778i
Numeric value of fourth root
   -0.3451 + 1.0778i

Si noti che le ultime due radici sono numeri complessi.

Risoluzione di equazioni di ordine superiore in ottava

L'esempio seguente risolve l'equazione del quarto ordine x 4 - 7x 3 + 3x 2 - 5x + 9 = 0.

Crea un file di script e digita il codice seguente:

v = [1, -7,  3, -5, 9];
s = roots(v);

% converting the roots to double type
disp('Numeric value of first root'), disp(double(s(1)));
disp('Numeric value of second root'), disp(double(s(2)));
disp('Numeric value of third root'), disp(double(s(3)));
disp('Numeric value of fourth root'), disp(double(s(4)));

Quando esegui il file, restituisce il seguente risultato:

Numeric value of first root
 6.6304
Numeric value of second root
-0.34509 + 1.07784i
Numeric value of third root
-0.34509 - 1.07784i
Numeric value of fourth root
 1.0598

Risoluzione di sistemi di equazioni in MATLAB

Il solvepuò essere utilizzata anche per generare soluzioni di sistemi di equazioni che coinvolgono più di una variabile. Facciamo un semplice esempio per dimostrare questo uso.

Risolviamo le equazioni -

5x + 9y = 5

3x - 6y = 4

Crea un file di script e digita il codice seguente:

s = solve('5*x + 9*y = 5','3*x - 6*y = 4');
s.x
s.y

Quando si esegue il file, viene visualizzato il seguente risultato:

ans =
   22/19
ans =
   -5/57

Allo stesso modo, puoi risolvere sistemi lineari più grandi. Considera il seguente insieme di equazioni:

x + 3y -2z = 5

3x + 5y + 6z = 7

2x + 4y + 3z = 8

Risolvere il sistema di equazioni in ottava

Abbiamo un approccio leggermente diverso per risolvere un sistema di 'n' equazioni lineari in 'n' incognite. Facciamo un semplice esempio per dimostrare questo uso.

Risolviamo le equazioni -

5x + 9y = 5

3x - 6y = 4

Un tale sistema di equazioni lineari può essere scritto come l'equazione a matrice singola Ax = b, dove A è la matrice dei coefficienti, b è il vettore colonna contenente il lato destro delle equazioni lineari ex è il vettore colonna che rappresenta la soluzione come mostrato nel programma seguente -

Crea un file di script e digita il codice seguente:

A = [5, 9; 3, -6];
b = [5;4];
A \ b

Quando si esegue il file, viene visualizzato il seguente risultato:

ans =

   1.157895
  -0.087719

Allo stesso modo, puoi risolvere sistemi lineari più grandi come indicato di seguito:

x + 3y -2z = 5

3x + 5y + 6z = 7

2x + 4y + 3z = 8

Espansione e raccolta di equazioni in MATLAB

Il expand e il collectfunzione espande e raccoglie rispettivamente un'equazione. Il seguente esempio dimostra i concetti:

Quando lavori con molte funzioni simboliche, dovresti dichiarare che le tue variabili sono simboliche.

Crea un file di script e digita il codice seguente:

syms x   %symbolic variable x
syms y   %symbolic variable x
% expanding equations
expand((x-5)*(x+9))
expand((x+2)*(x-3)*(x-5)*(x+7))
expand(sin(2*x))
expand(cos(x+y))
 
% collecting equations
collect(x^3 *(x-7))
collect(x^4*(x-3)*(x-5))

Quando si esegue il file, viene visualizzato il seguente risultato:

ans =
   x^2 + 4*x - 45
ans =
   x^4 + x^3 - 43*x^2 + 23*x + 210
ans =
   2*cos(x)*sin(x)
ans =
   cos(x)*cos(y) - sin(x)*sin(y)
ans =
   x^4 - 7*x^3
ans =
   x^6 - 8*x^5 + 15*x^4

Espansione e raccolta di equazioni in ottava

Hai bisogno di avere symbolic pacchetto, che fornisce expand e il collectfunzione per espandere e raccogliere un'equazione, rispettivamente. Il seguente esempio dimostra i concetti:

Quando lavori con molte funzioni simboliche, dovresti dichiarare che le tue variabili sono simboliche ma Octave ha un approccio diverso per definire le variabili simboliche. Notare l'uso diSin e Cos, che sono anche definiti nel pacchetto simbolico.

Crea un file di script e digita il codice seguente:

% first of all load the package, make sure its installed.
pkg load symbolic

% make symbols module available
symbols

% define symbolic variables
x = sym ('x');
y = sym ('y');
z = sym ('z');

% expanding equations
expand((x-5)*(x+9))
expand((x+2)*(x-3)*(x-5)*(x+7))
expand(Sin(2*x))
expand(Cos(x+y))
 
% collecting equations
collect(x^3 *(x-7), z)
collect(x^4*(x-3)*(x-5), z)

Quando si esegue il file, viene visualizzato il seguente risultato:

ans =

-45.0+x^2+(4.0)*x
ans =

210.0+x^4-(43.0)*x^2+x^3+(23.0)*x
ans =

sin((2.0)*x)
ans =

cos(y+x)
ans =

x^(3.0)*(-7.0+x)
ans =

(-3.0+x)*x^(4.0)*(-5.0+x)

Fattorizzazione e semplificazione delle espressioni algebriche

Il factor funzione fattorizza un'espressione e il simplifyfunzione semplifica un'espressione. Il seguente esempio dimostra il concetto:

Esempio

Crea un file di script e digita il codice seguente:

syms x
syms y
factor(x^3 - y^3)
factor([x^2-y^2,x^3+y^3])
simplify((x^4-16)/(x^2-4))

Quando si esegue il file, viene visualizzato il seguente risultato:

ans =
   (x - y)*(x^2 + x*y + y^2)
ans =
   [ (x - y)*(x + y), (x + y)*(x^2 - x*y + y^2)]
ans =
   x^2 + 4

MATLAB fornisce vari modi per risolvere problemi di calcolo differenziale e integrale, risolvere equazioni differenziali di qualsiasi grado e calcolo dei limiti. Soprattutto, puoi facilmente tracciare i grafici di funzioni complesse e controllare i massimi, i minimi e altri punti di cancelleria su un grafico risolvendo la funzione originale, così come la sua derivata.

Questo capitolo tratterà i problemi del calcolo. In questo capitolo discuteremo i concetti del pre-calcolo, ovvero il calcolo dei limiti delle funzioni e la verifica delle proprietà dei limiti.

Nel prossimo capitolo Differenziale , calcoleremo la derivata di un'espressione e troveremo i massimi e minimi locali su un grafico. Discuteremo anche la risoluzione di equazioni differenziali.

Infine, nel capitolo sull'integrazione , discuteremo del calcolo integrale.

Calcolo dei limiti

MATLAB fornisce il limitfunzione per il calcolo dei limiti. Nella sua forma più semplice, illimit la funzione accetta l'espressione come argomento e trova il limite dell'espressione quando la variabile indipendente va a zero.

Ad esempio, calcoliamo il limite di una funzione f (x) = (x 3 + 5) / (x 4 + 7), poiché x tende a zero.

syms x
limit((x^3 + 5)/(x^4 + 7))

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =
   5/7

La funzione limite rientra nel regno del calcolo simbolico; devi usare il filesymsfunzione per dire a MATLAB quali variabili simboliche stai utilizzando. Puoi anche calcolare il limite di una funzione, poiché la variabile tende a un numero diverso da zero. Per calcolare lim x-> a (f (x)), usiamo il comando limit con argomenti. Il primo è l'espressione e il secondo è il numero, che x si avvicina, qui è a .

Ad esempio, calcoliamo il limite di una funzione f (x) = (x-3) / (x-1), poiché x tende a 1.

limit((x - 3)/(x-1),1)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =
   NaN

Facciamo un altro esempio,

limit(x^2 + 5, 3)

MATLAB eseguirà l'istruzione sopra e restituirà il seguente risultato:

ans =
   14

Calcolo dei limiti utilizzando Octave

Di seguito è riportata la versione Octave dell'esempio precedente utilizzando symbolic pacchetto, prova ad eseguire e confrontare il risultato -

pkg load symbolic
symbols

x = sym("x");
subs((x^3+5)/(x^4+7),x,0)

Octave eseguirà l'istruzione precedente e restituirà il seguente risultato:

ans =
   0.7142857142857142857

Verifica delle proprietà di base dei limiti

Il Teorema algebrico del limite fornisce alcune proprietà di base dei limiti. Questi sono i seguenti:

Consideriamo due funzioni:

  • f (x) = (3x + 5) / (x - 3)
  • g (x) = x 2 + 1.

Calcoliamo i limiti delle funzioni per x tende a 5, di entrambe le funzioni e verifichiamo le proprietà di base dei limiti utilizzando queste due funzioni e MATLAB.

Esempio

Crea un file di script e digita il seguente codice al suo interno:

syms x
f = (3*x + 5)/(x-3);
g = x^2 + 1;
l1 = limit(f, 4)
l2 = limit (g, 4)
lAdd = limit(f + g, 4)
lSub = limit(f - g, 4)
lMult = limit(f*g, 4)
lDiv = limit (f/g, 4)

Quando esegui il file, viene visualizzato:

l1 =
   17
  
l2 =
   17
  
lAdd =
   34
 
lSub =
   0
  
lMult =
   289
  
lDiv =
   1

Verifica delle proprietà di base dei limiti utilizzando Octave

Di seguito è riportata la versione Octave dell'esempio precedente utilizzando symbolic pacchetto, prova ad eseguire e confrontare il risultato -

pkg load symbolic
symbols

x = sym("x");
f = (3*x + 5)/(x-3);
g = x^2 + 1;

l1 = subs(f, x, 4)
l2 = subs (g, x, 4)
lAdd = subs (f+g, x, 4)
lSub = subs (f-g, x, 4)
lMult = subs (f*g, x, 4)
lDiv = subs (f/g, x, 4)

Octave eseguirà l'istruzione precedente e restituirà il seguente risultato:

l1 =
   17.0
l2 =
   17.0
lAdd =
   34.0
lSub =
   0.0
lMult =
   289.0
lDiv =
   1.0

Limiti dei lati sinistro e destro

Quando una funzione ha una discontinuità per un valore particolare della variabile, il limite non esiste a quel punto. In altre parole, i limiti di una funzione f (x) hanno discontinuità in x = a, quando il valore del limite, quando x si avvicina a x dal lato sinistro, non è uguale al valore del limite quando x si avvicina dal lato destro.

Questo porta al concetto di limiti per mancini e destrimani. Un limite per mancini è definito come il limite come x -> a, da sinistra, cioè x si avvicina a, per valori di x <a. Un limite destrorso è definito come il limite come x -> a, da destra, cioè x si avvicina a, per valori di x> a. Quando il limite per la mano sinistra e il limite per la mano destra non sono uguali, il limite non esiste.

Consideriamo una funzione:

f(x) = (x - 3)/|x - 3|

Mostreremo che lim x-> 3 f (x) non esiste. MATLAB ci aiuta a stabilire questo fatto in due modi:

  • Tracciando il grafico della funzione e mostrando la discontinuità.
  • Calcolando i limiti e dimostrando che entrambi sono diversi.

I limiti per mancini e destrimani vengono calcolati passando le stringhe di caratteri "left" e "right" al comando limit come ultimo argomento.

Esempio

Crea un file di script e digita il seguente codice al suo interno:

f = (x - 3)/abs(x-3);
ezplot(f,[-1,5])
l = limit(f,x,3,'left')
r = limit(f,x,3,'right')

Quando esegui il file, MATLAB disegna il seguente grafico

Dopo che viene visualizzato questo output seguente:

l =
   -1
  
r =
   1

MATLAB fornisce il diffcomando per il calcolo delle derivate simboliche. Nella sua forma più semplice, passi la funzione che vuoi differenziare al comando diff come argomento.

Ad esempio, calcoliamo la derivata della funzione f (t) = 3t 2 + 2t -2

Esempio

Crea un file di script e digita il seguente codice al suo interno:

syms t
f = 3*t^2 + 2*t^(-2);
diff(f)

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

ans =
6*t - 4/t^3

Di seguito è riportato l'equivalente in ottava del calcolo precedente:

pkg load symbolic
symbols

t = sym("t");
f = 3*t^2 + 2*t^(-2);
differentiate(f,t)

Octave esegue il codice e restituisce il seguente risultato:

ans =
   -(4.0)*t^(-3.0)+(6.0)*t

Verifica delle regole elementari di differenziazione

Stabiliamo brevemente varie equazioni o regole per la differenziazione delle funzioni e verifichiamo queste regole. A questo scopo, scriveremo f '(x) per una derivata del primo ordine e f "(x) per una derivata del secondo ordine.

Di seguito sono riportate le regole per la differenziazione:

Regola 1

Per ogni funzione feg e ogni numero reale aeb sono la derivata della funzione -

h(x) = af(x) + bg(x) rispetto a x è dato da -

h'(x) = af'(x) + bg'(x)

Regola 2

Il sum e subtraction le regole stabiliscono che se f e g sono due funzioni, f 'e g' sono rispettivamente le loro derivate, allora,

(f + g)' = f' + g'

(f - g)' = f' - g'

Regola 3

Il product regola afferma che se f e g sono due funzioni, f 'e g' sono le loro derivate rispettivamente, allora,

(f.g)' = f'.g + g'.f

Regola 4

Il quotient regola afferma che se f e g sono due funzioni, f 'e g' sono le loro derivate rispettivamente, allora,

(f/g)' = (f'.g - g'.f)/g2

Regola 5

Il polynomial o la regola del potere elementare afferma che, se y = f(x) = xn, poi f' = n. x(n-1)

Un risultato diretto di questa regola è che la derivata di qualsiasi costante è zero, cioè se y = k, qualsiasi costante, quindi

f' = 0

Regola 6

Il chain regola afferma che, derivata della funzione di una funzione h(x) = f(g(x)) rispetto a x is,

h'(x)= f'(g(x)).g'(x)

Esempio

Crea un file di script e digita il seguente codice al suo interno:

syms x
syms t

f = (x + 2)*(x^2 + 3)
der1 = diff(f)
f = (t^2 + 3)*(sqrt(t) + t^3)
der2 = diff(f)
f = (x^2 - 2*x + 1)*(3*x^3 - 5*x^2 + 2)
der3 = diff(f)
f = (2*x^2 + 3*x)/(x^3 + 1)
der4 = diff(f)
f = (x^2 + 1)^17
der5 = diff(f)
f = (t^3 + 3* t^2 + 5*t -9)^(-6)
der6 = diff(f)

Quando esegui il file, MATLAB mostra il seguente risultato:

f =
   (x^2 + 3)*(x + 2)
 
   der1 =
   2*x*(x + 2) + x^2 + 3
  
f =
   (t^(1/2) + t^3)*(t^2 + 3)
 
   der2 =
   (t^2 + 3)*(3*t^2 + 1/(2*t^(1/2))) + 2*t*(t^(1/2) + t^3)
  
f =
   (x^2 - 2*x + 1)*(3*x^3 - 5*x^2 + 2)
  
der3 =
   (2*x - 2)*(3*x^3 - 5*x^2 + 2) - (- 9*x^2 + 10*x)*(x^2 - 2*x + 1)
 
f =
   (2*x^2 + 3*x)/(x^3 + 1)
  
der4 =
   (4*x + 3)/(x^3 + 1) - (3*x^2*(2*x^2 + 3*x))/(x^3 + 1)^2
  
f =
   (x^2 + 1)^17
  
der5 =
   34*x*(x^2 + 1)^16
  
f =
   1/(t^3 + 3*t^2 + 5*t - 9)^6
  
der6 =
   -(6*(3*t^2 + 6*t + 5))/(t^3 + 3*t^2 + 5*t - 9)^7

Di seguito è riportato l'equivalente in ottava del calcolo precedente:

pkg load symbolic
symbols

x = sym("x");
t = sym("t");
f = (x + 2)*(x^2 + 3) 
der1 = differentiate(f,x) 
f = (t^2 + 3)*(t^(1/2) + t^3) 
der2 = differentiate(f,t) 
f = (x^2 - 2*x + 1)*(3*x^3 - 5*x^2 + 2) 
der3 = differentiate(f,x) 
f = (2*x^2 + 3*x)/(x^3 + 1) 
der4 = differentiate(f,x) 
f = (x^2 + 1)^17 
der5 = differentiate(f,x) 
f = (t^3 + 3* t^2 + 5*t -9)^(-6) 
der6 = differentiate(f,t)

Octave esegue il codice e restituisce il seguente risultato:

f =

(2.0+x)*(3.0+x^(2.0))
der1 =

3.0+x^(2.0)+(2.0)*(2.0+x)*x
f =

(t^(3.0)+sqrt(t))*(3.0+t^(2.0))
der2 =

(2.0)*(t^(3.0)+sqrt(t))*t+((3.0)*t^(2.0)+(0.5)*t^(-0.5))*(3.0+t^(2.0))
f =

(1.0+x^(2.0)-(2.0)*x)*(2.0-(5.0)*x^(2.0)+(3.0)*x^(3.0))
der3 =

(-2.0+(2.0)*x)*(2.0-(5.0)*x^(2.0)+(3.0)*x^(3.0))+((9.0)*x^(2.0)-(10.0)*x)*(1.0+x^(2.0)-(2.0)*x)
f =

(1.0+x^(3.0))^(-1)*((2.0)*x^(2.0)+(3.0)*x)
der4 =

(1.0+x^(3.0))^(-1)*(3.0+(4.0)*x)-(3.0)*(1.0+x^(3.0))^(-2)*x^(2.0)*((2.0)*x^(2.0)+(3.0)*x)
f =

(1.0+x^(2.0))^(17.0)
der5 =

(34.0)*(1.0+x^(2.0))^(16.0)*x
f =

(-9.0+(3.0)*t^(2.0)+t^(3.0)+(5.0)*t)^(-6.0)
der6 =

-(6.0)*(-9.0+(3.0)*t^(2.0)+t^(3.0)+(5.0)*t)^(-7.0)*(5.0+(3.0)*t^(2.0)+(6.0)*t)

Derivate di funzioni esponenziali, logaritmiche e trigonometriche

La tabella seguente fornisce i derivati ​​delle funzioni esponenziali, logaritmiche e trigonometriche di uso comune:

Funzione Derivato
ca.x c a.x .ln ca (ln è il logaritmo naturale)
ex e x
ln x 1 / x
lncx 1 / x.ln c
xx x x . (1 + ln x)
sin(x) cos (x)
cos(x) -sin (x)
tan(x) sec 2 (x) o 1 / cos 2 (x) o 1 + tan 2 (x)
cot(x) -csc 2 (x), o -1 / sin 2 (x) o - (1 + cot 2 (x))
sec(x) sec (x) .tan (x)
csc(x) -csc (x) .cot (x)

Esempio

Crea un file di script e digita il seguente codice al suo interno:

syms x
y = exp(x)
diff(y)
y = x^9
diff(y)
y = sin(x)
diff(y)
y = tan(x)
diff(y)
y = cos(x)
diff(y)
y = log(x)
diff(y)
y = log10(x)
diff(y)
y = sin(x)^2
diff(y)
y = cos(3*x^2 + 2*x + 1)
diff(y)
y = exp(x)/sin(x)
diff(y)

Quando esegui il file, MATLAB mostra il seguente risultato:

y =
   exp(x)
   ans =
   exp(x)

y =
   x^9
   ans =
   9*x^8
  
y =
   sin(x)
   ans =
   cos(x)
  
y =
   tan(x)
   ans =
   tan(x)^2 + 1
 
y =
   cos(x)
   ans =
   -sin(x)
  
y =
   log(x)
   ans =
   1/x
  
y =
   log(x)/log(10)
   ans =
   1/(x*log(10))
 
y =
   sin(x)^2
   ans =
   2*cos(x)*sin(x)
 
y =
   cos(3*x^2 + 2*x + 1)
   ans =
   -sin(3*x^2 + 2*x + 1)*(6*x + 2)
  
y =
   exp(x)/sin(x)
   ans =
   exp(x)/sin(x) - (exp(x)*cos(x))/sin(x)^2

Di seguito è riportato l'equivalente in ottava del calcolo precedente:

pkg load symbolic
symbols

x = sym("x");
y = Exp(x)
differentiate(y,x)

y = x^9
differentiate(y,x)

y = Sin(x)
differentiate(y,x)

y = Tan(x)
differentiate(y,x)

y = Cos(x)
differentiate(y,x)

y = Log(x)
differentiate(y,x)

% symbolic packages does not have this support
%y = Log10(x)
%differentiate(y,x)

y = Sin(x)^2
differentiate(y,x)

y = Cos(3*x^2 + 2*x + 1)
differentiate(y,x)

y = Exp(x)/Sin(x)
differentiate(y,x)

Octave esegue il codice e restituisce il seguente risultato:

y =

exp(x)
ans =

exp(x)
y =

x^(9.0)
ans =

(9.0)*x^(8.0)
y =

sin(x)
ans =

cos(x)
y =

tan(x)
ans =

1+tan(x)^2
y =

cos(x)
ans =

-sin(x)
y =

log(x)
ans =

x^(-1)
y =

sin(x)^(2.0)
ans =

(2.0)*sin(x)*cos(x)
y =

cos(1.0+(2.0)*x+(3.0)*x^(2.0))
ans =

-(2.0+(6.0)*x)*sin(1.0+(2.0)*x+(3.0)*x^(2.0))
y =

sin(x)^(-1)*exp(x)
ans =

sin(x)^(-1)*exp(x)-sin(x)^(-2)*cos(x)*exp(x)

Calcolo di derivati ​​di ordine superiore

Per calcolare derivate superiori di una funzione f, usiamo la sintassi diff(f,n).

Calcoliamo la derivata seconda della funzione y = f (x) = x. E -3x

f = x*exp(-3*x);
diff(f, 2)

MATLAB esegue il codice e restituisce il seguente risultato:

ans =
9*x*exp(-3*x) - 6*exp(-3*x)

Di seguito è riportato l'equivalente in ottava del calcolo precedente:

pkg load symbolic
symbols

x = sym("x");
f = x*Exp(-3*x);
differentiate(f, x, 2)

Octave esegue il codice e restituisce il seguente risultato:

ans =

(9.0)*exp(-(3.0)*x)*x-(6.0)*exp(-(3.0)*x)

Esempio

In questo esempio, risolviamo un problema. Dato che una funzioney = f(x) = 3 sin(x) + 7 cos(5x). Dovremo scoprire se l'equazionef" + f = -5cos(2x) è vero.

Crea un file di script e digita il seguente codice al suo interno:

syms x
y = 3*sin(x)+7*cos(5*x);  % defining the function
lhs = diff(y,2)+y;        %evaluting the lhs of the equation
rhs = -5*cos(2*x);        %rhs of the equation
if(isequal(lhs,rhs))
   disp('Yes, the equation holds true');
else
   disp('No, the equation does not hold true');
end
disp('Value of LHS is: '), disp(lhs);

Quando si esegue il file, viene visualizzato il seguente risultato:

No, the equation does not hold true
Value of LHS is: 
-168*cos(5*x)

Di seguito è riportato l'equivalente in ottava del calcolo precedente:

pkg load symbolic
symbols

x = sym("x");
y = 3*Sin(x)+7*Cos(5*x);           % defining the function
lhs = differentiate(y, x, 2) + y;  %evaluting the lhs of the equation
rhs = -5*Cos(2*x);                 %rhs of the equation

if(lhs == rhs)
   disp('Yes, the equation holds true');
else
   disp('No, the equation does not hold true');
end
disp('Value of LHS is: '), disp(lhs);

Octave esegue il codice e restituisce il seguente risultato:

No, the equation does not hold true
Value of LHS is: 
-(168.0)*cos((5.0)*x)

Trovare i massimi e i minimi di una curva

Se stiamo cercando i massimi e minimi locali per un grafico, stiamo fondamentalmente cercando i punti più alti o più bassi sul grafico della funzione in una particolare località, o per un particolare intervallo di valori della variabile simbolica.

Per una funzione y = f (x) vengono chiamati i punti del grafico in cui il grafico ha pendenza zero stationary points. In altre parole, i punti stazionari sono dove f '(x) = 0.

Per trovare i punti stazionari di una funzione che differenziamo, dobbiamo impostare la derivata uguale a zero e risolvere l'equazione.

Esempio

Troviamo i punti stazionari della funzione f (x) = 2x 3 + 3x 2 - 12x + 17

Procedi nel seguente modo:

First let us enter the function and plot its graph.

syms x
y = 2*x^3 + 3*x^2 - 12*x + 17;   % defining the function
ezplot(y)

MATLAB esegue il codice e restituisce la seguente trama:

Ecco il codice equivalente a Octave per l'esempio precedente:

pkg load symbolic
symbols

x = sym('x');
y = inline("2*x^3 + 3*x^2 - 12*x + 17");

ezplot(y)
print -deps graph.eps

Our aim is to find some local maxima and minima on the graph, so let us find the local maxima and minima for the interval [-2, 2] on the graph.

syms x
y = 2*x^3 + 3*x^2 - 12*x + 17;   % defining the function
ezplot(y, [-2, 2])

MATLAB esegue il codice e restituisce la seguente trama:

Ecco il codice equivalente a Octave per l'esempio precedente:

pkg load symbolic
symbols

x = sym('x');
y = inline("2*x^3 + 3*x^2 - 12*x + 17");

ezplot(y, [-2, 2])
print -deps graph.eps

Next, let us compute the derivative.

g = diff(y)

MATLAB esegue il codice e restituisce il seguente risultato:

g =
   6*x^2 + 6*x - 12

Ecco l'equivalente in ottava del calcolo precedente:

pkg load symbolic
symbols

x = sym("x");
y = 2*x^3 + 3*x^2 - 12*x + 17;
g = differentiate(y,x)

Octave esegue il codice e restituisce il seguente risultato:

g =
   -12.0+(6.0)*x+(6.0)*x^(2.0)

Let us solve the derivative function, g, to get the values where it becomes zero.

s = solve(g)

MATLAB esegue il codice e restituisce il seguente risultato:

s =
   1
   -2

Di seguito è riportato l'equivalente in ottava del calcolo precedente:

pkg load symbolic
symbols

x = sym("x");
y = 2*x^3 + 3*x^2 - 12*x + 17;
g = differentiate(y,x)
roots([6, 6, -12])

Octave esegue il codice e restituisce il seguente risultato:

g =

-12.0+(6.0)*x^(2.0)+(6.0)*x
ans =

  -2
   1

This agrees with our plot. So let us evaluate the function f at the critical points x = 1, -2. Possiamo sostituire un valore in una funzione simbolica usando il subs comando.

subs(y, 1), subs(y, -2)

MATLAB esegue il codice e restituisce il seguente risultato:

ans =
   10
ans =
   37

Di seguito è riportato l'equivalente in ottava del calcolo precedente:

pkg load symbolic
symbols

x = sym("x");
y = 2*x^3 + 3*x^2 - 12*x + 17;
g = differentiate(y,x)

roots([6, 6, -12])
subs(y, x, 1), subs(y, x, -2)

ans =
   10.0
ans =
   37.0-4.6734207789940138748E-18*I

Pertanto, i valori minimo e massimo sulla funzione f (x) = 2x 3 + 3x 2 - 12x + 17, nell'intervallo [-2,2] sono 10 e 37.

Risoluzione di equazioni differenziali

MATLAB fornisce il dsolve comando per risolvere simbolicamente equazioni differenziali.

La forma più semplice di dsolve comando per trovare la soluzione a una singola equazione è

dsolve('eqn')

dove eqn è una stringa di testo utilizzata per inserire l'equazione.

Restituisce una soluzione simbolica con un insieme di costanti arbitrarie che MATLAB etichetta C1, C2 e così via.

È inoltre possibile specificare le condizioni iniziali e al contorno per il problema, come elenco delimitato da virgole che segue l'equazione come -

dsolve('eqn','cond1', 'cond2',…)

Allo scopo di utilizzare il comando dsolve, derivatives are indicated with a D. Ad esempio, un'equazione come f '(t) = -2 * f + cost (t) viene inserita come -

'Df = -2*f + cos(t)'

I derivati ​​superiori sono indicati seguendo la D nell'ordine del derivato.

Ad esempio, l'equazione f "(x) + 2f '(x) = 5sin3x deve essere inserita come -

'D2y + 2Dy = 5*sin(3*x)'

Prendiamo un semplice esempio di un'equazione differenziale del primo ordine: y '= 5y.

s = dsolve('Dy = 5*y')

MATLAB esegue il codice e restituisce il seguente risultato:

s =
   C2*exp(5*t)

Prendiamo un altro esempio di equazione differenziale del secondo ordine come: y "- y = 0, y (0) = -1, y '(0) = 2.

dsolve('D2y - y = 0','y(0) = -1','Dy(0) = 2')

MATLAB esegue il codice e restituisce il seguente risultato:

ans =
   exp(t)/2 - (3*exp(-t))/2

L'integrazione si occupa di due tipi di problemi essenzialmente diversi.

  • Nel primo tipo, viene data la derivata di una funzione e vogliamo trovare la funzione. Pertanto, sostanzialmente invertiamo il processo di differenziazione. Questo processo inverso è noto come anti-differenziazione, o trovare la funzione primitiva o trovare un fileindefinite integral.

  • Il secondo tipo di problemi consiste nel sommare un numero molto grande di quantità molto piccole e quindi prendere un limite quando la dimensione delle quantità si avvicina allo zero, mentre il numero dei termini tende all'infinito. Questo processo porta alla definizione didefinite integral.

Gli integrali definiti vengono utilizzati per trovare area, volume, baricentro, momento di inerzia, lavoro svolto da una forza e in numerose altre applicazioni.

Trovare l'integrale indefinito utilizzando MATLAB

Per definizione, se la derivata di una funzione f (x) è f '(x), allora diciamo che un integrale indefinito di f' (x) rispetto a x è f (x). Ad esempio, poiché la derivata (rispetto a x) di x 2 è 2x, possiamo dire che un integrale indefinito di 2x è x 2 .

In simboli -

f'(x2) = 2x, perciò,

∫ 2xdx = x2.

L'integrale indefinito non è univoco, perché anche la derivata di x 2 + c, per qualsiasi valore di una costante c, sarà 2x.

Questo è espresso in simboli come -

∫ 2xdx = x2 + c.

Dove, c è chiamata "costante arbitraria".

MATLAB fornisce un file intcomando per il calcolo dell'integrale di un'espressione. Per derivare un'espressione per l'integrale indefinito di una funzione, scriviamo -

int(f);

Ad esempio, dal nostro esempio precedente:

syms x 
int(2*x)

MATLAB esegue l'istruzione di cui sopra e restituisce il seguente risultato:

ans =
   x^2

Esempio 1

In questo esempio, troviamo l'integrale di alcune espressioni di uso comune. Crea un file di script e digita il seguente codice al suo interno:

syms x n

int(sym(x^n))
f = 'sin(n*t)'
int(sym(f))
syms a t
int(a*cos(pi*t))
int(a^x)

Quando si esegue il file, viene visualizzato il seguente risultato:

ans =
   piecewise([n == -1, log(x)], [n ~= -1, x^(n + 1)/(n + 1)])
f =
sin(n*t)
ans =
   -cos(n*t)/n
   ans =
   (a*sin(pi*t))/pi
   ans =
   a^x/log(a)

Esempio 2

Crea un file di script e digita il seguente codice al suo interno:

syms x n
int(cos(x))
int(exp(x))
int(log(x))
int(x^-1)
int(x^5*cos(5*x))
pretty(int(x^5*cos(5*x)))
int(x^-5)
int(sec(x)^2)
pretty(int(1 - 10*x + 9 * x^2))
int((3 + 5*x -6*x^2 - 7*x^3)/2*x^2)
pretty(int((3 + 5*x -6*x^2 - 7*x^3)/2*x^2))

Nota che il file pretty restituisce un'espressione in un formato più leggibile.

Quando si esegue il file, viene visualizzato il seguente risultato:

ans =
   sin(x)
 
ans =
   exp(x)
 
ans =
   x*(log(x) - 1)
 
ans =
   log(x)
 
ans =
(24*cos(5*x))/3125 + (24*x*sin(5*x))/625 - (12*x^2*cos(5*x))/125 + (x^4*cos(5*x))/5 - (4*x^3*sin(5*x))/25 + (x^5*sin(5*x))/5
                                    2             4 
   24 cos(5 x)   24 x sin(5 x)   12 x  cos(5 x)   x  cos(5 x) 
   ----------- + ------------- - -------------- + ------------ 
      3125            625             125              5 
   
        3             5 
 
   4 x  sin(5 x)   x  sin(5 x) 
   ------------- + ----------- 
         25              5
 
ans =
-1/(4*x^4)
 
ans =
tan(x)
        2 
  x (3 x  - 5 x + 1)
 
ans = 
- (7*x^6)/12 - (3*x^5)/5 + (5*x^4)/8 + x^3/2
 
      6      5      4    3 
    7 x    3 x    5 x    x 
  - ---- - ---- + ---- + -- 
     12     5      8     2

Trovare un integrale definito usando MATLAB

Per definizione, l'integrale definito è fondamentalmente il limite di una somma. Usiamo integrali definiti per trovare aree come l'area tra una curva e l'asse x e l'area tra due curve. Gli integrali definiti possono essere utilizzati anche in altre situazioni, dove la quantità richiesta può essere espressa come limite di una somma.

Il int la funzione può essere utilizzata per un'integrazione definita passando i limiti oltre i quali si vuole calcolare l'integrale.

Calcolare

scriviamo,

int(x, a, b)

Ad esempio, per calcolare il valore di

scriviamo -

int(x, 4, 9)

MATLAB esegue l'istruzione di cui sopra e restituisce il seguente risultato:

ans =
   65/2

Di seguito è riportato l'equivalente in ottava del calcolo precedente:

pkg load symbolic
symbols

x = sym("x");
f = x;
c = [1, 0];
integral = polyint(c);

a = polyval(integral, 9) - polyval(integral, 4);
display('Area: '), disp(double(a));

Octave esegue il codice e restituisce il seguente risultato:

Area: 

   32.500

Una soluzione alternativa può essere fornita usando la funzione quad () fornita da Octave come segue:

pkg load symbolic
symbols

f = inline("x");
[a, ierror, nfneval] = quad(f, 4, 9);

display('Area: '), disp(double(a));

Octave esegue il codice e restituisce il seguente risultato:

Area: 
   32.500

Esempio 1

Calcoliamo l'area racchiusa tra l'asse xe la curva y = x 3 −2x + 5 e le ordinate x = 1 ex = 2.

L'area richiesta è data da:

Crea un file di script e digita il codice seguente:

f = x^3 - 2*x +5;
a = int(f, 1, 2)
display('Area: '), disp(double(a));

Quando si esegue il file, viene visualizzato il seguente risultato:

a =
23/4
Area: 
   5.7500

Di seguito è riportato l'equivalente in ottava del calcolo precedente:

pkg load symbolic
symbols

x = sym("x");
f = x^3 - 2*x +5;
c = [1, 0, -2, 5];
integral = polyint(c);

a = polyval(integral, 2) - polyval(integral, 1);
display('Area: '), disp(double(a));

Octave esegue il codice e restituisce il seguente risultato:

Area: 

   5.7500

Una soluzione alternativa può essere fornita usando la funzione quad () fornita da Octave come segue:

pkg load symbolic
symbols

x = sym("x");
f = inline("x^3 - 2*x +5");

[a, ierror, nfneval] = quad(f, 1, 2);
display('Area: '), disp(double(a));

Octave esegue il codice e restituisce il seguente risultato:

Area: 
   5.7500

Esempio 2

Trova l'area sotto la curva: f (x) = x 2 cos (x) per −4 ≤ x ≤ 9.

Crea un file di script e scrivi il codice seguente:

f = x^2*cos(x);
ezplot(f, [-4,9])
a = int(f, -4, 9)
disp('Area: '), disp(double(a));

Quando esegui il file, MATLAB traccia il grafico:

L'output è fornito di seguito:

a = 
8*cos(4) + 18*cos(9) + 14*sin(4) + 79*sin(9)
 
Area: 
   0.3326

Di seguito è riportato l'equivalente in ottava del calcolo precedente:

pkg load symbolic
symbols

x = sym("x");
f = inline("x^2*cos(x)");

ezplot(f, [-4,9])
print -deps graph.eps

[a, ierror, nfneval] = quad(f, -4, 9);
display('Area: '), disp(double(a));

MATLAB rappresenta i polinomi come vettori riga contenenti coefficienti ordinati per potenze discendenti. Ad esempio, l'equazione P (x) = x 4 + 7x 3 - 5x + 9 potrebbe essere rappresentata come -

p = [1 7 0 -5 9];

Valutazione dei polinomi

Il polyvalviene utilizzata per valutare un polinomio a un valore specificato. Ad esempio, per valutare il nostro polinomio precedentep, in x = 4, digitare -

p = [1 7 0  -5 9];
polyval(p,4)

MATLAB esegue le istruzioni precedenti e restituisce il seguente risultato:

ans = 693

MATLAB fornisce anche il polyvalmfunzione per valutare un polinomio di matrice. Un polinomio di matrice è unpolynomial con matrici come variabili.

Ad esempio, creiamo una matrice quadrata X e valutiamo il polinomio p, in X -

p = [1 7 0  -5 9];
X = [1 2 -3 4; 2 -5 6 3; 3 1 0 2; 5 -7 3 8];
polyvalm(p, X)

MATLAB esegue le istruzioni precedenti e restituisce il seguente risultato:

ans =
      2307       -1769        -939        4499
      2314       -2376        -249        4695
      2256       -1892        -549        4310
      4570       -4532       -1062        9269

Trovare le radici dei polinomi

Il rootsfunzione calcola le radici di un polinomio. Ad esempio, per calcolare le radici del nostro polinomio p, digita -

p = [1 7 0  -5 9];
r = roots(p)

MATLAB esegue le istruzioni precedenti e restituisce il seguente risultato:

r =
   -6.8661 + 0.0000i
   -1.4247 + 0.0000i
   0.6454 + 0.7095i
   0.6454 - 0.7095i

La funzione polyè un inverso della funzione radici e ritorna ai coefficienti polinomiali. Ad esempio:

p2 = poly(r)

MATLAB esegue le istruzioni precedenti e restituisce il seguente risultato:

p2 =

   Columns 1 through 3:

      1.00000 + 0.00000i   7.00000 + 0.00000i   0.00000 + 0.00000i

   Columns 4 and 5:

      -5.00000 - 0.00000i   9.00000 + 0.00000i

Adattamento della curva polinomiale

Il polyfittrova i coefficienti di un polinomio che si adatta a un insieme di dati nel senso dei minimi quadrati. Se xey sono due vettori contenenti i dati xey da adattare a un polinomio di n gradi, allora otteniamo il polinomio che si adatta ai dati scrivendo -

p = polyfit(x,y,n)

Esempio

Crea un file di script e digita il codice seguente:

x = [1 2 3 4 5 6]; y = [5.5 43.1 128 290.7 498.4 978.67];   %data
p = polyfit(x,y,4)   %get the polynomial

% Compute the values of the polyfit estimate over a finer range, 
% and plot the estimate over the real data values for comparison:
x2 = 1:.1:6;          
y2 = polyval(p,x2);
plot(x,y,'o',x2,y2)
grid on

Quando esegui il file, MATLAB mostra il seguente risultato:

p =
   4.1056  -47.9607  222.2598 -362.7453  191.1250

E traccia il grafico seguente:

MATLAB fornisce il comando per lavorare con le trasformazioni, come le trasformate di Laplace e Fourier. Le trasformazioni sono utilizzate nella scienza e nell'ingegneria come strumento per semplificare l'analisi e guardare i dati da un'altra angolazione.

Ad esempio, la trasformata di Fourier ci permette di convertire un segnale rappresentato in funzione del tempo in una funzione di frequenza. La trasformata di Laplace ci consente di convertire un'equazione differenziale in un'equazione algebrica.

MATLAB fornisce il laplace, fourier e fft comandi per lavorare con trasformate di Laplace, Fourier e Fast Fourier.

La trasformata di Laplace

La trasformata di Laplace di una funzione del tempo f (t) è data dal seguente integrale -

La trasformata di Laplace è anche indicata come trasformata di f (t) in F (s). Puoi vedere che questo processo di trasformazione o integrazione converte f (t), una funzione della variabile simbolica t, in un'altra funzione F (s), con un'altra variabile s.

La trasformata di Laplace trasforma le equazioni differenziali in equazioni algebriche. Per calcolare una trasformata di Laplace di una funzione f (t), scrivi -

laplace(f(t))

Esempio

In questo esempio, calcoleremo la trasformata di Laplace di alcune funzioni di uso comune.

Crea un file di script e digita il codice seguente:

syms s t a b w

laplace(a)
laplace(t^2)
laplace(t^9)
laplace(exp(-b*t))
laplace(sin(w*t))
laplace(cos(w*t))

Quando si esegue il file, viene visualizzato il seguente risultato:

ans =
   1/s^2

ans =
   2/s^3

ans =
   362880/s^10

ans =
   1/(b + s)
  
ans =
   w/(s^2 + w^2)
  
ans =
   s/(s^2 + w^2)

Trasformata inversa di Laplace

MATLAB ci permette di calcolare la trasformata inversa di Laplace utilizzando il comando ilaplace.

Per esempio,

ilaplace(1/s^3)

MATLAB eseguirà l'istruzione precedente e visualizzerà il risultato -

ans =
   t^2/2

Esempio

Crea un file di script e digita il codice seguente:

syms s t a b w

ilaplace(1/s^7)
ilaplace(2/(w+s))
ilaplace(s/(s^2+4))
ilaplace(exp(-b*t))
ilaplace(w/(s^2 + w^2))
ilaplace(s/(s^2 + w^2))

Quando si esegue il file, viene visualizzato il seguente risultato:

ans =
   t^6/720

ans =
   2*exp(-t*w)

ans =
   cos(2*t)

ans =
   ilaplace(exp(-b*t), t, x)

ans =
   sin(t*w)

ans =
   cos(t*w)

Le trasformate di Fourier

La trasformata di Fourier trasforma comunemente una funzione matematica del tempo, f (t), in una nuova funzione, a volte indicata con o F, il cui argomento è la frequenza con unità di cicli / s (hertz) o radianti al secondo. La nuova funzione è quindi nota come trasformata di Fourier e / o spettro di frequenza della funzione f.

Esempio

Crea un file di script e digita il seguente codice al suo interno:

syms x 
f = exp(-2*x^2);     %our function
ezplot(f,[-2,2])     % plot of our function
FT = fourier(f)      % Fourier transform

Quando esegui il file, MATLAB traccia il grafico seguente:

Viene visualizzato il seguente risultato:

FT =
   (2^(1/2)*pi^(1/2)*exp(-w^2/8))/2

Tracciare la trasformata di Fourier come -

ezplot(FT)

Fornisce il grafico seguente:

Trasformate di Fourier inverse

MATLAB fornisce il ifouriercomando per calcolare la trasformata di Fourier inversa di una funzione. Per esempio,

f = ifourier(-2*exp(-abs(w)))

MATLAB eseguirà l'istruzione precedente e visualizzerà il risultato -

f =
   -2/(pi*(x^2 + 1))

GNU Octave è un linguaggio di programmazione di alto livello come MATLAB ed è principalmente compatibile con MATLAB. Viene anche utilizzato per calcoli numerici.

Octave ha le seguenti caratteristiche comuni con MATLAB:

  • le matrici sono tipi di dati fondamentali
  • ha il supporto integrato per i numeri complessi
  • ha funzioni matematiche e librerie incorporate
  • supporta funzioni definite dall'utente

GNU Octave è anche un software ridistribuibile gratuitamente. È possibile ridistribuirlo e / o modificarlo secondo i termini della GNU General Public License (GPL) come pubblicata dalla Free Software Foundation.

MATLAB vs Octave

La maggior parte dei programmi MATLAB vengono eseguiti in Octave, ma alcuni programmi Octave potrebbero non funzionare in MATLAB perché Octave consente una sintassi che MATLAB non consente.

Ad esempio, MATLAB supporta solo virgolette singole, ma Octave supporta virgolette singole e doppie per la definizione delle stringhe. Se stai cercando un tutorial su Octave, segui gentilmente questo tutorial dall'inizio che copre sia MATLAB che Octave.

Esempi compatibili

Quasi tutti gli esempi trattati in questo tutorial sono compatibili con MATLAB e con Octave. Proviamo a seguire l'esempio in MATLAB e Octave che produce lo stesso risultato senza modifiche alla sintassi -

Questo esempio crea una mappa della superficie 3D per la funzione g = xe - (x 2 + y 2 ) . Crea un file di script e digita il codice seguente:

[x,y] = meshgrid(-2:.2:2);
g = x .* exp(-x.^2 - y.^2);
surf(x, y, g)
print -deps graph.eps

Quando esegui il file, MATLAB mostra la seguente mappa 3-D:

Esempi non compatibili

Sebbene tutte le funzionalità principali di MATLAB siano disponibili in Octave, esistono alcune funzionalità, ad esempio, Calcolo differenziale e integrazione, che non corrispondono esattamente in entrambe le lingue. Questo tutorial ha cercato di fornire entrambi i tipi di esempi in cui differivano nella loro sintassi.

Considera il seguente esempio in cui MATLAB e Octave fanno uso di funzioni diverse per ottenere l'area di una curva: f (x) = x 2 cos (x) per −4 ≤ x ≤ 9. Di seguito è riportata la versione MATLAB del codice:

f = x^2*cos(x);
ezplot(f, [-4,9])
a = int(f, -4, 9)
disp('Area: '), disp(double(a));

Quando esegui il file, MATLAB traccia il grafico:

Viene visualizzato il seguente risultato

a =
8*cos(4) + 18*cos(9) + 14*sin(4) + 79*sin(9)
 
Area: 
   0.3326

Ma per dare un'area della stessa curva in Octave, dovrai farne uso symbolic pacchetto come segue -

pkg load symbolic
symbols

x = sym("x");
f = inline("x^2*cos(x)");

ezplot(f, [-4,9])
print -deps graph.eps

[a, ierror, nfneval] = quad(f, -4, 9);
display('Area: '), disp(double(a));

Simulink è un ambiente di simulazione e di progettazione basato su modelli per sistemi dinamici e integrati, integrato con MATLAB. Simulink, sviluppato anche da MathWorks, è uno strumento di linguaggio di programmazione grafico per flussi di dati per modellare, simulare e analizzare sistemi dinamici multi-dominio. È fondamentalmente uno strumento grafico per la creazione di diagrammi a blocchi con un set personalizzabile di librerie di blocchi.

Ti consente di incorporare algoritmi MATLAB nei modelli e di esportare i risultati della simulazione in MATLAB per ulteriori analisi.

Simulink supporta:

  • progettazione a livello di sistema
  • simulation
  • generazione automatica del codice
  • test e verifica di sistemi embedded

Esistono molti altri prodotti aggiuntivi forniti da MathWorks e prodotti hardware e software di terze parti disponibili per l'uso con Simulink.

Il seguente elenco fornisce una breve descrizione di alcuni di essi:

  • Stateflow consente di sviluppare macchine a stati e diagrammi di flusso.

  • Simulink Coder consente la generazione di codice sorgente C per l'implementazione automatica dei sistemi in tempo reale.

  • xPC Target insieme a x86-based real-time systems fornire un ambiente per simulare e testare i modelli Simulink e Stateflow in tempo reale sul sistema fisico.

  • Embedded Coder supporta target specifici incorporati.

  • HDL Coder permette di generare automaticamente VHDL e Verilog sintetizzabili.

  • SimEvents fornisce una libreria di blocchi grafici per la modellazione di sistemi di accodamento.

Simulink è in grado di verificare e convalidare sistematicamente i modelli attraverso il controllo dello stile di modellazione, la tracciabilità dei requisiti e l'analisi della copertura del modello.

Simulink Design Verifier ti consente di identificare gli errori di progettazione e di generare scenari di test case per il controllo del modello.

Utilizzando Simulink

Per aprire Simulink, digita nello spazio di lavoro MATLAB -

simulink

Simulink si apre con il Library Browser. Il browser della libreria viene utilizzato per creare modelli di simulazione.

Nel riquadro della finestra di sinistra, troverai diverse librerie classificate in base a vari sistemi, facendo clic su ciascuna di esse verranno visualizzati i blocchi di progettazione nel riquadro della finestra di destra.

Modelli di costruzione

Per creare un nuovo modello, fare clic su Newsulla barra degli strumenti del browser della libreria. Si apre una nuova finestra del modello senza titolo.

Un modello Simulink è uno schema a blocchi.

Gli elementi del modello vengono aggiunti selezionando gli elementi appropriati dal browser della libreria e trascinandoli nella finestra del modello.

In alternativa, è possibile copiare gli elementi del modello e incollarli nella finestra del modello.

Esempi

Trascina e rilascia elementi dalla libreria Simulink per creare il tuo progetto.

Ai fini di questo esempio, verranno utilizzati due blocchi per la simulazione: A Source (un segnale) e a Sink(un ambito). Un generatore di segnale (la sorgente) genera un segnale analogico, che verrà quindi visualizzato graficamente dall'oscilloscopio (il sink).

Inizia trascinando i blocchi richiesti dalla libreria alla finestra del progetto. Quindi, collega i blocchi insieme, cosa che può essere eseguita trascinando i connettori dai punti di connessione su un blocco a quelli di un altro.

Trasciniamo un blocco "Sine Wave" nel modello.

Seleziona "Sinks" dalla libreria e trascina un blocco "Scope" nel modello.

Trascina una linea di segnale dall'uscita del blocco Sine Wave all'ingresso del blocco Scope.

Eseguire la simulazione premendo il tasto 'Run'pulsante, mantenendo tutti i parametri predefiniti (puoi modificarli dal menu Simulazione)

Dovresti ottenere il grafico sottostante dall'ambito.