Visualizza sorgente di Diagrammi di flusso e Codice Matlab

'''Vitoantonio Bevilacqua''' [mailto:vitoantonio.bevilacqua@poliba.it vitoantonio.bevilacqua@poliba.it]

'''Antonio Brunetti''' [mailto:antonio.brunetti@poliba.it  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 [https://it.wikipedia.org/wiki/MATLAB 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:
#una "ellisse" che contiene al suo interno un label (etichetta) che può indicare l'"inizio" o la "fine" dell’algoritmo; 
# 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".
#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.
#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'''.
<div align="center"><gallery>
File:Ellisse.png | Ellisse di inizio e fine
File: Rettangolo.png | Blocco delle assegnazioni
File: Io.png | Blocchi di input/output
File: Rombo.png | Blocco condizionale
</gallery></div>

=== 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. 
[[File:Controllo_coda.png  | frame | 200px | center | 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 [https://en.wikipedia.org/wiki/Do_while_loop ciclo ''do-while'' del linguaggio C]). Come si può notare, è necessario utilizzare una [https://en.wikipedia.org/wiki/Boolean_data_type variabile booleana] affinché il costrutto presente in Matlab si comporti come un ciclo con controllo in coda.

<syntaxhighlight lang="matlab" line>
%% Snippet di codice per il ciclo con controllo in coda

% Eseguo una serie di operazioni

% Utilizzo una variabile booleana
flag = true;
while flag == true

    % Eseguo diverse operazioni

    flag = condition

end
</syntaxhighlight>

=== Decisione Binaria Vero-Falso ===
A seconda della veridicità o meno dell’espressione inserita si esegue il ramo del vero o del falso rispettivamente.
[[File:If_else.png | frame | 200px | center  | Rappresentazione di un blocco condizionale Vero - Falso]] 
Il seguente segmento di codice è la rappresentazione in codice matlab del blocco di decisione binaria.

<syntaxhighlight lang="matlab" line>
%% Snippet di codice per il blocco di decisione binaria if - else
% Eseguo una serie di operazioni

if condizione == true

    % Eseguo un determinato blocco di istruzioni
else

    % Eseguo un altro blocco di istruzioni
end
</syntaxhighlight>

== 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.
[[File:MEDIA.png | frame | 200px  | center | Diagramma di flusso per il calcolo della media]] 
<syntaxhighlight lang="matlab" line>
%% Codice per il calcolo della media di N numeri

% Acquisisco da tastiera la dimensione dell'insieme di numeri
% controllando che sia un numero maggiore di 0
flag = true;
while flag == true
   N = input('');
   flag = N <= 0;
end

% Una volta acquisita la dimensione dell'insieme dei numeri, inizializzo le
% variabili utili al programma e passo ad acquisire i numeri
SOMMA = 0;
i = 0;
flag = true;
while flag == true
   ADDENDO = input('');
   SOMMA = SOMMA + ADDENDO;
   i = i+1;
   flag = i < N;
end

% Calcolo il valore di MEDIA
MEDIA = SOMMA / N;

% Stampo a video il valore di MEDIA
disp(MEDIA);

%% Riferimenti utili
%
% # https://www.mathworks.com/help/releases/R2016b/matlab/ref/input.html
% # https://www.mathworks.com/help/releases/R2016b/matlab/ref/while.html
% # https://www.mathworks.com/help/releases/R2016b/matlab/ref/disp.html
%

</syntaxhighlight>

=== 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
[[File:Somma_prodotto.png | frame | 200px | center | Diagramma di flusso per il calcolo della somma dei numeri pari e il prodotto dei numeri dispari]] 
<syntaxhighlight lang="matlab" line>
%% Codice per il calcolo della somma degli elementi pari e il prodotto di quelli dispari

% Acquisisco da tastiera la dimensione dell'insieme di numeri
% controllando che sia un numero compreso tra 5 e 10 (estremi inclusi)
flag = true;
while flag == true
    N = input('');
    flag = N < 5 || N > 10;
end

% Una volta acquisita la dimensione dell'insieme dei numeri, inizializzo le
% variabili utili al programma e passo ad acquisire i numeri
i = 0;
SOMMA = 0;
PROD = 1;

flag = true;
while flag == true
    operando = input('');
    % Controllo se l'operando è pari o dispari
    if mod(operando, 2) == 0
        % Caso relativo all'operando pari
       SOMMA = SOMMA + operando;
    else
         % Caso relativo all'operando dispari
        PROD = PROD * operando;
    end
    
    i = i+1;
    flag = i < N;
end

% Mostro a video i valori di somma e prodotto
disp (SOMMA);
disp (PROD);

%% Riferimenti utili
%
% # 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/mod.html
% # https://www.mathworks.com/help/releases/R2016b/matlab/ref/disp.html
%
</syntaxhighlight>

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

[[File:Log2.png | center | 200px | frame | Diagramma di flusso per il calcolo del logaritmo in base 2 approssimato per eccesso]] 
<syntaxhighlight lang="matlab" line>
%% Codice per il calcolo dell'approssimazione per eccesso del logaritmo in base 2 di un numero

% Acquisisco da tastiera il numero di cui calcolare il logaritmo in base 2
% controllando che sia un numero maggiore di 0
flag = true;
while flag
    OP = input('');
    flag = OP <= 0;
end

% Una volta acquisito l'operando, inizializzo le variabili utili al programma 
% e passo al calcolo del logaritmo
i = 0;
RIS = 1;
flag = true;
while flag == true
   RIS = RIS * 2;
   i = i+1;
   flag = RIS < OP;
end

% Mostro a video il risultato
disp(i)

%% Riferimenti utili
%
% # 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>

=== 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
[[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>