Matematicamente
|
|
| If, switch, while, do-until, for, break, continue | di A. Calati M. Urbano |
|
Dichiarazioni
Possono essere
una semplice espressione costante o una lista complicata di cicli e condizioni.
Gli statements di controllo come IF, WHILE
controllano il flusso di esecuzione dei programmi in Octave. Tutti gli
statements di controllo iniziano con speciali parole chiave come IF e WHILE
per distinguerli dalle espressioni semplici. Molti statements di controllo
contengono altri statements; per esempio lo statement if contiene un altro
statement che può o non può essere eseguito. Ogni statement di controllo ha un
corrispondente end che segue la fine
del controllo. Per esempio endif segue
la fine dello statement if e endwhile
segue la fine dello statement while.
La lista degli statements presente fra if o while e il loro corrispondente end
è chiamato il corpo dello statement
di controllo.
Statement if
Prende le
decisioni in octave. Ci sono 3 forme base di if.
Forma più
semplice:
>> if (condizione)
>> Body
>> endif
Condizione è un’espressione che
controlla cosa fare nel resto dello statement. Il body è eseguito solo se la condizione
è vera. La condizione in uno statement if
è considerata vera se il suo valore è diverso da zero e falsa se il suo
valore è zero. Se la condizione è un vettore o matrice è considerata vera solo
se non è vuoto/a e tutti gli elementi sono diversi da zero.
Seconda forma:
>> if
(condizione)
>> body
>> else
>> else-body
>> endif
Se Condizione è vera, body viene eseguito altrimenti è eseguito elsebody.
Esempio:
>> if (rem(x,2)= =0)
>> printf (“x is even\n”)
>> else
>> printf (“x is odd\n”)
>> endif
In questo
esempio se l’espressione rem (x,2)=0 è vera (quindi x è divisibile per 2),
viene eseguito il primo printf altrimenti
viene eseguito il secondo printf.
La terza forma
di if permette di combinare decisioni
multiple in un singolo statement.
Esempio:
>> if
(condizione)
>> body
>> elseif (condizione)
>> else-body
>> endif
Si possono
inserire un qualsiasi numero di elseif.
Ogni condizione è testata a turno e di quella considerata vera viene eseguito
il body. Se nessuna condizione è vera
e c’è l’else viene eseguito il suo body. Ci può essere solo un else e deve trovarsi nell’ultima parte
dello statement. Tra else e if non ci devono essere spazi se no
Octave lo tratta come un nuovo if.
Statement switch
Valuta differenti
azioni che dipendono dal valore di una variabile. E’ possibile utilizzando
l’affermazione if nel seguente modo:
>> if (x= =1)
>> fai_ualcosa( );
>> elseif (x= =2)
>> fai_qualcos’_altro;
>> else
>> fai_qualcosa_diversa;
>> endif
Questo codice
può essere molto ingombrante sia da scrivere che da mantenere. Per superare
questo problema Octave prevede lo statement switch
.
L’esempio sopra
diventa:
>> switch (x)
>> case1
>> fai_qualcosa;
>> case 2
>> fai_qualcos’_altro;
>> otherwise
>> fai_qualcosa_diversa;
>> endswitch
Con questo
codice la struttura ripetitiva del problema è più esplicita e il codice è più
facile da leggere e da mantenere. Anche se x dovesse cambiare nome dovrebbe
essere cambiata solo una linea.
La forma generale
di switch è:
>> switch espressione
>> case label
>> lista_comandi
>> case label
>> lista_comandi
>>….
>> otherwise
>> lista_comandi
>> endswitch
Dove label può essere qualsiasi espressione.Uno
dei vantaggi nell’usare switch invece
di If è che le labels
possono essere stringhe. Con if nn si può scrivere:
>> if (x= = “stringa”) # non è valido
Con switch
invece si può scrivere:
>> switch (x)
>> case “stringa”
>> fai_qualcosa;
>>…..
>> endswitch
Statement while
Nella
programmazione un ciclo è una parte di programma che è (o può essere eseguita)
2 o più volte in successione. While è
lo statement di ciclo più semplice in Octave. Come con l’if , con while il ciclo
viene eseguito fin quando la condizione è vera (valore diverso da zero).
La sua forma è:
>> while (condizione)
>> body
>> endwhile
La prima cosa
che fa while è testare la condizione.
Se è vera esegue il body. Dopo che
l’ha eseguito, la condizione è testata di nuovo e se è ancora vera il body è eseguito di nuovo. Questo processo è
eseguito finché la condizione è vera. Se inizialmente la condizione è falsa il
body non è mai eseguito.
L’esempio sotto
crea una variabile fib che contiene i
primi 10 elementi della sequenza di Fibonacci:
>> fib=ones (1,10);
>> i=3;
>> while (i<=10)
>> fib(i)=fib (i-1)+fib(i-2);
>> i++;
>> endwhile
Qui il corpo del
ciclo contiene 2 statement. Il ciclo lavora così: prima i è posto uguale a 3.
Poi while testa se è minore o uguale a
Statement do-until
E’ simile alchile
solo che questo esegue rapidamente lo statement fino a che la condizione non è
vera e il test della condizione è alla fine del ciclo, così il corpo del ciclo
è sempre eseguito almeno una volta. Come con if la condizione è vera se diversa
da zero e falsa se è uguale a zero.
L’espressione di
do-until è :
>> do
>> body
>> until (condizione)
Qui il body è
uno statement o una lista di statements che sono chiamati corpo del ciclo e la condizione è l’espressione che controlla
quante volte il ciclo sarà eseguito.
Questo esempio
crea una variabile fib che contiene i
primi 10 elementi della sequenza di Fibonacci:
>> fib =ones (1,10);
>> i=2;
>> do
>>
i++;
>>
fib(i)=fib(i-1)+fib(i-2);
>> until (i= =10)
Statement for
Il for è più utile in quanto può contenere
iterazioni di cicli.
La forma
generale è:
>> for var=espressione
>> body
>> endfor
Dove body può essere uno statement o una
lista di statements, espressione è
qualsiasi espressione valida e var può
avere diverse forme. Di solito è un nome di variabile semplice o una variabile
indicizzata. Se espressione è una
struttura, var può anche essere un
vettore con 2 elementi. L’assegnazione nel for lavora un po’ diversamente dalle
normali assegnazioni in Octave. Invece di assegnare il risultato completo
dell’espressione, assegna ogni colonna dell’espressione al var a turno. Se espressione è
un range o un vettore riga o uno scalare, il valore di var sarà uno scalare
ogni volta che il corpo del ciclo sarà eseguito. Se var è un vettore colonna o
una matrice, var sarà un vettore colonna ogni volta che il corpo del ciclo è
eseguito.
Il seguente
esempio mostra un altro modo per creare un vettore che contenga i primi 10
elementi della sequenza di Fibonacci:
>> fib=ones (1,10);
>> for i=3:10
>> fib(i)=fib(i-1)+fib(i-2);
>> endfor
Questo codice
analizza prima l’espressione 3:10, poi produce un range di valori da
Statement break
Si trova dentro
i cicli for o while e può essere usato solo nel corpo del ciclo. Il seguente
esempio mostra il divisore più piccolo di un numero intero dato e identifica
anche i numeri primi:
>>
num=103;
>>
div=2;
>>
while (div*div<=num)
>> if (rem(num,div)= =0)
>> Break;
>> endif
>>
div++;
>> if
(rem(num,div)= =0)
>> printf(“il più piccolo divisore di %d è
%d/n”,num,div)
>> else
>> printf(“%d è prime\n”,num);
>> endif
Quando il resto
è zero nel primo while Octave break (interrompe)
il ciclo e procede allo statement seguente e il processo continua. Questo è
diverso da exit che ferma l’intero
programma.
Statement continue
Come break è usato solo nei cicli for e
while. Questo statement salta il resto del corpo del ciclo passando all’altro
ciclo che inizia subito (invece break salta tutto il ciclo).
Esempio:
>> # stampa gli elementi di un vettore casuale
formato da numeri interi
>> # crea un vettore di 10 numeri interi casuali
con valori da
>> vec=round(rand(1,10)*100);
>> # stampa ciò che noi vogliamo
>> for x=vec
>> if (rem(x,2) !=0)
>> continue;
>> endif
>> printf(“%d\n”,x);
>> endfor
Se uno degli
elementi di vec è un numero dispari questo esempio salta la stampa
dell’elemento e ritorna al primo statement nel ciclo.
Statement unwind_protect
Questo statement
gestisce le eccezioni.
Forma generale:
>> unwind_protect
>> body
>> unwind_protect_cleanup
>> cleanup
>> end_unwind_protect
Dove nody e
cleanup sono entrambi opzionali e possono contenere qualsiasi espressione o
commando di Octave. Gli statements in cleanup sono sicuramente eseguiti
indipendentemente dall’esito del controllo di body. Questo è utile per
proteggere cambiamenti temporanei della variabile globale da possibili errori.
Per esempio, il seguente codice mostra la rassegnazione del valore originario
alla variabile globale frobnositcate anche se si verifica un errore mentre si
esegue l’operazione indicizzata.
>> save_frobnositcate=frobnositcate;
>> unwind_protect
>> frobnositcate=true;
>>….
>> unwind-protect_clenup
>> frobnositcate=save_frobnositcate;
>> end_unwind_protect
Senza
unwind_protect il valore di frobnositcate non sarebbe riassegnato se si
verificasse un errore mentre si esegue l’operazione indicizzata perchè l’analisi
si fermerebbe al punto dell’errore e lo statement riassegnerebbe il valore non
eseguito.
Statement try
Questo statement
gestisce le eccezioni.
Forma generale:
>> try
>> body
>> catch
>> cleanup
>> end_try_catch
Dove body e
cleanup sono entrambi opzionali e possono contenere espressioni e comandi di
Octave. Lo statement in cleanup sarà eseguito solo se si verifica un errore in
body. Non sarà stampato nessun avviso o messaggio di errore mentre il body
eseguito. Se riverifica un errore durante l’esecuzione del corpo, cleanup può
usare la funzione lasterr per
accedere al testo del messaggio che è stato stampato.
Linee di continuazione
Nel linguaggio
Octave molti statments finiscono con un carattere di nuova linea e bisogna dire
ad Octave di ignorarle per continuare lo statement da quella linea al testo. Le
linee che finiscono con i caratteri “…” o “\” sono unite con la linea seguente
prima che siano divise dal decodificatore di Octave.
Per esempio, le linee:
>> x=long_variable_nome
>> +longer_variable_nome\
>> -42
Forma uno
statement singolo. Il carattere backslash (\)sulla seconda linea è interpretato
come un carattere di continuazione non come un operatore di divisione.
Scrivi Commento
Powered by AkoComment Tweaked Special Edition v.1.4.6 |
||||||
| < Prec. | Pros. > |
|---|
|
Iniziative editoriali
|
Test - quiz - simulazione |
Gioca con la matematica |
 |
|
|
|
|