Tutorial2b { ;Formula Tutorial ;Daniele Lupo global: ;Variabili usate dalla formula ;inserite nella sezione global ;perchè serve inizializzarle solo una volta float bailout = @bailo bool itera_a = @ita bool itera_b = @itb bool itera_c = @itc bool itera_d = @itd init: ;Variabili che devono essere ri-inzializzate ;ogni volta all'inizio dell'iterazione ;di ogni pixel complex a = @para complex b = @parb complex c = @parc complex d = #pixel complex z = (0.0,0.0) loop: ;Formula principale If (itera_a == True) a = a+b*z Endif If (itera_b == True) b = b-#pixel*b/(1,1) Endif z = @f1(a*z^3)+@f2(b*z^2)+@f3(c*z)+@f4(d) bailout: |z| < bailout default: title = "Tutorial 2b" Param para Caption = "a" Default = (1.0,0.0) Hint = "Valore a della formula" Endparam Param ita Caption = "Iterare a?" Default = False Hint = "Specifica se iterare la variabile a" Endparam Param parb Caption = "b" Default = (1.0,0.0) Hint = "Valore b della formula" Endparam Param itb Caption = "Iterare b?" Default = False Hint = "Specifica se iterare la variabile b" Endparam Param parc Caption = "c" Default = (1.0,0.0) Hint = "Valore c della formula" Endparam Param itc Caption = "Iterare c?" Default = False Hint = "Specifica se iterare la variabile c" Endparam Param itd Caption = "Iterare pixel?" Default = False Hint = "Specifica se iterare il valore del pixel" Endparam Param bailo Caption = "Bailout" Default = 4.0 Hint = "Valore di bailout della formula" Endparam Func f1 Caption = "f1" Default = ident() Hint = "Funzione per z^3" Endfunc Func f2 Caption = "f2" Default = ident() Hint = "Funzione per z^2" Endfunc Func f3 Caption = "f3" Default = ident() Hint = "Funzione per z" Endfunc Func f4 Caption = "f4" Default = ident() Hint = "Funzione per il pixel" Endfunc switch: }

   Una cosa che abbiamo lasciato in sospeso riguarda l'evoluzione del parametro c: per evolverlo, infatti, non useremo soltanto delle espressioni, ma dei cicli.

CICLI

    I cicli sono delle cose scritte nel seguente modo:

Il concetto, bene o male, è il seguente: se l'espressione booleana accanto il While è vera, allora esegui il suo blocco d'istruzioni: alla fine del blocco, ri-controlla il valore dell'espressione: se è ancora vero, ripeti di nuovo il blocco d'istruzioni. Ripeti li blocco fino a quando l'espressione booleana non diventa falsa; a questo punto, prosegui con le istruzioni seguenti.

    Come potete ben capire, è molto importante che, all'interno del blocco d'istruzioni, ci sia qualcosa in grado di cambiare il valore dell'espressione booleana: considerate il seguente esempio:

Se eseguo una formula di questo tipo, ho quello che si definisce un ciclo infinito: il ciclo while, in altre parole, viene eseguito sempre, senza mai fermarsi, perchè la sua espressione risulta sempre vera. E' una cosa assolutamente da non fare, pena il blocco del programma: non è che si blocchi, ma continuerebbe sempre a ripetere l'istruzione all'infinito, dato che non riceve mai, per così dire, un 'segnale' di blocco: notate anche che, essendo il ciclo eseguito durante una unica iterazione, il suo valore non influisce sul numero massimo di cicli, che continuerà ad oltranza.

    Considerate adesso lo stesso ciclo, con questa piccola modifica:

Come potete vedere, ad ogni ciclo il valore della variabile i viene incrementato di una unità: alla fine del 1° ciclo il suo valore sarà 3, poi 4 ecc. Non appena il suo valore diventa 10, allora l'espressione booleana che comanda il ciclo While non è più vera, e il ciclo finisce, e si eseguono le istruzioni sottostanti. Mi raccomando, è un errore che NON si deve commettere.

    Bene, adesso che ci siamo capiti, vediamo di modificare il valore di c, quando ciò è richiesto: per prima cosa, dobbiamo verificare, mediante l'If, se vogliamo far evolvere il parametro c e, in caso affermativo, dobbiamo far girare il ciclo while. Per farlo girare, mi servirò di una variabile ausiliaria i, che dovrò inizializzare nella sezione init: 

Riuscite a capire perché la variabile i è stata inizializzata nella sezione loop, e non in quella global oppure init (anche però, perchè per evitare warning nel Compiler Message è semprte bene inizializzare le variabili appena si dichiarano)? Perché, ad ogni iterazione della formula, devo far in modo che il valore iniziale della i sia 0: se l'avessi inizializzata nella sezione global o init, allora se itera_c fosse True, alla prima iterazione della formula eseguirei il ciclo While: dopo che questo si è concluso, i = 10, e rimarrebbe tale alla seconda iterazione, non essendoci un comando che riporti i al valore iniziale. Siccome adesso l'espressione booleana del While sarebbe falsa, il ciclo non verrebbe più eseguito. Per questo motivo è importante che la variabile i ritorni a 0 dopo ogni ciclo.

    In verità potreste non volerlo, magari perché volete creare una formula che abbisogna di una situazione particolare: sta a voi ed alla vostra inventiva, ma cercate sempre di non fare cose a completo casaccio, specialmente con i cicli. Se andate a tentoni, potreste incappare facilmente in casi come il ciclo infinito, che va a vostro discapito.

    Dopo averlo inserito e provato (l'avete fatto, VERRRRROOO???), facciamo una cosa simile per il parametro d, che è l'ultimo che ci rimane. Provate il seguente blocco:

    Ho notato che questo blocco dà interessanti risultati se decidete di iterare la d assieme alla b: non ho notato cose molto interessanti se viene azionato da solo, ma probabilmente variando i vari parametri si riuscirebbe ad ottenere qualche cosa di interessante. Notate che non ho inserito il testo necessario per la funzione f_d, dato che ormai dovreste sapere come si fa a introdurre delle funzioni nella formula.

    Qua sotto ho messo la formula completa, fino a dove siamo arrivati adesso: notate che, per poter visualizzare correttamente la formula, bisogna settare periodicity checking su off: questo è stato ottenuto impostato periodicity = 0 nella sezione default:

 Tutorial3 { ;Formula Tutorial ;Daniele Lupo global: ;Variabili usate dalla formula ;inserite nella sezione global ;perchè serve inizializzarle solo una volta float bailout = @bailo bool itera_a = @ita bool itera_b = @itb bool itera_c = @itc bool itera_d = @itd init: ;Variabili che devono essere ri-inzializzate ;ogni volta all'inizio dell'iterazione ;di ogni pixel complex a = @para complex b = @parb complex c = @parc complex d = #pixel complex z = (0.0,0.0) int i = 0 int j = 0 loop: i = 0 j = 0 ;Formula principale If (itera_a == True) a = a+b*z Endif If (itera_b == True) b = b-#pixel*b/(1,1) Endif If (itera_c == True) While (i < 10) c = c/1.5+a/c i = i+1 Endwhile Endif If (itera_d == True) While (j < 10) d = @f_d(d)/(b*2) j = j+1 Endwhile Endif z = @f1(a*z^3)+@f2(b*z^2)+@f3(c*z)+@f4(d) bailout: |z| < bailout default: title = "Tutorial 3" periodicity = 0 Param para Caption = "a" Default = (1.0,0.0) Hint = "Valore a della formula" Endparam Param var Caption = "Var" Default = True Endparam Param ita Caption = "Iterare a?" Default = False Hint = "Specifica se iterare la variabile a" Endparam Param parb Caption = "b" Default = (1.0,0.0) Hint = "Valore b della formula" Endparam Param itb Caption = "Iterare b?" Default = False Hint = "Specifica se iterare la variabile b" Endparam Param parc Caption = "c" Default = (1.0,0.0) Hint = "Valore c della formula" Endparam Param itc Caption = "Iterare c?" Default = False Hint = "Specifica se iterare la variabile c" Endparam Param itd Caption = "Iterare pixel?" Default = False Hint = "Specifica se iterare il valore del pixel" Endparam Param bailo Caption = "Bailout" Default = 4.0 Hint = "Valore di bailout della formula" Endparam Func f_d Caption = "fd" Default = ident() Hint = "Funzione valida solo se si itera il pixel" Endfunc Func f1 Caption = "f1" Default = ident() Hint = "Funzione per z^3" Endfunc Func f2 Caption = "f2" Default = ident() Hint = "Funzione per z^2" Endfunc Func f3 Caption = "f3" Default = ident() Hint = "Funzione per z" Endfunc Func f4 Caption = "f4" Default = ident() Hint = "Funzione per il pixel" Endfunc switch: }

PARAMETRI ENUMERATIVI

    Gli ultimi tipi di parametri sono quelli enumerativi: essi permettono di fare una scelta da un menù a discesa, come quello che hanno le funzioni.

    Aggiungeremo la possibilità di dividere, ad ogni iterazione, il valore finale di z per una delle costanti che abbiamo: a, b, c, pixel. Per prima cosa, dobbiamo introdurre il comando Param che descrive il menù a discesa: introduciamo le seguenti righe, nella sezione (avrete capito) Default, sotto itd:

La cosa importante che si note è l'aggiunta del comando Enum: è questo che consente di creare la lista di oggetti: ad ogni stringa è associato un valore numerico intero: alla prima frase (stringa) viene associato il valore 0, alla seconda il valore 1, alla terza il valore 2 e così via: in pratica, en è un parametro di tipo intero, con valori prefissati che hanno un nome, un alias: adesso, dichiariamo la variabile intera enumerat, e poniamola nella sezione global, uguagliandola al parametro en. Dopo la formula principale della sezione loop introduciamo il seguente codice:

    Quello che abbiamo ottenuto, in pratica è questo: se enumerat vale 0, non succede niente: se assume il valore 1, 2, 3, 4, allora esegue la divisione corrispondente. E' importante farr corrispondere le stringhe associate ai valori interi con il significato che assumono nella formula, altrimenti si genera confusione.

    Qua sotto c'è la funzione con quest'ultima modifica:

 Tutorial3a { ;Formula Tutorial ;Daniele Lupo global: ;Variabili usate dalla formula ;inserite nella sezione global ;perchè erve inizializzarle solo una volta float bailout = @bailo bool itera_a = @ita bool itera_b = @itb bool itera_c = @itc bool itera_d = @itd int enumerat = @en init: ;Variabili che devono essere ri-inzializzate ;ogni volta all'inizio dell'iterazione ;di ogni pixel complex a = @para complex b = @parb complex c = @parc complex d = #pixel complex z = (0.0,0.0) int i = 0 int j = 0 loop: i = 0 j = 0 ;Formula principale If (itera_a == True) a = a+b*z Endif If (itera_b == True) b = b-#pixel*b/(1,1) Endif If (itera_c == True) While (i < 10) c = c/1.5+a/c i = i+1 Endwhile Endif If (itera_d == True) While (j < 10) d = @f_d(d)/(b*2) j = j+1 Endwhile Endif z = @f1(a*z^3)+@f2(b*z^2)+@f3(c*z)+@f4(d) ;Uso del parametro enumerativo If (enumerat == 1) z = z/a Elseif (enumerat == 2) z = z/b Elseif (enumerat == 3) z = z/c Elseif (enumerat == 4) z = z/#pixel Endif bailout: |z| < bailout default: title = "Tutorial 3a" periodicity = 0 Param para Caption = "a" Default = (1.0,0.0) Hint = "Valore a della formula" Endparam Param var Caption = "Var" Default = True Endparam Param ita Caption = "Iterare a?" Default = False Hint = "Specifica se iterare la variabile a" Endparam Param parb Caption = "b" Default = (1.0,0.0) Hint = "Valore b della formula" Endparam Param itb Caption = "Iterare b?" Default = False Hint = "Specifica se iterare la variabile b" Endparam Param parc Caption = "c" Default = (1.0,0.0) Hint = "Valore c della formula" Endparam Param itc Caption = "Iterare c?" Default = False Hint = "Specifica se iterare la variabile c" Endparam Param itd Caption = "Iterare pixel?" Default = False Hint = "Specifica se iterare il valore del pixel" Endparam Param en Caption = "Dividi z?" Enum = "No" "Per a" "Per b" "Per c" "Per pixel" Default = 0 Hint = "Permette di dividere z per il valore prefissato\ ad ogni iterazione" Endparam Param bailo Caption = "Bailout" Default = 4.0 Hint = "Valore di bailout della formula" Endparam Func f_d Caption = "fd" Default = ident() Hint = "Funzione valida solo se si itera il pixel" Endfunc Func f1 Caption = "f1" Default = ident() Hint = "Funzione per z^3" Endfunc Func f2 Caption = "f2" Default = ident() Hint = "Funzione per z^2" Endfunc Func f3 Caption = "f3" Default = ident() Hint = "Funzione per z" Endfunc Func f4 Caption = "f4" Default = ident() Hint = "Funzione per il pixel" Endfunc switch: }

    Adesso potete divertirvi con questa formula: provate a cambiare qualcosa, per esempio le istruzioni eseguite nei vari cicli. Appena vi siete stufati, vedremo gli ultimi argomenti di questo importante tutorial.