Diagrammi di flusso e Codice Matlab: differenze tra le versioni

Da Bioingegneria Elettronica e Informatica.
(→‎Acquisizione e stampa degli elementi di un vettore)
 
(38 versioni intermedie di uno stesso utente non sono mostrate )
Riga 1: Riga 1:
−
'''Vitoantonio Bevilacqua''' Strutture di controllo e Diagrammi di flusso [mailto:vitoantonio.bevilacqua@poliba.it vitoantonio.bevilacqua@poliba.it]
+
'''Vitoantonio Bevilacqua''' [mailto:vitoantonio.bevilacqua@poliba.it vitoantonio.bevilacqua@poliba.it]
  
−
'''Sommario.''' Il presente paragrafo si riferisce alle lezioni del I Modulo di Informatica : Fondamenti di Informatica per il nuovo corso di laurea triennale in Ingegneria dei Sistemi Medicali del Dipartimento di Ingegneria Elettrica e dell'Informazione del Politecnico di Bari.  
+
'''Antonio Brunetti''' [mailto:antonio.brunetti@poliba.it  antonio.brunetti@poliba.it]
  
−
''Parole chiave:'' Algoritmo, Diagramma di flusso, Ricerca dicotomica.
+
''Parole chiave:'' Algoritmo, Diagramma di flusso.
−
 
+
−
<pre style="color: red">ATTENZIONE !!! - PAGINA IN ALLESTIMENTO</pre>
+
  
 
== Introduzione ==
 
== Introduzione ==
Riga 71: Riga 69:
 
</syntaxhighlight>
 
</syntaxhighlight>
  
−
== Esempi Applicativi ==
+
== Esempi Applicativi: diagramma di flusso e relativo codice MATLAB==
 
=== Media di una serie di numeri ===
 
=== Media di una serie di numeri ===
 
Data una dimensione N, si vuole calcolare la media aritmetica di N numeri e mostrare il risultato a video.
 
Data una dimensione N, si vuole calcolare la media aritmetica di N numeri e mostrare il risultato a video.
 
[[File:MEDIA.png | frame | 200px  | center | Diagramma di flusso per il calcolo della media]]  
 
[[File:MEDIA.png | frame | 200px  | center | Diagramma di flusso per il calcolo della media]]  
 
<syntaxhighlight lang="matlab" line>
 
<syntaxhighlight lang="matlab" line>
−
%% Codice per il calcolo di N numeri
+
%% Codice per il calcolo della media di N numeri
  
 
% Acquisisco da tastiera la dimensione dell'insieme di numeri
 
% Acquisisco da tastiera la dimensione dell'insieme di numeri
Riga 200: Riga 198:
 
%
 
%
 
</syntaxhighlight>
 
</syntaxhighlight>
−
 
−
== Esempi applicativi utilizzando i vettori ==
 
  
 
=== Acquisizione  e stampa degli elementi di un vettore ===
 
=== Acquisizione  e stampa degli elementi di un vettore ===
−
Si vuole creare un vettore di N elementi, acquisirli da tastiera e mostrare a video tali elementi
+
Si vuole creare un vettore di N elementi, con N maggiore di 0, acquisirli da tastiera e mostrare a video tali elementi
 
[[File:Vettore1.png | 200 px | frame | center | Diagramma di flusso per creazione e stampa di un vettore con N elementi]]
 
[[File:Vettore1.png | 200 px | frame | center | Diagramma di flusso per creazione e stampa di un vettore con N elementi]]
 +
 +
<syntaxhighlight lang="matlab" line>
 +
%% Codice per la creazione e stampa a video di un vettore di N elementi, con N maggiore di 0
 +
 +
flag = true;
 +
while flag == true
 +
    N = input('');
 +
    flag = N <= 0;
 +
end
 +
 +
% Creazione del vettore vuoto
 +
V = [];
 +
 +
% Acquisizione da tastiera delle componenti del vettore
 +
i = 0;
 +
flag = true;
 +
while flag == true
 +
    V = [V input('')];
 +
    i = i+1;
 +
    flag = i < N;
 +
end
 +
 +
% stampa a video delle componenti del vettore
 +
% ATTENZIONE ! - Per accedere alle componenti di
 +
% vettori e matrici l'indice deve iniziare da 1
 +
i = 1;
 +
flag = true;
 +
while flag == true
 +
  disp (V(i));
 +
  i = i+1;
 +
 
 +
  % ATTENZIONE ! - In questo modo cambia anche l'operatore di confronto
 +
  % per uscire dal blocco del while
 +
  flag = i <= N; 
 +
end
 +
 +
 +
%% Riferimenti utili
 +
%
 +
% # https://it.mathworks.com/help/matlab/learn_matlab/matrices-and-arrays.html
 +
% # https://www.mathworks.com/help/releases/R2016b/matlab/ref/while.html
 +
% # https://www.mathworks.com/help/releases/R2016b/matlab/ref/input.html
 +
% # https://it.mathworks.com/help/matlab/ref/logicaloperatorsshortcircuit.htm
 +
% # https://www.mathworks.com/help/releases/R2016b/matlab/ref/disp.html
 +
%
 +
</syntaxhighlight>
 +
 +
=== Ordinamento degli elementi di un vettore ===
 +
Si acquisisce da tastiera la dimensione N di un vettore, con il vincolo che sia compresa tra 5 e 10.
 +
Successivamente si acquisiscono, sempre da tastiera, gli N elementi di un vettore V ( Vi la generica componente). Quindi si ordinano, in maniera crescente, gli elementi del vettore. Infine si mostrano a video gli N elementi del vettore ordinato.
 +
 +
L'ordinamento presentato è realizzato attraverso l'algoritmo del [https://en.wikipedia.org/wiki/Selection_sort Selection Sort]. Tale algoritmo assicura che il numero degli scambi da effettuare sia sempre pari a N-1. Iterativamente la sequenza mostra quindi una sottosequenza già ordinata (la prima) seguita da una che deve ancora essere ordinata.
 +
[[File:Selection-Sort-Animation.gif | thumb]]
 +
 +
[[File:SelectionSort.png | 200 px | frame | center | Diagramma di flusso per l'ordinamento con l'algoritmo Selection Sort]]
 +
 +
<syntaxhighlight lang="matlab" line>
 +
%% Codice per l'ordinamento in ordine crescente degli elementi di un vettore utilizzando l'algoritmo del selection sotrt
 +
 +
% Acquisisco da tastiera la dimensione del vettore
 +
% controllando che sia un numero compreso tra 5 e 10 (estremi inclusi)
 +
N = 0;
 +
flag = true;
 +
while flag == true
 +
  N = input('');
 +
 
 +
  flag = N < 5 || N > 10 ;
 +
end
 +
 +
% Creazione del vettore vuoto
 +
V = [];
 +
 +
% Acquisizione da tastiera delle componenti del vettore
 +
i = 0;
 +
flag = true;
 +
while flag == true
 +
    V = [V, input('')];
 +
    i = i+1;
 +
    flag = i < N;
 +
end
 +
 +
% ATTENZIONE ! - Per accedere alle componenti di
 +
% vettori e matrici l'indice deve iniziare da 1
 +
i = 1;
 +
flag = true;
 +
while flag == true
 +
    i_min = i;
 +
    j = i+1;
 +
   
 +
    % Essendoci un blocco while annidato, ho la necessità di utilizzare un
 +
    % secondo flag
 +
    flag1 = true;
 +
    while flag1 == true
 +
        % Controllo se l'elemento corrente è minore di quello considerato
 +
        % come minimo
 +
        if V(j) < V(i_min)
 +
            % Se vero, aggiorno l'indice dell'elemento minimo
 +
            i_min = j;
 +
        end
 +
       
 +
        j = j+1;
 +
        % Attenzione alla condizione; è utilizzato il <= perchè in Matlab
 +
        % il primo elemento del vettore ha indice 1, mentre l'ultimo avrà
 +
        % indice pari a N
 +
        flag1 = j<=N;
 +
    end
 +
   
 +
    % Blocco di codice relativo allo scambio
 +
    temp = V(i);
 +
    V(i) = V(i_min);
 +
    V(i_min) = temp;
 +
   
 +
    i = i+1;
 +
    flag = i <=(N-1);
 +
end
 +
 +
% Stampa a video delle componenti del vettore
 +
i = 1;
 +
flag = true;
 +
while flag == true
 +
  disp(V(i));
 +
  i = i+1;
 +
  flag = i<=N;
 +
end
 +
 +
 +
%% Riferimenti utili
 +
%
 +
% # https://it.mathworks.com/help/matlab/learn_matlab/matrices-and-arrays.html
 +
% # https://www.mathworks.com/help/releases/R2016b/matlab/ref/while.html
 +
% # https://www.mathworks.com/help/releases/R2016b/matlab/ref/input.html
 +
% # https://it.mathworks.com/help/matlab/ref/logicaloperatorsshortcircuit.htm
 +
% # https://www.mathworks.com/help/releases/R2016b/matlab/ref/disp.html
 +
%
 +
</syntaxhighlight>
 +
 +
=== Prodotto tra matrici ===
 +
Si acquisiscono da tastiera le dimensioni (numero di righe e colonne) di due matrici A e B. Successivamente si acquisiscono, sempre da tastiera, gli elementi di entrambe le matrici (Aij la generica componente della matrice A, Bij la generica componente della matrice B). Quindi si calcola la matrice C che si ottiene dal prodotto tra le matrici A e B. Infine si mostrano a video gli elementi della matrice C.
 +
 +
[[File:Righe_colonne.png | 200 px | frame | center | Diagramma di flusso per il calcolo del prodotto tra due matrici]]
 +
 +
<syntaxhighlight lang="matlab" line>
 +
 +
%% Codice per il calcolo del prodotto riga per colonna di due matrici
 +
% Il programma permette di acquisire le dimensioni (numero righe e colonne)
 +
% di due matrici A, B, calcola la matrice prodotto C = AxB e stampa a video
 +
% le componenti della matrice C.
 +
 +
% Acquisizione del numero di righe della prima matrice
 +
flag = true;
 +
while flag == true
 +
  r1 = input('');
 +
  flag = r1 <= 0;
 +
end
 +
 +
% Acquisizione del numero di colone della prima matrice
 +
flag = true;
 +
while flag == true
 +
  c1 = input('');
 +
  flag = c1 <= 0;
 +
end
 +
 +
% Acquisizione del numero di righe della seconda matrice
 +
flag = true;
 +
while flag == true
 +
  r2 = input('');
 +
  % OSSERVAZIONE: Il ciclo sar? ripetuto fino a quando l'utente non
 +
  % inserisce un numero di righe per la seconda matrice pari al numero di
 +
  % colonne inserito per la prima matrice...perch??
 +
  flag = r2 ~= c1;
 +
end
 +
 +
% Acquisizione del numero di colonne della seconda matrice
 +
flag = true;
 +
while flag == true
 +
  c2 = input('');
 +
  flag = c2 <= 0;
 +
end
 +
 +
A = [];
 +
% Acquisisco gli elementi della prima matrice
 +
flag = true;
 +
i = 0;
 +
while flag == true
 +
    flag2 = true;
 +
    j = 0;
 +
    row = [];
 +
    while flag2 == true
 +
      row = [row,input('')];
 +
      j = j + 1;
 +
      flag2 = j < c1;
 +
    end
 +
    i = i+1;
 +
    A = [A; row;];
 +
    flag = i < r1;
 +
end
 +
 +
B = [];
 +
% Acquisisco gli elementi della seconda matrice
 +
flag = true;
 +
i = 0;
 +
while flag == true
 +
    flag2 = true;
 +
    j = 0;
 +
    row = [];
 +
    while flag2 == true
 +
      row = [row,input('')];
 +
      j = j + 1;
 +
      flag2 = j < c2;
 +
    end
 +
    i = i+1;
 +
    B = [B; row;];
 +
    flag = i < r2;
 +
end
 +
 +
% Calcolo la matrice prodotto C = A*B
 +
C = [];
 +
i = 1;
 +
flag = true;
 +
while flag == true
 +
    k =1;
 +
    flag2 = true;
 +
    while flag2 == true
 +
        j = 1;
 +
        C(i,k) = 0;
 +
        flag3 = true;
 +
        while flag3 == true
 +
          C(i,k) = C(i,k) + A(i,j) * B(j,k);
 +
          j = j+1;
 +
          flag3 = j <= c1;
 +
        end
 +
        k = k+1;
 +
        flag2 = k <=c2;
 +
    end
 +
    i = i+1;
 +
    flag = i <= r1;
 +
end
 +
 +
% Stampo a video il contenuto della matrice C
 +
i = 1;
 +
flag = true;
 +
while flag == true
 +
    j = 1;
 +
    flag2 = true;
 +
    while flag2 == true
 +
        fprintf('%d\t', C(i,j));
 +
        j = j+1;
 +
        flag2 = j <= c2;
 +
    end
 +
    fprintf('\n');
 +
    i = i+1;
 +
    flag = i <= r1;
 +
end
 +
 +
%% Ora prova a fare A*B...
 +
 +
%% Riferimenti utili
 +
%
 +
% # https://it.mathworks.com/help/matlab/learn_matlab/matrices-and-arrays.html
 +
% # https://www.mathworks.com/help/releases/R2016b/matlab/ref/while.html
 +
% # https://www.mathworks.com/help/releases/R2016b/matlab/ref/input.html
 +
% # https://it.mathworks.com/help/matlab/ref/logicaloperatorsshortcircuit.htm
 +
% # https://www.mathworks.com/help/releases/R2016b/matlab/ref/disp.html
 +
%
 +
</syntaxhighlight>
 +
 +
=== Algoritmo Merge Sort ===
 +
Consideriamo due vettori (V e W) già ordinati con lo stesso criterio e nelle ipotesi che la loro lunghezza non coincida, che ogni vettore non contenga elementi uguali e che non ci sono elementi comuni tra i due vettori. L'algoritmo merge sort crea un terzo vettore ordinato (U) dato dalla fusione dei primi due.
 +
La logica alla base dell'algoritmo è quella di far lavorare in un ciclo due indici (i e j), ciascuno su un vettore, scorrendo i quali si aggiunge al vettore fusione volta per volta l'elemento minore a cui fanno riferimento i due indici. Quando uno dei due vettori termina, si aggiungono al vettore fusione i restanti elementi dell'altro vettore. 
 +
 +
 +
[[File:Merge_sort.png | 200 px | frame | center | Diagramma di flusso dell'algoritmo merge sort]]
 +
 +
<syntaxhighlight lang="matlab" line>
 +
%% Script per il merge sort
 +
 +
% Acquisisco da tastiera la dimensione dei vettori V e W, rispettivamente N e
 +
% M
 +
 +
N = input('');
 +
M = input('');
 +
 +
% Creazione del vettore vuoto V
 +
V = [];
 +
 +
% Acquisizione da tastiera delle componenti del vettore V
 +
i = 0;
 +
flag = true;
 +
while flag == true
 +
    V = [V, input('')];
 +
    i = i+1;
 +
    flag = i < N;
 +
end
 +
 +
% Creazione del vettore vuoto W
 +
W = [];
 +
 +
% Acquisizione da tastiera delle componenti del vettore W
 +
i = 0;
 +
flag = true;
 +
while flag == true
 +
    W = [W, input('')];
 +
    i = i+1;
 +
    flag = i < M;
 +
end
 +
 +
% Ordinamento del vettore V
 +
 +
% ATTENZIONE ! - Per accedere alle componenti di
 +
% vettori e matrici l'indice deve iniziare da 1
 +
i = 1;
 +
flag = true;
 +
while flag == true
 +
    i_min = i;
 +
    j = i+1;
 +
   
 +
    % Essendoci un blocco while annidato, ho la necessità di utilizzare un
 +
    % secondo flag
 +
    flag1 = true;
 +
    while flag1 == true
 +
        % Controllo se l'elemento corrente è minore di quello considerato
 +
        % come minimo
 +
        if V(j) < V(i_min)
 +
            % Se vero, aggiorno l'indice dell'elemento minimo
 +
            i_min = j;
 +
        end
 +
       
 +
        j = j+1;
 +
        % Attenzione alla condizione; ? utilizzato il <= perchè in Matlab
 +
        % il primo elemento del vettore ha indice 1, mentre l'ultimo avrà
 +
        % indice pari a N
 +
        flag1 = j<=N;
 +
    end
 +
   
 +
    % Blocco di codice relativo allo scambio
 +
    temp = V(i);
 +
    V(i) = V(i_min);
 +
    V(i_min) = temp;
 +
   
 +
    i = i+1;
 +
    flag = i <=(N-1);
 +
end
 +
 +
% Ordinamento del vettore W
 +
 +
% ATTENZIONE ! - Per accedere alle componenti di
 +
% vettori e matrici l'indice deve iniziare da 1
 +
i = 1;
 +
flag = true;
 +
while flag == true
 +
    i_min = i;
 +
    j = i+1;
 +
   
 +
    % Essendoci un blocco while annidato, ho la necessit? di utilizzare un
 +
    % secondo flag
 +
    flag1 = true;
 +
    while flag1 == true
 +
        % Controllo se l'elemento corrente è minore di quello considerato
 +
        % come minimo
 +
        if W(j) < W(i_min)
 +
            % Se vero, aggiorno l'indice dell'elemento minimo
 +
            i_min = j;
 +
        end
 +
       
 +
        j = j+1;
 +
        % Attenzione alla condizione; ? utilizzato il <= perchè in Matlab
 +
        % il primo elemento del vettore ha indice 1, mentre l'ultimo avrà
 +
        % indice pari a N
 +
        flag1 = j<=M;
 +
    end
 +
   
 +
    % Blocco di codice relativo allo scambio
 +
    temp = W(i);
 +
    W(i) = W(i_min);
 +
    W(i_min) = temp;
 +
   
 +
    i = i+1;
 +
    flag = i <=(M-1);
 +
end
 +
 +
%% Inizio dell'algoritmo di merge sort
 +
 +
% Creazione del vettore vuoto U
 +
U = [];
 +
 +
% Inizializzatione delle variabili utili all'algoritmo
 +
i = 1;
 +
j = 1;
 +
k = 1;
 +
 +
flag = true;
 +
while flag == true
 +
    if V(i) < W(j)
 +
        U(k) = V(i);
 +
        i = i+1;
 +
    else
 +
        U(k) = W(j);
 +
        j = j+1;
 +
    end
 +
    k = k+1;
 +
   
 +
    flag = i<= N && j <= M;
 +
end
 +
 +
if i < N
 +
    for i = i : 1 : N
 +
        U(k) = V(i);
 +
        k = k+1;
 +
    end
 +
else
 +
    for j = j : M
 +
        U(k) = W(j);
 +
        k = k+1;
 +
    end
 +
   
 +
end
 +
 +
% Stampa a video delle componenti del vettore
 +
i = 1;
 +
flag = true;
 +
while flag == true
 +
  disp(U(i));
 +
  i = i+1;
 +
  flag = i<=k-1;
 +
end
 +
 +
%% Equivalentemente
 +
% for i = 1 : k-1
 +
%    disp(U(i));
 +
% end
 +
 +
%% Riferimenti utili
 +
%
 +
% # https://it.mathworks.com/help/matlab/ref/for.html
 +
% # https://it.mathworks.com/help/matlab/learn_matlab/matrices-and-arrays.html
 +
% # https://www.mathworks.com/help/releases/R2016b/matlab/ref/while.html
 +
% # https://www.mathworks.com/help/releases/R2016b/matlab/ref/input.html
 +
% # https://it.mathworks.com/help/matlab/ref/logicaloperatorsshortcircuit.htm
 +
% # https://www.mathworks.com/help/releases/R2016b/matlab/ref/disp.html
 +
%
 +
 +
 +
</syntaxhighlight>

Versione attuale delle 19:51, 14 gen 2017

Vitoantonio Bevilacqua vitoantonio.bevilacqua@poliba.it

Antonio Brunetti antonio.brunetti@poliba.it

Parole chiave: Algoritmo, Diagramma di flusso.

Introduzione

Un algoritmo è una sequenza ordinata di passi elementari che consente di passare da dati in ingresso a dati in uscita; alcune delle proprietà fondamentali di un algoritmo sono:

  • eseguibilità: ogni parte, ogni diramazione dell’algoritmo deve essere percorribile;
  • non ambiguità: la scelta di un percorso rispetto ad un altro è legata ad una condizione (cioè da ogni punto del programma non devo poter andare dove voglio);
  • finitezza: l’algoritmo deve finire altrimenti si va in "loop".


Un diagramma di flusso è una rappresentazione simbolica di un algoritmo e ha lo scopo di esprimere il meccanismo di interazione con l’utenza e le operazioni da fare a partire dai dati inseriti. Le operazioni esplicitate in un algoritmo necessitano di essere eseguite sotto il controllo di un esecutore che le interpreta ed esegue nell’ordine logico di esecuzione. Poiché gli algoritmi che incontreremo dovranno essere eseguiti in maniera automatica, l’esecutore è l’elaboratore e quindi l’algoritmo dovrà essere tradotto in una sequenza di istruzioni scritte in un linguaggio che l’elaboratore è in grado di interpretare ed eseguire. Un linguaggio che ci consente di fare ciò è appunto il linguaggio MATLAB.

Struttura di un diagramma di flusso

Un qualsiasi diagramma di flusso è gestito da quattro schemi fondamentali che, opportunamente combinati attraverso delle frecce, rappresentano la sequenza logica e temporale dell’evoluzione dell’algoritmo. I quattro schemi hanno un ordine e un valore logico completamente diverso, e sono:

  1. una "ellisse" che contiene al suo interno un label (etichetta) che può indicare l'"inizio" o la "fine" dell’algoritmo;
  2. il "blocco delle assegnazioni", che contiene appunto un’assegnazione (p.e. i = 0); in particolare si assegna la parte destra del segno di = alla variabile a sinistra del segno; un’assegnazione del tipo i = 0 è un’assegnazione "di inizializzazione".
  3. il "blocco di input/output": se di input, serve ad assegnare alla variabile contenuta nel blocco (ad es. N) un valore immesso dall’esterno; se di output, serve a stampare su video il valore della variabile contenuta nel blocco, precedentemente modificato dall'algoritmo.
  4. il "blocco condizionale", che controlla se la condizione contenuta sia vera o no e restituisce l’esito vero o falso come output; quindi in un diagramma di flusso si trova sempre dopo altre operazioni di assegnazione o di input; si può presentare sotto due forme principali: ciclo con controllo in coda oppure decisione binaria V-F.

  • Ellisse di inizio e fine

  • Blocco delle assegnazioni

  • Blocchi di input/output

  • Blocco condizionale

Ciclo con controllo in coda

Controlla se la condizione espressa nel blocco sia vera o no. Nel primo caso viene rieseguito il blocco di operazioni comprese tra la punta della freccia di ritorno e il blocco condizionale; se la condizione risultasse falsa, allora si uscirebbe dal ciclo.

Rappresentazione di un ciclo con controllo in coda

Il seguente segmento di codice è la rappresentazione in codice matlab del ciclo con controllo in coda (è l'equivalente del ciclo do-while del linguaggio C). Come si può notare, è necessario utilizzare una variabile booleana affinché il costrutto presente in Matlab si comporti come un ciclo con controllo in coda. 

  1. %% Snippet di codice per il ciclo con controllo in coda
  2.  
  3. % Eseguo una serie di operazioni
  4.  
  5. % Utilizzo una variabile booleana
  6. flag = true;
  7. while flag == true
  8.  
  9.     % Eseguo diverse operazioni
  10.  
  11.     flag = condition
  12.  
  13. end

Decisione Binaria Vero-Falso

A seconda della veridicità o meno dell’espressione inserita si esegue il ramo del vero o del falso rispettivamente.

Rappresentazione di un blocco condizionale Vero - Falso

Il seguente segmento di codice è la rappresentazione in codice matlab del blocco di decisione binaria. 

  1. %% Snippet di codice per il blocco di decisione binaria if - else
  2. % Eseguo una serie di operazioni
  3.  
  4. if condizione == true
  5.  
  6.     % Eseguo un determinato blocco di istruzioni
  7. else
  8.  
  9.     % Eseguo un altro blocco di istruzioni
  10. end

Esempi Applicativi: diagramma di flusso e relativo codice MATLAB

Media di una serie di numeri

Data una dimensione N, si vuole calcolare la media aritmetica di N numeri e mostrare il risultato a video.

Diagramma di flusso per il calcolo della media
  1. %% Codice per il calcolo della media di N numeri
  2.  
  3. % Acquisisco da tastiera la dimensione dell'insieme di numeri
  4. % controllando che sia un numero maggiore di 0
  5. flag = true;
  6. while flag == true
  7.    N = input('');
  8.    flag = N <= 0;
  9. end
  10.  
  11. % Una volta acquisita la dimensione dell'insieme dei numeri, inizializzo le
  12. % variabili utili al programma e passo ad acquisire i numeri
  13. SOMMA = 0;
  14. i = 0;
  15. flag = true;
  16. while flag == true
  17.    ADDENDO = input('');
  18.    SOMMA = SOMMA + ADDENDO;
  19.    i = i+1;
  20.    flag = i < N;
  21. end
  22.  
  23. % Calcolo il valore di MEDIA
  24. MEDIA = SOMMA / N;
  25.  
  26. % Stampo a video il valore di MEDIA
  27. disp(MEDIA);
  28.  
  29. %% Riferimenti utili
  30. %
  31. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/input.html
  32. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/while.html
  33. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/disp.html
  34. %

Somma dei numeri pari e prodotto dei numeri dispari

Dati N numeri, con N compreso tra 5 e 10, si vuole calcolare la somma dei numeri pari e il prodotto dei numeri dispari e mostrare tali valori a video

Diagramma di flusso per il calcolo della somma dei numeri pari e il prodotto dei numeri dispari
  1. %% Codice per il calcolo della somma degli elementi pari e il prodotto di quelli dispari
  2.  
  3. % Acquisisco da tastiera la dimensione dell'insieme di numeri
  4. % controllando che sia un numero compreso tra 5 e 10 (estremi inclusi)
  5. flag = true;
  6. while flag == true
  7.     N = input('');
  8.     flag = N < 5 || N > 10;
  9. end
  10.  
  11. % Una volta acquisita la dimensione dell'insieme dei numeri, inizializzo le
  12. % variabili utili al programma e passo ad acquisire i numeri
  13. i = 0;
  14. SOMMA = 0;
  15. PROD = 1;
  16.  
  17. flag = true;
  18. while flag == true
  19.     operando = input('');
  20.     % Controllo se l'operando è pari o dispari
  21.     if mod(operando, 2) == 0
  22.         % Caso relativo all'operando pari
  23.        SOMMA = SOMMA + operando;
  24.     else
  25.          % Caso relativo all'operando dispari
  26.         PROD = PROD * operando;
  27.     end
  28.  
  29.     i = i+1;
  30.     flag = i < N;
  31. end
  32.  
  33. % Mostro a video i valori di somma e prodotto
  34. disp (SOMMA);
  35. disp (PROD);
  36.  
  37. %% Riferimenti utili
  38. %
  39. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/while.html
  40. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/input.html
  41. % # https://it.mathworks.com/help/matlab/ref/logicaloperatorsshortcircuit.htm
  42. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/mod.html
  43. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/disp.html
  44. %

Logaritmo in base 2

Dato un numero maggiore di 0, si vuole calcolare il logaritmo in base 2 approssimato per eccesso di tale numero.

Diagramma di flusso per il calcolo del logaritmo in base 2 approssimato per eccesso
  1. %% Codice per il calcolo dell'approssimazione per eccesso del logaritmo in base 2 di un numero
  2.  
  3. % Acquisisco da tastiera il numero di cui calcolare il logaritmo in base 2
  4. % controllando che sia un numero maggiore di 0
  5. flag = true;
  6. while flag
  7.     OP = input('');
  8.     flag = OP <= 0;
  9. end
  10.  
  11. % Una volta acquisito l'operando, inizializzo le variabili utili al programma 
  12. % e passo al calcolo del logaritmo
  13. i = 0;
  14. RIS = 1;
  15. flag = true;
  16. while flag == true
  17.    RIS = RIS * 2;
  18.    i = i+1;
  19.    flag = RIS < OP;
  20. end
  21.  
  22. % Mostro a video il risultato
  23. disp(i)
  24.  
  25. %% Riferimenti utili
  26. %
  27. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/while.html
  28. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/input.html
  29. % # https://it.mathworks.com/help/matlab/ref/logicaloperatorsshortcircuit.htm
  30. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/disp.html
  31. %

Acquisizione e stampa degli elementi di un vettore

Si vuole creare un vettore di N elementi, con N maggiore di 0, acquisirli da tastiera e mostrare a video tali elementi

Diagramma di flusso per creazione e stampa di un vettore con N elementi
  1. %% Codice per la creazione e stampa a video di un vettore di N elementi, con N maggiore di 0
  2.  
  3. flag = true;
  4. while flag == true
  5.     N = input('');
  6.     flag = N <= 0;
  7. end
  8.  
  9. % Creazione del vettore vuoto
  10. V = [];
  11.  
  12. % Acquisizione da tastiera delle componenti del vettore
  13. i = 0;
  14. flag = true;
  15. while flag == true
  16.     V = [V input('')];
  17.     i = i+1;
  18.     flag = i < N;
  19. end
  20.  
  21. % stampa a video delle componenti del vettore
  22. % ATTENZIONE ! - Per accedere alle componenti di
  23. % vettori e matrici l'indice deve iniziare da 1
  24. i = 1;
  25. flag = true;
  26. while flag == true
  27.    disp (V(i));
  28.    i = i+1;
  29.  
  30.    % ATTENZIONE ! - In questo modo cambia anche l'operatore di confronto
  31.    % per uscire dal blocco del while
  32.    flag = i <= N;   
  33. end
  34.  
  35.  
  36. %% Riferimenti utili
  37. %
  38. % # https://it.mathworks.com/help/matlab/learn_matlab/matrices-and-arrays.html
  39. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/while.html
  40. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/input.html
  41. % # https://it.mathworks.com/help/matlab/ref/logicaloperatorsshortcircuit.htm
  42. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/disp.html
  43. %

Ordinamento degli elementi di un vettore

Si acquisisce da tastiera la dimensione N di un vettore, con il vincolo che sia compresa tra 5 e 10. Successivamente si acquisiscono, sempre da tastiera, gli N elementi di un vettore V ( Vi la generica componente). Quindi si ordinano, in maniera crescente, gli elementi del vettore. Infine si mostrano a video gli N elementi del vettore ordinato.

L'ordinamento presentato è realizzato attraverso l'algoritmo del Selection Sort. Tale algoritmo assicura che il numero degli scambi da effettuare sia sempre pari a N-1. Iterativamente la sequenza mostra quindi una sottosequenza già ordinata (la prima) seguita da una che deve ancora essere ordinata.

Selection-Sort-Animation.gif
Diagramma di flusso per l'ordinamento con l'algoritmo Selection Sort
  1. %% Codice per l'ordinamento in ordine crescente degli elementi di un vettore utilizzando l'algoritmo del selection sotrt
  2.  
  3. % Acquisisco da tastiera la dimensione del vettore
  4. % controllando che sia un numero compreso tra 5 e 10 (estremi inclusi)
  5. N = 0;
  6. flag = true;
  7. while flag == true
  8.    N = input('');
  9.  
  10.    flag = N < 5 || N > 10 ;
  11. end
  12.  
  13. % Creazione del vettore vuoto
  14. V = [];
  15.  
  16. % Acquisizione da tastiera delle componenti del vettore
  17. i = 0;
  18. flag = true;
  19. while flag == true
  20.     V = [V, input('')]; 
  21.     i = i+1;
  22.     flag = i < N;
  23. end
  24.  
  25. % ATTENZIONE ! - Per accedere alle componenti di
  26. % vettori e matrici l'indice deve iniziare da 1
  27. i = 1;
  28. flag = true;
  29. while flag == true
  30.     i_min = i;
  31.     j = i+1;
  32.  
  33.     % Essendoci un blocco while annidato, ho la necessità di utilizzare un
  34.     % secondo flag
  35.     flag1 = true;
  36.     while flag1 == true
  37.         % Controllo se l'elemento corrente è minore di quello considerato
  38.         % come minimo
  39.         if V(j) < V(i_min)
  40.             % Se vero, aggiorno l'indice dell'elemento minimo
  41.             i_min = j;
  42.         end
  43.  
  44.         j = j+1;
  45.         % Attenzione alla condizione; è utilizzato il <= perchè in Matlab
  46.         % il primo elemento del vettore ha indice 1, mentre l'ultimo avrà
  47.         % indice pari a N
  48.         flag1 = j<=N;
  49.     end
  50.  
  51.     % Blocco di codice relativo allo scambio
  52.     temp = V(i);
  53.     V(i) = V(i_min);
  54.     V(i_min) = temp;
  55.  
  56.     i = i+1;
  57.     flag = i <=(N-1);
  58. end
  59.  
  60. % Stampa a video delle componenti del vettore
  61. i = 1;
  62. flag = true;
  63. while flag == true
  64.    disp(V(i));
  65.    i = i+1;
  66.    flag = i<=N;
  67. end
  68.  
  69.  
  70. %% Riferimenti utili
  71. %
  72. % # https://it.mathworks.com/help/matlab/learn_matlab/matrices-and-arrays.html
  73. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/while.html
  74. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/input.html
  75. % # https://it.mathworks.com/help/matlab/ref/logicaloperatorsshortcircuit.htm
  76. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/disp.html
  77. %

Prodotto tra matrici

Si acquisiscono da tastiera le dimensioni (numero di righe e colonne) di due matrici A e B. Successivamente si acquisiscono, sempre da tastiera, gli elementi di entrambe le matrici (Aij la generica componente della matrice A, Bij la generica componente della matrice B). Quindi si calcola la matrice C che si ottiene dal prodotto tra le matrici A e B. Infine si mostrano a video gli elementi della matrice C.

Diagramma di flusso per il calcolo del prodotto tra due matrici
  1. %% Codice per il calcolo del prodotto riga per colonna di due matrici
  2. % Il programma permette di acquisire le dimensioni (numero righe e colonne)
  3. % di due matrici A, B, calcola la matrice prodotto C = AxB e stampa a video
  4. % le componenti della matrice C.
  5.  
  6. % Acquisizione del numero di righe della prima matrice
  7. flag = true;
  8. while flag == true
  9.    r1 = input('');
  10.    flag = r1 <= 0;
  11. end
  12.  
  13. % Acquisizione del numero di colone della prima matrice
  14. flag = true;
  15. while flag == true
  16.    c1 = input('');
  17.    flag = c1 <= 0;
  18. end
  19.  
  20. % Acquisizione del numero di righe della seconda matrice
  21. flag = true;
  22. while flag == true
  23.    r2 = input('');
  24.    % OSSERVAZIONE: Il ciclo sar? ripetuto fino a quando l'utente non
  25.    % inserisce un numero di righe per la seconda matrice pari al numero di
  26.    % colonne inserito per la prima matrice...perch??
  27.    flag = r2 ~= c1;
  28. end
  29.  
  30. % Acquisizione del numero di colonne della seconda matrice
  31. flag = true;
  32. while flag == true
  33.    c2 = input('');
  34.    flag = c2 <= 0;
  35. end
  36.  
  37. A = [];
  38. % Acquisisco gli elementi della prima matrice
  39. flag = true;
  40. i = 0;
  41. while flag == true
  42.     flag2 = true;
  43.     j = 0;
  44.     row = [];
  45.     while flag2 == true
  46.        row = [row,input('')];
  47.        j = j + 1;
  48.        flag2 = j < c1;
  49.     end
  50.     i = i+1;
  51.     A = [A; row;];
  52.     flag = i < r1; 
  53. end
  54.  
  55. B = [];
  56. % Acquisisco gli elementi della seconda matrice
  57. flag = true;
  58. i = 0;
  59. while flag == true
  60.     flag2 = true;
  61.     j = 0;
  62.     row = [];
  63.     while flag2 == true
  64.        row = [row,input('')];
  65.        j = j + 1;
  66.        flag2 = j < c2;
  67.     end
  68.     i = i+1;
  69.     B = [B; row;];
  70.     flag = i < r2; 
  71. end
  72.  
  73. % Calcolo la matrice prodotto C = A*B
  74. C = [];
  75. i = 1;
  76. flag = true;
  77. while flag == true
  78.     k =1;
  79.     flag2 = true;
  80.     while flag2 == true
  81.         j = 1;
  82.         C(i,k) = 0;
  83.         flag3 = true;
  84.         while flag3 == true
  85.            C(i,k) = C(i,k) + A(i,j) * B(j,k); 
  86.            j = j+1;
  87.            flag3 = j <= c1;
  88.         end
  89.         k = k+1;
  90.         flag2 = k <=c2;
  91.     end
  92.     i = i+1;
  93.     flag = i <= r1;
  94. end
  95.  
  96. % Stampo a video il contenuto della matrice C 
  97. i = 1;
  98. flag = true;
  99. while flag == true
  100.     j = 1;
  101.     flag2 = true;
  102.     while flag2 == true
  103.         fprintf('%d\t', C(i,j));
  104.         j = j+1;
  105.         flag2 = j <= c2;
  106.     end
  107.     fprintf('\n');
  108.     i = i+1;
  109.     flag = i <= r1;
  110. end
  111.  
  112. %% Ora prova a fare A*B...
  113.  
  114. %% Riferimenti utili
  115. %
  116. % # https://it.mathworks.com/help/matlab/learn_matlab/matrices-and-arrays.html
  117. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/while.html
  118. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/input.html
  119. % # https://it.mathworks.com/help/matlab/ref/logicaloperatorsshortcircuit.htm
  120. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/disp.html
  121. %

Algoritmo Merge Sort

Consideriamo due vettori (V e W) già ordinati con lo stesso criterio e nelle ipotesi che la loro lunghezza non coincida, che ogni vettore non contenga elementi uguali e che non ci sono elementi comuni tra i due vettori. L'algoritmo merge sort crea un terzo vettore ordinato (U) dato dalla fusione dei primi due. La logica alla base dell'algoritmo è quella di far lavorare in un ciclo due indici (i e j), ciascuno su un vettore, scorrendo i quali si aggiunge al vettore fusione volta per volta l'elemento minore a cui fanno riferimento i due indici. Quando uno dei due vettori termina, si aggiungono al vettore fusione i restanti elementi dell'altro vettore.


Diagramma di flusso dell'algoritmo merge sort
  1. %% Script per il merge sort
  2.  
  3. % Acquisisco da tastiera la dimensione dei vettori V e W, rispettivamente N e
  4. % M
  5.  
  6. N = input('');
  7. M = input('');
  8.  
  9. % Creazione del vettore vuoto V
  10. V = [];
  11.  
  12. % Acquisizione da tastiera delle componenti del vettore V
  13. i = 0;
  14. flag = true;
  15. while flag == true
  16.     V = [V, input('')]; 
  17.     i = i+1;
  18.     flag = i < N;
  19. end
  20.  
  21. % Creazione del vettore vuoto W
  22. W = [];
  23.  
  24. % Acquisizione da tastiera delle componenti del vettore W
  25. i = 0;
  26. flag = true;
  27. while flag == true
  28.     W = [W, input('')]; 
  29.     i = i+1;
  30.     flag = i < M;
  31. end
  32.  
  33. % Ordinamento del vettore V
  34.  
  35. % ATTENZIONE ! - Per accedere alle componenti di
  36. % vettori e matrici l'indice deve iniziare da 1
  37. i = 1;
  38. flag = true;
  39. while flag == true
  40.     i_min = i;
  41.     j = i+1;
  42.  
  43.     % Essendoci un blocco while annidato, ho la necessità di utilizzare un
  44.     % secondo flag
  45.     flag1 = true;
  46.     while flag1 == true
  47.         % Controllo se l'elemento corrente è minore di quello considerato
  48.         % come minimo
  49.         if V(j) < V(i_min)
  50.             % Se vero, aggiorno l'indice dell'elemento minimo
  51.             i_min = j;
  52.         end
  53.  
  54.         j = j+1;
  55.         % Attenzione alla condizione; ? utilizzato il <= perchè in Matlab
  56.         % il primo elemento del vettore ha indice 1, mentre l'ultimo avrà
  57.         % indice pari a N
  58.         flag1 = j<=N;
  59.     end
  60.  
  61.     % Blocco di codice relativo allo scambio
  62.     temp = V(i);
  63.     V(i) = V(i_min);
  64.     V(i_min) = temp;
  65.  
  66.     i = i+1;
  67.     flag = i <=(N-1);
  68. end
  69.  
  70. % Ordinamento del vettore W
  71.  
  72. % ATTENZIONE ! - Per accedere alle componenti di
  73. % vettori e matrici l'indice deve iniziare da 1
  74. i = 1;
  75. flag = true;
  76. while flag == true
  77.     i_min = i;
  78.     j = i+1;
  79.  
  80.     % Essendoci un blocco while annidato, ho la necessit? di utilizzare un
  81.     % secondo flag
  82.     flag1 = true;
  83.     while flag1 == true
  84.         % Controllo se l'elemento corrente è minore di quello considerato
  85.         % come minimo
  86.         if W(j) < W(i_min)
  87.             % Se vero, aggiorno l'indice dell'elemento minimo
  88.             i_min = j;
  89.         end
  90.  
  91.         j = j+1;
  92.         % Attenzione alla condizione; ? utilizzato il <= perchè in Matlab
  93.         % il primo elemento del vettore ha indice 1, mentre l'ultimo avrà
  94.         % indice pari a N
  95.         flag1 = j<=M;
  96.     end
  97.  
  98.     % Blocco di codice relativo allo scambio
  99.     temp = W(i);
  100.     W(i) = W(i_min);
  101.     W(i_min) = temp;
  102.  
  103.     i = i+1;
  104.     flag = i <=(M-1);
  105. end
  106.  
  107. %% Inizio dell'algoritmo di merge sort
  108.  
  109. % Creazione del vettore vuoto U
  110. U = [];
  111.  
  112. % Inizializzatione delle variabili utili all'algoritmo
  113. i = 1;
  114. j = 1;
  115. k = 1;
  116.  
  117. flag = true;
  118. while flag == true
  119.     if V(i) < W(j)
  120.         U(k) = V(i);
  121.         i = i+1;
  122.     else
  123.         U(k) = W(j);
  124.         j = j+1;
  125.     end
  126.     k = k+1;
  127.  
  128.     flag = i<= N && j <= M;
  129. end
  130.  
  131. if i < N
  132.     for i = i : 1 : N
  133.         U(k) = V(i);
  134.         k = k+1;
  135.     end
  136. else
  137.     for j = j : M
  138.         U(k) = W(j);
  139.         k = k+1;
  140.     end
  141.  
  142. end
  143.  
  144. % Stampa a video delle componenti del vettore
  145. i = 1;
  146. flag = true;
  147. while flag == true
  148.    disp(U(i));
  149.    i = i+1;
  150.    flag = i<=k-1;
  151. end
  152.  
  153. %% Equivalentemente
  154. % for i = 1 : k-1
  155. %     disp(U(i));
  156. % end
  157.  
  158. %% Riferimenti utili
  159. %
  160. % # https://it.mathworks.com/help/matlab/ref/for.html
  161. % # https://it.mathworks.com/help/matlab/learn_matlab/matrices-and-arrays.html
  162. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/while.html
  163. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/input.html
  164. % # https://it.mathworks.com/help/matlab/ref/logicaloperatorsshortcircuit.htm
  165. % # https://www.mathworks.com/help/releases/R2016b/matlab/ref/disp.html
  166. %
Estratto da "http://www.vitoantoniobevilacqua.it/wiki/index.php?title=Diagrammi_di_flusso_e_Codice_Matlab&oldid=345"