Cosa ci Serve per Programmare?

Somma degli Elementi di un Vettore

Proviamo a calcolare la somma degli elementi di un vettore

Come fare?

• La somma è inizialmente uguale a 0
• Consideriamo tutti gli elementi successivi
• Aggiungiamoli uno ad uno alla somma

Somma degli Elementi di un Vettore

Proviamo a calcolare la somma degli elementi di un vettore

• La somma è inizialmente uguale a 0

s = 0;

• Consideriamo tutti gli elementi successivi

??? % Non sappiamo "spostarci" su un vettore

• Aggiungiamoli uno ad uno alla somma

s = s + ??? % E neanche accedere ad un elemento

Ancora non ci siamo: vediamo di rimediare...

Accesso a Vettori in Octave

Abbiamo visto come costruire un vettore in Octave:

[1, 3, 5]

Quando si implementano algoritmi può essere utile:

• Accedere ad un elemento specifico...
• ...Per "leggerlo" o "modificarlo"

In Octave lo si può fare utilizzando la notazione:

<vettore>(<espressione>)

• <vettore> è una espressione che denota un vettore
• <espressione> è deve denotare un indice (un intero)

Accesso a Vettori in Octave

Gli elementi del vettore (o celle dell'array) sono numerate:

• Il primo indice è sempre 1
• L'ultimo indice è uguale al numero di elementi

Per ottenere il numero di elementi si può usare la funzione:

length(<array>)

• Attenzione: length fa cose diverse se invoca su altri tipi di dato

Accesso a Vettori in Octave

Gli elementi del vettore (o celle dell'array) sono numerate:

• Il primo indice è sempre 1
• L'ultimo indice è uguale al numero di elementi

In alternativa, si può accedere direttamente all'ultimo elemento con:

<array>(end)

• end funziona solo se usato come indice

Accesso a Vettori in Octave

Gli elementi del vettore vengono trattati come variabili

Supponiamo di avere:

x = [1,2,3,5,6,7]

Possiamo ottenere il valore di un element con:

x(4) % denota il valore 5

E modificare un elemento con:

x(4) = 2 % assegna il valore 2 alla 4° cella

Accesso a Vettori in Octave

Sempre assumendo di avere:

x = [1,2,3,5,6,7]

Se usiamo un indice < 1, otteniamo un errore:

x(0) % errore
x(0) = 2 % errore

Se usiamo un indice > length(x), invece:

x(9) % ancora un errore
x(9) = 1 % Otteniamo x = [1,2,3,5,6,7,0,0,1]

• Il vettore viene espanso, riempiendo con 0 le celle intermedie

Una Aggiunta: Vettore/matrice Vuoto

Il simbolo [] denota un vettore/matrice vuoto

Possiamo definire un vettore vuoto:

x = [] % x è vuoto, length(x) è 0

Possiamo estendere un vettore vuoto:

x(3) = 10 % otteniamo x = [0, 0, 10]

Possiamo cancellare un elemento assegnandovi []:

x(2) = [] % otteniamo x = [0, 10]

L'estensione e [] consentono di manipolare la lunghezza

Tornando alla Somma di un Vettore...

Vediamo come usare queste informazioni per il nostro algoritmo

• Supponiamo che il nostro vettore si chiami v

v = % il nostro vettore
s = 0;
<facciamo variare una variabile ii da 1 a length(v)>
  s = s + v(ii)

• Quando ii avrà raggiunto il valore length(v)...
• ...la variabile s conterrà la somma

Ci rimane da capire come gestire l'indice ii

Istruzioni di Iterazione: Ciclo for

Octave ci permette di farlo utilizzando una istruzione

• Istruzione = unità esecutiva elementare di un programma
• Un programma è in prima battuta una sequenza di istruzioni

Un esempio:

• Espressione + [invio] = una istruzione

Vediamo ora un nuovo tipo di istruzione:

Istruzioni di Iterazione: Ciclo for

La nostra prima istruzione di iterazione si chiama "ciclo for"

Sintassi:

for <variabile> = <vettore>
  <corpo>
end % o anche endfor (incompatibile con matlab)

• <corpo> è una sequenza di istruzioni
• Il corpo viene ripetuto per ogni elemento di <vettore>

Ad ogni ripetizione (i.e. iterazione):

• <variabile> assume il valore di un elemento di vettore

Nota: il simbolo "=" in questo caso non ha il solito significato...

Istruzioni di Iterazione: Ciclo for

Un esempio semplice:

for v = [2, 4, 6]
  v % denota il valore di "v"
end

Quando inserite una istruzione for nella finestra dei comandi:

• Octave non esegue subito l'istruzione
• Vi permette di continuare a scrivere e premere [invio]
• Finché non inserite la parola chiave end

Solo allora l'istruzione for è completa (e quindi eseguibile)

Ciclo for e Somma di un Vettore

Il ciclo for ci permette di codificare il nostro algoritmo:

Supponendo che il nostro vettore si chiami v

s = 0;
for ii = 1:length(v)
  s = s + v(ii)
end

Oppure, in modo ancora più semplice:

s = 0;
for w = v % w assume uno per uno i valori di v
  s = s + w
end

La funzione predefinita sum in Octave fa (più o meno) questo

Modalità di Accesso Avanzate per Vettori

• Octave offre delle modalità avanzate di accesso ai vettori
• In alcuni casi fanno molto comodo

Indicizzazione Mediante Vettori

Si può usare un vettore per accedere ad elementi multipli:

La sintassi è:

<vettore>(<vettore di indici>)

Per esempio:

x = [2, 4, 6, 8]; 
ii = [2, 3]; % "ii" per evitare di rendere
             % inaccessibile l'unità immaginaria
x(ii) % denota [4, 6]

• Il risultato è un nuovo vettore
• Contiene gli elementi di x, agli indici specificati da ii

Indicizzazione Mediante Vettori: Esempio

Supponiamo di voler sommare le celle adiacenti di:

a = [1, 2, 3, 4, 5]

Possiamo usare:

a(1:end-1) + a(2:end)

• a(1:end-1) denota [1, 2, 3, 4]
• a(2:end) denota [2, 3, 4, 5]

Il risultato è:

[3, 5, 7, 9] % [1, 2, 3, 4] + [2, 3, 4, 5]

Indicizzazione Mediante Vettori: Esempio

Oppure, supponiamo di voler sommare le celle pari e dispari:

a = [1, 2, 3, 4, 5, 6]

Possiamo usare:

a(1:2:end) + a(2:2:end)

• a(1:2:end) denota [1, 3, 5]
• a(2:2:end) denota [2, 4, 6]

Il risultato è:

[3, 7, 11]

Indicizzazione Mediante Vettori

L'accesso mediante vettori funziona anche in assegnamento!

Sintassi:

<vettore>(<vettore di indici>) = <vettore>

Per esempio:

x = [2, 4, 6, 8];
ii = [2, 3];
x(ii) = [10, 11] % otteniamo x = [2, 10, 11, 8]

Se le dimensioni non combaciano, Octave fa broadcasting:

x(ii) = 0 % otteniamo x = [2, 0, 0, 8]

• È utile per fare un assegnamento "in massa"

Elementi di Informatica e
Applicazioni Numeriche T

Octave: Acceso a Matrici
e Cicli Innestati

Somma di una Matrice

Alziamo un po' il livello di difficoltà

Supponiamo di voler sommare gli elementi di una matrice

Un possibile algoritmo:

M = % la nostra matrice
s = 0
<per ogni elemento della matrice>
  s = s + <un elemento della matrice>

Come iterare sugli elementi di una matrice?

• Potremmo utilizzare un ciclo for...

Somma di una Matrice

Vediamo cosa succede iterando con un for su una matrice:

M = [1, 2, 3; 4, 5, 6; 7, 8, 9]; % [1, 2, 3]
                                 % [4, 5, 6]
                                 % [7, 8, 9]
for w = M
  w % giusto per stampare w
end

La variabile w assume i valori:

• [1; 4; 7], poi [2; 5; 8], poi [3; 6; 9]

Ossia le colonne di M!

Come possiamo fare per iterare sugli elementi?

Somma di una Matrice

Una soluzione semplice: usare due cicli for

M = [1, 2, 3; 4, 5, 6; 7, 8, 9];
for c = M % itero sulle colonne
  for v = c % poi sugli elementi della colonna
    v 
  end % fine ciclo interno
end % fine ciclo esterno

• for è una istruzione
• Quindi il corpo di un for può contenere un altro for!

I due cicli si dicono innestati

• end si riferisce sempre all'ultimo for non ancora chiuso

Somma di una Matrice

Ecco quindi un possibile codice per il nostro algoritmo:

M = % la nostra matrice
s = 0
for c = M
  for v = c
    s = s + v
  end
end

Notate come il corpo di ogni for è leggermente indentato?

• Non è obbligatorio, ma rende il codice più leggibile

Somma di una Matrice

In alternativa, possiamo usare la funzione sum

Ci vuole però qualche accortezza:

M = [1, 2; 3, 4] % [1, 2]
                 % [3, 4]
sum(M) % denota [4, 6]

• Se applicata ad una matrice...
• ...sum calcola la somma colonna per colonna

Per avere la somma di tutti gli elementi:

sum(sum(M)) % denota 10

• La seconda applicazione di sum ottiene la somma totale

Somma di una Matrice

E se volessi iterare riga per riga?

M = % la nostra matrice
s = 0
for ii = 1:<numero di righe>
  for jj = 1:<numero di colonne>
    s = s + <elemento in posizione i,j>
  end
end

Occorre un modo per:

• Conoscere la dimensione della matrice (righe/colonne)
• Accedere ad un elemento arbitrario

Accesso a Matrici in Octave

Accedere ad elemento arbitrario di una matrice è facile:

Sintassi:

<matrice>(<indice riga>,<indice colonna>)

Per esempio:

a = [2, 4; 6, 8]; % corrisponde a  [2, 4]
                  %                [6, 8]
a(1,2) % denota 4
a(2,2) % denota 8
a(1, 1) = 0 % assegna 0 nella posizione 1,1

Accesso a Matrici in Octave

Per ottenere le dimensioni di una matrice invece si usa:

rows(<matrice>) % denota il numero di righe
columns(<matrice>) % denota il numero di colonne
size(<matrice>) % denota entrambi, in un vettore

Qualche esempio:

a = [2, 4; 6, 8]; % corrisponde a  [2, 4]
                  %                [6, 8]
rows(a) % denota 2
columns(a) % denota 2
size(a) % denota [2, 2]

Matrici, Vettori o Scalari?

Qualche osservazione interessante:

a = [2, 4; 6, 8];
b = [2, 4];
c = 2;
size(a) % denota [2, 2]
size(b) % denota [1, 2]
size(c) % denota [1, 1]

• Octave tratta vettori e scalari come particolari matrici!
• In realtà, tutti e tre sono considerati array multidimensionali

Per noi, parlare di scalari/vettori/matrici sarà sufficiente

Modalità di Accesso Avanzate per Matrici

• Esistono modalità di accesso avanzate anche per le matrici
• Di nuovo, possono fare molto comodo

Accesso a Righe e Colonne

Se vogliamo accedere ad una sola riga/colonna:

Usiamo il simbolo : al posto dell'indice non specificato

<matrice>(2,:) % accede alla seconda riga
<matrice>(:,2) % accede alla seconda colonna

• La notazione è identica a quella dei range...
• ...Mancano i due "estremi", però...
• ...Ed il significato è proprio diverso

Si può cancellare una una riga/colonna assegnandovi []

<matrice>(1,:) = [] % cancella la prima riga

Accesso a Righe e Colonne

Qualche esempio:

a = [2, 4; 6, 8]; % corrisponde a  [2, 4]
                  %                [6, 8]
a(1,:) % denota [2, 4]
a(:,1) % denota [4; 8]
a(1,:) = [1, 1] % otteniamo [1, 1]
                %           [6, 8]
a(:,2) = [0; 0] % otteniamo [1, 0]
                %           [6, 0]
a(1,:) = [] % cancella la prima riga,
            % otteniamo [6, 0]

Accesso a Matrici Mediante Vettori

Per accedere a righe/colonne multiple, usiamo vettori di indici

Sintassi:

<matrice>(<vettore righe>, <vettore colonne>)

Qualche esempio:

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

Accesso a Matrici Mediante Vettori

Se accediamo ad una matrice con un indice unico:

• Viene trattata come se fosse un vettore
• Con le colonne disposte in sequenza

$$\left(\begin{array}{cc} a & b \\ c & d \\ \end{array}\right) \longleftrightarrow \left(\begin{array}{cccc} a & c & b & d \end{array}\right)$$

Permette di accedere ad un gruppo arbitrario di elementi:

a = [2, 4; 6, 8]; % [2, 4]
                  % [6, 8]
a(1) % denota 2
a(2) % denota 6
a(3) % denota 4
a(4) % denota 8

Conversione di Matrice in Vettore

Una conseguenza importante:

La notazione:

<matrice>(:)

Restituisce tutti gli elementi, in forma di vettore

Possiamo usarla per calcolare la somma:

M = [1, 2; 3, 4];
V = M(:) % ottiene V = [1, 3, 2, 4]
sum(V)

Oppure direttamente sum(M(:))

Elementi di Informatica e
Applicazioni Numeriche T

Octave: Valori Logici
ed Istruzioni Condizionali

Massimo di un Vettore

Supponiamo di voler calcolare il massimo di un vettore

Cosa riusciamo a scrivere con le istruzioni che conosciamo?

V = % il nostro vettore
y = V(1) % primo tentativo: max = il primo elemento
for ii = 2:length(V) % iteriamo sul resto del vettore
  <se V(ii) è maggiore di y, allora y = V(ii)>
end

Abbiamo bisogno di un costrutto che:

• Permetta di stabilire se V(ii) è maggiore di y
• Se questo è vero, esegua l'istruzione y = V(ii)

Questa funzionalità è fornita dalle istruzioni condizionali

Istruzione Condizionale if

Noi utilizzare una sola istruzione condizionale, chiamata if

Sintassi:

if <espressione>
  <corpo1>
else % opzionale
  <corpo2> % opzionale
end % oppure endif (incompatibile con matlab)

• <espressione> può denotare "vero" o "falso"
• <corpo1> e <corpo2> sono sequenze di istruzioni
• <corpo1> esegue se <espressione> denota il valore "vero"
• <corpo2> esegue se <espressione> denota il valore "falso"

Ma cosa vuol dire "denotare vero o falso"?

Valori Logici ed Operatori di Confronto

Octave infatti supporta anche valori logici:

Sintassi:

true % vero
false % falso

Vengono restituiti dagli operatori di confronto:

Sintassi e semantica:

<dato> == <dato> % "true" se i dati sono uguali
<dato> ~= <dato> % "true" si i dati sono diversi
<dato> != <dato> % come ~=, incompatibile con matlab
<, <=, >, >=  % fanno quello che vi aspettate :-)

Servono a verificare se due dati soddisfino una condizione

Valori Logici ed Operatori di Confronto

Qualche esempio:

c = 2;
c < 3 % denota true
c ~= 2 % denota false

Nel nostro algoritmo:

V = % il nostro vettore
y = V(1)
for ii = 2:length(V)
  if V(ii) > y
    y = V(ii)
  end
end

• L'indentazione non è necessaria, ma è consigliata

Operatori Logici

Per esprimere condizioni complesse usiamo gli operatori logici

Sintassi e semantica:

<dato> & <dato> % true sse i due dati sono true
<dato> | <dato> % true sse almeno un dato è true
~ <dato> % true sse il dato è falso

Qualche esempio:

(x >= 3) & (x < 5) % true se x è tra 3 e 5
(x == 0) | (x > 2)

• Esistono anche con forma/semantica diversa: &&, ||...
• ...Ma non la considereremo in questo corso

Valori Logici e Numeri

I valori logici sono assimilabili ai numeri 1 ("vero") e 0 ("falso")

• Si comportano come numeri se usati per fare calcoli
• È possibile usare numeri al posto di valori logici
  • 0 corrisponde a "falso"
  • Qualunque numero diverso da 0 corrisponde a vero

Un errore da manuale:

if x = 5 % l'operatore di uguaglianza è "=="!
  y = y + 1
end

• x = 5 denota 5, che corrisponde a true!

Operatori Logici e Vettori/Matrici

Gli operatori di confronto e logici:

Se applicati a vettori o matrici, operano elemento per elemento

a = [1, 2; 3, 4]; % [1, 2]
                  % [3, 4]
b = [1, 2, 3];
a < 3 % denota [1, 1]
      %        [0, 0]
(b > 1) & (b < 3) % [0, 1, 1] & [1, 1, 0]
                  % quindi [0, 1, 0]

• È utile per verificare molte condizioni in un colpo solo
• In questo caso, può essere necessario aggregare i risultati

Ci sono due funzioni principali per farlo: all e any

Funzioni all e any

Le funzioni all e any hanno il comportamento seguente:

all(<vettore>) % true se tutti gli elementi sono true
any(<vettore>) % true se almeno un elemento è true

• Se i vettori contengono numeri, ogni valore diverso da 0 è true

Qualche esempio:

a = [1, 2, 3];
all(a < 3) % all([1, 1, 0]) --> false
any(a < 2) % any([1, 0, 0]) --> true

Se applicate a matrici, all ed any operano colonna per colonna

• Esattamente come sum

Accesso a Vettori/Matrici via Valori Logici

Possiamo accedere ad un vettore/matrice usando valori logici

Sintassi:

<vettore/matrice A>(<vettore/matrice I>)

• I due vettori/matrici devono avere la stessa dimensione

Semantica:

• Restituisce un vettore contente gli elementi di A...
• ...Alle posizioni in cui I contiene il valore true

A che serve? Vediamo qualche esempio...

Accesso a Vettori/Matrici via Valori Logici

Supponiamo di avere:

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

Proviamo a selezionare i valori maggiori di 3:

ii = (a > 3) % denota [0, 0, 0]
                    % [1, 1, 1]
                    % [1, 1, 1]
a(ii) % denota [4, 5, 6, 7, 8, 9]

In forma compatta:

a(a > 3)

Elementi di Informatica e
Applicazioni Numeriche T

Octave: Altre Istruzioni di Iterazione
e Teorema del Programma Strutturato

Funzione Zeta di Riemann

Supponiamo di voler calcolare la somma della serie:

$$\zeta(s) = \sum_{n=1}^\infty \frac{1}{n^s}$$

• Si tratta della funzione Zeta di Riemann (per num. reali)
• Converge per $s > 1$

Funzione Zeta di Riemann

Supponiamo di voler calcolare la somma della serie:

$$\zeta(s) = \sum_{n=1}^\infty \frac{1}{n^s}$$

• Si tratta della funzione Zeta di Riemann (per num. reali)
• Converge per $s > 1$

Proviamo ad abbozzare un algoritmo:

z = 0;
for n = 1:???? % Il problema è qui
  z = 1 / n.^s
end

• La serie ha infiniti termini!

Funzione Zeta di Riemann

Supponiamo di voler calcolare la somma della serie:

$$\zeta(s) = \sum_{n=1}^\infty \frac{1}{n^s}$$

• La funzione non è computabile nel caso generale
• Però possiamo approssimarla!

Tipicamente: ci si ferma ad un certo livello di precisione

• Sia $\zeta_k(s)$ la nostra approssimazione dopo $k$ iterazioni
• Ci fermiamo quando $\left|\zeta_k(s) - \zeta_{k-1}(s)\right| < \varepsilon$
• Dove $\varepsilon$ è la tolleranza che riteniamo accettabile

Però ancora non sappiamo a priori il numero di iterazioni...

Ciclo while

Ci serve una istruzione di iterazione capace di:

• Fermarsi in base al soddisfacimento di una condizione
• Anziché alla fine di un vettore

Una istruzione di questo tipo è il ciclo while

Sintassi:

while <espressione> % vera o falsa
  <corpo>
end % oppure endwhile (incompatibile con matlab)

• Il corpo viene ripetuto
• Fintanto che <espressione> denota true

Funzione Zeta di Riemann

Possiamo usare while per scrivere un algoritmo per $\zeta(s)$:

$$\zeta(s) = \sum_{n=1}^\infty \frac{1}{n^s}$$

tol = 1e-9;                % tolleranza
z = 0;                     % val. della somma
n = 1;                    
old_z = -Inf;              % vecchio z
while abs(z - old_z) > tol % abs = valore assoluto
  old_z = z;               % memorizzo il vecchio z
  z = z + 1 ./ n.^s;
  n = n + 1;               % incremento n
end

• Inf è un valore speciale che denota $\infty$

Qualche Accorgimento

Il ciclo while non fornisce garanzie di terminazione

Per esempio:

n = 1;
s = 0;
while n < 10
  s = s + n;
end

• Questo ciclo non termina
• Perché n non viene incrementato!

Se vi capita, niente panico: basta premere [ctrl+c]

Istruzioni break e continue

In alcuni casi può essere utile interrompere un ciclo

Lo si può fare con l'istruzione break

• Vediamo un esempio sulla Zeta di Riemann

...
while true     % Di base, non smetto mai di iterare
  old_z = z;
  z = z + 1 ./ n.^s;
  n = n + 1;
  if abs(z - old_z) < tol
    break
  end
end

• Qui break è usato per controllare la condizione in fondo al ciclo

Programmazione Strutturata

Le istruzioni condizionali e di iterazione:

• Sono anche note come istruzioni di controllo di flusso
• Sono importanti per un particolare risultato:

• Composizione per sequenza = scrivere le istruzioni una dopo l'altra

Quasi tutti i linguaggi si basano su questi tre metodi di composizione

Elementi di Informatica e
Applicazioni Numeriche T

Octave: File di Script

Mettiamoci Comodi

Riguardiamo un altro il nostro codice per $\zeta(s)$:

tol = 1e-9;
z = 0;
n = 1;
old_z = -Inf;
while abs(z - old_z) > tol
  old_z = z;
  z = z + 1 ./ n.^s;
  n = n + 1;
end

• È lunghetto... e scomodo da inserire una riga per volta
• Sarebbe utile poterlo scrivere a parte e poi eseguirlo

Per fortuna si può! Anzi, è il modo normale di lavorare in Octave

File di Script

In Octave, si chiama file di script:

• Un file di testo (tipo quelli di blocco note)...
• ...Che termina con l'estensione .m...
• ...E che contiene una sequenza di istruzioni

In sostanza, è un programma scritto in Octave

Un file di script può essere eseguito con la sintassi:

<nome del file senza ".m">[invio]

• Per esempio zeta.m si esegue con zeta + [invio]
• Il file deve essere nella cartella corrente

Eseguire uno script equivale a scrivere le sue istruzioni sul prompt

Qualche Dritta sugli Script

Scegliete il nome con un filo di attenzione

• Se chiamate lo script pi.m...
• ...quando scrivete l'istruzione pi+[invio]...
• ...eseguirete lo script, invece di ottenere il valore di $\pi$!

Soluzione: aggiungete sempre un prefisso/suffisso al nome del file

• Io li chiamo chXX_nomescript.m
  • XX è il numero del "capitolo" del corso

Qualche Dritta sugli Script

È possibile inserire commenti nel codice:

Sintassi:

% Ecco un commento!
% Finalmente è chiaro cosa siano questi "cosi" :-)

• Il testo che segue il simbolo % viene ignorato

Commentare aiuta a ragionare e ricordare

• Un giorno un programmatore incappò in questo commento :-)

% When I wrote this, only God and I knew
%      what I was doing
% Now, God only knows

Qualche Dritta sugli Script

Mantenete il codice leggibile

• Usate l'indentazione
• Non comprimete troppe operazioni in una sola riga

sum(all(a(1:2:end, :)(:) * b')) % UNA BRUTTA IDEA

• Se una riga è troppo lunga, potete andare a capo con "..."

a = [1, 2, 3, 4, 5, 6, 7, 8, ...
     9, 10, 11, 12, 13, 14]

• Ma soprattutto: ricordatevi di commentare

Elementi di Informatica e
Applicazioni Numeriche T

Octave: Definizione di Funzioni

Limiti degli Script in Octave

Supponiamo di avere il nostro algoritmo per $\zeta(s)$ in uno script:

s = 3;
tol = 1e-9;
z = 0;
old_z = -1;
n = 1;
while abs(z - old_z) > tol
  old_z = z;
  z = z + 1 ./ n.^s;
  n = n+1;
end

Limiti degli Script in Octave

Supponiamo di avere il nostro algoritmo per $\zeta(s)$ in uno script:

s = 3;  % <-- il problema è qui
tol = 1e-9;
z = 0;
old_z = -1;
n = 1;
while abs(z - old_z) > tol
  old_z = z;
  z = z + 1 ./ n.^s;
  n = n+1;
end

• Possiamo eseguirlo molte volte, ma sempre con s = 3
• Per cambiare s, dobbiamo modificare lo script
• Se $\zeta(s)$ va valutata spesso, diventa molto scomodo

Limiti degli Script in Octave

Gli script in Octave sono utili per:

• Effettuare test
• Eseguire una analisi di dati specifici
• Risolvere un preciso problema numerico

Non sono adatti a definire un algoritmo generico!

Per tali casi possiamo definire una nuova funzione

• Una funzione è un sotto-programma (come uno script)
• Ma può ricevere dei parametri
• E può restituire un risultato

Definizione di Funzioni in Octave

Per definire una nuova funzione si usa la sintassi:

function <ret> = <nome funz.>(<p1>, <p2>, ...)
  <corpo>
end % oppure endfunction (incompatibile con Matlab)

• <fn> è il nome della funzione
• <pXX> sono nomi di variabili (si chiamano parametri formali)
• <ret> è il nome della variabile da restituire

Usiamo come esempio la nostra Zeta di Riemann:

function z = zeta(s)
  ...
end

Semantica di una Chiamata a Funzione

Cosa succede quando eseguiamo (e.g.) zeta(3)+[invio]?

• La chiamata segue il paradigma cliente-servitore

Semantica di una Chiamata a Funzione

Cosa succede quando eseguiamo (e.g.) zeta(3)+[invio]?

• Cliente = il chiamante (lo script, in questo caso)

Semantica di una Chiamata a Funzione

Cosa succede quando eseguiamo (e.g.) zeta(3)+[invio]?

• Servitore = la funzione chiamata

Semantica di una Chiamata a Funzione

Cosa succede quando eseguiamo (e.g.) zeta(3)+[invio]?

• Valutazione dei i parametri nel chiamante (detti parametri attuali)

Semantica di una Chiamata a Funzione

Cosa succede quando eseguiamo (e.g.) zeta(3)+[invio]?

• Viene allocata memoria per la funzione (il suo record di attivazione)

Semantica di una Chiamata a Funzione

Cosa succede quando eseguiamo (e.g.) zeta(3)+[invio]?

• I valori dei parametri attuali sono copiati nei parametri formali

Semantica di una Chiamata a Funzione

Cosa succede quando eseguiamo (e.g.) zeta(3)+[invio]?

• Viene eseguila la funzione

Semantica di una Chiamata a Funzione

Cosa succede quando eseguiamo (e.g.) zeta(3)+[invio]?

• La funzione definisce variabili nel suo record di attivazione

Semantica di una Chiamata a Funzione

Cosa succede quando eseguiamo (e.g.) zeta(3)+[invio]?

• La funzione termina (z vale circa 1.2)

Semantica di una Chiamata a Funzione

Cosa succede quando eseguiamo (e.g.) zeta(3)+[invio]?

• Il valore della variabile di nome <ret> viene copiato nel chiamante

Semantica di una Chiamata a Funzione

Cosa succede quando eseguiamo (e.g.) zeta(3)+[invio]?

• Il record di attivazione viene distrutto

Semantica di una Chiamata a Funzione

Cosa succede quando eseguiamo (e.g.) zeta(3)+[invio]?

• Il risultato viene assegnato as ans (zeta è stata chiamata dal prompt)

Alcune Osservazioni

Alcune osservazioni

1) Se la funzione non definisce una variabile di nome <ret>:

• Non viene restituito nulla (niente copia verso il chiamante)

2) Le variabili definite dalla funzione:

• Vengono distrutte insieme al record di attivazione
• Esistono solo per la durata della chiamata

3) Il corpo di una funzione può contenere una chiamata a fuzione

• zeta(s) per esempio chiama gli operatori aritmetici
• Avremmo potuto chiamare qualunque funzione, però

Ambienti e Regole di Visibilità

Abbiamo visto che:

• Lo script principale ha il suo spazio di memoria
• Ogni chiamata a funzione ha un suo record di attivazione

Entrambi si chiamano ambienti

• Conseguenza: le variabili definite da una funzione si dicono locali
• Ci sono eccezioni, ma non le vedremo

Interazione con l'Ambiente Corrente

È possibile ispezionare l'ambiente corrente utilizzando i comandi:

who % stampa i nomi delle variabili definite
whos % stampa i nomi + altre informazioni

È possibile eliminare una variabile utilizzando:

clear <nome variabile>

È possibile eliminare tutte le variabili con:

clear all

File di Funzione

Ci sono diverse alternative, ma ne considereremo solo una:

Una funzione va definita all'interno di un file di funzione

Un file di funzione è un file di testo che:

• Ha lo stesso nome della funzione, con estensione .m
• Ha come prima istruzione la definizione della funzione

Per esempio:

% nel file "zeta.m":
function z = zeta(s)
  ...
end

File di Funzione

Quando proviamo ad invocare (e.g.) zeta(3):

• Octave cerca un file di nome "zeta.m"
• Se lo trova, legge la definizione della funzione e la esegue

La ricerca avviene all'interno di una serie di cartelle:

• Una di esse è sempre la cartella corrente
• È qui che possiamo mettere i nostri file di funzione

Attenzione ai nomi!

• Se definiiamo una funzione sum in "sum.m"
• "Oscuriamo" la funzione sum di Octave