1

SOFTWARE: applicazioni.
HARDWARE: dispositivi fisici che compongono il calcolatore.
Il software specifica operazioni che vengono eseguite dall’hardware.

Architettura Esterna (Hardware)

- Unità Centrale: Processore, Memoria di lavoro (memoria RAM);
- Dispositivi di Uscita: Monitor, Casse audio, Stampanti;
- Dispositivi di Ingresso: Tastiera, Mouse;
- Memorie di Massa: Disco Rigido, Dischi Floppy, CD/DVD;

ARCHITETTURA DI VON NEUMANN

L’architettura Interna è l’architettura dei componenti dell’unità centrale. L’architettura di
“Von Neumann” è l’architettura di tutti i calcolatori moderni (dagli anni 50 ad oggi) ed è
composta da tre componenti fondamentali: processore, memoria RAM e interfacce delle
periferiche.
- Schema di funzionamento:
1) il processore acquisisce dati dalle periferiche di ingresso o da una memoria di massa
2) li memorizza nella memoria RAM
3) accede alla RAM ed effettua operazioni
4) scrive i risultati nella RAM, invia i risultati alle periferiche di uscita
5) trasferisce i dati permanentemente sulle memorie di massa

PROCESSORE: o CPU (“Central Processing Unit”), è il circuito integrato che effettua i calcoli
ed è responsabile di tutte le operazioni. Legge e scrive dati dalla memoria RAM, effettua
operazioni aritmetiche ed è in grado di pilotare le periferiche.

INTERFACCE VERSO LE PERIFERICHE: sono i circuiti a cui sono connesse le periferiche,

hanno memorie di massa e possono essere dispositivi di ingresso o uscita.
Il processore comanda l’interfaccia e l’interfaccia si occupa di gestire la comunicazione con
la periferica.

MEMORIA RAM: o “Random Access Memory” è la memoria di lavoro per il processore,

consiste in un circuito elettronico capace di mantenere uno stato in presenza di
alimentazione e che memorizza lo stato di segnali elettrici.
È volatile, perde lo stato in assenza di tensione.
Le elaborazioni del processore avvengono esclusivamente su dati nella RAM.

ORGANIZZAZIONE DELLA RAM

La RAM è composta di numerosi circuiti (celle), ciascuno capaci di memorizzare un bit di
informazione. Il Bit (“Binary Digit”) e un’unità di memorizzazione per il calcolatore, può
valere 1 oppure 0 ed è facilmente rappresentabile con un segnale elettrico. Tutte le
informazioni sono rappresentate attraverso sequenze di bit.
Con un bit: due numeri (0 e 1) (21)
Con due bit: quattro numeri (00, 01, 10, 11) (22)
Con tre bit: otto numeri (000, 001, 010, ..., 110, 111) (23)
Per rappresentare 1.000.000 di numeri servono 20 bit (220)

UNITà DI MISURA DELLA MEMORIA

- Bit: 0/1
- Byte: 8 bit, unità convenzionale di riferimento.
- KiloByte: 210 byte (1024 byte), 1024x8 bit = 8192 bit
- MegaByte: 220 byte (1 milione di byte), circa 8 milioni di bit
- GigaByte: 230 byte (1 miliardo di byte), circa 8 miliardi di bit

Struttura della RAM: bit organizzati in registri

Registro: 16, 32 o 64 bit, ogni registro ha un suo indirizzo
Es: 4GByte di RAM: 4 miliardi di byte, 1 miliardo di registri da 32 bit (2 30 registri)

Rappresentazione delle Informazioni

- Codifica (o Codice): insieme di regole per rappresentare oggetti con altri oggetti in questo
caso: lettere, numeri, immagini ecc., attraverso sequenze di bit.
- Interazione con il calcolatore: l’utente ha l’impressione di lavorare con oggetti familiari
(parole, cifre, ecc.), è una rappresentazione interna in forma di bit.

Rappresentazione dei Numeri

- Rappresentazione dei num. interi positivi: rappresentazione posizionale in base 2.
È semplice (simile a quella dei numeri decimali): ogni bit è una cifra.
- Rappresentazione dei num. interi relativi: codifica in “complemento a 2”.
Ha regole complesse.
- Rappresentazione dei numeri reali: codifica in “virgola mobile”.
Il numero viene rappresentato attraverso due altri numeri mantissa ed esponente: N = m2 e,
con 1 <= m < 2. Alcuni numeri reali non possono essere rappresentati in modo esatto.
In particolare, la rappresentazione in virgola mobile consente di rappresentare solo un
numero fissato di cifre decimali. Alcuni numeri (es: 1/3) devono essere approssimati
“troncando” le cifre decimali.

Rappresentazione dei Caratteri

- Codice ASCII a 7 bit: al carattere è associato un numero tra 0 e 127 e la rappresentazione
del carattere coincide con quella del numero. Vale anche per le cifre (0-9) ed i caratteri
speciali (es: +). Il limite del codice ASCII a 7 bit è il numero di caratteri rappresentabili molto
basso (non include lettere accentate). ‘A’->65-> 1000001 ‘0’->48->0011000
- Codice ASCII a 8 bit (“Extended ASCII”): al carattere è associato un num. tra 0 e 255. È
maggiore il numero di caratteri rappresentabili rispetto a quello a 7 bit
Linguaggi di Programmazione
Sono i linguaggi per impartire istruzioni al processore.
Il programma è una sequenza di istruzioni, normalmente pensato per risolvere un
problema
di calcolo. Al programma
vengono forniti dei dati,
calcola eseguendo le
istruzioni e restituisce i
risultati. Esistono
numerosi linguaggi,
differenti per funzionalità
e tecnologia.

Sintassi
È la “grammatica” del linguaggio, l’insieme delle regole che stabiliscono quali programmi
sono corretti. Es.: In italiano: “maiuscola dopo il punto”, in C++: “le istruzioni si concludono
con “;”. La correttezza sintattica consiste in assenza di errori sintattici e il programma è
eseguibile. Viene verificata dal compilatore o dall’interprete e consente di eliminare gli
errori sintattici.

Semantica
È il “significato” del linguaggio, l’insieme delle regole che stabiliscono come il calcolatore
esegue i programmi corretti. Es.: in italiano: “andrò è un’azione nel futuro”, in C++: cout <<
“Ciao”; . La correttezza semantica (o Logica) implica la correttezza sintattica e il programma
risolve correttamente il problema. Viene verificata dall’esecuzione e “test” del
programma, con prove di funzionamento per controllare che il programma si comporti
correttamente.

Il Concetto di Algoritmo
Il punto di partenza è la descrizione del problema. Il punto di arrivo è l’applicazione
correttamente funzionante. Un passo intermedio fondamentale è concepire una strategia
per la soluzione del problema. L’algoritmo è la strategia per la soluzione del problema, è
una procedura di calcolo che serve a risolvere un problema.

Ciclo di Vita di un Programma

Avendo concepito l’algoritmo è possibile procedere alla scrittura del codice.
Codice sorgente: istruzioni del linguaggio di programmazione.
Linguaggio macchina: linguaggio di comandi eseguibili dal processore.
Un passo cruciale è la trasformazione del codice sorgente in codice oggetto.
Esistono due approcci: compilazione del codice sorgente (richiede l’utilizzo di uno
strumento chiamato compilatore) oppure l’interpretazione del codice sorgente (richiede
l’utilizzo di uno strumento chiamato interprete).
Compilazione del Codice Sorgente
Processo di compilazione: Si verifica la correttezza sintattica che trasforma il codice
sorgente in codice “oggetto”.
Processo di collegamento: collega il codice oggetto a quello delle “librerie” esterne e
produce il codice eseguibile completo dell’applicazione.
Il processo di compilazione è di gran lunga il più diffuso tra i linguaggi di programmazione, i
vantaggi principali sono che il compilatore individua subito gli errori sintattici e inoltre il
codice può essere ottimizzato per l’esecuzione rapida sulla macchina.
Ma ci sono alcuni svantaggi, il processo di verifica del codice è meno immediato.

Interpretazione del codice sorgente

Un processo molto più immediato è l’interpretazione del codice. Il codice viene scritto
all’interno di uno strumento apposito, detto interprete che ovviamente supporta anche le
funzioni di scrittura e fornisce un comando “Esegui” oppure “Run”.
All’esecuzione del comando “Run” l’interprete analizza le istruzioni una per una, a partire
dalla prima, traduce ciascuna istruzione in linguaggio macchina e chiede al processore di
eseguirla poi passa all’istruzione successiva. Il collegamento avviene tipicamente in modo
dinamico, ovvero ogni volta che un’istruzione del codice lo richiede. Al momento
dell’esecuzione di quella istruzione, l’interprete localizza la libreria esterna e la collega al
codice dell’applicazione per eseguirla.

In un linguaggio compilato la trasformazione del codice sorgente in linguaggio macchina

viene fatta tutta assieme prima dell’esecuzione, il codice non può essere eseguito se
contiene errori sintattici.
In un linguaggio interpretato la trasformazione del codice sorgente in linguaggio macchina
viene fatta istruzione per istruzione durante l’esecuzione, il codice può essere eseguito
anche se contiene errori sintattici. In questo caso l’esecuzione comincia e poi si
interrompe al momento in cui viene incontrata l’istruzione sintatticamente scorretta.

Un Linguaggio Compilato: C/C++

- Scrittura del programma: editor di codice (es: Notepad++ o TextMate);
- Compilatore e Linker: compilatore MinGw – e relativo linker, si utilizzano dal Prompt dei
Comandi. Oppure si può utilizzare un Ambiente Integrato di Sviluppo (IDE).
- Code::Blocks è un IDE open-source gratuito multi-piattaforma.
- Xcode: IDE Apple: Scaricabile da App Store, supporta diversi linguaggi tra cui C++ ed è una
valida alternativa a Code::Blocks.
- repl.it: un compilatore on-line che consente di scrivere, compilare ed eseguire on-line
programmi in C++. Consente di salvare il programma realizzato. Consente a più
programmatori di collaborare sullo stesso codice sorgente. Il programma realizzato, per
funzionare, ha bisogno di un browser.

Un Linguaggio Interpretato: Matlab

Matlab (MATrix LABoratory) è un ambiente di sviluppo interattivo per il calcolo scientifico
consente agli studenti di utilizzare le principali librerie di calcolo numerico senza dover
programmare in FORTRAN.
2

Elementi Sintattici di Base

Il codice è composto da istruzioni. Le categorie principali di istruzioni sono: direttive al
compilatore, dichiarazioni dei dati, operazioni sui dati e commenti.

DIRETTIVE: sono direttive di inclusione e servono ad “includere” nel programma codice

già scritto, ovvero le librerie. In particolare: #include <iostream>, include il codice relativo
alle operazioni di lettura e stampa dei dati da console.
È necessaria un’operazione di collegamento tra le librerie incluse ed il codice del
programma.

DICHIARAZIONI: servono a specificare il nome ed il tipo delle variabili utilizzate nel

programma e a riservare in memoria lo spazio necessario a contenere il valore assunto dalla
variabile.
Es: const float pigreco = 3.14;
int raggio;
float cerchio, circonf;

OPERAZIONI: possono essere di diverso tipo:

- istruzioni di assegnazione di valori ed
espressioni;
cerchio = raggio * raggio * pigreco;
circonf = 2 * pigreco * raggio;
- Istruzioni di lettura e stampa dei dati.
cout << “Immetti la lungh. del raggio”;
cin >> raggio;

COMMENTI: testi che forniscono informazioni sul programma, ignorati dal compilatore

PROGRAMMA: Funzionamento di base:

- l’utente fornisce dei dati (es: numeri)
- Il programma esegue delle operazioni sui dati
- il programma visualizza i risultati delle
operazioni
Regola sintattica:
- le istruzioni si concludono con “;”
- fanno eccezione le direttive al compilatore

Esecuzione del programma:

- esecuzione delle istruzioni
- le istruzioni vengono eseguite una alla volta
- il programma comincia con la prima istruzione
- termina quando raggiunge la parentesi finale

Dati principali di un programma: costanti e variabili.

Sono contraddistinti da un nome, “identificatore”, e un tipo.

IDENTIFICATORI: sono i nomi assegnati agli oggetti di un programma

Regole sintattiche:
- sequenza composta da lettere e/o cifre e/o dal carattere “underscore” ‘_’:
- il primo carattere è una lettera oppure underscore
- sono sensibili alle maiuscole
- la lunghezza massima dipende dal compilatore ma è opportuno trovare un
compromesso tra leggibilità e lunghezza.
- Gli identificatori riservati sono parole chiave del linguaggio.
La loro funzione è di specificare la natura del dato, ed in particolare: l’insieme dei valori che
il dato può assumere e lo spazio di memoria associato al dato

TIPI DI DATO
- Tipo intero: int (numeri interi)
- Tipo reale: float (numeri reali, precisione singola)
- Tipo reale doppia precisione: double (numeri reali, doppia precisione)
- Tipo carattere: char, le cui variabili rappresentano caratteri come una lettera o una
cifra. I caratteri sono delimitati da ‘a’ Non sono inclusi i simboli estesi, le accentate, e
vale per i singoli caratteri, non per le “stringhe di caratteri”.
- Tipo carattere: string, consente di rappresentare sequenze di caratteri
- Tipo booleano: bool, le cui variabili possono assumere due soli valori: vero, falso, che
sono memorizzate come 0 e 1.

COSTANTI: un dato che assume lo stesso valore per tutta la durata della esecuzione del
programma. Ne esistono due tipi: costanti ordinarie, come numeri, caratteri, stringhe
utilizzati nel programma, e costanti simboliche, ovvero valori costanti a cui viene attribuito
un nome, dichiarate attraverso la parola chiave “const”.
La loro sintassi è: const <tipo> <nome> = <valore>;
Dove:
- <tipo> è uno dei tipi di dato del linguaggio
- <nome> è un identificatore
- <valore> è il valore della costante; deve essere compatibile con il tipo di dati
Il valore viene memorizzato nello spazio di memoria e non può essere cambiato durante
l’esecuzione del programma.

VARIABILI: è un dato che può assumere valori differenti durante l’esecuzione del
programma. Deve essere dichiarata prima di essere utilizzata nel programma.
La loro sintassi è: <tipo> <nome>;
Dove:
- <tipo> è uno dei tipi di dato del linguaggio;
 - <nomi> sono identificatori distinti.
Per usare una variabile è necessario attribuirle un valore iniziale, con un’operazione di
inizializzazione. È possibile effettuare l’inizializzazione assieme alla dichiarazione.
La sintassi è: <tipo> <nome> = <valore>;

OVERFLOW: l'overflow è un fenomeno che si verifica quando il risultato di un'operazione

supera la capacità di rappresentazione di un tipo di dato.

Istruzione di Assegnazione in C++

Assegnare un valore ad una variabile:
- primo modo: istruzione di assegnazione
- secondo modo: lettura del valore da un dispositivo esterno (es: tastiera o file)
Le istruzioni di assegnazione sono le funzionalità essenziali di ogni linguaggio e servono ad
effettuare calcoli e a conservare i risultati nelle variabili.
Due elementi principali:
- identificatore della variabile (parte sinistra)
- espressione (parte destra)
Sintassi: <nomeVariabile> = <espressione>;
Dove:
- <nomeVariabile> è un identificatore,
- = è l’operatore di assegnazione,
- <espressione> è una formula per il calcolo di un valore.
Semantica “operazionale”: descrive le operazioni effettuate dal processore per eseguire
l’istruzione, per interpretare le istruzioni è necessario attenersi alla semantica operazionale.
Viene calcolato il valore dell’espressione a partire dai valori delle costanti e delle variabili, se
il valore risultante è compatibile con il tipo della variabile, viene assegnato alla variabile,
altrimenti si genera un errore.

ESPRESSIONI: sono composte da operandi e operatori.

Operandi: costanti e variabili.
Operatori: operatori predefiniti e funzioni predefinite.
Operatori Predefiniti:
- Operatori aritmetici: tipo intero e tipo reale
Tipo Intero: operatori: +, - , *, / , %
Tipo Reale: operatori: +, - , *, /
++ incremento; a++ coincide con a = a+1
-- decremento; a-- coincide con a = a-1;
+= a += b coincide con a = a + b
-= a -= b coincide con a = a - b
*= a *= b coincide con a = a * b
/= a /= b coincide con a = a / b
- Operatori booleani: tipo bool;
Operatore logico AND (&&): Restituisce true se entrambi gli operandi sono true,
altrimenti restituisce false.
 Operatore logico OR (||): Restituisce true se almeno uno dei due operandi è true,
altrimenti restituisce false.
Operatore logico NOT (!): Restituisce l'opposto del valore dell'operando, ovvero true
se l'operando è false e viceversa.
- Operatori di confronto: per tutti i tipi, il loro risultato non è un numero, un carattere,
o una stringa, ma un valore vero o falso.
Operatori: ==, !=, >, >=, <, <=, confrontano due operandi di tipo compatibile e
restituiscono un valore booleano.
Funzioni predefinte
Funzioni ad argomenti interi e risultato intero
Funzioni ad arg. numerici e risultato reale:
radice quadrata di x: sqrt(x)
valore assoluto di x: fabs(x)
elevamento a potenza xy : pow(x,y)
esponenziale ex: exp(x)
seno di x: sin(x)
coseno di x: cos(x)
arcotangente di x: atan(x)
Per utilizzare le funzioni predefinite è necessario includere la libreria cmath ( #include
<cmath>)

Operatore di Cast
L'operatore di cast viene utilizzato per convertire un tipo di dato in un altro tipo di dato.
Sintassi: (<tipo>)<valore>
Semantica: il processore trasforma la rappresentazione in memoria del <valore> nella
corrispondente rappresentazione del <tipo> specificato, il risultato dell’applicazione
dell’operatore di cast è un valore del <tipo> specificato.

ISTRUZIONI DI STAMPA: servono per visualizzare i valori delle variabili sui dispositivi di
uscita.
ISTRUZIONI DI LETTURA: servono per acquisire i valori delle variabili dai dispositivi di
ingresso.
Ci sono due tipi di FLUSSO:
- il flusso di uscita, che invia i dati al dispositivo di uscita,
- il flusso di ingresso, che riceve i dati dal dispositivo di ingresso.
I programmi hanno due flussi predefiniti: lo standard output (per la stampa) e lo standard
input (per la lettura).
È possibile stampare dati sullo schermo o su file e leggere dati dalla tastiera o da file.
In C++, per stampare su console si utilizza l'oggetto "cout" e l'operatore "<<" mentre per
leggere dalla tastiera si utilizza l'oggetto "cin" e l'operatore ">>". La sintassi per la stampa è
"cout << argomento;" e per la lettura è "cin >> variabile;".
Durante la lettura, il flusso viene analizzato in base a un formato specificato e i dati vengono
memorizzati temporaneamente in un buffer prima di essere copiati nel flusso. Sono presenti
anche caratteri speciali come spazio, fine riga e tabulatore che possono essere utilizzati per
formattare le stampe. Tuttavia, è importante fare attenzione agli errori durante la lettura,
poiché possono verificarsi condizioni inaspettate che influenzano i valori delle variabili.

String
È una sequenza di caratteri racchiusa tra “ “. È diverso dal il tipo char, che è un singolo
carattere (tra apici singoli).
Sintassi ordinaria: string <nomeVar>; string <nomeVar1>, <nomeVar2>; string <nomeVar> =
<valoreIniziale>;
Semantica: alla variabile viene assegnato uno spazio nella memoria, lo spazio dipende dalla
lunghezza della stringa. La stringa ha un numero di caratteri contenuti. Inizialmente la
stringa viene considerata di lunghezza 0, successivamente viene occupato lo spazio di
memoria necessario per rappresentare il valore.

Operatori sulle stringhe

Esistono operatori predefiniti sulle stringhe e funzioni predefinite sulle stringhe.

Accesso ai caratteri: s[i]. Estrae il carattere in posizione i

dalla stringa, il primo carattere è in posizione 0.

Concatenazione: +, concatena il valore di due stringhe.

Confronti: confrontano i valori di due stringhe.

Funzioni predefinite
Sintassi particolare: <stringa>.<funzione>, es: string s; s.size();
- s.size(): calcola la lunghezza della stringa
- s.insert(x, s1): inserimento di una stringa in un’altra
- s.erase(x, y): cancellazione di una sottostringa
- s.substr(x, y): estrazione di una sottostringa
- s.find(s1): ricerca della posizione di una sottostringa
- s.replace(x, y, s1): sostituzione di una sottostringa con un’altra

Per quanto riguarda la stampa delle stringhe, è possibile farlo in modo ordinario utilizzando
l'operatore "<<". Per quanto riguarda la lettura delle stringhe, è consigliabile evitare
l'utilizzo dell'istruzione "cin >>" per l'input formattato. Questo perché l'input formattato
elimina gli spazi che possono essere rilevanti nelle stringhe. Invece, si utilizza un approccio
diverso, in cui l'input non viene formattato.
Per la lettura di una riga di caratteri non formattata, si utilizza l'istruzione "getline(<flusso>,
<stringa>)". In questa sintassi, "<stringa>" rappresenta una variabile di tipo string, mentre
"<flusso>" rappresenta il flusso da cui leggere, ad esempio "cin".
In breve, per leggere una riga di caratteri non formattata si utilizza l'istruzione
"getline(<flusso>, <stringa>)", mentre per stampare una stringa si utilizza l'operatore "<<".
3

STRUTTURE DI CONTROLLO: sono le istruzioni per eseguire o meno una porzione di

programma, oppure per ripetere più volte l’esecuzione di una porzione di programma a
seconda che una opportuna condizione sia verificata o meno.
Le due tipologie di strutture di controllo sono le istruzioni condizionali e le istruzioni
iterative o "cicli". Queste strutture hanno una semantica diversa ma entrambe sono
composte da due componenti fondamentali: la condizione e uno o più blocchi di istruzioni.
Condizione: Espressione che assume valori booleani. Serve a controllare se durante
l’esecuzione del programma si verificano opportune circostanze.

BLOCCO: sequenza di istruzioni tra parentesi graffe.

Sintatticamente un blocco è fatto di un’unica istruzione può essere, scritto anche senza
parentesi.

Strutture condizionali: Consentono di eseguire un blocco di istruzioni, a seconda del valore

vero o falso della condizione
if (<condizione>)
<blocco1>
else
<blocco2>
Strutture iterative o Cicli: consentono di ripetere l’esecuzione di un blocco di istruzioni più
volte finché la condizione è verificata.
Due forme
- while (<condizione>)
<blocco>
- for (<espressioni>)
<blocco>

Istruzione if-then-else: esecuzione di blocco di codice oppure di un altro a seconda che una
condizione sia vera o falsa
La Sintassi: if (<condizione>)
<blocco1>
else
<blocco2>
Dove:
- <condizione> è una espressione con valore booleano
- <blocco1> e <blocco2> blocchi di istruzioni
Semantica: se il valore dell’espressione è true si esegue <blocco1>, se il valore
dell’espressione è false si esegue <blocco2>, in entrambi i casi l’esecuzione procede con
l’istruzione immediatamente successiva.
Istruzione if-then: esecuzione di un blocco di codice se la condizione è vera, altrimenti
nessun effetto.
La sintassi: if (<condizione>)
<blocco>
Semantica: se la condizione è vera viene eseguito il blocco e poi si prosegue con l’istruzione
successiva, se la condizione è falsa si prosegue direttamente con l’istruzione successiva
(NON viene eseguita alcuna istruzione).

Istruzioni Condizionali Nidificate

Nidificazione: le istruzioni che seguono l’if e/o l’else possono essere istruzioni qualsiasi, in
particolare, possono essere a loro volta istruzioni condizionali e il processo può essere
ripetuto a molti livelli.

Istruzioni Iterative o “Cicli”

Le istruzioni iterative o "cicli" consentono di eseguire ripetutamente una porzione di
programma finché una condizione opportuna è verificata. Quando la condizione non è più
verificata, l'esecuzione si interrompe e si procede con le istruzioni successive.
Le parti fondamentali di un ciclo sono il "corpo del ciclo", che consiste nelle istruzioni da
ripetere, e la "condizione del ciclo", che regola l'esecuzione del ciclo.
Il corpo del ciclo può essere costituito da un'istruzione semplice o da un blocco di istruzioni.
La condizione del ciclo è un'espressione che restituisce un valore booleano.
Nei linguaggi procedurali, sono disponibili due istruzioni di ciclo: il "ciclo while" e il "ciclo
for".
È importante prestare attenzione nello studio dei cicli. Il ciclo while è relativamente
semplice da comprendere dal punto di vista semantico, ma può essere difficile utilizzarlo
correttamente in pratica. Il ciclo for, invece, ha una semantica leggermente più articolata,
ma è più semplice da utilizzare nella pratica.

Tipologie di Iterazione
Ci sono due tipologie di iterazione che vengono comunemente utilizzate nelle applicazioni:
l'iterazione aperta e l'iterazione chiusa (o a conteggio). Queste tipologie corrispondono a
esigenze diverse di programmazione.
- L'iterazione aperta si verifica quando non è possibile stabilire a priori quante volte
dovranno essere eseguite le operazioni da ripetere. Il numero di ripetizioni dipende dal
valore di una condizione. In questa tipologia di iterazione, potrebbero verificarsi 0 ripetizioni
se la condizione non è verificata fin dall'inizio, oppure potrebbero verificarsi ripetizioni
indefinite se la condizione è sempre verificata.
- L'iterazione chiusa o a conteggio, invece, prevede che il numero di ripetizioni sia noto
prima dell'inizio dell'iterazione. Questo viene realizzato attraverso una tecnica di conteggio
utilizzando una variabile intera per "contare" le ripetizioni. Viene fissato un valore iniziale e
un valore finale per la variabile, e la differenza tra questi due valori corrisponde al numero
di ripetizioni da effettuare. Ad ogni ripetizione, il valore della variabile viene incrementato
fino a quando non raggiunge il valore massimo stabilito.
Istruzione WHILE
Sintassi: while (<condizione>) <corpo>
Dove:
- <condizione> è un’espressione booleana
- <corpo> è un blocco di istruzioni
Semantica: quando viene incontrato il ciclo, viene valutata la condizione. Se la condizione
viene trovata vera viene eseguito il corpo del ciclo
Al termine dell’esecuzione del corpo, si torna in cima e si valuta nuovamente la condizione,
se la condizione viene trovata falsa il ciclo si interrompe e si passa all’istr. successiva.
Ci sono casi in cui il corpo del ciclo non viene mai eseguito; Es: digito dubito 0
C sono casi in cui l’esecuzione può andare avanti indefinitamente; es: non digito mai 0
Possono esserci situazioni di errore e condizioni di ciclo infinito, ovvero un ciclo scritto in
modo tale che la condizione è sempre verificata.
Con il while si possono scrivere anche iterazioni
chiuse.
Tecnica standard per realizzarlo:
- uso una variabile intera (es: i) per “contare”
quante volte il ciclo viene eseguito inizialmente
i = 0 e ad ogni esecuzione i = i + 1
- mi fermo quando i raggiunge il valore massimo

ISTRUZIONE FOR
L’istruzione FOR consente di scrivere in modo più compatto il ciclo, ed in particolare i 3
elementi fondamentali.
Sintassi: for (<e1>; <e2>; <e3>) <corpo>
Dove:
- <e1> è l’inizializzazione della variabile
- <e2> è la condizione del ciclo
- <e3> è l’incremento della variabile
- <corpo> è un blocco di istruzioni
Semantica: è equivalente ad un while.
Più in dettaglio:
- viene eseguita l’inizializzazione (e1)
- viene verificata la condizione (e2)
- se la condizione viene valutata come vera, viene eseguito il corpo
- al termine viene effettuato l’incremento (e3)
- viene valutata di nuovo la condizione
- se la condizione viene valutata come falsa, il ciclo termina e si passa all’istruzione succ.
La variabile del ciclo serve per contare, di conseguenza normalmente è una variabile
intera (tipo int).
Le strutture di controllo possono essere nidificate liberamente.
Tecniche Algoritmiche: rappresentano
soluzioni standard a problemi ricorrenti di
programmazione e un bagaglio di conoscenze
riutilizzabili per il programmatore. (es
contatore esami).
Implica l’utilizzo di una variabile intera (es
numeroEsami) all’interno di un ciclo, la
variabile svolge le funzioni di “contatore”, ha
un valore iniziale pari a 0 ed incrementata ad
ogni nuovo elemento.
Tre operazioni:
- reset del conteggio
- incremento del conteggio
- lettura del valore contato
è la stessa tecnica che viene utilizzata per controllare i cicli a conteggio, anche in quel caso
viene utilizzato un contatore.

Somma con Accumulatore: si usa per calcolare la somma dei valori di una collezione (es:
somma dei voti). Si utilizza una variabile intera all’interno di un ciclo come “accumulatore”.
Inizialmente la variabile vale 0, sommo ogni nuovo valore al valore dell’accumulatore fino a
questo punto.
Come fermare il ciclo quando non deve essere
più eseguito:
- utilizzo di una variabile bandiera (“flag”)
viene utilizzata una variabile booleana
inizializzata a true, il ciclo prosegue finchè la
variabile è vera (la var. è la bandiera che da via
libera al ciclo). Ad ogni nuovo voto si controlla
se l’utente vuole interrompere; in questo caso
la variabile diventa falsa)
- utilizzo della programmazione non
strutturata

Programmazione Non Strutturata

Per semplificare il codice è possibile in alcuni casi
utilizzare uno stile di “programmazione non
strutturata”, in cui i blocchi di istruzioni possono
essere interrotti a metà.
Per farlo ci sono due istruzioni nuove: break e
continue.

Istruzione BREAK: Si usa nelle strutture di controllo

Sintassi: break.
Semantica: interrompe l’esecuzione del corpo del ciclo per proseguire con l’istruzione
successiva.

Istruzione CONTINUE
Sintassi: continue;
Semantica: interrompe l’esecuzione del corpo del ciclo per ritornare in cima e valutare di
nuovo la condizione di uscita.
Differenza con break: non necessariamente termina il ciclo.

4
Sottoprogrammi
Esistono due categorie di sottoprogrammi:
- Funzioni: servono a effettuare calcoli non previsti dalle funzioni predefinite,
restituiscono il risultato del calcolo
- Procedure: servono a eseguire operazioni non previste dalle istruzioni predefinite,
non restituiscono alcun valore
Per usare i sottoprogrammi bisogna per cominciare “definirli” e poi utilizzarli
La definizione di un sottoprogramma descrive il comportamento del sottoprogramma
Un sottoprogramma è un blocco di istruzioni, prevede una serie di “parametri” su cui
eseguire le operazioni specificate. Ai parametri possono essere associati in ogni esecuzione
“argomenti”, ovvero “dati specifici” su cui effettuare concretamente le operazioni.
Dati nei sottoprogrammi:
 costanti
 variabili
 parametri: dati speciali che hanno un legame con argomenti esterni

Definizione della funzione discriminante

Def. della Procedura “leggiEquazione”

Oltre ai parametri, ogni sottoprogramma ha i suoi dati “locali”, ovvero dati dichiarati
all’interno del sottoprogramma, i dati sono “privati” e non utilizzabili dagli altri moduli del
programma.
(costanti locali, variabili locali)
Quando viene incontrata una “chiamata” del sottoprogramma, si interrompe l’esecuzione
del programma e avviene il “passaggio dei parametri”. Si avvia l’esecuzione del
sottoprogramma, al termine dell’esecuzione del sottoprogramma riprende l’esecuzione del
programma.

Come modificare il valore di un argomento nel sottoprogramma?

Il parametro attraverso il quale è possibile modificare il valore dell’argomento. In questi
casi, prima del parametro, è necessario specificare la &.

Definizione di Funzioni
Sintassi: <tipoRisultato> <nome> (<parametri>)
<corpo>
Dove:
- <tipoRisultato> è un tipo di dato
- <nome> è un identificatore
- <parametri> è l’elenco dei parametri
- <corpo> è un blocco di istruzioni
Elenco dei parametri: <tipoP1> <nomeP1>, <tipoP2> <nomeP2>...
Dove:
- <tipoP1>, <tipoP2> ... sono tipi di dato
- <nomeP1>, <nomeP2> ... sono identificatori
Ci possono essere sottoprogrammi che NON hanno parametri, in questo caso si utilizzano le
parentesi vuote ().
Istruzione return: il corpo deve contenerne almeno una
Sintassi: return <espressione>;
Dove:<espressione> deve restituire un valore compatibile con il tipo del risultato
Semantica: l’esecuzione dell’istruzione return interrompe l’esecuzione della funzione.
Funzioni Predefinite: sono quelle già fornite dal linguaggio o da specifiche librerie
Per poterla utilizzare devo conoscere:
- il nome della funzione (sin)
- il numero e il tipo degli argomenti (1 argomento di tipo double)
- il tipo del risultato restituito (double)
Definizione di Procedure
Sintassi: void <nome> (<parametri>)
<corpo>
Dove:
- void è una parola riservata del linguaggio
- <nome> è un identificatore
- <parametri> è l’elenco dei parametri
- <corpo> è un blocco di istruzioni
Parametri standard (o “per valore”): <tipoPar> <nomePar>
Parametri per riferimento: <tipoPar> & <nomePar>
Semantica: i parametri per riferimento possono essere utilizzati per modificare i
corrispondenti argomenti, i parametri standard no
Procedure Predefinite: Sono quelle già fornite dal linguaggio o da specifiche librerie.
Per poterla utilizzare devo conoscere:
- il nome della procedura (getline)
- il numero e il tipo degli argomenti (1 argomento di tipo istream, 1 argomento di tipo
string)
- il fatto che il secondo argomento viene modificato.

Utilizzo delle funzioni: esclusivamente all’interno di espressioni, per calcolare valori.

Utilizzo delle procedure: sotto forma di nuove istruzioni.

Chiamata di Funzioni
Sintassi: <nomeFunzione>(<arg1>, <arg2>,...<argn>)
Dove:
- <nomeFunzione> è il nome della funzione
- <arg1>, <arg2>, ...<argn> sono gli argomenti
Argomenti: espressioni generiche, in particolare costanti simboliche o numeriche, oppure
variabili, devono corrispondere in numero e ordinatamente in tipo con i parametri.
In realtà possono anche essere a loro volta parametri.

Chiamata di Procedure
Sintassi: <nomeProcedura>(<arg1>,<arg2>,...<argn>);
Dove:
- <nomeProcedura> è il nome della procedura
- <arg1>, <arg2>, ...<argn> sono gli argomenti
Argomenti: l’argomento è una variabile del modulo chiamante, oppure è un parametro del
sottoprogramma chiamante.

5
ARRAY: sono funzionalità dei linguaggi di programmazione che consentono di dichiarare con
un’unica istruzione molte variabili dello stesso tipo e di manipolarle in modo più efficace
nelle istruzioni. Gli array consentono di passare tutte le variabili ai sottoprogrammi
attraverso un unico parametro. Inoltre, il meccanismo di nomi consente di
snellire le operazioni utilizzando i cicli (nomi uguali con un indice intero che cambia).
Gli array possono avere molte dimensioni. Gli array ordinari hanno un’unica dimensione
(collezione lineare di variabili) e gli array bidimensionali hanno due dimensioni
(concettualmente: riga e colonna). Possono esistere array con più di due dim.

- Dichiarazione di Array monodimensionali

Sintassi: <tipo> <nomeArray> [<dim>];
Dove:
 <tipo> è uno dei tipi di dato del linguaggio
 <nomeArray> è un identificatore
 <dim> è un valore costante intero positivo (costante numerica o simbolica o
espressione costante, ovvero espressione in cui gli operandi sono costanti)
Semantica: la dichiarazione ha l’effetto di dichiarare <dim> variabili del tipo specificato. Le
variabili sono dette “componenti” dell’array.
I nomi delle variabili sono costituiti di due parti: l’identificatore dell’array <nomeArray> e un
indice intero che va da 0 a <dim>-1. Ovvero: <nomeArray>[<indice>]

Esempio: char segniSchedina [13];

Ha l’effetto di dichiarare 13 variabili di tipo char:
segniSchedina[0]
segniSchedina[1]
...
segniSchedina[12]
(il primo elemento ha sempre indice 0 e l’ultimo elemento ha sempre indice pari alla
dimensione – 1)

Oltre alle componenti, la dichiarazione dell’array ha l’effetto di dichiarare una ulteriore

variabile: l’array nel suo complesso.
Variabile array: il suo valore è l’indirizzo della memoria della prima componente dell’array.
La variabile array è una variabile particolare, è teoricamente possibile stamparne il valore
ma non è possibile cambiarlo. Viene utilizzata esclusivamente per il passaggio dei parametri,
non deve essere utilizzata in altre istruzioni.

Come per le altre variabili, contestualmente alla dichiarazione è possibile inizializzare le

componenti dell’array.
Sintassi: <tipo> <nome> [<dim>]={<listaValori>};
Dove: <listaValori> è un elenco di valori del tipo delle compon. dell’array, separati da virgole.
Es: int superEnalotto[6] = {1,24,23,5,82,4};
Le operazioni sull’array si fanno componente per componente.
Unica eccezione è il passaggio dei parametri, è l’unica operazione che viene effettuata con la
variabile che rappresenta l’intero array

Passaggio dei Parametri

Nel sottoprogramma viene specificato un parametro di tipo array, il parametro è sempre un
parametro standard (non c’è la &).
Nel modulo chiamante viene usata come argomento la variabile che rappresenta l’intero
array (variabile array). Il sottoprogramma acquisisce l’indirizzo di memoria della prima
componente.

Le restanti operazioni vengono effettuate sulle singole componenti.

Utilizzo delle Componenti
Esiste anche un modo alternativo per usare le componenti, basato sul particolare nome.
Viene specificata come indice un’espressione, il processore al momento dell’esecuzione
calcola il valore dell’espressione e stabilisce quale componente utilizzare.
Sintassi per l’uso delle componenti: <nomeArray>[<espressione>]
Dove: <espressione> è un’espressione a valori interi
Esempi: temperature[3], segniSchedina[0]
segniSchedina[i]
prova[i + j]

Scansione degli Array: operazione tipica sulle variabili dell’array, consiste nell’utilizzare un
ciclo per poter eseguire la stessa operazione su tutte le componenti dell’array. È possibile
effettuare le stesse operazioni su molte variabili scrivendo un’unica volta le istruzioni
corrispondenti.
Si utilizza un ciclo for con una variabile di controllo (es: i) che varia da 0 fino alla dimensione
dell’array (es: N). Il corpo contiene una istruzione che agisce sulla componente i-esima
dell’array (es: temperature[i])

Es: void leggi(float temperature[N]){

int i;
cout << "Immetti le temperature \n";
for (i = 0; i < N; i++) {
cout << "Mese n. " << i+1 << ": ";
cin >> temperature[i];
}
return;
}

Le parentesi quadre vengono utilizzate in due modi diversi.

Nella dichiarazione dell’array per indicare la dimensione dell’arrey.
(es: char segniSchedina[13];)
Nell’utilizzo delle componenti per specificare una singola componente.
(es: cout << segniSchedina[5];)

Array e Stringhe
Il tipo string sequenze di caratteri di lunghezza arbitraria. In effetti per certi versi una
variabile di tipo string è assimilabile ad un array, in particolare un array di variabili di tipo
char. I caratteri di una stringa sono manipolabili come variabili di tipo char.

- dichiarazioni di Array bidimensionali

Sintassi: <tipo> <nome> [<dim1>][<dim2>];
Dove:
 <tipo> è uno dei tipi di dato del linguaggio
 <nome> è un identificatore
 <dim1> e <dim2> sono valori costanti interi positivi (costante numerica o simbolica o
 espressione costante)
Semantica: la dichiarazione ha l’effetto di dichiarare <dim1>*<dim2> variabili del tipo
specificato, più una ulteriore variabile corrispondente all’array nel suo complesso.
I nomi delle variabili costituiti di tre parti: l’identificatore dell’array, una coppia di indici
interi, il primo da 0 a <dim1>-1 ed il secondo da <dim2>-1
Es: const int N = 2;
const int M = 3;
int matrice[N][M];

Ha l’effetto di dichiarare 7
variabili, di cui 6 di tipo int:
matrice[0][0]
matrice[0][1]
matrice[0][2]
matrice[1][0]
matrice[1][1]
matrice[1][2]

Anche per gli array bidimensionali è possibile inizializzare le componenti alla dichiarazione:
inizializzazione “riga” per “riga”.
Es: int matrice[2][3] = { {1, -7, 6}, {12, 45, 6} }

Nel caso di array bidimensionali è necessario utilizzare due indici.

Sintassi: <nomeArray>[<espr1>][<espr2>]
Semantica: i risultati del calcolo delle due espressioni vengono utilizzati come indici per
identificare la componente dell’array.
Tipicamente vengono utilizzati due cicli nidificati, uno esterno per il primo indice, uno
interno per il secondo indice. Il ciclo esterno serve a scandire le “righe” e il ciclo interno
serve a scandire le “colonne” di una riga.

- Dichiarazioni di array multidimensionali

È possibile dichiarare array con un numero qualsiasi di dimensioni, raramente però ne
servono più di due.
Tecniche Algoritmiche
Due nuove tecniche algoritmiche: ricerca del minimo e del massimo. Si tratta di due
varianti della stessa tecnica.
Ricerca del minimo: viene cercata la posizione dell’elemento con valore minimo attraverso
una funzione, è una tecnica comune utilizzando gli array.
Strategia per la ricerca del minimo è l’analisi dell’array tenendo traccia della posizione
del “minimo corrente” (cioè del valore minimo incontrato fino a quel punto), all’inizio il
minimo corrente è l’elemento in posizione 0 (il primo elemento), scandisco l’array con un
ciclo per esaminare i restanti elementi (VERIFICA)
Se trovo un elemento di valore minore del minimo corrente, l’elemento diventa il nuovo
minimo corrente (aggiorno la posizione). Al termine del ciclo ho la posizione del minimo
complessivo.

Verifica di Condizioni
Condizione “locale”: condizione su un numero limitato di valori vicini della collezione
Condizione “globale”: condizione sulla collezione nel complesso
Differenza tra i due casi: la verifica di condizioni locali è algoritmicamente intuitiva, posso
effettuarla durante la scansione. La verifica di condizioni globali è meno intuitiva,
sembrerebbe che sia necessario esaminare tutti i valori contemporaneamente.
Attenzione allo sconfinamento: se la condizione locale richiede di ispezionare più di un
elemento alla volta, è necessario fermare il ciclo prima del solito.

Verifica di Condizioni Globali

Apparentemente più complessa. Ci sono due possibili tecniche:
- Conteggio: conto gli elementi che soddisfano la condizione e poi confronto il risultato con
un numero di riferimento
- Riduzione a condizione locale: mi riduco se possibile a verificare una condizione locale
equivalente. devo però ragionare al contrario: per verificare se la cond. globale è
soddisfatta, devo verificare. se la cond. locale è violata, fino a prova contraria, la condizione
globale è soddisfatta (tutti i numeri sono tra 1 e 90. scandisco l’array, e se verifico che
localmente la condizione è violata (c’è un numero <1 oppure >90), vuol dire che la
condizione globale non è soddisfatta.

Composizione di tecniche
Verifica che i numeri siano tutti diversi, per la soluzione posso comporre due tecniche
Algoritmiche: conteggio (conto il numero di occorrenze di un elemento della giocata) e
verifica di condizione globale per riduzione a condizione locale (non esiste un numero che
compare più di una volta).

6
1
La storia di MatLab ha origine negli anni '70 presso l'Università del Nuovo Messico sotto la
guida di Cleve Moler. Inizialmente, l'obiettivo era fornire agli studenti un modo per utilizzare
le librerie di calcolo numerico senza la necessità di programmare in FORTRAN. MatLab è
l'acronimo di Matrix Laboratory.
Successivamente, Cleve Moler ha fondato la società MathWorks nel 1984. La società ha
riscritto MatLab in linguaggio C e ha avviato la commercializzazione del software.
Attualmente, MatLab è diventato un prodotto commerciale e ha raggiunto la versione 9.x
nel 2020. È una piattaforma molto ricca per la programmazione e il calcolo.
Oltre a MatLab, esistono anche dei "cloni" open-source come Octave e FreeMat, che
offrono funzionalità simili. Octave è un progetto GNU attualmente attivo e supporta
Windows, Linux e MacOS, mentre FreeMat è un progetto fermo al 2013.

MatLab ha diverse "anime" o filosofie di utilizzo. Può essere utilizzato come linguaggio di
programmazione procedurale, consentendo agli utenti di scrivere codice e crearne nuove
funzioni. Offre un ambiente interattivo per il calcolo, simile a una calcolatrice
programmabile, dove è possibile inserire dati, eseguire operazioni e ottenere risultati.
Tutte le variabili in MatLab sono considerate array, anche gli scalari che sono considerati
array di dimensioni 1x1. MatLab fornisce operatori e funzioni che lavorano direttamente su
matrici, semplificando l'elaborazione e l'analisi dei dati.

2
L'utilizzo interattivo di MATLAB si svolge all'interno della finestra della console, che è simile
alla console di un sistema operativo. Durante una sessione di lavoro, gli utenti possono
impartire comandi utilizzando il prompt dei comandi e interagire con l'ambiente MATLAB
come se fosse una calcolatrice programmabile.
Nella console, è possibile eseguire assegnazioni di variabili utilizzando la sintassi
`<variabile> = <espressione>`, ad esempio `a = b + sin(c)`. È anche possibile chiamare
procedure con argomenti, ad esempio `plot(x)`, e utilizzare comandi per interagire con
l'ambiente come `help` e `doc`.
Le espressioni possono includere operatori aritmetici, funzioni predefinite e funzioni
definite dall'utente. Per ottenere aiuto sui comandi disponibili, è possibile utilizzare i
comandi `help <comando>` e ‘doc <comando>`. Il primo fornisce una breve descrizione del
comando, mentre il secondo apre la documentazione completa.
Una particolarità è rappresentata dalle istruzioni senza assegnazione, ad esempio `log(c)` o
`a + 1`. In questo caso, l'interprete assegna il risultato alla variabile predefinita `ans` con la
sintassi `ans = <espressione>`.
Durante l'utilizzo interattivo, l'interprete fornisce un feedback stampando i valori delle
variabili che vengono modificate a seguito di un'istruzione. È possibile disabilitare il
feedback aggiungendo `;` alla fine dell'istruzione.
La sessione di lavoro può essere assimilata alla scrittura di un programma, in cui le istruzioni
vengono eseguite una per una. Le variabili vengono dichiarate man mano che vengono
utilizzate.

Riconsideriamo le zone della finestra:

- console: standard input/standard output.
- history: codice del programma scritto nel corso della sessione.
- workspace: stato della memoria, insieme delle variabili utilizzate, con il loro tipo ed il loro
valore.
Alcuni comandi utili includono `clc` per pulire lo standard output, `who` per stampare lo
stato del workspace e `clear` per azzerare il workspace e avviare l'esecuzione di un nuovo
gruppo di comandi o programma. È possibile cambiare il formato di stampa dei numeri
utilizzando il comando `format <formato>`.

È anche possibile salvare e caricare dati o l'intero ambiente di lavoro in un file, utilizzando i
comandi `save` e `load`. Ad esempio, `save nomefile.mat` crea un file contenente lo stato
del workspace, che può essere successivamente caricato utilizzando `load nomefile.mat`.
MATLAB aggiunge automaticamente l'estensione `.mat` ai file salvati, mentre Octave non lo
fa. È possibile salvare singole variabili specificando i nomi delle variabili nel comando `save`.

In sintesi, l'utilizzo interattivo di MATLAB permette agli utenti di eseguire comandi,

assegnare variabili, chiamare procedure e interagire con l'ambiente di lavoro come una
calcolatrice programmabile, fornendo un feedback sullo stato delle variabili e consentendo
il salvataggio.

3
MATLAB offre un linguaggio procedurale interpretato e un ambiente interattivo per il
calcolo.
Procedura per la scrittura di un codice:
- l’utente scrive il codice di un programma (con l’editor del MatLab o un altro editor)
- lo salva in un file <nome>.m (estensione di MatLab)
- lo esegue dall’ambiente interattivo digitando il comando <nome> (senza .m)
- l’utente interagisce con il programma fornendo i dati in ingresso e ottenendo attraverso
l’ambiente interattivo i dati in uscita

Organizzazione del Codice

In MatLab tutti i moduli del programma sono funzioni (function) e una procedura non è
altro che una funzione senza valori di ritorno (come in C++). La funzione principale del
programma ha lo stesso nome del file .m in cui è contenuta. (diversamente dal C++ dove si
chiama main)

Elementi di Base
Commenti: linee precedute da %. Le righe iniziali di commento di un file .m vengono
visualizzati dal comando <help> (es: help cerchio)
MatLab è un linguaggio debolmente tipato, orientato agli array dinamici.
Linguaggio debolmente tipato: le variabili possono essere utilizzate senza essere dichiarate.
Il tipo di dato viene deciso al primo utilizzo, sulla base del valore che gli viene assegnato.
Ma attenzione: tutte le variabili sono sempre considerate array.

Tipi di dato principali:

- interi a 16 bit: es: 10
- reali a 64 bit: es: 10.345
- caratteri a 16 bit (codifica unicode): es: ‘a’
- booleani (tipo “logical”): true/1, false/0
- numeri complessi
Le stringhe sono array di caratteri.

Istruzioni di assegnazione: <nomeVariabile> = <espressione>[;]

Dove <nomeVariabile> è un identificatore sintatticamente equivalente a quelli del C++, il
linguaggio è “case sensitive”. Utilizzo del ; (opzionale)
Non è necessario dichiarare le variabili prima di utilizzarle. Tutte le variabili vengono
automaticamente considerate di tipo array (inzialmente 1x1), il tipo e le dimensioni possono
cambiare in modo dinamico.

Utilizzo del ; il punto e virgola NON è il separatore tra le istruzioni in MatLab, serve a
sopprimere l’output interattivo.
Istruzione MatLab (senza ; finale): dopo l’esecuzione stampa un resoconto delle variabili
modificate sullo standard output, aggiungendo il ; il resoconto viene soppresso.

Identificatori riservati
- i, j (vengono usati per i numeri complessi)
- pi: pigreco, costante predefinita
- ans: variabile predefinita
- Inf, -Inf: valore infinito superiore ed inferiore
- NaN: valore non numerico

Espressioni:
- +, -, *, /, ^ (elevamento a potenza)
- \ : divisione inversa (a \ b = b / a)
- &&, II, ~ (ATTENZIONE al not come tilde) NOTA: è possibile usare anche & e |
- ==, ~=, >, <, >=, <= (tilde: ALT 5)

Alcune funzioni utili:

- round(): arrotonda un numero intero
- floor(): parte intera inferiore
- ceil(): parte intera superiore
Istruzioni di Lettura e Stampa

Istruzioni di Lettura e Stampa

Usando MatLab con la programmazione è possibile utilizzare disp() e input()
Acquisizione dallo standard input: <var> = input(‘Messaggio’) (es: raggio = input(‘Raggio: ’);)
Visualizza il messaggio, effettua l’input formattato e assegna il valore alla variabile.
Stampa sullo standard output: disp(<array>). Disp va sempre a capo dopo aver visualizzato
il suo argomento sullo standard output, per output più complessi occorre utilizzare l’output
formattato con fprintf.

Strutture di Controllo
Strutture di controllo in MatLab: if-then e if-then-else, for e while.

Strutture condizionali

if <condizione> if <condizione1>
<istruzioni> <istruzioni>
[else [elseif <condizione2>
<istruzioni>] <istruzioni>]
end [else
<istruzioni>]
end

Strutture iterative

for <var> = <start> : <end> while <condizione>

<istruzioni> <istruzioni>
end end

Esistono le istruzioni break e continue. Break interrompe l’esecuzione di un ciclo e

passa all’istruzione successiva, continue interrompe un’iterazione e torna all’inizio del ciclo
per cominciare l’iterazione successiva.

4
I sottoprogrammi in MATLAB includono procedure e funzioni, entrambe dichiarate con la
parola chiave "function". Possono avere parametri in ingresso e valori in uscita (le
procedure sono funzioni senza valori in uscita).

Tuttavia, ci sono alcune particolarità da considerare. In MATLAB, i parametri dei

sottoprogrammi devono essere di tipo standard e non ci sono parametri per riferimento.
Inoltre, una funzione può restituire un numero arbitrario di valori, non solo uno.

Le funzioni che restituiscono più valori possono essere utilizzate per simulare il
comportamento dei parametri per riferimento.

Sintassi della dichiarazione: function [<v1>,...<vn>] = <nome> (<params>)

Dove <nome> è un identificatore, <params> sono i parametri standard e [<v1>, ... <vn>] è
l’elenco dei nomi delle variabili locali che conterranno i valori da restituire, eventualmente
vuoto (per ciascuna ci vuole un’assegnazione nel corpo)
È possibile utilizzare l'istruzione "return" per interrompere l'esecuzione di una funzione in
qualsiasi momento.

Le regole di visibilità in MATLAB prevedono che ogni funzione abbia dati locali, inclusi
parametri e variabili locali. Per utilizzare variabili globali, è necessario dichiararle con la
parola chiave "global".
L'approccio alla programmazione modulare in MATLAB prevede la creazione di una
collezione di funzioni, organizzando il codice in modo modulare. È possibile adottare due
approcci: tutto in un unico file o utilizzare il collegamento dinamico tra file.m contenenti le
funzioni. È anche possibile creare librerie MATLAB che contengono un insieme di file .m.
È possibile eseguire un programma MATLAB digitando il nome della funzione principale
nell'ambiente interattivo o utilizzando il collegamento dinamico tra file.m presenti nella
directory di lavoro o nelle librerie configurate.

5
Tipi strutturati di MATLAB:
- gli array (tipo principale)
- le stringhe (array di caratteri).
- "cell array", che sono array di componenti con tipi diversi.

Array:
- Gli array in MATLAB sono strutture di dati dinamiche con indicizzazione a base 1.
- È possibile lavorare con gli array componente per componente o manipolare l'intero array
in una singola volta.
Inizializzazione degli array:
Tutto in una volta:
- I modo: elenco esplicito dei valori. A = [0 0; 0 0] (oppure A = [0, 0; 0, 0])
- II modo: solo l’ultima componente. A(2, 2) = 0
- III modo: funzione predefinita. A = zeros(2, 2)

Utilizzo delle funzioni predefinite:

- zeros(n, m): tutti zeri
- ones(n, m): tutti 1
- rand(n, m): tutti numeri casuali
- eye(n, m): pone 1 gli elementi di posto (i,i)
- length(M): restituisce la dimensione di una matrice unidimensionale M
- size(M, i): restituisce la dimensione di M lungo la dimensione i (1: righe, 2: col., ecc.)
- size(M): restituisce un vettore con tutte le dimensioni
- numel(M): restituisce il numero di elementi complessivi di un array (utile per le matrici
multidimensionali)
Principali operatori sulle matrici: ð +, -, *, ^, ’ (trasposta). Gli operatori devono essere
preceduti dal . . ES: .* ./ .^

Stringhe: sono array di caratteri.

Funzioni principali sulle stringhe: estrazione di sottostringa e concatenazione
Estrazione di sottostringa: <stringa>(<inizio>:<fine>)
Concatenazione: si utilizza l’operatore di costruzione di array []. Per concatenare un numero
bisogna trasformarlo in stringa (array di caratteri). funzione num2str(<numero>)
6
La vettorizzazione permette di eseguire operazioni su matrici senza l'utilizzo di cicli.
Consiste nell'utilizzo di operatori e funzioni dedicate di MatLab che eseguono scansioni
estremamente ottimizzate su matrici senza ricorrere a cicli.
ESEMPIO: calcolo delle radici di un’equazione
I coefficienti dell’equazione vengono rappresentati come un vettore.
es: eq = [4 2.5 -1 2] % grado arbitrario
Si utilizza l’operatoreroots() che restituisce un vettore di tutte le radici.
es: radici = roots(eq)
radici =
-1.82
0.28 + 0.6823i
0.28 - 0.6823i

Tuttavia, la vettorizzazione può essere complessa e il codice risultante può essere meno
leggibile rispetto all'approccio tradizionale. È importante comprendere i concetti alla base
della sintassi della vettorizzazione per interpretare il codice complesso. La vettorizzazione è
particolarmente efficace quando si manipolano dati di grandi dimensioni, mentre in altri
casi può essere preferibile utilizzare l'approccio tradizionale più semplice.

La costruzione delle matrici è un esempio di vettorizzazione in MatLab. È possibile utilizzare

gli operatori `:` (due punti), `,` (virgola) e `;` (punto e virgola) per costruire matrici
combinando vettori e sottomatrici. Ad esempio, l'operatore `:` viene utilizzato per costruire
vettori riga, mentre `,` e `;` vengono utilizzati per aggiungere colonne e righe a una matrice
esistente. L'operatore `[ ]` permette di costruire una nuova matrice combinando le
sottomatrici specificate.

L’operatore ‘:’ serve in realtà a costruire vettori riga.

V = <start> [: <step>] : <stop> (NOTA: se <step> è omesso vale 1)
Esempio: V = 3 : 2 : 7 % V = [3 5 7]
L’operatore [ ] costruisce un array di array.
Operatore , (virgola) aggiunge una colonna ad una matrice
Operatore ; (punto e virgola) aggiunge una riga ad una matrice

Per accedere agli elementi di una matrice, è possibile utilizzare gli indici tradizionali
`A(<riga>, <colonna>)` o l'indicizzazione lineare `A(<posizione>)`, dove la posizione
rappresenta la sequenza lineare degli elementi della matrice per colonne. È importante
notare che in MatLab ogni singolo elemento è un array 1x1.

Considera l’array come una sequenza lineare di elementi scalari in cui la posizione di ciascun
elemento si determina leggendo la matrice per colonne.
L’elemento 1, 1 è in posizione 1
L’elemento 2, 1 è in posizione 2 (1o elemento della 2a riga, 2o elemento della 1a riga)
Array di Indici
Sintassi generale: vettori di indici: A(<array>, <array>), indicizzazione lineare: A(<array>)
È un modo per individuare le componenti dell’array che voglio elaborare, il risultato è un
array di espressioni del tipo A(n, m) oppure A(n) che corrisponde ad un gruppo di
componenti dell’array da elaborare.
Indicizzazione lineare: espressioni del tipo A(<array>)
Semantica: primo passo: espandere l’array di indici per ottenere un vettore P = [P(1), P(2), ...
, P(n)] di n indici
secondo passo: generare il vettore risultato vars = [A(P(1)), A(P(2)), ... , A(P(n))]

Esempi: A = [-1 4; 7 0.5; 12 1]

A(1:3) % P = [1 2 3]
% vars =[A(1) A(2) A(3)]
% ans = [-1 7 12]
A([2:4 6]) % P = [2 3 4 6]
% vars = [A(2) A(3) A(4) A(6)]
% ans = [7 12 4 1]

L'introduzione tratta dei tipi strutturati in MATLAB, in particolare degli array, delle stringhe e
dei "cell array" (array di componenti con tipi diversi). Successivamente, si passa ad
affrontare gli array in modo più dettagliato. Gli array in MATLAB sono strutture di dati
dinamiche indicizzate a partire da 1. Ci sono due modi principali per lavorare con gli array:
componente per componente o con operazioni sull'intero array. Viene presentata una breve
introduzione all'inizializzazione degli array, con diversi metodi come l'inizializzazione
componente per componente o tramite funzioni predefinite come "zeros". Vengono forniti
esempi di dichiarazione esplicita dei valori degli array, dichiarazione dell'ultima componente
e l'uso di funzioni predefinite come "ones", "rand" e "eye". Altre funzioni utili sugli array
sono illustrate, come "length", "size" e "numel". Viene sottolineato che le funzioni
matematiche sugli array possono lavorare componente per componente o per colonne, a
seconda del tipo di funzione. Vengono forniti esempi di funzioni non aggregative come "sin"
e "abs", e di funzioni aggregative come "sum", "max", "min" e "mean". Gli operatori sugli
array sono presentati, con l'attenzione a utilizzare gli operatori di "array operations"
(preceduti da un punto) per operare su singoli valori degli array. Viene menzionato che le
stringhe in MATLAB sono array di caratteri, e vengono forniti esempi di estrazione di
sottostringhe e concatenazione di stringhe. Infine, vengono evidenziate alcune differenze
tra MATLAB e il linguaggio C++, come il fatto che MATLAB è un linguaggio interpretato,
debolmente tipato e con una vasta libreria di operazioni sugli array. Si menziona anche la
vettorizzazione avanzata in MATLAB per la programmazione su array.

Il testo discute l'aspetto avanzato di MATLAB chiamato "vettorizzazione", che è una tecnica
di programmazione basata sull'utilizzo di operatori e funzioni specifiche di MATLAB per
lavorare su matrici senza l'uso di cicli. La vettorizzazione consente di eseguire operazioni
efficienti su matrici di grandi dimensioni.

Viene fornito un esempio di vettorizzazione che riguarda il calcolo delle radici di

un'equazione. Invece di utilizzare cicli per calcolare le radici una per una, viene utilizzato
l'operatore `roots()`, che accetta una matrice di coefficienti e restituisce un vettore
contenente tutte le radici.

Viene evidenziato che la vettorizzazione è importante perché è più veloce rispetto

all'approccio tradizionale basato sui cicli. Viene presentato un esperimento in cui viene
conteggiato il numero di elementi maggiori di zero in una matrice casuale, confrontando
l'approccio basato sulla scansione e conteggio con l'approccio basato sulla vettorizzazione.
Si dimostra che l'approccio vettorizzato è molto più veloce.

Il testo fornisce anche alcune annotazioni sulla vettorizzazione in MATLAB. Viene

sottolineato che la vettorizzazione è più veloce solo quando si lavora con dati di grandi
dimensioni, mentre per problemi più semplici può essere preferibile l'approccio
tradizionale. Inoltre, si evidenzia che il codice vettorizzato può essere meno leggibile e più
complesso da scrivere rispetto al codice tradizionale basato sui cicli.

Successivamente, vengono presentati alcuni operatori e tecniche di costruzione delle

matrici in MATLAB, tra cui l'operatore ":" per la creazione di vettori riga, l'operatore "," per
aggiungere colonne a una matrice e l'operatore ";" per aggiungere righe a una matrice.
Viene mostrato come combinare queste operazioni per costruire matrici complesse
utilizzando l'operatore "[ ]".

Infine, vengono introdotti gli operatori di accesso e modifica delle matrici, inclusi gli indici
per accedere agli elementi specifici di una matrice e l'indicizzazione lineare per trattare
l'array come una sequenza lineare di elementi. Viene fornito un esempio di come utilizzare
gli array di indici per accedere a elementi specifici di una matrice.

L'argomento trattato nel testo è l'indicizzazione logica nell'ambito della programmazione

algoritmica utilizzando il linguaggio MATLAB. L'indicizzazione logica è un metodo per fare
riferimento alle parti di una matrice utilizzando un array di booleani che segnala quali
componenti dell'array originale considerare (valori "true") e quali ignorare (valori "false").

Il testo fornisce diversi esempi di indicizzazione logica e le relative funzioni essenziali. La

funzione "find()" estrae le posizioni dei valori "true" in un array logico, mentre le funzioni
"any()" e "all()" restituiscono rispettivamente "true" se almeno un valore è "true" e "true"
se tutti i valori sono "true". Queste funzioni possono essere utilizzate anche su matrici
bidimensionali, generando un risultato per ogni colonna.
Viene poi illustrato l'utilizzo dell'indicizzazione logica per creare array logici in modo
efficiente, basandosi su condizioni specifiche delle matrici. Viene mostrato come esprimere
condizioni complesse utilizzando operatori di confronto e operatori booleani.

Successivamente, vengono presentati esempi di implementazione di algoritmi utilizzando

sia l'approccio tradizionale, componente per componente, che l'approccio vettorizzato.
Vengono forniti esempi di algoritmi per la somma dei valori di una matrice, il calcolo del
massimo e del minimo, la somma di elementi positivi e il conteggio di valori positivi in una
matrice. Viene anche mostrato come verificare la presenza di determinate condizioni in una
matrice, come la presenza di almeno un elemento uguale a zero o la presenza di tutti gli
elementi diversi da zero.

Infine, viene illustrato l'utilizzo della funzione "find()" per la ricerca di un elemento in un
array monodimensionale e la conversione degli indici lineari restituiti da "find()" in indici
bidimensionali per le matrici bidimensionali.

In sintesi, l'argomento principale trattato nel testo è l'indicizzazione logica e la sua

applicazione nell'indicizzazione e nell'implementazione di algoritmi utilizzando MATLAB.

Questo testo riassume diversi concetti relativi all'utilizzo di MATLAB per tabulare una
funzione, disegnare il grafico di una funzione e risolvere un sistema lineare.

1. Tabulare una Funzione per Punti:

- Tabulare una funzione y = f(x) significa calcolare il vettore dei valori di f(x) corrispondenti a
un vettore di valori di x.
- È necessario definire la funzione in un file .m utilizzando gli operatori su componenti.
- Esempio di definizione di una funzione parabola: y = 2.*x.^2 - 5.*x + 1.
- La valutazione della funzione su un vettore può essere fatta in modo scalare utilizzando un
ciclo o mediante vettorizzazione.

2. Disegnare il Grafico di una Funzione:

- Il comando plot viene utilizzato per disegnare il grafico di una funzione.
- È possibile specificare le coordinate degli assi x e y come vettori per tracciare una curva
che passa attraverso quei punti.
- Esempi di utilizzo del comando plot per disegnare diverse funzioni.

3. Sovrapporre Curve su un Grafico:

- Il comando plot consente di sovrapporre più curve sullo stesso grafico.
- Se si hanno le tabulazioni di due funzioni nei vettori y e z corrispondenti a un vettore x, è
possibile utilizzare il comando plot(x, y, x, z) per disegnare le due curve sullo stesso grafico.

4. Ulteriori Dettagli per il Grafico di una Funzione:

- È possibile personalizzare il grafico utilizzando diverse opzioni come colori e simboli.
- Esempi di utilizzo delle opzioni per colorare il grafico o disegnare simboli specifici.
5. Risolvere un Sistema Lineare:
- MatLab può essere utilizzato per risolvere un sistema lineare Ax = b, dove A è una matrice
N x N, x e b sono vettori colonna.
- È possibile risolvere l'equazione utilizzando l'inversa della matrice A (x = inv(A) * b), ma
questa approccio può essere computazionalmente oneroso e lento.
- Un'alternativa più efficiente è utilizzare l'operatore backslash (\) (x = A\b) per calcolare la
soluzione del sistema.
- L'operatore backslash utilizza un algoritmo appropriato in base alla natura della matrice A
(ad esempio, matrice diagonale, triangolare, simmetrica, ecc.).

Questo riassunto fornisce una panoramica delle principali considerazioni e comandi relativi
alla tabulazione di funzioni, al disegno di grafici e alla risoluzione di sistemi lineari
utilizzando MATLAB.