Supponiamo di forzare l’ingresso con un segnale sinusoidale a pulsazione specificata, del tipo

amath u(t) = X sin(omega t + phi) => U(s) = {s cos phi - omega sin phi}/{s^2 + omega^2} endamath

Dalla relazione tra funzione di trasferimento e ingresso, applicando lo sviluppo in fratti semplici, abbiamo che:

amath Y(s) = G(s) U(s) = (sum_{i=1}^n {k_i}/{s+p_i}) + {Q}/{s-j omega} + {bar(Q)}/{s + j omega} endamath

Possiamo dire, in parole semplici, che l’uscita è formata da due componenti:

• Componente amath Y_1(s) endamath, corrispondente ai modi del sistema, destinati a generare una risposta nulla a regime per ipotesi (sistema asintoticamente stabile).
• Componente amath Y_2(s) endamath, corrispondente ai modi forzanti applicati al sistema.

Determiniamo ora, sfruttando i teoremi sui residui, il valore di Q e del suo complesso coniugato.

amath Q = [(s - j omega) G(s) {s cos phi - omega sin phi}/{s^2 + omega^2} ]_{s = j omega} =

= X G(j omega) {j omega cos phi - omega sin phi}/{j omega + j omega}=

= X G(j omega) (1/2 cos phi - 1 / {2j} sin phi) = endamath

Applicando ora le relazioni di Eulero si ha

amath Q = X G(j omega) (1/2 {e^{j phi} + e^{-j phi}}/2 - 1 / {2j} {e^{j phi} - e^{-j phi}}/{2j}) =

= 1/4 X G(j omega) 2 e^{j phi} =

=1/2 X G(j omega) e^{j phi} endamath

La funzione amath G(j omega) è complessa di variabile complessa, pertanto rappresentabile nella sua forma esponenziale:

amath = G(j omega) = |G(j omega)| e^{j /_G(j omega)} endamath

Utilizzando questa notazione, riscriviamo il valore di Q.

amath Q = 1/2 X |G(j omega)| e^{j /_(G(j omega))} e^{j phi} =

= 1/2 X |G(j omega)| e^{j (phi + /_G(j omega))} endamath

Il numero Q è quindi complesso, caratterizzato da:

• Modulo: amath 1/2 X |G(j omega)| endamath
• Fase: amath phi + /_G(j omega) endamath

A questo punto è immediato, antitrasformando l’espressione dell’uscita, ricavare

amath y_2(t) = 2 |Q| cos (omega t + /_Q) =

= 2 1/2 X |G(j omega)| cos (omega t + phi + /_G(j omega)) =

= Y(omega) cos (omega t + phi(omega)) endamath

Come si nota, quindi, sull’uscita si presenta un segnale temporale di tipo periodico, che non si estingue nel tempo come le componenti asintoticamente stabili già descritte in precedenza. Il sistema continuerà quindi a presentare, sull’uscita, un segnale periodico di frequenza amath 1/omega endamath. Essendo tutti gli altri contribuiti destinati ad esaurirsi nel tempo (per l’ipotesi di asintotica stabilità), possiamo affermare che, terminato il transitorio, l’andamento a regime del sistema sarà proprio di tipo sinusoidale.

Questo importante risultato permette di formulare immediatamente il teorema del regime permanente:

Un sistema dinamico lineare, tempo invariante ed asintoticamente stabile, soggetto ad un’eccitazione sinusoidale, presenta, a regime, un’uscita sinusoidale di frequenza uguale a quella del segnale d’ingresso.

Vogliamo ora definire una funzione complessa, di variabile reale, che contenga al suo interno informazioni relative a quanto il segnale di ingresso viene amplificato/attenuato e di quanto sfasato. Risulta quindi intuitiva la definizione della seguente funzione di risposta armonica:

amath F(omega) = {Y(omega)}/X e^{j (phi(omega) - phi} endamath

In cui:

• amath X endamath rappresenta il modulo del segnale in ingresso
• amath phi endamath rappresenta la fase del segnale di ingresso
• amath Y(omega) endamath e amath phi(omega) endamath rappresentano le funzioni sovra definite e dipendono, in generale, sia dalle caratteristiche del sistema che da quelle della forzante

Sviluppando i calcoli, si ottiene l’importante relazione tra funzione di trasferimento e funzione di risposta armonica.

amath F(omega) = {Y(omega)}/X e^{j (phi(omega) - phi} =

= {X |G(j omega)|}/X e^ {j (phi + /_G(j omega) - phi} =

= |G(j omega)| e^{j /_G(j omega)} =

= G(j omega) endamath

L’importante conclusione è dunque la seguente:

Sussiste una relazione di equivalenza tra funzione di trasferimento e funzione di risposta armonica. In particolare, si ha che amath F (omega) = G(j omega) endamath.

La seguente relazione è molto importante, poiché permette di analizzare le prestazioni di un sistema partendo da un’analisi sperimentale. Infatti la funzione di risposta armonica, per come è stata definita, si presta molto bene ad una determinazione sperimentale, come descritto di seguito.

Si supponga di avere un sistema (dinamico, lineare, stazionario, asintoticamente stabile) e di forzarlo con un segnale sinusoidale ad ampiezza e fase fissati e frequenza variabile. Terminato il transitorio, come detto, l’uscita avrà andamento sinusoidale con la stessa frequenza del segnale di ingresso. Misurando quindi ampiezza e fase dell’uscita, e registrandone i valori opportunamente modificati (l’ampiezza deve essere divisa per quella del segnale di ingresso ed alla fase deve essere sottratta quella del segnale d’ingresso), sarà possibile tracciare un diagramma approssimato sia del modulo che della fase della funzione di risposta armonica. Mediante tecniche di interpolazione, poi, sarà possibile determinarne l’espressione analitica e, attraverso diverse tecniche, anche l’espressione della corrispondente funzione di trasferimento.

amath Y(s) = G(s) * U(s) endamath

Dove

• Y(s) rappresenta l’uscita
• G(s) rappresenza la funzione di trasferimento
• U(s) rappresenza l’ingresso

La trattazione farà inoltre riferimento a sistemi di tipo SISO (Single - Input, Single - Output), ma è naturale ed immediato estenderla a sistemi MIMO.

Altro requisito importante per lo studio di questa proprietà è l’asintotica stabilità esterna del sistema, che viene tradotta, normalmente, nella condizione che i poli della funzione di trasferimento siano tutti a parte reale negativa.

La proprietà bloccante degli zeri afferma che modi forzanti coincidenti con zeri della funzione di trasferimento non hanno effetti sull’andamento asintotico del sistema.

Per chiarire meglio, si supponga di avere un sistema caratterizzato da:

amath G(s) = {s^2+omega_i^2}/{s+2} endamath

e che si ponga al suo ingresso un segnale sinusoidale elementare, del tipo

amath u(t) = sin(omega_u t) => U(s) = {omega_u^2}/{s^2 + omega_u^2} endamath

Distinguiamo allora due casi:

• amath w_i != w_u endamath
• amath w_i = w_u endamath

Il secondo caso è di particolare interesse, poiché avviene una semplificazione tra il denominatore della forzante e il numeratore della funzione di trasferimento:

amath Y(s) = G(s)*U(s) = {s^2+omega^2}/{s+2} * {omega^2}/{s^2 + omega^2} = {omega^2}/{s+2} endamath

E’ facile calcolare quindi l’uscita nel dominio temporale:

amath y(t) = L^{-1}[Y(s)] = L^{-1}[{omega^2}/{s+2}] = omega^2 e^(-2t) endamath

L’uscita, a regime, sarà quindi nulla. Come si vede, quindi, la presenza di una forzante su un sistema di per sé asintoticamente stabile non porta ad alcuna modifica dello stesso. La forzante non ha effetti a regime.

Ancora più interessante è il caso di analisi della proprietà bloccante degli zeri nel dominio delle frequenze. In questo caso, la coppia di zeri complessi coniugati genera una risposta in ampiezza con un picco di amath -oo d B endamath in corrispondenza della pulsazione amath omega endamath.

Bode

Questa proprietà ha un’interessante conseguenza: l’utilizzo, come forzante, di un’armonica a pulsazione amath omega endamath genera un’uscita a pulsazione nulla (attenuazione totale). Infatti, si ha che

amath|G(j omega)| = -oo d B => 20 log |G(j omega)| = -oo => |G(j omega)| = 0 endamath

Pertanto, rappresentando il modulo della funzione di trasferimento il fattore di amplificazione o attenuazione dell’uscita, abbiamo un’armonica nulla in corrispondenza di tale pulsazione.

Analisi Hardware

Il TIC

Il TIC, il temporizzatore di sistema, è un dispositivo diviso in 4 canali. Ogni canale è composto da un contatore a 16 bit che si decrementa con una frequenza

f = 1.19318 MHz

Ogni volta che il contatore raggiunge il valore zero, viene generato un interrupt hardware sul piedino INTR del microprocessore (interrupt mascherabile), dopodichè il conteggio riparte.
Il costruttore assicura che il TIC genera un interrupt di priorità massima rispetto a tutti gli altri.
Utilizzando il valore della frequenza fornita dal costruttore, si ricava che, se il contatore parte dal valore massimo (FFFFh), esso si azzera ogni

amath N = 18.2 {v o l t e}/{s e c o n d o} endamath

Il TIC ha compiti molto importanti all’interno del sistema microprocessore: tra le attività che svolge, c’è quella fondamentale di eseguire il refresh della RAM dinamica.
Uno dei canali del TIC è reso disponibile per il programmatore: ogni volta che il rispettivo contatore si azzera, si genera un interrupt hardware al vettore 8.
Tuttavia, la funzione corrispondente è importante per il sistema operativo, quindi non possiamo semplicemente sovrascriverla cambiando il valore del vettore 8. Per nostra fortuna questa situazione era stata prevista dai costruttori, che hanno fatto in modo che, alla fine della routine puntata dal vettore 8, sia generato un secondo interrupt al vettore 1Ch. E questo interrupt è generato apposta per il programmatore, quindi possiamo tranquillamente far eseguire una nostra routine.

Analisi Software

Programmazione della tabella dei vettori

La tabella dei vettori non è scrivibile direttamente dal programmatore, ma solo attraverso l’utilizzo di apposite routine fornite dal sistema operativo sotto forma di servizi interrupt software.
In particolare, il DOS (int 21h) fornisce il servizio 25h:

• Servizio 25H, set interrupt vector (in AL=interrupt number, DS:DX=new vector)

In pratica, le azioni da eseguire per settare una nuova routine nella tabella dei vettori sono

Blocco Interrupt
AL <- Numero del vettore
DS <- Code Segment
DX <- Indirizzo della routine
Riattivazione interrupt
!!! Ripristino del DS !!!

Va notato che, per ricavare l’indirizzo della routine, è sufficiente riferirsi ad essa con la sua label, il nome che le abbiamo assegnato: infatti la label non è altro che un modo per definire un’etichetta mnemonica al posto di un indirizzo: le label nell’area codice definiscono un indirizzo della zona codice (quindi con segmento CS), pertanto il nome di una routine corrisponde al punto di entrata della stessa.
Va precisato che la manipolazione della tabella degli interrupt deve avvenire sotto protezione dalla rilevazione di interrupt, per evitare problemi causati dalla modifica parziale dei registri o dall’aggiornamento della tabella stessa.

Gestione del tempo con il TIC

Abbiamo detto che il TIC genera un interrupt hardware al vettore 8 (e, conseguentemente, all’1Ch) 18.2 volte al secondo. Quindi la nostra routine viene eseguita appunto questo numero di volte ogni secondo. Se vogliamo rilevare il passaggio di un secondo, dobbiamo eseguire ciò che vogliamo solo ogni 18 chiamate alla routine.
Ma manca una questione: ogni 5 secondi è necessario aspettare un’esecuzione in più (19 in tutto) in modo da “pareggiare” gli scompensi che si sono creati eseguendo il codice ogni 18 volte (invece che ogni 18.2).
Infatti abbiamo che

amath 18.2 * 5 = 91 = 4*18 + 19 endamath

Va precisato subito che, all’entrata della routine di servizio, il data segment è sporco (viene sporcato dalla routine puntata dal vettore 8), quindi deve essere ripristinato con un’opportuna istruzione. In realtà sarà sufficiente spostare nel registro DS il valore @data, che contiene automaticamente il valore iniziale del DS impostato all’avvio del programma.

DS <- @data

Stampa dell’orologio

Possiamo immaginare l’orologio come tre contatori (secondi, minuti, ore) che si incrementano automaticamente ogni secondo (il passaggio del tempo si può rilevare con il TIC). Se la nostra routine lavora con dei dati già presenti in memoria (e quindi i contatori sono visti come delle label che puntano a dei byte), sarà quindi sufficiente inizializzare quest’area al valore dell’orario attuale per ottenere l’orologio.

Notare che la stampa deve avvenire comunque attraverso simboli ASCII, quindi abbiamo due strade da percorrere:

1. Lavoriamo direttamente con contatori in formato ASCII
2. Lavoriamo con contatori numerici ma prima della stampa convertiamo il tutto in ASCII

La via che ho scelto, perché mi sembrava la più comoda, è quella di gestire i contatori in formato ASCII. In pratica, necessitiamo di 6 byte:

1. Decine delle ore (’0′…’2′)
2. Unità delle ore (’0′…’9′)
3. Decine dei minuti (’0′…’5′)
4. Unità dei minuti (’0′…’9′)
5. Decide dei secondi (’0′…’5′)
6. Unità dei secondi (’0′…’9′)

La nostra routine di servizio dovrà quindi aggiornare le unità dei secondi e, se necessario, aggiornare in cascata tutti gli altri contatori coinvolti (sarà sufficiente controllare il superamento del valore massimo).

Rilevo se è passato un secondo
		Aggiorno il contatore unità secondi
			Se è arrivato a '9' + 1
				Aggiorno le decine dei secondi
					Se... e così via fino alle unità delle ore
		Eseguo la stampa

Discorso a parte meritano le ore, perché, oltre a gestire il riporto unità – decine, è necessario prevedere un controllo quando l’orario arriva a 24: in questo caso, infatti, tutto il dispositivo deve essere azzerato.

Se l'orario è 24
			ore <- '0'
			ore+1 <- '0'

In realtà è sufficiente azzerare la parte delle ore, perché le altre parti, per come è strutturato il nostro algoritmo, sono già state azzerate in cascata prima di poter arrivare alla modifica dei contatori dell’ora.

Va notato che le routine di gestione degli interrupt non sono mai generiche: anche nel nostro caso esse si basano su dati presenti in memoria a particolari label, quindi non saranno adattabili ad altri casi.

L’ultima cosa da fare è sistemare le locazioni di memoria utilizzate per la routine di servizio: per farlo è necessario rilevare l’orario di sistema. Ho scelto di utilizzare l’interrupt software 1Ah che permette di avere l’orario in formato BCD compattato, facilmente scomponibile in ASCII con una routine di mascheratura.

• Servizio 2, Read real time clock (returns in BCD : CH=hours, CL=minutes, DH= seconds)

Una volta sistemata l’ora di partenza, andrà solamente sistemata la tabella degli interrupt e il nostro problema è risolto.
Una precisazione: se non si esegue una prima stampa nel main, l’orario verrà stampato per la prima volta quando la routine di gestione viene effettivamente eseguita completamente, ossia dopo il primo secondo di esecuzione. Per ovviare il problema, come detto, è sufficiente stampare l’orario anche all’inizio del programma.

Rileva l'ora di sistema
	Stampa l'ora di sistema
	Imposta la routine di gestione degli Interrupt
	Rimani in esecuzione indeterminatamente

Il programma rimane in loop infinito, in modo che l’ora sia stampata continuamente finché l’utente non interrompe l’esecuzione manualmente.

Jump lontani

Per come sono interpretate le istruzioni di jump condizionale, esse non permettono un salto di oltre 256 byte. Se ciò dovesse essere necessario, come nel mio caso, si ricorre ad un piccolo trucchetto, che consiste nel far saltare il programma ad un punto “morto”, ossia dove l’esecuzione normalmente non arriverebbe, e porre in quel punto un JMP secco alla label che ci interessava.

Va notato che i punti morti del nostro programma sono essenzialmente dopo tutte le istruzioni JMP non condizionali: infatti, arrivati a quel punto, l’esecuzione si sposterà in un’altra zona, impedendo l’esecuzione della successiva istruzione.

Struttura del programma

Programma principale

1. Inizializza le variabili necessarie per il programma
2. Rileva l’ora di sistema
3. Effettua la prima stampa
4. Imposta la tabella degli interrupt

Routine “orol”

1. Ripristina il data segment
2. Routine associata all’interrupt generato dal TIC
3. Rileva il passaggio di un secondo
4. Aggiorna tutti i rispettivi contatori
5. Stampa l’orario
6. Richiede le locazioni di memoria
   • conta: inizializzato a 18, indica il numero di chiamate a vuoto prima che sia passato un secondo
   • pareggio: inizializzato a 5, indica ogni quanti secondi deve essere eseguita una chiamata a vuoto per pareggiare il tempo
   • Locazioni di memoria per ore, minuti e secondi (2 byte ognuna); N.B. Il byte a indirizzo basso di ogni coppia indica le decine. Inoltre la struttura che devono avere questi byte è quella della stampa, quindi ORE, separatore, MINUTI, separatore, SECONDI, carattre $ come terminatore della sequenza
7. Sistema i contatori per la rilevazione successiva

Routine “stampaora”

1. La routine riceve in ingresso una coppia di byte che indica la posizione in cui stampare e la stringa dell’orario (formato ore, separatore, minuti, separatore, secondi, separatore, carattere $ come terminatore della convenzione DOS). La stringa termina con $ perché per la stampa si utilizza l’interrupt 21h del DOS.
2. La routine si posiziona sullo schermo e stampa la stringa

Routine “scompatta”

1. La routine riceve in ingresso un dato BCD compattato a 8 bit e lo scompatta nelle sue due componenti (decine e unità), depositando i risultati in due byte puntati dal registro SI ([SI] e [SI+1])

Costanti di servizio

Costante “separa”
E’ un byte ASCII che indica il carattere da stampare per separare ore, minuti e secondi: generalmente è ‘:’

Costanti “maschera_alta” e “maschera_bassa”
Sono le due maschere utilizzate dalla routine scompatta per prelevare la parte alta e la parte bassa del numero BCD compattato.

Costante “posizione_stampa”
Indica la posizione utilizzata dall’interrupt 10h del video in cui posizionare il cursore per la stampa. E’ formata da due byte: il primo indica la riga, il secondo la colonna

Costanti “num_pareggio” e “tic_secondo”
Costanti utilizzate per la gestione del TIC. La prima indica ogni quanti secondi deve essere eseguita una chiamata “a vuoto” della routine di gestione dell’interrupt per pareggiare il tempo. La seconda indica quante chiamate della routine devono essere effettuate prima che sia passato un secondo effettivo.

Codice

;------------------------------------------------------------------------------
; STUDENTE:		Andrea Asta
; PROGRAMMA:		orologio.asm
; DESCRIZIONE:	Stampa un orologio digitale sfruttando gli interrupt del TIC
;------------------------------------------------------------------------------
 
; Segmentazione del DOS
	DOSSEG
; Modello di memoria
	.MODEL	small
; Memoria per lo stack
	.STACK	100h
 
;------------------------------------------------------------------------------
; Data segment
;------------------------------------------------------------------------------
	.DATA
 
; Cose di servizio
separa	         	EQU	':'
maschera_alta	   	EQU	11110000b
maschera_bassa	   	EQU	00001111b
posizione_stampa	EQU	0520h
 
; Propri dati
ore	  	db	? , ?
	     	db 	separa
minuti  	db    ? , ?
	     	db 	separa
secondi 	db    ? , ?
	     	db    '$'
 
; Richieste per il funzionamento del tic
num_pareggio EQU    5
tic_secondo  EQU    18
conta        db     ?
pareggio     db     ?
 
;------------------------------------------------------------------------------
; Code Segment
;------------------------------------------------------------------------------
	.CODE
 
stampaora	PROC
      	; Stampa la stringa HH-MM-SS
	; DX -> Posizione di stampa
	; DS:SI -> Stringa completa HH-MM-SS
 
	PUSHF
	PUSH	AX BX DX
 
	; Riposiziono il cursore
     	MOV     BH , 0
     	MOV     AH , 2
     	INT     10h
 
      	; Stampo la stringa
	MOV	DX , SI
	MOV	AH , 9
	INT	21h
 
	POP     DX BX AX
	POPF
	RET
	ENDP
 
scompatta	PROC
 
	PUSHF
	PUSH	AX
 
; Riceve in ingresso un dato 8 bit (AL) BCD compattato
; e un puntatore ad una zona di memoria di 2 byte (SI)
; Mette in SI <- decine e in SI + 1 <- Unità
 
      	; Prelievo le decine
	MOV	AH , AL
	AND	AH , maschera_alta
	SHR	AH , 4
	ADD	AH , '0'
	MOV	BYTE PTR [SI] , AH
 
 	; Prelievo le unità
	MOV	AH , AL
	AND	AH , maschera_bassa
	ADD	AH , '0'
	MOV	BYTE PTR [SI+1] , AH
 
	POP	AX
	POPF
	RET
	ENDP
 
orol   	PROC
       	PUSH    AX DX DS ES SI BX
 
        ; Ripristino DS
        MOV     AX , @data
        MOV     DS , AX
 
        ; E' passato un secondo?
        CMP     [conta] , 0
        JNZ     lamp_supp
 
        ; E' stato anche effettuato l'eventuale "pareggio"?
        CMP     [pareggio]   ,  0
        JZ      lamp_supp2
 
             ; E' passato il mio secondo effettivo
             ;--------------------------------------------
             ; Scrivi ciò che vuoi fare nella routine
 
             ; Incremento i secondi (le unità)
             INC      BYTE PTR [secondi+1]
             CMP      BYTE PTR [secondi+1] , '9' + 1
             JNZ      lamp_x5
             MOV      BYTE PTR [secondi+1] , '0'
 
             ; E in cascata eventualmente tutto il resto!
             INC      BYTE PTR [secondi]
             CMP      BYTE PTR [secondi] , '5' + 1
             JNZ      lamp_x5
             MOV      BYTE PTR [secondi] , '0'
 
             INC      BYTE PTR [minuti+1]
             CMP      BYTE PTR [minuti+1] , '9' + 1
             JNZ      lamp_x5
             MOV      BYTE PTR [minuti+1] , '0'
 
             INC      BYTE PTR [minuti]
             CMP      BYTE PTR [minuti] , '5' + 1
             JNZ      lamp_x5
             MOV      BYTE PTR [minuti] , '0'
 
             INC      BYTE PTR [ore+1]
             CMP      BYTE PTR [ore+1] , '9' + 1
             JNZ      lamp_x5check
             MOV      BYTE PTR [ore+1] , '0'
 
             INC      BYTE PTR [ore]
             JMP      lamp_x5
 
             ; Label di supporto per i far JMP
lamp_supp:   JMP      lamp_x6
lamp_supp2:  JMP      lamp_x3
 
lamp_x5check:; Devo controllare che non siano le 24!
             CMP      BYTE PTR [ore+1], '4'
             JNZ      lamp_x5
             CMP      BYTE PTR [ore], '2'
             JNZ      lamp_x5
             MOV      [ore] , '0'
             MOV      [ore+1] , '0'
 
lamp_x5:     	; Stampa
		MOV	    DX , posizione_stampa
		LEA	    SI , ore
 	       	CALL	    stampaora
 
	;--------------------------------------------
 
             ; Aggiorno i vari contatori del tempo
             MOV     [conta] , tic_secondo
             DEC     [pareggio]
             JMP     lamp_x2
 
lamp_x6:     JMP     lamp_x2
 
lamp_x3:     MOV     [pareggio]   ,  num_pareggio
             JMP     lamp_x4
 
lamp_x2:     DEC     [conta]
 
lamp_x4:     POP     BX SI ES DS DX AX
             IRET
             ENDP
 
; Inizio del programma
Begin:       StartupCode
 
      		MOV     [conta] , tic_secondo
      		MOV     [pareggio] , num_pareggio
 
		; Prelevo l'orario
		MOV	AH , 2
		INT	1Ah
 
		; Scompatto i dati
		MOV	AL , CH
		LEA	SI , ore
		CALL	scompatta
 
		MOV	AL , CL
		LEA	SI , minuti
		CALL	scompatta
 
		MOV	AL , DH
		LEA	SI , secondi
		CALL	scompatta
 
		; Prima stampa
		MOV	DX , posizione_stampa
		LEA	SI , ore
		CALL	stampaora
 
       ; Aggiorno la tabella degli interrupt, ma prima mi proteggo da altri INT
       CLI
 
       ; Salvo DS
       PUSH    DS
 
       ; Sistemo i valori da impostare nella tabella
       MOV     AX , CS
       MOV     DS , AX
       LEA     DX , orol
 
       ; Imposto la tabella con la mia routine (orol)
       MOV     AH , 25h
       MOV     AL , 1Ch
       INT     21h
 
       ; E ora ripristino tutto e tolgo la protezione
       POP     DS
       STI
 
       ; Rimango in attesa
       JMP     $
 
       END		Begin

Dati due byte residenti in memoria, depositare in una terza locazione la loro somma.

Analisi del problema

Per sommare due byte non abbiamo alcun tipo di problema dal punto di vista hardware: essendo il processore 8086 dotato di un circuito interno per la somma aritmetica, possiamo tranquillamente utilizzare le rispettive istruzioni per eseguire la somma.
L’unico problema a cui dobbiamo prestare sufficiente attenzione è quello relativo all’eventuale overflow: eseguendo la somma tra due byte, infatti, è possibile che questo risultato non sia contenibile in un byte, ma sia invece necessaria una word. In realtà, trattandosi di due soli byte, basterebbero 1 byte più un eventuale bit per il riporto finale, ma ragionando dal punto di vista software, l’elemento di definizione dato minimo dopo il byte è la word (2 byte).

Registri utilizzati

Registri a 8 bit

• AH: Parte alta della somma
• AL: Primo addendo, Parte bassa della somma

Codice del programma

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

;--------------------------------------
; Direttive all'assemblatore
;--------------------------------------
   DOSSEG               ; Segmentazione DOS
   .MODEL small         ; Modello di memoria
   .STACK 100h          ; Dimensione dello stack
 
;--------------------------------------
; Data Segment
;--------------------------------------
 	.DATA
X   db    30            ; Primo addendo
Y   db    50            ; Secondo addendo
S   dw    ?             ; Somma
 
;--------------------------------------
; Code segment
;--------------------------------------
	.CODE
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Programma principale
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Begin: StartupCode      ; Inizio del programma
 
; Inizializzazione variabili
  MOV   AL , [X]        ; Prelevo il primo addendo
  MOV   AH , 0          ; Azzero il registro per il Carry
 
; Algoritmo
  ADD   AL , [Y]        ; Aggiungo il secondo...
  ADC   AH , 0          ; ...e l'eventuale Carry
 
; Salvataggio risultati
  MOV   [S] , AX        ; Salvo la somma
 
; Operazioni finali
	ExitCode 0             ; Esecuzione corretta del programma
	END Begin              ; Fine del programma

Prove effettuate

Prova #01

Prova con dati generici pseudo - casuali.

Valori in input

• X -> 30
• Y -> 50

Valori attesi in output

• S -> 50h (80)

Valori in input

• S -> 50h (80)

Prova #02

Prova al limite inferiore.

Valori in input

• X -> 0
• Y -> 0

Valori attesi in output

• S -> 0

Valori in input

• S -> 0

Prova #03

Prova con dati generici pseudo - casuali.

Valori in input

• X -> FFh
• Y -> FFh

Valori attesi in output

• S -> 01FEh

Valori in input

• S -> 01FEh

Teoria degli alberi binari

Definizioni

Si definisce albero binario un insieme, eventualmente vuoto, di nodi connessi da archi detti rami. Un particolare nodo è detto radice e ogni nodo è tale da essere collegato a due sottoinsiemi distinti e disgiunti, anch’essi alberi binari (sottoalbero sinistro e destro).

Albero binario

Nell’albero mostrato in Figura 1, la radice è il nodo A, da cui si diramano altri due sottoalberi binari.

Terminologia

Un nodo si dice foglia se non ha figli. I nodi che non sono foglie sono detti nodi interni. Nell’esempio precedente, sono foglie i nodi F, I, M e N.

Dati due nodi i e j, si definisce cammino o percorso da i a j la sequenza di rami da percorrere per passare da i a j.

PROPRIETA’
In un albero, esiste sempre un cammino che collega una arbitraria coppia di nodi.

Si definisce profondità o livello di un nodo i, la sua distanza dalla radice, ossia il numero di archi da percorrere (ovviamente, nel caso migliore) per raggiungere i partendo dalla radice. Per convenzione la radice ha profondità 0.

Si definisce altezza o profondità di un albero binario l’altezza massima delle sue foglie. Nell’esempio precedente, l’albero ha altezza 5.

E’ possibile stabilire dei legami di parentela tra i nodi, del tutto simili a quelli della vita reale: la radice è il padre o genitore dei due nodi a lui connessi, che quindi saranno suoi figli. I figli di uno stesso genitore sono fratelli. Allo stesso modo si possono stabilire i legami di parentela nonno, zio ecc…

PROPRIETA’
Ogni nodo di un albero ha un solo genitore e, nel caso degli alberi binari, al massimo due figli.

Un albero binario si dice pieno se sono soddisfatte contemporaneamente queste condizioni:

1. Tutte le foglie hanno lo stesso livello
2. Tutti i nodi interni hanno esattamente 2 figli

Un albero binario pieno, formato da n nodi, ha profondità uguale a

amath L = |__ log_{2} n __| endamath

Notare che con le parentesi quadrate inferiormente si intende l’approssimazione per difetto (le parentesi quadrate superiormente intendono invece l’approssimazione per eccesso).

Un albero binario pieno, di altezza h, ha un numero di nodi pari esattamente a

amath n = 2 ^ {h+1} - 1 endamath

Un albero binario è bilanciato quando tutte le foglie hanno lo stesso livello, con un margine di errore di 1. Quindi, se l’altezza dell’albero è h, tutte le foglie dovranno avere livello h o al più h-1.
Un albero binario bilanciato in cui tutte le foglie hanno livello h si dice perfettamente bilanciato.

L’attraversamento di un albero consiste nell’elencarne tutti i nodi una e una sola volta.

Attraversamenti

Per gli alberi binari sono definiti tre metodi di attraversamento, che illustreremo uno ad uno:

1. Ordine anticipato (preorder)
2. Ordine posticipato (postorder)
3. Ordine simmetrico (inorder)

Ordine anticipato
Se l’albero binario non è vuoto:

1. Visito la radice
2. Attraverso il sottoalbero sinistro in ordine anticipato
3. Attraverso il sottoalbero destro in ordine anticipato

Ordine posticipato
Se l’albero binario non è vuoto:

1. Attraverso il sottoalbero sinistro in ordine posticipato
2. Attraverso il sottoalbero destro in ordine posticipato
3. Visito la radice

Ordine simmetrico

1. Attraverso il sottoalbero sinistro in ordine simmetrico
2. Visito la radice
3. Attraverso il sottoalbero destro in ordine posticipato

Va notato che le tre visite differiscono solo nel fatto che viene alterato l’ordine di visita dei sottoalberi e della radice.
Riferendosi all’albero di Figura 1, ecco come risultano le visite.

• ANTICIPATA:  ABDFCEGIHLMN
• POSTICIPATA: FDBIGMNLHECA
• SIMMETRICA:  DFBACIGEMLNH

Alberi binari di ricerca

Un albero binario di ricerca (ABR, oppure BST dall’inglese Binary Search Tree) è un albero binario in cui tutti gli elementi del sottoalbero sinistro sono minori della radice, tutti gli elementi del sottoalbero destro sono maggiori della radice e  con l’ulteriore vincolo per cui anche i due sottoalberi sono alberi binari di ricerca a loro volta. Non sono ammessi elementi duplicati.

Albero binario di ricerca

In modo intuitivo si può capire come una struttura dati del genere sia particolarmente indicata per inserimenti ordinati e per la ricerca di tipo dicotomico (che viene anche detta binaria).
Una particolare proprietà dei BST è che la visita simmetrica fornisce gli elementi esattamente in ordine crescente.

• SIMMETRICA:  5 6 7 8 9 10 11 15 18 20

Implementazione di un albero binario

Struttura di un albero binario

La prima cosa che dobbiamo affrontare è la scrittura del codice che ci permetterà di definire ogni nodo di un albero binario. E’ chiaro che ogni struttura avrà almeno un campo di tipo informativo, più due puntatori ad altri nodi, che sono il figlio sinistro ed il figlio destro. Come convenzione stabiliamo che, se un nodo non ha uno o alcuno dei figli, i puntatori avranno come valore NULL.

1
2
3
4
5
6
7
8

struct nodo {
  // Campi informativi
  int dato;
  // Puntatori ai prossimi nodi
  nodo*  sin;
  nodo*  des;
};
typedef nodo* albin;

L’istruzione typedef ci permetterà di trattare il puntatore ad un nodo come un nuovo tipo di dato, evitando confusione quando dobbiamo passare alle funzioni parametri di questo tipo.

Funzioni di gestione basilare

Le prime funzioni che ci accingiamo a creare sono decisamente banali e spesso possono anche essere omesse: si tratta delle funzioni che restituiscono il figlio sinistro e destro di un nodo, il campo informativo, oppure un albero vuoto. L’utilizzo di queste funzioni faciliterà, in futuro, l’eventuale revisione e riadattamento del codice, anche nel prospetto di una conversione ad un altro linguaggio di programmazione.
Saranno definite quindi le seguenti funzioni:

bool test_vuoto(albin root);
albin f_sinistro(albin);
albin f_destro(albin);
int dato(albin);
albin albero_vuoto();

La versione basilare che presentiamo è compilabile sia in linguaggio C sia in linguaggio C++.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

bool test_vuoto(albin root)
{
  // Verifica se root è un albero vuoto
  return root == NULL;
}
 
albin f_sinistro(albin root)
{
  // Restituisce il figlio sinistro di root
  if (!test_vuoto(root))
    return root->sin;
}
 
albin f_destro(albin root)
{
  // Restituisce il figlio destro di root
  if (!test_vuoto(root))
    return root->des;
}
 
int dato(albin root)
{
  // Restituisce il campo informativo di root
  if (!test_vuoto(root))
    return root->dato;
}
 
albin albero_vuoto()
{
  // Restituisce un albero vuoto
  return NULL;
}

Utilizzando il C++ è possibile migliorare leggermente le funzioni restituendo il valore di f_sinistro() e f_destro() come reference: in questo modo saranno possibili assegnazioni del tipo

f_sinistro(mioalbero) = new nodo;

Del resto, restando nell’ambito del C, è possibile scrivere due semplici funzioni imposta_sinistro() e imposta_destro() che svolgono lo stesso compito.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

albin& f_sinistro(albin root)
{
  // Restituisce il figlio sinistro di root
  if (!test_vuoto(root))
    return root->sin;
}
 
albin& f_destro(albin root)
{
  // Restituisce il figlio destro di root
  if (!test_vuoto(root))
    return root->des;
}
 
int& dato(albin root)
{
  // Restituisce il campo informativo di root
  if (!test_vuoto(root))
    return root->dato;
}

Ecco ora il codice in C.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

bool imposta_sinistro(albin root, albin what)
{
  if (!test_vuoto(root))
  {
    root->sin = what;
    return true;
  }
  return false;
}
 
bool imposta_destro(albin root, albin what)
{
  if (!test_vuoto(root))
  {
    root->des = what;
    return true;
  }
  return false;
}
 
void imposta_radice(albin* root, albin what)
{
  *root = what;
}
 
bool imposta_dato(albin root, int x)
{
  if (!test_vuoto(root))
  {
    root->dato = x;
  }
}

Le funzioni di inserimento nel figlio sinistro e destro restituiscono true se l’inserimento è stato possibile, false altrimenti. D’ora in avanti faremo riferimento alle funzioni C per compatibilità maggiore, chi utilizza il C++ sappia che può risparmiare queste tre funzioni semplicemente modificando le tre precedenti come mostrato sopra.

Teoria elementare della ricorsione

Perché la ricorsione

Come avrete notato, le definizioni di albero binario e albero binario di ricerca si prestano bene ad essere implementate con una procedura ricorsiva.
In realtà vedremo che quasi tutti gli algoritmi relativi agli alberi binari si prestano bene ad essere implementati ricorsivamente. Ecco qualche esempio.

• Conteggio del numero di foglie
  Se l’attuale nodo è una foglia, restituisci 1, altrimenti restituisci la somma del numero di foglie del sottoalbero sinistro e del sottoalbero destro.
• Calcolo della profondità
  La profondità di un albero è uguale a 1 sommato alla profondità massima tra il sottoalbero sinistro e quello destro.

Vedremo che, per risolvere un qualsiasi problema relativo agli alberi, sarà quasi più importante pensare all’algoritmo e alla definizione in modo ricorsivo, piuttosto che scrivere il codice.
Tuttavia la ricorsione non è una tecnica del tutto immediata e, se non si presta sufficiente attenzione al codice che si scrive, è facile cadere in cicli infiniti, ossia in ricorsioni che non terminano mai.

Un esempio pratico

Va innanzitutto chiarito che tutti gli algoritmi iterativi possono essere trasformati nella controparte ricorsiva e viceversa. Tuttavia è bene valutare un problema di efficienza: la ricorsione, da una parte rende il codice più compatto e facile da comprendere, dall’altra allunga il tempo di esecuzione, in quanto ogni chiamata a funzione richiede l’utilizzo della memoria per salvare il punto di ritorno e richiede la ricostruzione di tutte le variabili locali.

Un esempio classico di ricorsione è dato dal calcolo del fattoriale di un numero. Dato un numero naturale n

amath n in NN endamath

si definisce fattoriale si n e si indica con amath n! endamath il prodotto di tutti i numeri naturali e positivi minori o uguali a n.

amath n! = n (n-1) (n-2) … 3 * 2 * 1 = prod_{i=1}^n i endamath

Data questa definizione, è facile scrivere un programma iterativo per il calcolo del fattoriale: lo stesso simbolo di produttoria sottintende l’utilizzo di un semplice ciclo per la codifica.
Un’ultima nota sulla definizione è che si assume

amath 0! = 1 endamath

La motivazione va cercata nel calcolo combinatorio, ma non è questo il nostro interesse, quindi possiamo prendere l’identità mostrata come un assioma.

1
2
3
4
5
6
7

long fattoriale_iterativo (short int n)
{
  long f = 1;
  for (short int i = 1; i < n; i++)
    f *= i;
  return f;
}

Il programma calcola il fattoriale anche nel caso di n = 0, visto che la variabile f è inizializzata a 1 e l’esecuzione non entrerà mai nel ciclo con n = 0.
La funzione viene eseguita anche se è passato un parametro errato, come un numero negativo. In questo caso, però, il valore restituito sarà comunque 1. Per ovviare il problema è possibile definire meglio il parametro di ingresso, ad esempio di tipo unsigned short int, oppure inserire un ulteriore controllo all’interno della funzione per la gestione degli errori. Ad esempio, è chiaro che il fattoriale non restituirà mai un valore uguale a 0, quindi si può utilizzare questo valore di ritorno come sentinella di errore.

1
2
3
4
5
6
7
8
9

long fattoriale_iterativo (short int n)
{
  if (n < 0)
    return 0;
  long f = 1;
  for (short int i = 1; i < n; i++)
    f *= i;
  return f;
}

Abbiamo visto come la versione iterativa del fattoriale sia abbastanza semplice da implementare. Tuttavia, è anche possibile definire un algoritmo ricorsivo per il calcolo del fattoriale.
Basta infatti capire che il fattoriale di un numero n è interpretabile anche come

amath n! = n * (n-1)! endamath

ossia il fattoriale di n è uguale al prodotto di n per il fattoriale di n-1. Del resto è facile capirne la dimostrazione. Il fattoriale di 6, ad esempio, si trova prendendo il fattoriale di 5 (amath 5*4*3*2*1 endamath) e moltiplicandogli appunto 6.
Con una definizione del genere è facile scrivere la procedura ricorsivo corrispondente.

1
2
3
4
5
6

long fattoriale_ricorsivo (unsigned short int n)
{
  if (n == 0)
    return 1;
  return n * fattoriale_ricorsivo (n – 1); 
}

Se la funzione è richiamata, ad esempio con n = 5, avremo

fattoriale_ricorsivo (5)
5 * fattoriale_ricorsivo (4);
		4 * fattoriale_ricorsivo (3);
			3 * fattoriale_ricorsivo (2);
				2 * fattoriale_ricorsivo (1);
					1 * fattoriale_ricorsivo (0);
						1
					1 * 1 = 1
				2 * 1 = 2
			3 * 2 = 6
		4 * 6 = 24
	5 * 24 = 120
120

Come si è visto nell’esempio, la ricorsione termina in modo corretto e il risultato ottenuto è quello previsto.
Tuttavia, per una funzione del genere, l’utilizzo della ricorsione pare decisamente inutile e, anzi, decisamente dannoso per le prestazioni. Osserviamo infatti che:

1. La funzione ha una variabile globale di tipo long (generalmente 4 byte), che viene ricreata ad ogni chiamata ricorsiva
2. La funzione è chiamata un numero di volte pari a n più la chiamata di partenza (n+1 volte totali). Ogni volta il sistema dovrà memorizzare il punto di ritorno, andando così ad utilizzare lo stack.
3. La chiarezza dell’algoritmo non è tanto maggiore rispetto alla versione iterativa
   E’ chiaro che, quando si verifica una situazione del genere, è bene restare nel campo dell’iterazione.

Tecniche di ricorsione

Abbiamo visto un esempio di procedura ricorsiva, dimostrando “brutalmente” il suo funzionamento. Adesso, tuttavia, è bene riorganizzare il tutto e descrivere i punti fondamentali della ricorsione, da seguire sempre quando si scrive una procedura ricorsiva:

1. La procedura deve risolvere manualmente almeno un caso base.
2. La procedura deve essere chiamata ricorsivamente con parametri che convergono sempre di più verso il caso base. In generale, la procedura deve essere sempre richiamata con parametri sempre più piccoli.
3. Deve essere possibile la convergenza insiemistica.

Se si verificano queste tre condizioni, siamo sicuri che la nostra procedura ricorsiva terminerà.
Nel caso del fattoriale, il caso base era 0! e la procedura era richiamata sempre con parametri più vicini al caso base, in particolare sempre più piccoli.

Il terzo punto merita un esempio apposito. Supponiamo di avere una funzione f(x) definita come segue:

amath f(x) = {(2 + f(x/2)),(f(1)=1),(x in NN - {0}):} endamath

La funzione gestisce un caso base e la ricorsione è chiamata con parametri sempre più convergenti verso il caso base. Tuttavia, se x è dispari, la divisione per due non porterà mai al caso base 1.
Infatti, dividendo un numero dispari per 2 avremo sempre un numero dispari. Il più piccolo numero dispari naturale è 1, che, se diviso ancora per 2, porta al risultato 0. Se la funzione è richiamata con parametro 0, allora si entra in un loop infinito. I problemi di questa funzione sono quindi che il caso base gestito non è l’unico possibile e che gli insiemi non convergono.
Come verificato, quindi, una procedura che non soddisfi esattamente tutti e tre i punti sopra elencati, di sicuro non terminerà. E’ bene prestare attenzione particolare alla fase di progetto di un algoritmo ricorsivo, analizzando tutti i possibili casi di ingresso.

Algoritmi di base

Stampa dell’albero binario

La visita di un albero binario è l’algoritmo più semplice da implementare, si tratta infatti di applicare le definizioni ricorsive prima fornite alla lettera e di trascriverle in linguaggio di programmazione.
Per prima cosa ci soffermeremo su un algoritmo di base, che si occupa di stampare a video tutti i nodi di un albero, utilizzando uno dei tre metodi di attraversamento.

void stampa_preorder(albin);
void stampa_inorder(albin);
void stampa_postorder(albin);

Per la stampa utilizzeremo la funzione printf(), ma è chiaro che in C++ è sufficiente utilizzare l’oggetto di output a schermo, cout.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

void stampa_preorder(albin root)
{
  // Stampa in preorder
  if (!test_vuoto(root))
  {
    printf ("%i ",dato(root));
    stampa_preorder(f_sinistro(root));
    stampa_preorder(f_destro(root));
  }
}
 
void stampa_inorder(albin root)
{
  // Stampa in inorder
  if (!test_vuoto(root))
  {
    stampa_inorder(f_sinistro(root));
    printf ("%i ",dato(root));
    stampa_inorder(f_destro(root));
  }
}
 
void stampa_postorder(albin root)
{
  // Stampa in postorder
  if (!test_vuoto(root))
  {
    stampa_postorder(f_sinistro(root));
    stampa_postorder(f_destro(root));
    printf ("%i ",dato(root));
  }
}

Come si nota, per ottenere le tre diverse visite, è sufficiente scambiare l’ordine delle tre istruzioni visita-attraversa-attraversa.

Visita generica dell’albero binario

Quello che vogliamo ottenere adesso è visitare l’albero binario, quindi come abbiamo fatto nel paragrafo precedente, ma non per stampare semplicemente i campi informativi. Vogliamo adesso che anche l’azione da eseguire sul nodo visitato possa essere specificata come parametro della funzione. Si tratta soltanto di passare un puntatore a funzione che definisca cosa fare con il dato del nodo.
Possiamo per prima cosa definire un puntatore generico ad una funzione, come segue:

typedef int (*funz)(int);

Abbiamo definito il tipo di puntatore con il nome funz. La funzione accetterà un parametro intero e restituirà un intero.
Ecco adesso come possono essere trasformate le visite utilizzando i puntatori a funzione.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

void visita_preorder(albin root, funz f)
{
  // Visita in preorder
  if (!test_vuoto(root))
  {
    imposta_dato(root,f(dato(root)));
    visita_preorder(f_sinistro(root),f);
    visita_preorder(f_destro(root),f);
  }
}
 
void visita_inorder(albin root, funz f)
{
  // Visita in inorder
  if (!test_vuoto(root))
  {
    visita_inorder(f_sinistro(root),f);
    imposta_dato(root,f(dato(root)));
    visita_inorder(f_destro(root),f);
  }
}
 
void visita_postorder(albin root, funz f)
{
  // Visita in postorder
  if (!test_vuoto(root))
  {
    visita_postorder(f_sinistro(root),f);
    visita_postorder(f_destro(root),f);
    imposta_dato(root,f(dato(root)));
  }
}

Il codice risultante è decisamente meno comprensibile, ma sicuramente è adattabile a situazioni differenti. Con il puntatore a funzione, possiamo infatti fare qualsiasi cosa, dal cambiare il valore del nodo, a scriverlo su file e così via. Da notare che il risultato di f(x) viene salvato come nuovo valore del nodo, quindi la funzione dovrà provvedere a restituire un valore sensato al termine della propria esecuzione.
Supponiamo di voler decrementare di una unità tutti i nodi di un albero: sarà sufficiente utilizzare un qualsiasi attraversamento, passando come puntatore una funzione che, ricevuto un intero x, lo restituisce decrementato.
Molti altri algoritmi potrebbero essere riadattati utilizzando questo puntatore a funzione, ma visto che i puntatori a funzione non sono un concetto noto a tutti continueremo a presentare tutti gli algoritmi in maniera classica, senza ricorrere alle versioni con puntatore a funzione.

Creazione dell’albero binario

Esistono diversi modi per creare un albero binario: il primo è quello di creare un albero binario di ricerca, in cui gli inserimenti sono semplici e immediati da fare, l’altra prevede invece la lettura di tutti i nodi dall’utente, supponendo di avere un carattere particolare per indicare un nodo vuoto.
Partiamo con la creazione del BST. Per creare un BST sarà sufficiente scorrere l’albero, procedendo a destra o a sinistra a seconda che l’elemento da inserire sia maggiore o minore di quello attualmente in esame.
Il codice dell’inserimento è il seguente.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

albin creaBST (albin root, int x)
{
  // Crea l'albero binario di ricerca
  if (test_vuoto(root))
  {
    // Creo il nodo
    root = new nodo;
    imposta_dato(root,x);
    imposta_sinistro(root,albero_vuoto());
    imposta_destro(root,albero_vuoto());
  }
  else
    if (x < dato(root))
      // Inserisco a sinistra
      imposta_sinistro (root,creaBST(f_sinistro(root),x));
    else
      if (x > root->dato)
        // Inserisco a destra
        imposta_destro(root,creaBST(f_destro(root),x));
      else
        // Errore, elemento duplicato
        return NULL;
  // Restituisco il nodo
  return root;
}

La funzione riceve in ingresso la radice del BST e un numero da inserirvi, quindi provvede al giusto posizionamento.
A questo punto, per creare un BST sarà sufficiente leggere i valori da inserire e utilizzare questa funzione per inserirli in un albero inizialmente vuoto. E’ chiaro che la forma del BST sarà alterata dall’ordine in cui sono inseriti i numeri. L’unica cosa di cui siamo sicuri è che, leggendo il BST in ordine simmetrico, avremo sempre i dati ordinati in modo crescente.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

#include <iostream>
#include <cstdlib>
 
#ifndef EXIT_SUCCESS
#define EXIT_SUCCESS 0
#endif
 
#ifndef EXIT_FAILURE
#define EXIT_FAILURE 1
#endif
 
struct nodo {
  // Campi informativi
  int dato;
  // Puntatori ai prossimi nodi
  nodo*  sin;
  nodo*  des;
};
 
// Definizione del tipo puntatore
typedef nodo* albin;
 
// Definizione di puntatore a funzione che riceve un parametro intero
typedef int (*funz)(int);
 
// Funzioni di base
bool test_vuoto(albin);
albin f_sinistro(albin);
albin f_destro(albin);
int dato(albin);
albin albero_vuoto();
 
// Modifica dei figli sinistro e destro
bool imposta_sinistro(albin,albin);
bool imposta_destro(albin,albin);
void imposta_radice(albin*,albin);
 
// Imposta il dato
bool imposta_dato(albin,int);
 
// Attraversanenti
void stampa_preorder(albin);
void stampa_inorder(albin);
void stampa_postorder(albin);
 
// Creazione dell'albero
albin creaBST(albin,int);
 
int main()
{
  // Creo l'albero vuoto
  albin roo;
  imposta_radice (&root, albero_vuoto());
 
  // Dato da leggere
  int n;
 
  // Leggo il BST
  do {
    cout << "Valore da inserire (0 per terminare): ";
    scanf("%i",&n);
    if (n != 0)
      imposta_radice (&root, creaBST(root,n));
  } while (n != 0);
 
  // Stampa anticipata
  printf ("Preorder:    ");
  stampa_preorder(root);
  printf ("\r\n");
 
  // Stampa simmetrica
  printf ("Inorder:     ");
  stampa_inorder(root);
  printf ("\r\n");
 
  // Stampa posticipata
  printf ("Postoridine: ");
  stampa_postorder(root);
  printf ("\r\n");
 
  // Fine del programma
  system ("pause");
  return EXIT_SUCCESS;  
}

Il metodo utilizzato per uscire dal ciclo è un valore sentinella, ma sarebbe stato possibile utilizzare anche un altro metodo: chiedere il numero di nodi da inserire, oppure chiedere se si desidera inserire un nuovo nodo alla fine di ogni iterazione.

Questo metodo di lettura è comodo e veloce, però non permette di “disegnare” l’albero come uno vorrebbe, stabilendo per ogni nodo i propri figli. A questo punto sorge la necessità di leggere l’albero nel secondo modo presentato. Pensando all’algoritmo in modo ricorsivo sarà tutto più facile

1. Leggo una stringa
2. 1. Se la stringa è un “.” allora inserisco nel nodo corrente NULL
   2. Altrimenti inserisco l’informazione nel nodo corrente e analizzo il sottoalbero sinistro e destro.

A questo punto la funzione non dovrebbe risultare troppo complessa da scrivere. E’ chiaro che questo tipo di algoritmo simula una lettura in preorder. Del resto, come abbiamo già visto, per realizzare altri tipi di lettura, non sarà necessario altro che l’inversione dell’ordine delle istruzioni.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

albin creaAB (albin root)
{
  // Crea l'albero leggendo i dati in ordine anticipato
  // (. = NULL)
  char str[11];
  scanf("%s",str);
  if (str[0] == '.')
  {
    imposta_radice (&root, albero_vuoto());
  }
  else
  {
    int num = atoi(str);
    imposta_radice (&root, new nodo);
    imposta_dato (root,num);
    imposta_sinistro(root,creaAB(f_sinistro(root)));
    imposta_destro(root,creaAB(f_destro(root)));
  }
  return root;
}

Notare che questa funzione non necessita del supporto di alcun ciclo: per la corretta lettura dell’albero, saranno sufficienti le istruzioni.

Questo metodo richiede più tempo e attenzione, visto che per ogni foglia è necessario inserire due volte il carattere '.', scelto come sentinella, ma almeno permette un controllo totale sul design dell'albero.

Se, nel complesso, inseriamo la sequenza
5 4 3 . . 5 . . 6 . 9 7 . . 2 . .
avremo l’equivalente dell’albero
Albero binario generato da una stringa
Calcolo dei parametri dell’albero
Abbiamo visto come creare e attraversare un albero, adesso vedremo come calcolarne i parametri, quali altezza, numero di nodi, numero di foglie ecc.

Il primo problema che ci poniamo è calcolare il numero totale dei nodi presenti nell’albero: ragionando ricorsivamente, possiamo dire che il numero di nodi è uguale a 1 (radice) sommato al numero di nodi del sottoalbero sinistro e a quello del sottoalbero destro, a patto ovviamente che la radice non sia un insieme vuoto.

1
2
3
4
5
6
7
int contaNodi (albin root)
{
  // Conta i nodi
  if (!test_vuoto(root))
    return 1 + contaNodi(f_sinistro(root)) + contaNodi(f_destro(root));
  return 0;
}

Il secondo problema è quello di contare le foglie, ossia i nodi che non hanno figli: se il nodo in esame è una foglia, restituiamo 1, altrimenti sommiamo il numero di foglie del sottoalbero sinistro e quelle del sottoalbero destro.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int contaFoglie (albin root)
{
  // Conta le foglie
  if (test_vuoto(root))
  {
    // Albero vuoto
    return 0;
  }
 
  if (test_vuoto(f_sinistro(root)) && test_vuoto(f_destro(root)))
    // Il nodo attuale è una foglia
    return 1;
 
  return contaFoglie(f_sinistro(root)) + contaFoglie(f_destro(root));
}

E’ chiaro che, se volessimo calcolare il numero di nodi interni, avremo almeno due strade:

Fare la differenza tra il numero totale di nodi e il numero di foglie
Calcolare il numero di nodi interni utilizzando lo stesso metodo utilizzato per le foglie ma restituendo 1 non quando viene trovata una foglia, ma quando non viene trovata. 

Il prossimo problema che vogliamo risolvere è quello di calcolare la profondità di un albero binario: come già detto, il processo ricorsivo è abbastanza intuitivo. Se l’albero non è vuoto, l’altezza è data dal massimo livello dei due sottoalberi incrementato di 1. Se l’albero è vuoto, l’altezza è -1. Se la radice è una foglia, l’altezza è 0.

1
2
3
4
5
6
7
8
9
int altezza (albin root)
{
  // Altezza dell'albero (RADICE => 0)
  if (test_vuoto(root))
    return -1;
  int ls = altezza(f_sinistro(root));
  int ld = altezza(f_destro(root));
  return ls > ld ? 1 + ls : 1 + ld;
}

Stampe dei livelli
bbiamo visto come stampare gli alberi utilizzando uno qualsiasi dei metodi di attraversamento. Adesso ci poniamo un obiettivo leggermente superiore: per ogni nodo, oltre al campo informativo, vogliamo stampare anche il livello.

Il metodo più semplice è modificare leggermente le funzioni di stampa aggiungendo una variabile static che viene modificata in modo da contenere sempre il livello esatto. Se non si vuole usare una variabile static, sarà sufficiente aggiungere alla funzione un nuovo parametro, di tipo intero, passato sempre per indirizzo.

E’ chiaro che, utilizzando il valore del livello, possiamo realizzare anche l’effetto di “stampa indentata” dell’albero.

L’esempio più semplice è quello di stampa anticipata.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void stampa_liv_preorder (albin root)
{
  static int l = 0;
  if (!test_vuoto(root))
  {
    for (int i = 0; i < l; i++)
      printf("  ");
    printf ("[L%i] %i\r\n",l,dato(root));
    l++;
    stampa_liv_preorder(f_sinistro(root));
    stampa_liv_preorder(f_destro(root));
    l--;
  }
}

]]>
			http://www.andrea-asta.com/techworld/2008/10/alberi-binari-parte-1/feed/
		
		
		
		http://www.andrea-asta.com/techworld/2008/10/partono-i-lavori-per-il-nuovo-portfolio/
		http://www.andrea-asta.com/techworld/2008/10/partono-i-lavori-per-il-nuovo-portfolio/#comments
		Sat, 25 Oct 2008 11:25:29 +0000
		Andrea Asta
		
		

		http://www.andrea-asta.com/techworld/?p=31
		
			Dopo tanto tempo lontano dall’informatica e dalle scienze, ho pensato fosse il caso di dare una spolveratina ai miei vecchi lavori e mettere su il nuovo portfolio. Dopo diverse meditazioni, ho deciso di buttarmi su WordPress, lo stesso sistema che già uso per Volley World. Le motivazioni sono molteplici, ma partono tutte dal presupposto che ormai, con tutti gli standard esistenti e tutte le buone regole di programmazione ed accessibilità, ritengo non sia più conveniente creare un sito standard da zero.

Mi spiego: se non ho esigenze particolari (come può essere, per l’appunto, il caso di un portfolio), creare un sito da zero richiede oggi molto più tempo di quanto ne richiedeva una decina di anni fa. Allora bastava aprire il proprio editor preferito, inserire due o tre tabelle, qualche gif animata e tutto era pronto. Adesso bisogna rispettare gli standard, è consigliabile utilizzare fogli di stile, bisogna validare il codice, provarlo con diversi browser e diverse versioni. In più, per dare un senso a ciò che si sta facendo, è bene non trascurare le regole per la reperibilità dei motori di ricerca, sfruttare sistemi XML (quali possono essere i feed RSS e le SiteMap) e, insomma, avere la voglia e il tempo di creare un progetto solido e robusto. Non dimentichiamo, infine, l’importanza basilare dell’utilizzo “sensato” di linguaggi lato server e database, che fanno crescere esponenzialmente la complessità dei propri problemi (si pensi, banalmente, ad un sito web gestito da 2-3 persone, che richiede quindi la creazione di un pannello amministrativo con, magari, tre livelli di accesso). Orbene, ce n’è davvero l’esigenza? L’utente moderno cerca il contenuto o il sito fatto in casa? Sinceramente, credo che ormai non sia più così divertente e fruttifero creare un sito web standard da zero. I CMS esistono e hanno successo proprio per questo motivo.
Si pongono poi problemi etici e egocentristi, del tipo: “I CMS li usa chi non sa fare i siti, io che sono capace me lo faccio da solo“. Ma il punto di riflessione è sempre lo stesso: ce n’è veramente il bisogno? All’utente interessa veramente? E’ lo stesso spirito con cui, ad oggi, non conviene più riscriversi le proprie funzioni, all’interno di un programma, da soli. Se esistono e sono disponibili, utilizziamole! Non è forse questa la filosofia dei recenti linguaggi di progrmamazione, quali Java o C#?
Siamo quindi al punto cruciale: esistono ancora siti che vale la pena programmare? La risposta è sì. Ma con cautela. Nel senso, io mi metto a scrivere codice da zero solo quando sono sicuro che ciò che sto facendo è veramente innovativo. E’ questo il succo di tutto. Io studio, raccolgo materiale, riutilizzo codice degli altri al puro scopo di innovare. L’innovazione è, a mio avviso, il vero step che serve all’informatica. Lavorare su progetti nuovi ed interessanti. Ad esempio, lavoro da più di un anno ad un sito web (che andrebbe definito come Web-Application) per allenatori di pallavolo, il Volley Coaching System. Valeva la pena programmarlo da zero? Certamente! Perché, banalmente, tutto ciò che è quel progetto non esiste altrove.
Fatte queste premesse, ripartiamo: nei prossimi giorni, settimane, mesi, tenterò di ripristinare il vecchio materiale e di inserirne di nuovo. Nel frattempo, buona navigazione.
]]>
			http://www.andrea-asta.com/techworld/2008/10/partono-i-lavori-per-il-nuovo-portfolio/feed/